[C] Puissance 4 arbres de possibilité

Puissance 4 arbres de possibilité [C] - C - Programmation

Marsh Posté le 09-11-2011 à 17:18:04    

Bonjour, j'ai un projet a réaliser en C.
C'est un puissance 4, 7 colonnes, 6 lignes.
 
La première partie a été faite, c'est a dire en joueur contre joueur.
La deuxième partie doit utiliser des arbres pour calculer toutes les possibilités.
 
Le premier fichier correspond au jeu en JvsJ, le deuxième fichier va contenir toute les procédures et fonction pour calculer l'arbre, évaluer les possibilités, parcourir l'arbre, et devra retourner juste le numéro de la colonne a jouer pour l'ordi.
 
J'aimerais avoir de l'aide sur toute la deuxième partie, je bloque depuis 2 jours sur ces points la.
 
 
Voici le code de la première partie :
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. //#include "p4IA.c"
  5. //constante
  6. #define N 50
  8. //variable
  9. /*ce tableau à deux dimensions représente la structure du support de jeu*/
  10. char tab_p4[6][7];
  11. /*ce tableau représente la capacité en pion d'une colonne*/
  12. int remplircol[7];
  13. /*Cette variable représente un booléen 0=perdu, 1=gagné*/
  14. int win;
  16. /******************************************************************************************************/
  17. //prototype
  18. int jouable(int colonnes);
  19. int saisie();
  20. void afficher_tab_p4();
  21. int tab_p4_rempli();
  22. int pion_cote(int col, int lign,int dirVer, int dirHor);
  23. void gagner(int c,int l);
  24. void jouer(int *cpt,char c,char nom[N]);
  25. void jeu1j();
  26. void jeu2j();
  27. int choix();
  28. void jouer_ordi(int *cpt,char c,char nom[N]);
  30. /******************************************************************************************************/
  31. //corps
  32. void main (){
  33.       choix();
  34. }
  36. /******************************************************************************************************/
  37. int choix(){
  39. int reponse=0;
  41. printf("Choisissez un mode de jeux\n\n" );
  42. printf("1-Mode joueur contre joueur\n" );
  43. printf("2-Mode joueur contre ordinateur\n" );
  44. scanf("%d",&reponse);
  45. do{
  46.       switch (reponse) {
  47.       case 1:
  48.            jeu2j();
  49.            break;
  50.       case 2:
  51.            jeu1j();
  52.           break;
  53.        }
  54. }while(reponse!=1||reponse!=2);
  55. }
  56. /******************************************************************************************************/
  57. void jeu1j(){
  59. int i,j,joueur=0,compt1=0;
  61. char nom1[N],nom2[N]="Ordinateur",recom;
  63. win=0;// 1 gagné // 0 perdu
  65. printf("\t\t\t\t\t\t **********Puissance4********** \n\n" );
  66. printf("\n\n\t\t\t\t\t\t *****Partie contre l'ordinateur***** \n\n\n\n\n\n" );
  67. printf("Nom du joueur!!\n" );
  68. scanf("%s",&nom1[N]);
  69. afficher_tab_p4();
  71. do{
  72.      for (i=0;i<6;i++)
  73.      {
  74.            for (j=0;j<7;j++)
  75.      {
  76.       tab_p4[i][j]=' '; //Déclare le caractère de la fonction afficher_tab_p4 pour organiser le tableau
  77.     }
  78. }
  79.         for(j=0;j<7;j++){
  80.                       /* Iniatilisation de la fonction remplircol à zéro*/
  81.             remplircol[j]=0;
  82.         }
  83.         do{
  84.                  //Gestion des pions du joueur 1
  85.                  if (joueur%2==0){
  86.                  jouer(&compt1,'O',nom1);
  87.         }
  88.          //Gestion des pions de l'ordinateur
  89.          if(joueur%2!=0){
  90.                  jouer_ordi(&compt1,'X',nom2);
  91.          }
  92.          // joueur incrémenté
  93.          joueur=joueur+1;
  94.          // répéter tant que la grille n’est pas remplie ou que la partie n’est pas gagnée
  95.          } while(( !tab_p4_rempli() && win==0 ) );
  97.        do{
  98.              fflush(stdin);//vide le tampon des scanf effectuer
  99.              printf("\t\tSouhaitez-vous recommencer la partie ? (o/n) : " );
  100.              scanf("%c",&recom);
  101.        }while(recom!='o' && recom!='n');
  102. printf("\n" );
  103. }while (recom=='o');
  106. }
  107. /******************************************************************************************************/
  108. void jeu2j(){
  110. int i,j,joueur=0,compt1=0;
  112. char nom1[N],nom2[N],recom;
  114. win=0;// 1 gagné // 0 perdu
  116. printf("\t\t\t\t\t\t **********Puissance4********** \n\n" );
  117. printf("\n\n\t\t\t\t\t\t *****Partie à deux joueurs***** \n\n\n\n\n\n" );
  118. printf("Nom du premier joueur!!\n" );
  119. scanf("%s",&nom1[N]);
  120. printf("Nom du deuxième joueur\n" );
  121. scanf("%s",&nom2[N]);
  123. afficher_tab_p4();
  124. do{
  126.       for (i=0;i<6;i++)
  127.       {
  128.            for (j=0;j<7;j++)
  129.            {
  130.                   tab_p4[i][j]=' '; //Déclare le caractère de la fonction afficher_tab_p4 pour organiser le tableau
  131.            }
  132.       }
  134.       for(j=0;j<7;j++){
  135.                  /* Iniatilisation de la fonction remplircol à zéro*/
  136.                remplircol[j]=0;
  137.        }
  138. do{
  139.         //Gestion des pions du joueur 1
  140.         if (joueur%2==0){
  141.                  jouer(&compt1,'O',nom1);
  142.         }
  143.         //Gestion des pions du joueur 2
  144.         if(joueur%2!=0){
  145.                 jouer(&compt1,'X',nom2);
  146.          }
  147.          // joueur incrémenté
  148.          joueur=joueur+1;
  149.          // répéter tant que la grille n’est pas remplie ou que la partie n’est pas gagnée
  150. } while(( !tab_p4_rempli() && win==0 ) );
  152. do{
  153.          fflush(stdin);//vide le tampon des scanf effectuer
  154.          printf("\t\tSouhaitez-vous recommencer la partie ? (o/n) : " );
  155.          scanf("%c",&recom);
  156. }while(recom!='o' && recom!='n');
  157. printf("\n" );
  158. }while (recom=='o');
  160. }
  161. /**********************************************************************************************************/
  162. /* fonction qui renvoie vrai s'il est possible de poser un pion dans la colonne colonnes*/
  163. int jouable(int colonnes){
  164.            if ((colonnes>=0) && (colonnes<7) && (remplircol[colonnes]>=0) && (remplircol[colonnes]<6)) return 1;
  165.            else return 0;
  166. }
  168. /**********************************************************************************************************/
  169. /*fonction de saisie d'un coup fait par le joueur*/
  170. int saisie(){
  171. int x; /* x est la colonne */
  172. do{
  173.         printf("\t Veuillez entrer un chiffre entre 0 et 6:\n\t Attention aux colonnes déjà remplies!\n" );
  174.         scanf("%d",&x);
  175.         if (jouable(x)==1) return x;
  177. }while(jouable(x)!=1);
  178. return 0;
  179. }
  182. /**********************************************************************************************************/
  183. void afficher_tab_p4() //Procédure qui permet d'afficher une grille de jeu Puissance4
  184. {
  185. int i,j;
  186. printf("\t\t\t\t\t\t **********Puissance4********** \n\n" );
  187.           for (i=0;i<6;i++)
  188.           {
  189.                 printf("\t\t\t\t\t\t ø-ø-ø-ø-ø-ø-ø-ø \n" );
  190.                 printf("\t\t\t\t\t\t" );
  191.                 for (j=0;j<7;j++)
  192.                 {
  193.                        printf("|%c",tab_p4[5-i][j]); //Le %c permet de declarer un espace vide pour un caractère non déclaré pour le moment
  194.                 }
  195.            printf("| %d\n",i); //Indice de la grille afficher horizontalement
  196.            }
  197. printf("\t\t\t\t\t\t ø-ø-ø-ø-ø-ø-ø-ø \n" );
  198. printf("\t\t\t\t\t\t" );
  199.          
  200.            for(j=0;j<=6;j++)
  201.            {
  202.                     printf(" %d",j); //Indice de la grille afficher verticalement
  203.            }
  204. printf("\n\n\t\t" );
  205. }
  208. /******************************************************************************************************/
  209. int tab_p4_rempli(){
  211. int colon,complet=0;
  213. /* la fonction cherche quel sont les cases de la grille qui sont remplies */
  215.            for(colon=0;colon<=6;colon++){
  216.                       if(jouable(colon)){
  217.                                  complet=complet+1;
  218.                       }
  219.            }
  221. //Après avoir incrémenté chaque colonne, la fonction renvoie si la grille est complete (return 1) ou non (return 0) */
  222.            if (complet==0) return 1;
  223.            else return 0;
  224. }
  226. /******************************************************************************************************/
  227. /*La fonction pion_cote permet de verifier pour chaque direction, par rapport a un pion donné, si le pion mitoyen est de meme symbole.
  228. Cela permet, grâce à un compteur, de compter le nombre de pions cote à cote*/
  230. int pion_cote(int col, int lign,int dirVer, int dirHor)
  231. {
  232. int n=0;
  234. if(dirVer==-1){
  235. if(dirHor==0){
  236.            while((tab_p4[lign][col])==(tab_p4[lign-1][col])&&(tab_p4[lign][col]!=' ')){
  237.                       n++;
  238.                       lign--;
  239.            }
  240. }
  241. else if(dirHor==-1){
  242.            while((tab_p4[lign][col])==(tab_p4[lign-1][col-1])&&(tab_p4[lign][col]!=' ')){
  243.                       n++;
  244.                       col--;
  245.                       lign--;
  246.             }
  247. }
  248. else if(dirHor==1){
  249.            while((tab_p4[lign][col])==(tab_p4[lign-1][col+1])&&(tab_p4[lign][col]!=' ')){
  250.                       n++;
  251.                       col++;
  252.                       lign--;
  253.            }
  254. }
  255. }
  257. if(dirVer==0){
  258.            if(dirHor==1){
  259.                       while((tab_p4[lign][col])==(tab_p4[lign][col+1])&&(tab_p4[lign][col]!=' ')){
  260.                                  n++;
  261.                                  col++;
  262.                       }
  263.            }
  264. else if(dirHor==-1){
  265.            while((tab_p4[lign][col])==(tab_p4[lign][col-1])&&(tab_p4[lign][col]!=' ')){
  266.                       n++;
  267.                       col--;
  268.            }
  269. }
  270. }
  271. return(n);
  272. }
  273. /******************************************************************************************************/
  274. void gagner(int c,int l){
  276. /*Appele la fonction pion_cote, et teste dans tout les sens par rapport au pion donné*/
  277. if ((pion_cote(c,l,0,1) +pion_cote(c,l,0,-1)) >=3 ||
  278. ( pion_cote(c,l,1,0) +pion_cote(c,l,-1,0)) >=3 ||
  279. ( pion_cote(c,l,1,1) +pion_cote(c,l,-1,-1))>=3 ||
  280. ( pion_cote(c,l,1,-1)+pion_cote(c,l,-1,1) >=3))
  282. win=1;
  283. else win=0;
  284. }
  285. /*******************************************************************************************************/
  286. //procedure permettant au joueur de jouer // // problème lors de l'execution //
  287. void jouer(int *cpt,char c,char nom[N]){
  288.            int l,col;
  289.            // on rentre son nommax
  290.            printf("%s, posez votre pion\n",&nom[N]);
  291.            col=saisie();
  292.            //la fonction remplircol définit les lignes de la colonne
  293.            l=remplircol[col];
  294.            tab_p4[l][col]=c;
  295.            remplircol[col]=remplircol[col]+1;
  296.            (*cpt)++;
  297.            afficher_tab_p4();
  298.            gagner(col,l);
  299.            // si la partie est gagnée
  300.            if( win==1){
  301.                       printf("%s gagne au %deme coup\n",&nom[N],(*cpt)/2+1);
  302.            }
  303. }
  304. /*******************************************************************************************************/
  305. void jouer_ordi(int *cpt,char c,char nom[N]){
  306.            int l,col;
  307.            int profondeur;
  308.            col=getCol();
  309.            //la fonction remplircol définit les lignes de la colonne
  310.            l=remplircol[col];
  311.            tab_p4[l][col]=c;
  312.            remplircol[col]=remplircol[col]+1;
  313.            (*cpt)++;
  314.            afficher_tab_p4();
  315.            gagner(col,l);
  316.            // si la partie est gagnée
  317.            if( win==1){
  318.                       printf("%s gagne au %deme coup\n",&nom[N],(*cpt)/2+1);
  319.            }
  320. }


 
 
Merci


Message édité par zulfine le 10-11-2011 à 16:23:00
Reply

Marsh Posté le 09-11-2011 à 17:18:04   

Reply

Marsh Posté le 10-11-2011 à 13:24:05    

Salut,
Peux-tu indenter ton code? C'est assez illisible.
Du coup je n'ai pas tout lu, mais... tu as testé ça:

Code :
  1. scanf("%d",&reponse);
  2. do{
  3.   switch (reponse) {
  4.   case 1:
  5.     jeu2j();
  6.     break;
  7.   case 2:
  8.     jeu1j();
  9.     break;
  10.   }
  11. }while(reponse!=1||reponse!=2);


?

 


Si tu bloques sur la deuxième partie, c'est plutôt ce code là qu'il fallait donner. Sur quoi bloques-tu?

 


edit: Après un rapide copier-coller et en enlevant ce qui concerne le joueur ordinateur, je vois pas mal de choses dans l'affichage qui trahissent des problèmes de dépassement de chaînes et autres mauvais usages de pointeurs. Tu devrais refaire une vérif.


Message édité par ptitchep le 10-11-2011 à 14:26:32

---------------
deluser --remove-home ptitchep
Reply

Marsh Posté le 10-11-2011 à 16:31:59    

La totalité du programme fonctionne et à déjà été tester pour la partie 2 joueur.
 
C'est vraiment la partie de l'ia qui pose problème avec la fonction min max que j'arrive pas à codé.
 
Je doit avoir l'arbre complet (avec toutes les possibilités) déjà construit et ensuite l'algo minmax permet de ressortir la meilleur position pour que l'ordi place sa piece
 
voilà
 

Message cité 2 fois
Reply

Marsh Posté le 10-11-2011 à 16:41:11    

Tu devrais d'abord corriger les erreurs de ton code avant d'attaquer la partie IA. Ce n'est pas parce que ça fonctionne et que ça a été testé que le code est juste. Quoi que, quand ton programme plantera, tu pourras toujours dire 'it's not a bug ! it's a feature !'. ;)
 
Pour l'algo minimax le but n'est pas de stocker l'arbre et de piocher la réponse dans la table, mais d'explorer l'arbre pour vérifier les possibilités. Note qu'avec un minimax basique, tu ne pourras pas explorer grand chose, ce sera trop long, c'est pour ça qu'il y a pas mal d'optimisations liées à ça (mais tu n'en es pas encore là....).

Reply

Marsh Posté le 10-11-2011 à 18:23:10    

zulfine a écrit :

La totalité du programme fonctionne et à déjà été tester pour la partie 2 joueur.

Vu les scanf, elle n'a manifestement été testée qu'en supposant qu'il n'y aura pas de faute de frappe en entrée.
Cette lecture est recommandée: http://home.datacomm.ch/t_wolf/tw/c/getting_input.html
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 14-11-2011 à 14:02:15    

zulfine a écrit :

La totalité du programme fonctionne et àa déjà été testerée pour la partie 2 joueurs.

Non. Tester ne veut pas dire essayer le cas où tout va bien.
 

zulfine a écrit :

C'est vraiment la partie de l'ia qui pose problème avec la fonction min max que jje n'arrive pas à codéer.


Où en es-tu?

zulfine a écrit :


Je doits avoir l'arbre complet (avec toutes les possibilités) déjà construit et ensuite l'algo minmax permet de ressortir la meilleur position pour que l'ordi place sa pieèce.
 
voilà
 



---------------
deluser --remove-home ptitchep
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed