Partage
  • Partager sur Facebook
  • Partager sur Twitter

zMorp - 1ère partie

Créer un morpion

    20 janvier 2011 à 21:27:12

    @Pouet: euh c'est quoi tous ces chiffres? Tu devrais avoir un joli tableau. J'utilise la table ASCII sous Windows pour fabriquer un cadre.
    • Partager sur Facebook
    • Partager sur Twitter
      20 janvier 2011 à 22:18:34

      Citation : darkipod

      sous Windows


      Et les autres ? ;)
      Je suis pas sous windows !
      • Partager sur Facebook
      • Partager sur Twitter
        21 janvier 2011 à 6:27:14

        Ah dommage je modifie donc pour avoir un code portable , je pensais qu'il était je n'ai pourtant utilise aucun "appel du système "?
        La table ASCII n'est pas universelle?
        • Partager sur Facebook
        • Partager sur Twitter
          21 janvier 2011 à 8:55:47

          Pas la table ASCII étendue. ;)
          • Partager sur Facebook
          • Partager sur Twitter
            22 janvier 2011 à 23:43:26

            zMorp - 1ère partie - Correction


            Rien de bien compliqué dans cet exercice, il suffisait simplement de faire comme si on jouait sur papier.
            Le plus dur est sûrement la fonction qui teste quel joueur a gagné. Pour cela il y avait plusieurs options :
            - Si vous partez sur un morpion 3x3 (taille fixe), vous pouvez faire un gros 'if' qui teste toutes les positions. Pas grand chose, il y a 8 positions à tester. :)
            - Si vous partez sur un morpion NxN (taille variable), il n'y a rien de bien compliqué non plus. Pour éviter de tester toute la grille, on ne testera que le dernier coup joué. Pour ça, il suffit de partir du dernier coup joué et de teste la colonne, la ligne et les 2 diagonales à partir du coup. Tous les autres coups ne nous intéressent pas, ils ne changent pas !
            Vous pouvez le faire de plusieurs manières, mais toutes se ressemblent plus ou moins. La méthode proposée dans mon code est simplement de se dire qu'on a 4 directions à tester (1 ligne, 1 colonne, 2 diagonales) et de compter le nombre de pions alignés. On teste également les directions 'inverse' ('derrière' le pion) et on ajoute ce compte aux directions 'normales'. Si le nombre de pions alignés trouvés sont supérieurs ou égaux au nombre qu'il faudrait aligner, c'est qu'on a gagné, autrement on teste les autres directions. :)

            Voilà le code, je n'ai pas mis de commentaires, il me paraît assez clair, mais si vous voyez un endroit qui vous paraît obscur, dîtes le moi :

            #include <ctype.h>
            #include <ctype.h>
            #include <stdio.h>
            #include <stdlib.h>
            #include <time.h>
            
            enum {
              TAB_H = 3,              /* Hauteur  */
              TAB_W = 3,              /* Largeur  */
              TAB_T = TAB_H * TAB_W,  /* Nbre total de cases      */
              NBR_P = 3               /* Nbre de pions à aligner  */
            };
            
            enum {
              VIDE  = 0,
              J1    = 1,
              J2    = 2
            };
            
            typedef struct Coord_ {
              int x;
              int y;
            } Coord;
            
            void viderStdin(void) {
              int c;
              while ((c = getchar()) != '\n' && c != EOF)
                ;
            }
            
            int testerCoup(int * tab, Coord * c) {
              if (c->x < 0 || c->x >= TAB_W || c->y < 0 || c->y >= TAB_H ||
                  tab[c->y * TAB_W + c->x] != VIDE)
                return 0;
              else
                return 1;
            }
            
            int saisieCoord(int * tab, Coord * c) {
              
              do {
                printf("Entrez les coordonees (x y) : ");
                scanf("%d%d", &c->x, &c->y);
                viderStdin();
                c->x--;
                c->y--;
              } while (!testerCoup(tab, c));
              
              return 0;
            }
            
            int jouerCoup(int * tab, Coord * c, int joueur) {
              tab[c->y * TAB_W + c->x] = joueur;
              return 0;
            }
            
            void affiche(int * tab) {
              char * s = ".XO";
              int i;
              
              for (i = 0; i < TAB_T; i++) {
                if (i && i % TAB_H == 0)
                  puts("");
                putchar(s[tab[i]]);
              }
              puts("");
            }
            
            int compterDir(int * tab, Coord * c, int x, int y, int joueur) {
              int cnt, i, j;
              
              cnt = 0;
              i = c->x + x;
              j = c->y + y;
              while (i >= 0 && i < TAB_W && j >= 0 && j < TAB_H &&
                     tab[j * TAB_W + i] == joueur) {
                cnt++;
                j += y;
                i += x;
              }
              
              return cnt;
            }
            
            int estCoupGagnant(int * tab, Coord * c, int joueur) {
              Coord dir[4] = {
                { 0, 1 }, { 1,  0 },
                { 1, 1 }, { 1, -1 }
              };
              int cnt, i;
              
              for (i = 0; i < 4; i++) {
                cnt =  compterDir(tab, c, dir[i].x,  dir[i].y,  joueur);
                cnt += compterDir(tab, c, -dir[i].x, -dir[i].y, joueur);
                if (cnt + 1 >= NBR_P)
                  return 1;
              }
              
              return 0;
            }
            
            int estGagnant(int ret, int joueur, int pce) {
              if (ret)
                printf("Joueur %d gagne !\n", joueur);
              else if (pce >= TAB_T)
                printf("Match nul !\n");
              else
                return 0;
              return 1;
            }
            
            void jouer(int joueur) {
              int tab[TAB_T] = { 0 };
              int done, pce, ret;
              Coord c;
              
              printf("Joueur %d commence !\n\n", joueur);
              affiche(tab);
              
              pce = 0;
              done = 0;
              while (!done) {
                saisieCoord(tab, &c);
                jouerCoup(tab, &c, joueur);
                pce++;
                ret = estCoupGagnant(tab, &c, joueur);
                done = estGagnant(ret, joueur, pce);
                affiche(tab);
                joueur = 3 - joueur;
              }
            }
            
            int rejouer(void) {
              int c;
              
              do {
                printf("Voulez-vous rejouer (o)ui/(n)on ? ");
                c = getchar();
                viderStdin();
                c = toupper(c);
              } while (c != 'N' && c != 'O');
              return c == 'O';
            }
            
            int init(void) {
              srand(time(NULL));
              return 0;
            }
            
            int main(void) {
              int joueur;
              init();
              
              joueur = rand() % 2 + 1;
              do {
                jouer(joueur);
                joueur = 3 - joueur;
              } while (rejouer());
              
              return EXIT_SUCCESS;
            }
            

            J'ai modifié compterDir parce que c'est vrai qu'elle était pas très lisible. :-)
            Edit: Modif mineure (nom de variable).
            • Partager sur Facebook
            • Partager sur Twitter
              23 janvier 2011 à 0:14:04

              o_O Je rêve ou tu as un trait obsessionnel au niveau des fonctions (obsession des fonctions) ?
              int init(void) {  // C'est exagérer non ?
                srand(time(NULL));
                return 0;
              }
              

              Et aussi :
              int jouerCoup(int * tab, Coord * c, int joueur) {
                tab[c->y * TAB_W + c->x] = joueur; // Une seule ligne. -_-"
                return 0;
              }
              


              Sinon j'aime bien ta fonction affiche (c'est qui ces types qui veulent pas faire comme tout le monde et qui fond des fonctions originales pour afficher un tableau). Et j'ai pas le courage de me lancer dans ta fonction testerGrille().

              Edit :
              Ah aussi :
              enum {
                VIDE  = 0,
                J1    = 1,
                J2    = 2
              };
              

              Ce ne sont pas les valeurs qui sont attribuées automatiquement ? Et d'ailleurs tu n'as pas vraiment besoin de leur attribuer de valeur non ? Dernière chose, ni J1 ni J2 n'est utilisée.
              • Partager sur Facebook
              • Partager sur Twitter
              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                23 janvier 2011 à 0:34:40

                Citation : @che


                Je rêve ou tu as un trait obsessionnel au niveau des fonctions (obsession des fonctions) ?


                Faire des fonctions, même petites, c'est considéré comme une bonne pratique.

                Là tu ne vois pas l'intérêt de la fonction init, ok, mais lorsque le programme va évoluer ça demandera surement moins de travail que tout en dur dans le main.


                Citation : @che


                (c'est qui ces types qui veulent pas faire comme tout le monde et qui fond des fonctions originales pour afficher un tableau).


                Marrant ce point de vue. :D
                Mais ça n'a rien d'original, c'est seulement sale. :D
                Non, même pas, je veux bien pour compteDir, mais la fonction d'affichage est très classique!

                Pour la série d'enum suivante je suis d'accord.

                Pour finir, c'est dur de pondre un code qui satisfait tout le monde, hein! ;)
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoir, le site qui en a dans le citron !
                  23 janvier 2011 à 0:39:45

                  Exagéré ? non.
                  Pour la fonction init, certes elle parait seule et isolée mais si tu regardes bien, si je passe mon jeu en SDL, bah ma fonction est déjà prête. :p
                  Pour la fonction jouerCoup, bah, simplement que c'est plus lisible de lire ça que une affectation de tableau foireuse. Là elle n'est utilisée qu'une seule fois, mais si tu l'utilises 50 fois dans ton programme ? tu la modifieras 50 fois dans ton programme au risque d'en oublier...

                  Citation : @che

                  Et j'ai pas le courage de me lancer dans ta fonction testerGrille().


                  Bah, ya rien de compliqué la dedans, il suffit juste de réfléchir un peu...

                  Les valeurs de l'enum sont attribuées automatiquement, simplement je n'avais pas utilisé ces valeurs là au départ, je les ai donc laissées. Les valeurs de l'enum ne sont pas utilisées non plus, mais encore une fois c'est pour l'évolution du programme, pour l'IA par exemple (que tu n'as pas faite).

                  Comme je l'ai dis, il faut essayer de faire un programme évolutif, regardes mon programme console et SDL, tu verras que le nombre de fonctions qui ont été touchées par le passage console->SDL est très faible (genre 2 ou 3 fonctions pas plus).

                  GurneyH > Sale pour mon affichage ? mouais bof, je préfère ça à une série de if...else et cie. ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    23 janvier 2011 à 1:00:07

                    Citation : Pouet_forever

                    Les valeurs de l'enum sont attribuées automatiquement, simplement je n'avais pas utilisé ces valeurs là au départ, je les ai donc laissées. Les valeurs de l'enum ne sont pas utilisées non plus, mais encore une fois c'est pour l'évolution du programme, pour l'IA par exemple (que tu n'as pas faite)


                    Hum qu'es-ce que tu sous entends par cette petite phrase ?

                    Citation : Pouet_forever


                    Comme je l'ai dis, il faut essayer de faire un programme évolutif, regardes mon programme console et SDL, tu verras que le nombre de fonctions qui ont été touchées par le passage console->SDL est très faible (genre 2 ou 3 fonctions pas plus).


                    C'est vrais. Désolé je compte pas faire l'exo en SDL, je préfère en console. :p

                    • Partager sur Facebook
                    • Partager sur Twitter
                    🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                      23 janvier 2011 à 1:03:37

                      Citation : @che

                      Hum qu'es-ce que tu sous entends par cette petite phrase ?


                      Ca : http://www.siteduzero.com/forum-83-597 [...] e-partie.html ;)
                      • Partager sur Facebook
                      • Partager sur Twitter
                        23 janvier 2011 à 1:10:14

                        J'y participerais certainement. Mais pas tout de suite :p .
                        • Partager sur Facebook
                        • Partager sur Twitter
                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                          23 janvier 2011 à 13:27:16

                          Merci Pouet pour cette correction. ^^

                          J'avais complètement zappé la partie 2 de l'exo... j'édite immédiatement ma signature et je vais me tenté à l'algo min-max ou alpha-beta (promis, pas 50 if / else if).
                          • Partager sur Facebook
                          • Partager sur Twitter
                            27 février 2011 à 1:23:14

                            Salut tout le monde !!

                            J'ai fait un petit code pour ce fameux morpion. Il est fini (presque mais j'expliquerais pourquoi après), et débuggé, reste plus qu'à le critiquer. Je n'ai pas fait d'IA (je ne trouve pas très intéressant de me taper une série de if / else sachant que j'ai déjà subit ça avec un jeu de mastermind).
                            Je me lancerait dans l'IA avec les algorithmes que tu as cité après en avoir fini avec les différentes tailles de grille, parce que comme qui dirait : chaque chose en son temps quand on est débutant !!

                            Pourquoi il n'est pas vraiment fini? Parce que ma fonction testWinMoche() est, comme son nom l'indique, moche :D C'est un truc trivial qui ne fonctionne qu'en 3x3 et qui est justement une série de if toute moche.

                            Donc sur ce, je vous soumet le code tel quel et je me penche sur une solution qui regardera ligne / colonne / diagonale du dernier coup pour pouvoir jouer sur des 4x4 et 5x5 sans avoir à refaire une fonction encore plus longue.


                            PS : Pouet Forever, c'est pas contre toi mais j'aime vraiment pas cette indentation, on dirait du Eclipse berk !!



                            Le code :

                            main.c :
                            #include <stdio.h>
                            #include <stdlib.h>
                            #include "fct.h"
                            
                            int main()
                            {
                                int win=RIEN, joueurActuel=J1, coup=0, erreur=0;
                                char grille[NB_CASES]={0};
                            
                                InitJeu(grille,NB_CASES);
                            
                                AffGrille(grille,NB_CASES);
                            
                                while(win==RIEN)
                                {
                                    /*Récupérer le coup du joueur 1 ou 2*/
                                    printf("Joueur %d : ",joueurActuel);
                                    coup=recupCoup();
                            
                                    /*mettre à jour le tableau*/
                                    if(grille[coup-1]=='.')
                                        grille[coup-1]=(joueurActuel==J1)?'o':'x'; /*Joueur 1 a les 'o' et joueur 2 a les 'x'*/
                                    else
                                    {
                                        printf("Erreur, case deja jouee.\n");
                                        erreur=1;
                                    }
                            
                                    /*Afficher la grille*/
                                    AffGrille(grille,NB_CASES);
                            
                                    /*tester si gagnant : win j1, win j2, nul, continuer à jouer*/
                                    win=testWinMoche(grille,NB_CASES,coup);
                                    annonceWin(win,joueurActuel);
                            
                            
                                    /*Changement de joueur, test si case jouée ou pas*/
                                    if(erreur) /*Si erreur, on recommence*/
                                    {
                                        erreur=0;
                                    }else /*Sinon c'est à l'autre joueur de jouer*/
                                    {
                                        if(joueurActuel==J1)
                                            joueurActuel=J2;
                                        else joueurActuel=J1;
                                    }
                                }
                                return 0;
                            }
                            


                            fct.c
                            #include <stdio.h>
                            #include <stdlib.h>
                            #include <math.h>
                            #include "fct.h"
                            
                            void InitJeu(char *tab, int tablen)
                            {
                                int i=0;
                            
                                for(i=0;i<tablen;i++)
                                    tab[i]='.';
                            }
                            
                            void AffGrille(char *tab, int tablen)
                            {
                                int i=0, j=0, casesParLignes=(int)sqrt((double) tablen);
                            
                                for(i=0;i<casesParLignes;i++)
                                {
                                    for(j=tablen-((i+1)*casesParLignes);j<(tablen-(i*casesParLignes));j++)
                                        printf("%c",tab[j]);
                                    printf("\n");
                                }
                            
                                printf("\n\n");
                            }
                            
                            int recupCoup(void)
                            {
                                int coup=0;
                            
                                scanf("%d",&coup);
                                while(getchar()!='\n');
                            
                                coup=(coup<=0||coup>NB_CASES)?1:coup; /*sécurité temporaire, une boucle remplacera ça*/
                            
                                return coup;
                            }
                            
                            int testWinMoche(char *tab, int tablen, int dernierCoup)
                            {
                                int win=RIEN;
                                int flag=0, i=0;
                            
                                /*test lignes - ALGORITHME MOCHE (seulement 9 cases)*/
                                if(tab[0]!='.')
                                {
                                    if(tab[1]==tab[0]&&tab[2]==tab[0]) /*ligne du haut*/
                                        win=WIN;
                                    else if(tab[3]==tab[0]&&tab[6]==tab[0]) /*colonne de gauche*/
                                        win=WIN;
                                }
                                if(tab[4]!='.')
                                {
                                    if(tab[3]==tab[4]&&tab[5]==tab[4]) /*ligne du milieu*/
                                        win=WIN;
                                    else if(tab[1]==tab[4]&&tab[7]==tab[4]) /*colonne du milieu*/
                                        win=WIN;
                                }
                                if(tab[8]!='.')
                                {
                                    if(tab[7]==tab[8]&&tab[6]==tab[8]) /*ligne du bas*/
                                        win=WIN;
                                    else if(tab[5]==tab[8]&&tab[2]==tab[8])   /*colonne de droite*/
                                        win=WIN;
                                }
                            
                                /*si impair : test diagonales en plus - ALGORITHME MOCHE (seulement 9 cases)*/
                                if(dernierCoup%2!=0)
                                {
                                    if(tab[4]!='.')
                                    {
                                        if(tab[0]==tab[4]&&tab[8]==tab[4]) /*diagonale haut-gauche / bas-droite*/
                                            win=WIN;
                                        else if(tab[2]==tab[4]&&tab[6]==tab[4]) /*diagonale haut-droite / bas-gauche*/
                                            win=WIN;
                                    }
                                }
                            
                                /*test nulle*/
                                for(i=0;i<tablen;i++)
                                {
                                    if(tab[i]!='.')
                                        flag++;
                                }
                                if(flag==9)
                                    win=NUL;
                            
                                return win;
                            }
                            
                            void annonceWin(int flag, int joueurActuel)
                            {
                                if(flag==WIN)
                                    printf("Bravo, joueur %d a gagne !\n",joueurActuel);
                                else if(flag==NUL)
                                    printf("Partie nulle !\n");
                            }
                            


                            et fct.h :
                            #include <stdio.h>
                            #include <stdlib.h>
                            
                            #define NB_CASES 9
                            #define J1 1
                            #define J2 2
                            #define WIN 15
                            #define NUL 16
                            #define RIEN 17
                            
                            void InitJeu(char *tab, int tablen);
                            void AffGrille(char *tab, int tablen);
                            int recupCoup(void);
                            int testWinMoche(char *tab, int tablen, int dernierCoup);
                            void annonceWin(int flag, int joueurActuel);
                            
                            • Partager sur Facebook
                            • Partager sur Twitter
                              27 février 2011 à 10:53:01

                              quentin-fait-du-c> Merci pour ta participation. :)
                              Si la fonction ne prend aucun argument, il faudrait la déclarer prenant 'void' comme argument (int main(void))
                              Dans ta fonction AffGrille, tu pourrais éviter l'appel à sqrt et faire soi ta propre fonction sqrt prenant et retournant un int ou soit utiliser le modulo dans ta boucle
                              Ta boucle est quelque peu curieuse, pourquoi ne pas faire les calculs dans l'indice du tableau directement ? ça rendrait ton code plus clair :)
                              Je ne dis rien sur ta fonction recupCoup, tu la modifieras apparemment ^^
                              Pour ta gestion d'erreur, tu peux faire une fonction ou mettre ça dans une boucle, là c'est un peu bizarre
                              Je ne dis rien sur ta fonction testWinMoche non plus
                              Tu pourrais protéger ton header contre les inclusions infinies
                              Tu n'as pas besoin de stdio.h et stdlib.h dans ton header
                              Tu n'as pas besoin de stdlib.h dans aucun de tes fichiers
                              Les valeurs que tu as utilisé pour tes define sont quelque peu curieuses :-°
                              Ce que je te conseille, c'est d'utiliser des 0,1,2 pour ton tableau (qui correspondent à VIDE, J1, J2) et ne te préocuper des 'o' et cie uniquement dans ta fonction d'affichage. Ca te permettrait de rendre ton code un peu plus clair.
                              Tu pourrais utiliser des enum pour tes déclarations de constantes (rien ne t'y oblige)

                              PS : Moi j'aime bien et je m'y suis habitué. Après, chacun à son propre style d'indentation, ce qu'il y a c'est qu'il faut s'y tenir. :)
                              • Partager sur Facebook
                              • Partager sur Twitter
                                27 février 2011 à 12:29:48

                                Ola grand chef !

                                Citation : Pouet_forever

                                Si la fonction ne prend aucun argument, il faudrait la déclarer prenant 'void' comme argument (int main(void))


                                Ben ça c'est C::B qui me met cette forme automatiquement. Je vais supprimer ça de suite.

                                Citation : Pouet_forever

                                Dans ta fonction AffGrille, tu pourrais éviter l'appel à sqrt et faire soi ta propre fonction sqrt prenant et retournant un int ou soit utiliser le modulo dans ta boucle


                                Ou alors je peux faire comme toi et faire une série de #define qui calculeront les valeurs. Je trouve ça bien plus simple ^^

                                Citation : Pouet_forever

                                Ta boucle est quelque peu curieuse, pourquoi ne pas faire les calculs dans l'indice du tableau directement ? ça rendrait ton code plus clair


                                Euh ^^ parce que je ne maitrise pas les trucs de la forme tab[i++]=... et que donc j'ai pas envie de faire d'erreur que je ne saurais pas débugger ^^ Pour changer ça, il va me falloir un coup de main !

                                Citation : Pouet_forever

                                Pour ta gestion d'erreur, tu peux faire une fonction ou mettre ça dans une boucle, là c'est un peu bizarre


                                Bonne idée je vais essayer de faire ça dans un fonction ^^ En théorie ça devrait pas me poser de problème.

                                Citation : Pouet_forever

                                Les valeurs que tu as utilisé pour tes define sont quelque peu curieuses :-°
                                Ce que je te conseille, c'est d'utiliser des 0,1,2 pour ton tableau (qui correspondent à VIDE, J1, J2) et ne te préocuper des 'o' et cie uniquement dans ta fonction d'affichage. Ca te permettrait de rendre ton code un peu plus clair.
                                Tu pourrais utiliser des enum pour tes déclarations de constantes (rien ne t'y oblige)


                                Ben ça c'est des valeurs au pif comme qui dirait ^^ Je vais modifier ça. Pour les enum, j'aime pas trop ça ^^ les defines permettent de maitriser la valeur et de faire des debuggages (plus) facilement.
                                Je vais essayer de remplacer tous les caractères dans le code par leur code et de faire vraiment l'interface algo / affichage.

                                EDIT : Au final, comme c'est déjà débuggé et que ça fonctionne (sauf si j'ai pas tout testé), j'ai remplacé par 2 enum et j'ai pris les dimensions d'un carré par calcul à partir de la taille du coté. Voilà ^^
                                Me reste plus qu'à faire une fonction testWin -PAS MOCHE-, mais ça c'est un sacré problème.

                                Je voudrais que la fonction regarde la ligne, la colonne, et la diagonale (le cas échéant) du dernier coup joué pour tester un alignement. Sauf que si je joue sur les cases 1, 4, 7, 8, 9 (du pavé numérique), pas de problème. Pour les autres, il va falloir que je décrémente l'indice à un moment et pour ça, je ne sais pas comment faire. Il me faudrait un algo qui tue !
                                Un ptit coup de main? :D
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  28 février 2011 à 23:45:17

                                  Bonsoir à tous, désolé pour le double post mais je me permet de demander un coup de main.

                                  Suite aux explications de Pouet_forever, j'ai essayé de faire un code avec sa méthode dans mon contexte ^^
                                  J'ai juste pas repris le principe des double boucles, je trouve que c'est plus lisible comme ça. Cette fonction testWin m'aura donné du mal...

                                  Sauf que là, j'ai un sacré problème !
                                  J'ai une des 4 fonctions qui délire (verifHor Ver Diag1 et Diag2), car à part 3 pauvres cases, les coups sont gagnants à chaque fois. Il y a donc un problème d'algo. Moi, ça fait 1h30 que je cherche et je commence a vraiment avoir besoin de ma pause clope :s Je me suis donc décidé à poster ici mon code.

                                  Je ne met que la partie testWin pour ne pas vous surcharger inutilement, ce qu'il y a à savoir :
                                  - ma grille est un grille[GRILLE_H] qui est converti en (x;y) par les deux fonctions XYEnLin() et LinEnXY().
                                  - la fonction renvoie le flag `win' qui vaut RIEN, WIN ou NUL, et une autre fonction agit en conséquence.

                                  voilà le code :
                                  int testWin(int *grille, int dernierCoup)
                                  {
                                      int win=RIEN, flag_hor=RIEN, flag_ver=RIEN, flag_diag1=RIEN,
                                                    flag_diag2=RIEN, flag_nul=RIEN;
                                      int x=0, y=0;
                                  
                                      /*conversion en coordonnées X Y*/
                                      LinEnXY(&x,&y,dernierCoup-1); /*le -1 est nécessaire pour correspondre
                                                                      aux indices du tableau*/
                                      /*calcul horizontal*/
                                      flag_hor=verifHor(grille,dernierCoup);
                                  
                                      /*calcul vertical*/
                                      flag_ver=verifVer(grille,dernierCoup);
                                  
                                      /*diag haut gauche - bas droite*/
                                      if(x==y)
                                          flag_diag1=verifDiag1(grille,dernierCoup);
                                  
                                      /*diag haut droite - bas gauche*/
                                      if((x+y)==(GRILLE_H-1))
                                          flag_diag2=verifDiag2(grille,dernierCoup);
                                  
                                      flag_nul=testNul(grille);
                                  
                                      if((flag_hor==WIN || flag_ver==WIN || flag_diag1==WIN 
                                          || flag_diag2==WIN) && flag_nul==RIEN)
                                          win=WIN;
                                      else if(flag_nul==NUL)
                                          win=NUL;
                                  
                                      return win;
                                  }
                                  
                                  void LinEnXY(int *x, int *y, int coup)
                                  {
                                      *x=coup%GRILLE_H;
                                      *y=coup/GRILLE_H;
                                  }
                                  
                                  int XYEnLin(int x, int y)
                                  {
                                      return (x+(y*GRILLE_H));
                                  }
                                  
                                  int verifHor(int *grille, int dernierCoup)
                                  {
                                      int win=RIEN;
                                      int i=0, ligne=0, x=0, y=0;
                                  
                                      LinEnXY(&x,&y,dernierCoup);
                                  
                                      for(i=0;i<GRILLE_H;i++)
                                      {
                                          if(grille[XYEnLin(i,y)]==grille[XYEnLin(x,y)])
                                              ligne++;
                                      }
                                  
                                      if(ligne==GRILLE_H)
                                          win=WIN;
                                  
                                      return win;
                                  }
                                  
                                  int verifVer(int *grille, int dernierCoup)
                                  {
                                      int win=RIEN;
                                      int i=0, ligne=0, x=0, y=0;
                                  
                                      LinEnXY(&x,&y,dernierCoup);
                                  
                                      for(i=0;i<GRILLE_H;i++)
                                      {
                                          if(grille[XYEnLin(x,i)]==grille[XYEnLin(x,y)])
                                              ligne++;
                                      }
                                  
                                      if(ligne==GRILLE_H)
                                          win=WIN;
                                  
                                      return win;
                                  }
                                  
                                  int verifDiag1(int *grille, int dernierCoup)
                                  {
                                      int win=RIEN;
                                      int i=0, ligne=0, x=0, y=0;
                                  
                                      LinEnXY(&x,&y,dernierCoup);
                                  
                                      for(i=0;i<GRILLE_H;i++)
                                      {
                                          if(grille[XYEnLin(i,i)]==grille[XYEnLin(x,y)])
                                              ligne++;
                                      }
                                  
                                      if(ligne==GRILLE_H)
                                          win=WIN;
                                  
                                      return win;
                                  }
                                  
                                  int verifDiag2(int *grille, int dernierCoup)
                                  {
                                      int win=RIEN;
                                      int i=0, ligne=0, x=0, y=0;
                                  
                                      LinEnXY(&x,&y,dernierCoup);
                                  
                                      for(i=0;i<GRILLE_H;i++)
                                      {
                                          if(grille[XYEnLin(GRILLE_H-i-1,i)]==grille[XYEnLin(x,y)])
                                              ligne++;
                                      }
                                  
                                      if(ligne==GRILLE_H)
                                          win=WIN;
                                  
                                      return win;
                                  }
                                  
                                  int testNul(int *grille)
                                  {
                                      int i=0;
                                  
                                      for(i=0;i<NB_CASES;i++)
                                      {
                                          if(grille[i]==VIDE)
                                              return RIEN;
                                      }
                                  
                                      return NUL;
                                  }
                                  


                                  Si il manque des informations, j'éditerais à votre demande. Si l'erreur est trop bête, pardonnez-moi à l'avance :(
                                  Merci à vous :)
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    7 mars 2011 à 16:15:50

                                    Désolé quentin, je n'avais pas vu ton post. :(
                                    Je pense que pour toutes tes questions, je t'ai répondu en MP. :)
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      23 mai 2011 à 12:57:20

                                      Bonjour, tout le monde!
                                      Je suis débutant, et du coup, je pense avoir fait une faute dans mon code, mais je ne vois pas laquelle... En effet, , d'un coup à l'autre, la grille ne se modifie pas!
                                      Alors, si quelqu'un avait une idée...


                                      voilà mes trois fichiers:

                                      le main:
                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      #include <time.h>
                                      #include <ctype.h>
                                      #include <math.h>
                                      #include "fonction.h"
                                      #define NOMBRE_DE_POINTS 9
                                      
                                      
                                      int main()
                                      {
                                          int continuer=1;
                                          while (continuer)
                                          {
                                          int quelJoueur=0, i=0, choixCase=0;
                                          const int MAX=2, MIN=1;
                                          int quelsPointsOntEteMis[NOMBRE_DE_POINTS]={0};//tableau pour savoir qui a joué quoi
                                      
                                          srand(time(NULL));
                                          quelJoueur=(rand()%(MAX - MIN + 1)) + MIN;
                                          printf("\tBienvenue dans le jeu de Morpion!\n\t\t*** par Clement ***\n\n\n");
                                      
                                          i=0;
                                          do
                                          {
                                              i++;
                                              jouer (&quelJoueur);
                                              affichage(quelsPointsOntEteMis);
                                              choixCase=saisie();
                                      
                                              if (testerCoup(choixCase, quelsPointsOntEteMis))
                                              {
                                                  jouerCoup(&quelsPointsOntEteMis[NOMBRE_DE_POINTS], choixCase, quelJoueur);// à définir dans fonction.c
                                              }
                                              else
                                              {
                                                  int j=0;
                                                  while (j==0)
                                                  {
                                                      printf ("\n\nCette selection n'est pas valide, veuillez recommencer.\n\n");
                                                      choixCase=saisie();
                                                      j=testerCoup(choixCase, quelsPointsOntEteMis);
                                                      printf("%d", j);//probleme, il ne le fait pas
                                                  }
                                                  jouerCoup(quelsPointsOntEteMis[NOMBRE_DE_POINTS], choixCase, quelJoueur);
                                              }
                                      
                                              printf("%d", i);
                                      
                                          }while (i<NOMBRE_DE_POINTS && !testerGagnant(quelsPointsOntEteMis));
                                      
                                      
                                          if (testerGagnant(quelsPointsOntEteMis)==1)
                                              printf("\n\nBravo, joueur %d, vous avez gagne!!!", quelJoueur);
                                          else
                                              printf("\n\nEGALITE");
                                          printf("\n\nVoulez-vous recommencer?\n\n1 oui\n2 non\n");
                                          scanf("%d", &continuer);
                                          }
                                      
                                      
                                          return 0;
                                      }
                                      


                                      le .c annexe:
                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      #include <time.h>
                                      #include <ctype.h>
                                      #include <math.h>
                                      #include "fonction.h"
                                      #define NOMBRE_DE_POINTS 9
                                      
                                      void jouer(int *quelJoueur)
                                      {
                                          *quelJoueur=3-*quelJoueur;
                                          printf("\n\nC'est a joueur %d de jouer\n\n", *quelJoueur);
                                      }
                                      
                                      void affichage(int quelsPointsOntEteMis[])
                                      {
                                          int i=0;
                                          int racine=0;
                                          for (i=0; i<NOMBRE_DE_POINTS; i++)
                                          {
                                              if (quelsPointsOntEteMis[i]==0)
                                                  printf(". ");
                                              else if (quelsPointsOntEteMis[i]==1)
                                                  printf("X ");
                                              else if (quelsPointsOntEteMis[i]==2)
                                                  printf("O ");
                                              else
                                                  printf("erreur d'affichage");
                                      
                                              racine=sqrt(NOMBRE_DE_POINTS);
                                              if ((i+1)%racine==0)
                                                  printf("\n");
                                          }
                                      }
                                      
                                      int saisie()
                                      {
                                          int choixCase=0;
                                          printf("\nPour jouer, veuillez entrer un nombre entier naturel entre 1 et 9 inclus. Celui-ci correspodra a une case de la grille ; il vous suffit de compter les points de gauche a droite :");
                                          scanf ("%d", &choixCase);
                                          return choixCase;
                                      
                                      }
                                      
                                      int testerCoup(int choixCase, int quelsPointsOntEteMis[])
                                      {
                                          int i;
                                          if (quelsPointsOntEteMis[choixCase]==0 && choixCase<=NOMBRE_DE_POINTS && choixCase > 0)
                                              i=1;
                                          else
                                              i=0;
                                      
                                          return i;
                                      }
                                      
                                      void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur)
                                      {
                                              quelsPointsOntEteMis[choixCase]=quelJoueur;
                                      }
                                      
                                      int testerGagnant(int quelsPointsOntEteMis[])
                                      {
                                          int resultat=0;
                                          if (quelsPointsOntEteMis[0]==1 && quelsPointsOntEteMis[1]==1 && quelsPointsOntEteMis[2]==1)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[3]==1 && quelsPointsOntEteMis[4]==1 && quelsPointsOntEteMis[5]==1)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[6]==1 && quelsPointsOntEteMis[7]==1 && quelsPointsOntEteMis[8]==1)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[0]==1 && quelsPointsOntEteMis[4]==1 && quelsPointsOntEteMis[8]==1)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[2]==1 && quelsPointsOntEteMis[4]==1 && quelsPointsOntEteMis[6]==1)
                                              resultat=1;
                                      
                                          if (quelsPointsOntEteMis[0]==2 && quelsPointsOntEteMis[1]==2 && quelsPointsOntEteMis[2]==2)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[3]==2 && quelsPointsOntEteMis[4]==2 && quelsPointsOntEteMis[5]==2)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[6]==2 && quelsPointsOntEteMis[7]==2 && quelsPointsOntEteMis[8]==2)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[0]==2 && quelsPointsOntEteMis[4]==2 && quelsPointsOntEteMis[8]==2)
                                              resultat=1;
                                          if (quelsPointsOntEteMis[2]==2 && quelsPointsOntEteMis[4]==2 && quelsPointsOntEteMis[6]==2)
                                              resultat=1;
                                          else
                                              resultat=0;
                                      
                                          return resultat;
                                      }
                                      




                                      et le haeder:
                                      #define NOMBRE_DE_POINTS 9
                                      
                                      void jouer(int* quelJoueur);
                                      
                                      void affichage(int quelsPointsOntEteMis[]);
                                      
                                      int saisie();
                                      
                                      int testerCoup(int choixCase, int quelsPointsOntEteMis[]);
                                      
                                      void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur);
                                      
                                      int testerGagnant(int quelsPointsOntEteMis[]);
                                      
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        24 mai 2011 à 21:39:01

                                        Bonsoir,

                                        je viens soumettre mon code pour l'exercice zMorp très très en retard :( .
                                        Sans plus tarder, le code:


                                        main.c
                                        #include <stdio.h>
                                        #include <stdlib.h>
                                        #include <time.h>
                                        
                                        #include "zmorp.h"
                                        
                                        int main(void){
                                            int premier = 0;
                                        
                                            srand(time(NULL));
                                            premier = rand() % 2 + 1;
                                        
                                            jouer(premier);
                                        
                                            return EXIT_SUCCESS;
                                        }
                                        

                                        zmorp.h
                                        #ifndef DEF_ZMORP
                                        #define DEF_ZMORP
                                        
                                        #define TAILLE_PLATEAU 9
                                        
                                        void jouer(int);
                                        void affichage(char*);
                                        int recupererSaisie(int);
                                        int testerCoup(char*, int);
                                        void jouerCoup(char*, int, int);
                                        int testerGagnant(char*, int);
                                        int nul(char*);
                                        
                                        #endif
                                        


                                        zmorp.c
                                        #include <stdio.h>
                                        #include <stdlib.h>
                                        
                                        #include "zmorp.h"
                                        
                                        void affichage(char * plateau){
                                            int i;
                                        
                                            putchar('\n');
                                        
                                            for(i = 0; plateau[i] != '\0'; i++){
                                                if(i != 0 && i % 3 == 0)
                                                    putchar('\n');
                                                printf("%c  ", plateau[i]);
                                            }
                                            putchar('\n');
                                        }
                                        
                                        int recupererSaisie(int numDuJoueur){
                                            int valeur = 0;
                                        
                                            printf("Joueur %d : ", numDuJoueur);
                                            scanf("%d", &valeur);
                                        
                                            return valeur;
                                        }
                                        
                                        int testerCoup(char * plateau, int coup){
                                            coup--;
                                        
                                            if(plateau[coup] == 'x' || plateau[coup] == 'o')
                                                return 0;
                                        
                                            return 1;
                                        }
                                        
                                        int nul(char * plateau){
                                            int i;
                                        
                                            for(i = 0; plateau[i] != '\0'; i++){
                                                if(plateau[i] == '.')
                                                    return 1;
                                            }
                                        
                                            printf("\nMatch nul !\n");
                                            return 0;
                                        }
                                        
                                        void jouerCoup(char * plateau, int position, int joueur){
                                            char joueur1 = 'o', joueur2 = 'x';
                                        
                                            position--;
                                        
                                            if(position >= 0){
                                                if(joueur == 1)
                                                    plateau[position] = joueur1;
                                                else
                                                    plateau[position] = joueur2;
                                            }
                                        }
                                        
                                        int testerGagnant(char * plateau, int joueur){
                                            char c;
                                        
                                            if(joueur == 1)
                                                c = 'o';
                                            else if(joueur == 2)
                                                c = 'x';
                                        
                                            if(   (plateau[0] == c && plateau[1] == c && plateau[2] == c)
                                               || (plateau[3] == c && plateau[4] == c && plateau[5] == c)
                                               || (plateau[6] == c && plateau[7] == c && plateau[8] == c)
                                               || (plateau[0] == c && plateau[3] == c && plateau[6] == c)
                                               || (plateau[1] == c && plateau[4] == c && plateau[7] == c)
                                               || (plateau[2] == c && plateau[5] == c && plateau[8] == c)
                                               || (plateau[0] == c && plateau[4] == c && plateau[8] == c)
                                               || (plateau[2] == c && plateau[4] == c && plateau[6] == c))
                                                return 1;
                                        
                                            else
                                                return 0;
                                        }
                                        
                                        void jouer(int premierJoueur){
                                            char plateau[TAILLE_PLATEAU + 1] = ".........";
                                            int joueurActuel = 0, saisie;
                                        
                                            printf("C'est le joueur %d qui commence !\n", premierJoueur);
                                        
                                            joueurActuel = premierJoueur;
                                        
                                            do{
                                                saisie = recupererSaisie(joueurActuel);
                                                if(testerCoup(plateau, saisie)){
                                                    jouerCoup(plateau, saisie, joueurActuel);
                                                }else{
                                                    do{
                                                        printf("Coup non valide : Recommoncez\n");
                                                        saisie = recupererSaisie(joueurActuel);
                                                    }while(testerCoup(plateau, saisie) == 0);
                                        
                                                    jouerCoup(plateau, saisie, joueurActuel);
                                                }
                                        
                                                affichage(plateau);
                                        
                                                if(testerGagnant(plateau, joueurActuel)){
                                                    printf("Le joueur %d a gagne!", joueurActuel);
                                                    break;
                                                }
                                        
                                                if(joueurActuel == 1)
                                                    joueurActuel = 2;
                                                else if(joueurActuel == 2)
                                                    joueurActuel = 1;
                                        
                                            }while(testerGagnant(plateau, joueurActuel) == 0 && nul(plateau));
                                        }
                                        


                                        N'hésitez pas d'apporter vos conseils sur mon code et surtout sur ma façon de coder :)

                                        Perso je trouve la fonction jouer trop longue :-°

                                        Merci ;)
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          25 mai 2011 à 19:47:24

                                          Capricornus > Ton erreur doit être au niveau de la ligne 45 du fichier main.c (ton appel de fonction est faux). :)

                                          Quelques remarques rapides :
                                          Tu déclares plusieurs fois NOMBRE_DE_POINTS
                                          Tu ne protèges pas ton header contre l'inclusion infinie
                                          Tu appelles srand plusieurs fois dans ton programme (dans la boucle principale), il faudrait l'appeler qu'une seule fois
                                          quelJoueur=(rand()%(MAX - MIN + 1)) + MIN; >> A vrai dire, un simple rand()%2 + 1 suffit pas besoin de faire compliqué !
                                          Dans ta fonction 'jouer' tu modifies le joueur et tu affiches le joueur, ce n'est pas trop ce qu'on attendrait de cette fonction. :-°
                                          L'utilisation de racine=sqrt(NOMBRE_DE_POINTS); est couteuse et inutile, il serait plus judicieux de déclarer une variable qui contient le nombre de lignes/colonnes :)
                                          Les fonctions qui ne prennent pas de paramètres devraient avoir 'void' (ex. : int main(void))
                                          Dans 'testerCoup' tu fais : if (quelsPointsOntEteMis[choixCase]==0 && choixCase<=NOMBRE_DE_POINTS && choixCase > 0) tu devrais faire l'inverse, là tu testes la case et ensuite si tu es dans les bornes, il faudrait d'abord tester les bornes et ensuite vérifier la grille !
                                          Si l'utilisateur entre une entrée invalide, tu réécris quelque chose que tu as déjà écrit dans la fonction, tu peux simplifier !
                                          Le 'else' dans ta fonction testerGagnant (vers la fin) ne sert à rien. Je pense qu'il ne fait pas non plus ce que tu penses (il est 'valide' qu'avec le dernier if et non tous les autres)

                                          Dans l'ensemble c'est pas trop mal. :)

                                          LeBri@n > Dans ta fonction 'jouer', tu fais un tableau de TAILLE_PLATEAU+1 et tu l'initialises avec une chaîne, mais qu'est-ce qui se passe si je change la valeur de TAILLE_PLATEAU ? :lol:
                                          Dans ta fonction 'testerCoup' tu ne testes pas les bornes de 'coup' (tu le teste dans ta fonction jouerCoup, tu devrais le faire dans testerCoup)
                                          Dans ta fonction 'jouer' tu fais une 2ème boucle si l'utilisateur a entré un coup non valide, tu peux simplifier
                                          Dans ta fonction affichage, tu fais un %3, mais si tu changes la taille de ton tableau, ça ne fonctionnera plus ^^
                                          Tu appelles 2 fois ta fonction testerGagnant par boucle (une fois dans le if et une fois dans le while)

                                          Dans l'ensemble c'est correct. Maintenant, tu pourrais améliorer ton code pour qu'il soit plus évolutif (genre modifier la taille de la grille). ;)
                                          Et éventuellement d'autres choses (genre si je veux modifier les signes des joueurs, je dois le faire dans plusieurs fonctions).



                                          Merci de votre participation ! :)
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            2 juin 2011 à 10:34:30

                                            coucou :)

                                            je suis vraiment débutant et quand je vois vos codes... :-°

                                            mais bon je m'y suis mis quand même ;)
                                            je pense que mon code peut être énormément simplifié mais je ne vais pas trop m'attarder dessus

                                            je le poste :
                                            #include <stdio.h>
                                            #include <stdlib.h>
                                            #include <time.h>
                                            #include "main.h"
                                            #define MIN 1
                                            #define MAX 2
                                            #define ligne printf("\n");
                                            
                                            // joueur 1 = CROIX
                                            // joueur 2 = ROND
                                            
                                            enum{MATCHNULL, JOUEUR1, JOUEUR2, CROIX, ROND, VIDE, OK, VIDE, RIE/*inutile*/};
                                            
                                            int fin = 1, gagnant, coup, joueur, emplacement[9];
                                            
                                            int main()
                                            {
                                            	jouer();
                                            	return 0;
                                            }
                                            
                                            void initEmplacement()
                                            {
                                                int i;
                                                for (i = 0 ; i < 9 ; i++) emplacement[i] = VIDE;
                                            }
                                            
                                            void jouer()
                                            {
                                                initEmplacement();
                                                srand(time(NULL));
                                                joueur = (rand() % (MAX - MIN + 1)) + MIN;
                                                printf("Joueur %d commence !\n", joueur);
                                                affichage();
                                                while (fin)
                                                {
                                                    saisie();
                                                    if (testerCoup() != OK)
                                                    {
                                                        printf("Vous ne pouvez pas jouer ce coup.\n");
                                                        continue;
                                                    }
                                                    jouerCoup();
                                                    testerGagnant();
                                                    affichage();
                                                    changementJoueur();
                                                }
                                            }
                                            
                                            void affichage()
                                            {
                                                int i, onRevient = 1;
                                                ligne
                                                for (i = 0 ; i < 9 ; i++, onRevient++)
                                                {
                                                    if (emplacement[i] == CROIX) printf("X ");
                                                    else if(emplacement[i] == ROND) printf("O ");
                                                    else printf(". ");
                                                    if (onRevient ==  3)
                                                    {
                                                        onRevient = 0;
                                                        ligne
                                                    }
                                                }
                                                ligne
                                            }
                                            
                                            void saisie()
                                            {
                                                printf("Joueur %d : ", joueur);
                                                scanf("%d", &coup);
                                                coup -= 1;
                                                ligne
                                            }
                                            
                                            int testerCoup()
                                            {
                                                if (coup > 9) return RIEN;
                                                else if (emplacement[coup] == VIDE) return OK;
                                                else return RIEN;
                                            }
                                            
                                            void jouerCoup()
                                            {
                                                if (joueur == 1) emplacement[coup] = CROIX;
                                                if (joueur == 2) emplacement[coup] = ROND;
                                            }
                                            
                                            void testerGagnant()
                                            {
                                                int i, test = CROIX, joueurno = 1;
                                                for (i = 0 ; i < 2 ; i++, test == ROND, joueurno++)
                                                {
                                                    if ((emplacement[0] == test && emplacement[1] == test && emplacement[2] == test) ||
                                                        (emplacement[2] == test && emplacement[5] == test && emplacement[8] == test) ||
                                                        (emplacement[8] == test && emplacement[7] == test && emplacement[6] == test) ||
                                                        (emplacement[6] == test && emplacement[3] == test && emplacement[0] == test) ||
                                                        (emplacement[0] == test && emplacement[4] == test && emplacement[8] == test) ||
                                                        (emplacement[2] == test && emplacement[4] == test && emplacement[6] == test) ||
                                                        (emplacement[1] == test && emplacement[4] == test && emplacement[7] == test) ||
                                                        (emplacement[3] == test && emplacement[4] == test && emplacement[5] == test))
                                                    {
                                                        printf("\n\nLe joueur %d a gagne ! ! ! !\n", joueurno);
                                                        fin = 0;
                                                    }
                                                }
                                            }
                                            
                                            void changementJoueur()
                                            {
                                                if (joueur == 1) joueur = 2;
                                                else joueur = 1;
                                            }
                                            

                                            il y a un bug car joueur 0 ne peut gagner que si joueur 1 a gagné plus maintenant
                                            et je n'ai pas fait de match null (pas encore ;) )

                                            EDIT: je n'aime vraiment pas ma fonction testerGagnant
                                            si je veux augmenter la taille de mon plateau... bonjour le nombre de lignes ! :lol:
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              13 juin 2011 à 22:51:39

                                              Bonjour ,voici le code que j'ai fais, il marche mais contient certainement des erreurs qui pourrait permettre de le rendre plus performant ...

                                              #include <stdio.h>
                                              #include <stdlib.h>
                                              #include <time.h>
                                              
                                              void affiche (int *tableau [], int tailleTableau);
                                              int reception (int joueur);
                                              void testCoup (int i, int *grille [], int *joueur);
                                              void coupGagnant (int *gameOver, int *grille[], int joueur);
                                              void grilleRemplit (int *grille [], int *gameOver);
                                              void changementJoueur (int *joueur);
                                              
                                              int main()
                                              {
                                                  int gameOver = 0, joueur = 0, entre = 0;
                                                  srand(time(NULL));
                                                  joueur = rand() % 2 + 1;
                                                  printf("Le joueur 1 a les pions X\nLe joueur 2 a les pions O\n\n");
                                                  printf("Joueur %d commence !\n\n", joueur);
                                                  int tableauCase [9] = {'.', '.','.','.','.','.','.','.','.'},TailleTableau = 9;
                                                  affiche(tableauCase, TailleTableau);
                                                  do
                                                  {
                                                      entre =  reception(joueur);
                                                      testCoup(entre, tableauCase, &joueur);
                                                      affiche(tableauCase, TailleTableau);
                                                      coupGagnant(&gameOver, tableauCase, joueur);
                                                      if (gameOver != 1)
                                                      {
                                                          grilleRemplit(tableauCase, &gameOver);
                                                      }
                                                      changementJoueur(&joueur);
                                              
                                              
                                              
                                                  } while ( gameOver != 1);
                                              
                                                  printf("Game Over !!\n\n");
                                              
                                                  return 0;
                                              }
                                              
                                              
                                              void affiche (int *tableau [],int tailleTableau)
                                              {
                                                  int i = 0, j = 0;
                                                  for (i = 0 ; i < 9 ; i++)
                                                  {
                                                      printf("%c  ", tableau [i]);
                                                      j++;
                                                      if (j == 3)
                                                      {
                                                          printf("\n\n");
                                                          j = 0;
                                                      }
                                                  }
                                                  printf("\n");
                                              }
                                              
                                              int reception (int joueur)
                                              {
                                                  int varReception = 0;
                                                  while (varReception < 1 || varReception > 9)
                                                  {
                                                      printf("Joueur %d : ", joueur);
                                                      scanf("%d", &varReception);
                                                      printf("\n");
                                                  }
                                              
                                                  varReception--;
                                                  return varReception;
                                              }
                                              
                                              
                                              void testCoup (int i, int *grille [], int *joueur)
                                              {
                                                  if ( grille [i] == '.')
                                                  {
                                                      if (*joueur == 1)
                                                      {
                                                          grille [i] = 'X';
                                                      }
                                                      else
                                                      {
                                                          grille [i] = 'O';
                                                      }
                                                  }
                                                  else
                                                  {
                                                      printf("Coup impossible\n\n");
                                                  }
                                              
                                              }
                                              
                                              
                                              void coupGagnant (int *gameOver, int *grille[], int joueur)
                                              {
                                                  if ((grille[0] == grille[1] && grille[0] == grille[2] && grille[0] != '.')||
                                                      (grille[3] == grille[4] && grille[3] == grille[5] && grille[3] != '.') ||
                                                      (grille[6] == grille[7] && grille[6] == grille[8] && grille[6] != '.') ||
                                                      (grille[0] == grille[3] && grille[0] == grille[6] && grille[0] != '.') ||
                                                      (grille[1] == grille[4] && grille[1] == grille[7] && grille[1] != '.') ||
                                                      (grille[2] == grille[5] && grille[2] == grille[8] && grille[2] != '.') ||
                                                      (grille[0] == grille[4] && grille[0] == grille[8] && grille[0] != '.') ||
                                                      (grille[2] == grille[4] && grille[2] == grille[6] && grille[2] != '.'))
                                                  {
                                                      *gameOver = 1;
                                                      printf("Joueur %d gagne !\n\n", joueur);
                                                  }
                                              }
                                              
                                              
                                              void grilleRemplit (int *grille [], int *gameOver)
                                              {
                                                  int i = 0, j = 0;
                                                  for (i = 0 ; i < 9 ; i++)
                                                  {
                                                      if (grille [i] != '.')
                                                      {
                                                          j++;
                                                      }
                                                  }
                                                  if (j == 9)
                                                  {
                                                      *gameOver = 1;
                                                      printf("Egalite parfaite !!\n\n");
                                                  }
                                              
                                              
                                              }
                                              
                                              void changementJoueur (int *joueur)
                                              {
                                                  if (*joueur == 1)
                                                  {
                                                      *joueur = 2;
                                                  }
                                                  else
                                                  {
                                                      *joueur = 1;
                                                  }
                                              }
                                              
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                13 juin 2011 à 23:02:31

                                                Endorion >
                                                Le prototype de ta fonction 'affiche' est faux, tableau est un tableau et non un pointeur de pointeur. :)
                                                Le prototype aurait dû être : void affiche (int * tableau,int tailleTableau)
                                                Tu pourrais utiliser un double boucle dans ta fonction affiche
                                                Le prototype de ta fonction testCoup est faux pour les mêmes raisons citées plus haut
                                                Pareil pour coupGagnant et grilleRemplit
                                                Si tu entres 2 fois le même coup, ça t'affiches 'Coup impossible' mais ça change quand même de joueur
                                                Dans ta fonction coupGagant, tu testes la grille, tu devrais tester le joueur courant (ça ne devrait pas arriver normalement, rien de faux dans ton code)
                                                Pour savoir si tu as gagné ou égalité, tu devrais faire ça dans une fonction et non dans plusieurs fonctions différentes

                                                Dans l'ensemble, c'est correct, merci pour ta participation. :)
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  14 juin 2011 à 17:04:17

                                                  Oups en effet j'avais pas vu que j'ai fais la faute un peu partout :o
                                                  J'ai rectifier donc tous les prototypes & fonctions , j'ai aussi changer le bug du "coup impossible", je peux rectifier les autres problèmes aussi mais sa fais trop brouillon et code bidoullié :-° ce qui ne me plait pas trop ...

                                                  Il faudrait que je recommence sur un nouveau "plan"

                                                  Moi qui avait prévu d'avancer un peu dans le cours je vais me re-pencher sur la question :euh:


                                                  ÉDIT : voila le résultat après une reprise du sujet , le code marche et sans bug apparent ( enfin peut-être que je ne suis pas allée fouiné assez loin)
                                                  les changements sont :
                                                  _ rectifications des prototypes ( avec changement des noms pour la plupars des fonctions et variables ( j'ai tout repris de zéro ))
                                                  _ Utilisation ( ou du moin tentative ) d'affichage avec la double boucle comme tu m'a dis ( je sais pas si c'est ce que tu avait en tête mais moi j'ai pensé a un truc comme ça )
                                                  _ Réparation du bug "Coup impossible"
                                                  _ la décision entre égalité et égale est dorénavant dans la même fonction.

                                                  En esperant ne pas avoir fais d'autre erreurs ( je pense qu'il y en a que je n'ais pas vu ;) )

                                                  #include <stdio.h>
                                                  #include <stdlib.h>
                                                  #include <time.h>
                                                  
                                                  void afficherGrille (int *grille);
                                                  int ReceptionCoup (int joueur, int *grille);
                                                  int TestCoup (int i, int *grille);
                                                  void jouerCoup (int coup, int *grille, int joueur);
                                                  void changementJoueur (int *joueur);
                                                  void etatGrille (int *gameOver , int *grille, int joueur);
                                                  
                                                  int main()
                                                  {
                                                      int grilleDeJeu [9] = {'.', '.','.','.','.','.','.','.','.'}, joueur = 0, gameOver = 0, coupJouer = 0;
                                                      srand(time(NULL));
                                                      joueur = rand() % 2 + 1;
                                                      printf("Le joueur 1 a les pions X\nLe joueur 2 a les pions O\n\n");
                                                      printf("Joueur %d commence !\n\n", joueur);
                                                      afficherGrille(grilleDeJeu);
                                                      do
                                                      {
                                                          coupJouer = ReceptionCoup(joueur, grilleDeJeu);
                                                          jouerCoup(coupJouer, grilleDeJeu, joueur);
                                                          afficherGrille(grilleDeJeu);
                                                          etatGrille(&gameOver, grilleDeJeu, joueur);
                                                          changementJoueur(&joueur);
                                                  
                                                      } while ( gameOver != 1);
                                                  
                                                      return 0;
                                                  }
                                                  
                                                  
                                                  void afficherGrille (int *grille)
                                                  {
                                                      int i = 0,j = 0;
                                                      for (i = 0 ; i < 3 ; i++)
                                                      {
                                                          for (j = (i * 3) ; j < (3 + i * 3 ); j++)
                                                          {
                                                              printf(" %c ", grille[j]);
                                                          }
                                                          printf("\n\n");
                                                      }
                                                  }
                                                  
                                                  int ReceptionCoup (int joueur, int *grille)
                                                  {
                                                      int reception = 0, bonneEntre = 0;
                                                      while (bonneEntre != 1)
                                                      {
                                                          printf("Joueur %d : ", joueur);
                                                          scanf("%d", &reception);
                                                          printf("\n");
                                                          if (reception > 0 && reception < 10)
                                                          {
                                                              reception--;
                                                              bonneEntre = TestCoup(reception, grille);
                                                          }
                                                          else
                                                          {
                                                              printf("Coup impossible \n\n");
                                                          }
                                                      }
                                                  
                                                      return reception;
                                                  }
                                                  
                                                  int TestCoup (int i, int *grille)
                                                  {
                                                      int test = 0;
                                                      if (grille[i] == '.')
                                                      {
                                                          test = 1;
                                                      }
                                                      else
                                                      {
                                                          printf("Coup impossible \n\n");
                                                      }
                                                      return test;
                                                  }
                                                  
                                                  void jouerCoup (int coup, int *grille, int joueur)
                                                  {
                                                      if (joueur == 1)
                                                      {
                                                          grille[coup] = 'X';
                                                      }
                                                      else
                                                      {
                                                          grille[coup] = 'O';
                                                      }
                                                  }
                                                  
                                                  void changementJoueur (int *joueur)
                                                  {
                                                      if (*joueur == 1)
                                                      {
                                                          *joueur = 2;
                                                      }
                                                      else
                                                      {
                                                          *joueur = 1;
                                                      }
                                                  }
                                                  
                                                  void etatGrille (int *gameOver , int *grille, int joueur)
                                                  {
                                                      if ((grille[0] == grille[1] && grille[0] == grille[2] && grille[0] != '.')||
                                                          (grille[3] == grille[4] && grille[3] == grille[5] && grille[3] != '.') ||
                                                          (grille[6] == grille[7] && grille[6] == grille[8] && grille[6] != '.') ||
                                                          (grille[0] == grille[3] && grille[0] == grille[6] && grille[0] != '.') ||
                                                          (grille[1] == grille[4] && grille[1] == grille[7] && grille[1] != '.') ||
                                                          (grille[2] == grille[5] && grille[2] == grille[8] && grille[2] != '.') ||
                                                          (grille[0] == grille[4] && grille[0] == grille[8] && grille[0] != '.') ||
                                                          (grille[2] == grille[4] && grille[2] == grille[6] && grille[2] != '.'))
                                                      {
                                                          *gameOver = 1;
                                                          printf("Joueur %d gagne !\n\n", joueur);
                                                      }
                                                      else
                                                      {
                                                          int i = 0, j = 0;
                                                          for (i = 0 ; i < 9 ; i++)
                                                          {
                                                              if (grille [i] != '.')
                                                              {
                                                                  j++;
                                                              }
                                                          }
                                                          if (j == 9)
                                                          {
                                                              *gameOver = 1;
                                                              printf("Egalite parfaite !!\n\n");
                                                          }
                                                      }
                                                  }
                                                  
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    14 juin 2011 à 19:42:43

                                                    De loin, comme ça, ça m'a l'air correct. Bravo ! :)
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      17 juin 2011 à 23:14:40

                                                      Déjà fait, mais c'est plus pour windows et stylisé...


                                                      main.c
                                                      #include "definitions.h"
                                                      #include "gestion.h"
                                                      #include "saisie.h"
                                                      #include "ia.h"
                                                      
                                                      int main(int argc, char *argv[]) {
                                                      	int menu = 0, i;
                                                      	int continuer = 1;
                                                      	
                                                      	initNbAleatoire();
                                                      	title();
                                                      
                                                      	while(continuer){
                                                      	
                                                      	clearScreen();
                                                      	titre();
                                                      	printf("\t1. 1 Joueurs\n");
                                                      	printf("\t2. 2 Joueurs\n");
                                                      	printf("\t3. Instructions\n");
                                                      	printf("\t4. Cr%cdits\n", -126);
                                                      	printf("\t5. Quitter\n");
                                                      
                                                      	#ifdef __WIN32__
                                                      		menu = (int)getch();
                                                      	#else
                                                      		menu = (int)getchar();
                                                      		viderBuffer();
                                                      	#endif
                                                      		
                                                      	switch(menu){
                                                      		case '1':
                                                      			jouer1j();
                                                      			break;
                                                      		case '2':
                                                      			jouer2j();
                                                      			break;
                                                      		case '3':
                                                      			instructions();
                                                      			break;
                                                      		case '4':
                                                      			credit();
                                                      			break;
                                                      		case '5':
                                                      			continuer = 0;
                                                      			break;
                                                      	}
                                                      
                                                      	}
                                                      			
                                                      	
                                                      
                                                      }
                                                      


                                                      ia.c
                                                      #include "ia.h"
                                                      
                                                      void chooseCase(char grille[3][3])
                                                      {
                                                      	int tmpL = 0;
                                                      	int tmpC = 0;
                                                      	int i = 0;
                                                      
                                                      	/* On vérifie si le joueur peut gagner pour le bloquer */
                                                      
                                                      	while(1)
                                                      	{
                                                      		      
                                                      		/* En colonnes */
                                                      	for(i=0; i < 3; i++)
                                                      	{
                                                      		if(grille[1][i] == 'x')        //  o
                                                      		{                              //  x
                                                      			if(grille[2][i] == 'x')    //  x
                                                      			{                   
                                                      				if(grille[0][i] == ' ')
                                                      				{
                                                      					grille[0][i] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      		else if(grille[0][i] == 'x')   //  x
                                                      		{                              //  o
                                                      			if(grille[2][i] == 'x')    //  x
                                                      			{                    
                                                      				if(grille[1][i] == ' ')
                                                      				{
                                                      					grille[1][i] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      		else if(grille[0][i] == 'x')   //  x
                                                      		{                              //  x
                                                      			if(grille[1][i] == 'x')    //  o
                                                      			{                         
                                                      				if(grille[2][i] == ' ')
                                                      				{
                                                      					grille[2][i] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      	}
                                                      
                                                      		/* En lignes */
                                                      
                                                      	for(i = 0; i < 3; i++)
                                                      	{
                                                      		if(grille[i][0] == 'x')        //  x x o
                                                      		{
                                                      			if(grille[i][1] == 'x')
                                                      			{
                                                      				if(grille[i][2] == ' ')
                                                      				{
                                                      					grille[i][2] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      		else if(grille[i][1] == 'x')   //  o x x
                                                      		{
                                                      			if(grille[i][2] == 'x')	
                                                      			{
                                                      				if(grille[i][0] == ' ')
                                                      				{
                                                      					grille[i][0] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      		else if(grille[i][0] == 'x')   //  x o x
                                                      		{
                                                      			if(grille[i][2] == 'x')
                                                      			{
                                                      				if(grille[i][1] == ' ')
                                                      				{
                                                      					grille[i][1] = 'o';
                                                      					return;
                                                      				}
                                                      				else
                                                      					return;
                                                      			}
                                                      		}
                                                      	}
                                                      	
                                                      		
                                                      		/* En diagonales */
                                                      	if(grille[0][0] == 'x')       //  x
                                                      	{                             //    x
                                                      		if(grille[1][1] == 'x')   //      o
                                                      		{
                                                      			if(grille[2][2] == ' ')
                                                      			{
                                                      				grille[2][2] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      	else if(grille[0][0] == 'x')  //  x
                                                      	{                             //    o
                                                      		if(grille[2][2] == 'x')   //      x
                                                      		{
                                                      			if(grille[1][1] == ' ')
                                                      			{
                                                      				grille[1][1] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      	else if(grille[1][1] == 'x')  //  o
                                                      	{                             //    x
                                                      		if(grille[2][2] == 'x')   //      x
                                                      		{
                                                      			if(grille[0][0] == ' ')
                                                      			{
                                                      				grille[0][0] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      
                                                      	if(grille[0][2] == 'x')       //      x
                                                      	{                             //    x
                                                      		if(grille[1][1] == 'x')   //  o
                                                      		{
                                                      			if(grille[2][0] == ' ')
                                                      			{
                                                      				grille[2][0] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      	if(grille[0][2] == 'x')       //      x
                                                      	{                             //    o
                                                      		if(grille[2][0] == 'x')   //  x
                                                      		{
                                                      			if(grille[1][1] == ' ')
                                                      			{
                                                      				grille[1][1] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      	if(grille[2][0] == 'x')       //      o
                                                      	{                             //    x
                                                      		if(grille[1][1] == 'x')   //  x
                                                      		{
                                                      			if(grille[0][2] == ' ')
                                                      			{
                                                      				grille[0][2] = 'o';
                                                      				return;
                                                      			}
                                                      			else
                                                      				return;
                                                      		}
                                                      	}
                                                      
                                                      
                                                      		tmpL = nbAleatoire(0, 2);
                                                      		tmpC = nbAleatoire(0, 2);
                                                      		if (grille[tmpC][tmpL] == ' ')
                                                      		{
                                                      			grille[tmpC][tmpL] = 'o';
                                                      			return;
                                                      		}
                                                      	}
                                                      
                                                      }
                                                      
                                                      void initNbAleatoire(void)
                                                      {
                                                      	srand(time(NULL));
                                                      }
                                                      
                                                      int nbAleatoire(int MIN, int MAX)
                                                      {
                                                      	return (rand() % (MAX - MIN + 1)) + MIN;
                                                      }
                                                      


                                                      gestion.c
                                                      #include "definitions.h"
                                                      
                                                      #include "gestion.h"
                                                      #include "saisie.h"
                                                      #include "ia.h"
                                                      #define MORPION_VERSION "2.1 (with first AI)"
                                                      
                                                      int gagne(char cases[3][3]) {
                                                      	int gagner = 0;
                                                      	
                                                      	
                                                      	/* Premier : # lignes # */
                                                      		
                                                      	if(cases[0][0] == 'x' && cases[0][1] == 'x' && cases[0][2] == 'x')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[0][0] == 'o' && cases[0][1] == 'o' && cases[0][2] == 'o')
                                                      		gagner = 2;
                                                      			
                                                      
                                                      	else if(cases[1][0] == 'o' && cases[1][1] == 'o' && cases[1][2] == 'o')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[1][0] == 'x' && cases[1][1] == 'x' && cases[1][2] == 'x')
                                                      		gagner = 2;
                                                      		
                                                      	else if(cases[2][0] == 'o' && cases[2][1] == 'o' && cases[2][2] == 'o')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[2][0] == 'x' && cases[2][1] == 'x' && cases[2][2] == 'x')
                                                      		gagner = 2;
                                                      	
                                                      	/* Second : # colonnes # */
                                                      		
                                                      	if(cases[0][0] == 'x' && cases[1][0] == 'x' && cases[2][0] == 'x')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[0][0] == 'o' && cases[1][0] == 'o' && cases[2][0] == 'o')
                                                      		gagner = 2;
                                                      			
                                                      
                                                      	else if(cases[0][1] == 'o' && cases[1][1] == 'o' && cases[2][1] == 'o')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[0][1] == 'x' && cases[1][1] == 'x' && cases[2][1] == 'x')
                                                      		gagner = 2;
                                                      		
                                                      	else if(cases[0][2] == 'o' && cases[1][2] == 'o' && cases[2][2] == 'o')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[0][2] == 'x' && cases[1][2] == 'x' && cases[2][2] == 'x')
                                                      		gagner = 2;
                                                      	
                                                      	/* Troisieme : # Diagonales # */
                                                      			
                                                      	else if(cases[0][0] == 'o' && cases[1][1] == 'o' && cases[2][2] == 'o')
                                                      		gagner = 1;
                                                      			
                                                      
                                                      	else if(cases[0][0] == 'x' && cases[1][1] == 'x' && cases[2][2] == 'x')
                                                      		gagner = 2;
                                                      		
                                                      	else if(cases[2][0] == 'o' && cases[1][1] == 'o' && cases[0][2] == 'o')
                                                      		gagner = 1;
                                                      	
                                                      
                                                      	else if(cases[2][0] == 'x' && cases[1][1] == 'x' && cases[0][2] == 'x')
                                                      		gagner = 2;
                                                      	
                                                      
                                                      	return gagner;
                                                      		
                                                      }
                                                      
                                                      void afficheGrille(char cases[3][3])
                                                      {
                                                      	#ifdef __WIN32__
                                                      	printf("\n         1     2     3\n");
                                                      	printf("      ÉÍÍÍÍÍËÍÍÍÍÍËÍÍÍÍÍ»\n");
                                                      	printf("    A º  %c  º  %c  º  %c  º\n", cases[0][0], cases[0][1] ,cases[0][2]);
                                                      	printf("      ÌÍÍÍÍÍÎÍÍÍÍÍÎÍÍÍÍ͹\n");
                                                      	printf("    B º  %c  º  %c  º  %c  º\n", cases[1][0], cases[1][1], cases[1][2]);
                                                      	printf("      ÌÍÍÍÍÍÎÍÍÍÍÍÎÍÍÍÍ͹\n");
                                                      	printf("    C º  %c  º  %c  º  %c  º\n", cases[2][0], cases[2][1], cases[2][2]);
                                                      	printf("      ÈÍÍÍÍÍÊÍÍÍÍÍÊÍÍÍÍͼ\n");
                                                      	#else
                                                      	printf("          1      2     3\n");
                                                      	printf("      +------+------+------+\n");
                                                      	printf("    A |  %c   |  %c   |  %c   |\n", cases[0][0], cases[0][1] ,cases[0][2]);
                                                      	printf("      +------+------+------+\n");
                                                      	printf("    B |  %c   |  %c   |  %c   |\n", cases[1][0], cases[1][1], cases[1][2]);
                                                      	printf("      +------+------+------+\n");
                                                      	printf("    C |  %c   |  %c   |  %c   |\n", cases[2][0], cases[2][1], cases[2][2]);
                                                      	printf("      +------+------+------+\n");
                                                      	#endif
                                                      }
                                                      
                                                      int jouer1j(void)
                                                      {
                                                      	char cases[3][3];
                                                      	char j1[MAXCARACTERENOM] = {0}, j2[MAXCARACTERENOM] = {0};
                                                      	int i=0;
                                                      	int Jactu = 1, continuer = 1;
                                                      	char nb[3];
                                                      
                                                      	for(i=0;i<3;i++) {
                                                      		cases[i][0] = ' ';
                                                      		cases[i][1] = ' ';
                                                      		cases[i][2] = ' ';
                                                      	}
                                                      
                                                      	clearScreen();
                                                      	titre();
                                                      	printf("\nQuels est votre nom (Pas plus de %d caracteres) ? ", MAXCARACTERENOM);
                                                      	lire(j1, MAXCARACTERENOM);
                                                      	sprintf(j2, "Ordinateur");
                                                      
                                                      	while(continuer) {
                                                      		
                                                      		clearScreen();
                                                      
                                                      		titre();
                                                      		afficheGrille(cases);
                                                      
                                                      		#ifdef __WIN32__
                                                      			if(Jactu == 1) 
                                                      			{
                                                      				printf("\nC'est …");
                                                      				color(14, 0);
                                                      				printf(" %s ", j1);
                                                      				color(15, 0);
                                                      				printf("de jouer.\n");
                                                      			} 
                                                      			else if(Jactu == 2) 
                                                      			{ 
                                                      				printf("\nC'est …");
                                                      				color(14, 0);
                                                      				printf(" %s ", j2);
                                                      				color(15, 0);
                                                      				printf("de jouer.\n");
                                                      				
                                                      				#ifdef __WIN32__
                                                      					Sleep(2000);
                                                      				#else
                                                      				#endif
                                                      			}
                                                      		#else
                                                      			if(Jactu == 1) { printf("\nC'est à %s de jouer. \n", j1); Jactu++;} 
                                                      			else if(Jactu == 2) { printf("\nC'est à %s de jouer.\n", j2); Jactu--;}
                                                      		#endif
                                                      
                                                      		if(Jactu == 1)
                                                      		{
                                                      			printf("\nVotre choix : ");
                                                      			lire(nb, 3);
                                                      
                                                      			if((!strcmp(nb,"A1") || !strcmp(nb,"a1")) && cases[0][0] == ' ')
                                                      					cases[0][0] = 'x';
                                                      				
                                                      			else if((!strcmp(nb,"A2") || !strcmp(nb,"a2")) && cases[0][1] == ' ')
                                                      					cases[0][1] = 'x';
                                                      
                                                      			else if((!strcmp(nb,"A3") || !strcmp(nb,"a3")) && cases[0][2] == ' ')
                                                      					cases[0][2] = 'x';
                                                      						
                                                      			else if((!strcmp(nb,"B1") || !strcmp(nb,"b1")) && cases[1][0] == ' ')
                                                      					cases[1][0] = 'x';
                                                      	
                                                      			else if((!strcmp(nb,"B2") || !strcmp(nb,"b2")) && cases[1][1] == ' ')
                                                      					cases[1][1] = 'x';
                                                      			
                                                      			else if((!strcmp(nb,"B3") || !strcmp(nb,"b3")) && cases[1][2] == ' ')
                                                      					cases[1][2] = 'x';
                                                      	
                                                      			else if((!strcmp(nb,"C1") || !strcmp(nb,"c1")) && cases[2][0] == ' ')
                                                      					cases[2][0] = 'x';
                                                      	
                                                      			else if((!strcmp(nb,"C2") || !strcmp(nb,"c2")) && cases[2][1] == ' ')
                                                      					cases[2][1] = 'x';
                                                      	
                                                      			else if((!strcmp(nb,"C3") || !strcmp(nb,"c3")) && cases[2][2] == ' ')
                                                      					cases[2][2] = 'x';
                                                      			
                                                      			else
                                                      			{
                                                      				#ifdef __WIN32__
                                                      					color(12, 0);
                                                      					printf("\nVous vous Štes tromp‚...\n");
                                                      					color(15, 0);
                                                      				#else
                                                      					printf("\nVous vous ètes trompé...\n");
                                                      				#endif
                                                      				printf("Pour la peine, vous passez votre tour !");
                                                      				pause();
                                                      			}
                                                      			Jactu++;
                                                      		}
                                                      		else
                                                      		{
                                                      			chooseCase(cases);
                                                      			Jactu--;
                                                      		}
                                                      
                                                      		if(gagne(cases) == 1){
                                                      			continuer = 0;
                                                      			clearScreen();
                                                      			titre();
                                                      			afficheGrille(cases);
                                                      			
                                                      			#ifdef __WIN32__
                                                      				color(10, 0);
                                                      				printf("\nC'est %s qui a gagn‚ !\n", j1); //symbole windows 'é' : '‚' 
                                                      				color(15, 0);
                                                      			#else
                                                      				printf("\nC'est %s qui gagne !\n", j1);
                                                      			#endif
                                                      		}
                                                      		else if(gagne(cases) == 2){
                                                      			continuer = 0;
                                                      			clearScreen();
                                                      			titre();
                                                      			afficheGrille(cases);
                                                      
                                                      			#ifdef __WIN32__
                                                      				color(10, 0);
                                                      				printf("C'est %s qui a gagn‚ !\n", j1); //symbole windows 'é' : '‚' 
                                                      				color(15, 0);
                                                      			#else
                                                      				printf("C'est %s qui gagne !\n", j1);
                                                      			#endif
                                                      		}
                                                      
                                                      		
                                                      	
                                                      	}
                                                      
                                                      	getch();
                                                      	return 0;
                                                      }
                                                      
                                                      int jouer2j(void){
                                                      	char cases[3][3];
                                                      	char j1[MAXCARACTERENOM] = {0}, j2[MAXCARACTERENOM] = {0};
                                                      	int i=0;
                                                      	int Jactu = 1, continuer = 1;
                                                      	char nb[3];
                                                      
                                                      	for(i=0;i<3;i++) {
                                                      		cases[i][0] = ' ';
                                                      		cases[i][1] = ' ';
                                                      		cases[i][2] = ' ';
                                                      	}
                                                      
                                                      	clearScreen();
                                                      	titre();
                                                      	printf("\nQuels est le nom de J1 (Pas plus de %d caracteres) ? ", MAXCARACTERENOM);
                                                      	lire(j1, MAXCARACTERENOM);
                                                      	printf("\nQuels est le nom de J2 (Pas plus de %d caracteres) ? ", MAXCARACTERENOM);
                                                      	lire(j2, MAXCARACTERENOM);
                                                      
                                                      	while(continuer) {
                                                      		
                                                      		clearScreen();
                                                      
                                                      		titre();
                                                      		afficheGrille(cases);
                                                      
                                                      		#ifdef __WIN32__
                                                      			if(Jactu == 1) 
                                                      			{
                                                      				printf("\nC'est …");
                                                      				color(14, 0);
                                                      				printf(" %s ", j1);
                                                      				color(15, 0);
                                                      				printf("de jouer.\n");
                                                      				Jactu++;
                                                      			} 
                                                      			else if(Jactu == 2) 
                                                      			{ 
                                                      				printf("\nC'est …");
                                                      				color(14, 0);
                                                      				printf(" %s ", j2);
                                                      				color(15, 0);
                                                      				printf("de jouer.\n");
                                                      				Jactu--;
                                                      			}
                                                      		#else
                                                      			if(Jactu == 1) { printf("\nC'est à %s de jouer. \n", j1); Jactu++;} 
                                                      			else if(Jactu == 2) { printf("\nC'est à %s de jouer.\n", j2); Jactu--;}
                                                      		#endif
                                                      		printf("\nVotre choix : ");
                                                      		lire(nb, 3);
                                                      
                                                      		if((!strcmp(nb,"A1") || !strcmp(nb,"a1")) && cases[0][0] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[0][0] = 'x';
                                                      			else
                                                      				cases[0][0] = 'o';
                                                      		}
                                                      			
                                                      			
                                                      		else if((!strcmp(nb,"A2") || !strcmp(nb,"a2")) && cases[0][1] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[0][1] = 'x';
                                                      			else
                                                      				cases[0][1] = 'o';
                                                      		}	
                                                      
                                                      		else if((!strcmp(nb,"A3") || !strcmp(nb,"a3")) && cases[0][2] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[0][2] = 'x';
                                                      			else
                                                      				cases[0][2] = 'o';
                                                      		}
                                                      			
                                                      		else if((!strcmp(nb,"B1") || !strcmp(nb,"b1")) && cases[1][0] == ' '){
                                                      				if(Jactu == 1)
                                                      					cases[1][0] = 'x';
                                                      				else
                                                      					cases[1][0] = 'o';
                                                      		}
                                                      
                                                      		else if((!strcmp(nb,"B2") || !strcmp(nb,"b2")) && cases[1][1] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[1][1] = 'x';
                                                      			else
                                                      				cases[1][1] = 'o';
                                                      		}	
                                                      
                                                      		else if((!strcmp(nb,"B3") || !strcmp(nb,"b3")) && cases[1][2] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[1][2] = 'x';
                                                      			else
                                                      				cases[1][2] = 'o';
                                                      		}
                                                      
                                                      		else if((!strcmp(nb,"C1") || !strcmp(nb,"c1")) && cases[2][0] == ' ') {
                                                      			if(Jactu == 1)
                                                      				cases[2][0] = 'x';
                                                      			else
                                                      				cases[2][0] = 'o';
                                                      		}
                                                      
                                                      		else if((!strcmp(nb,"C2") || !strcmp(nb,"c2")) && cases[2][1] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[2][1] = 'x';
                                                      			else
                                                      				cases[2][1] = 'o';
                                                      		}	
                                                      
                                                      		else if((!strcmp(nb,"C3") || !strcmp(nb,"c3")) && cases[2][2] == ' '){
                                                      			if(Jactu == 1)
                                                      				cases[2][2] = 'x';
                                                      			else
                                                      				cases[2][2] = 'o';
                                                      		}
                                                      		else{
                                                      			#ifdef __WIN32__
                                                      				color(12, 0);
                                                      				printf("\nVous vous Štes tromp‚...\n");
                                                      				color(15, 0);
                                                      			#else
                                                      				printf("\nVous vous ètes trompé...\n");
                                                      			#endif
                                                      			printf("Pour la peine, vous passez votre tour !");
                                                      			pause();
                                                      		}
                                                      
                                                      		if(gagne(cases) == 1){
                                                      			continuer = 0;
                                                      			clearScreen();
                                                      			titre();
                                                      			afficheGrille(cases);
                                                      			
                                                      			#ifdef __WIN32__
                                                      				color(10, 0);
                                                      				printf("\nC'est %s qui a gagn‚ !\n", j1); //symbole windows 'é' : '‚' 
                                                      				color(15, 0);
                                                      			#else
                                                      				printf("\nC'est %s qui gagne !\n", j1);
                                                      			#endif
                                                      		}
                                                      		else if(gagne(cases) == 2){
                                                      			continuer = 0;
                                                      			clearScreen();
                                                      
                                                      			afficheGrille(cases);
                                                      
                                                      			#ifdef __WIN32__
                                                      				color(10, 0);
                                                      				printf("C'est %s qui a gagn‚ !\n", j1); //symbole windows 'é' : '‚' 
                                                      				color(15, 0);
                                                      			#else
                                                      				printf("C'est %s qui gagne !\n", j1);
                                                      			#endif
                                                      		}
                                                      
                                                      		
                                                      	
                                                      	}
                                                      
                                                      	getch();
                                                      	return 0;
                                                      }
                                                      
                                                      void credit(void){
                                                      
                                                      	char someText[MAXTC] = {'\0'};
                                                      	int i;
                                                      	
                                                      	color(rougefluo, noir); // On met la couleur
                                                      	sprintf(someText, "\t* Morpion %s *", MORPION_VERSION); // On initialise le texte de la variable
                                                      	clearScreen(); // On efface l'écran
                                                      	defile(someText);
                                                      	printf("\n\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(blanc, noir); // On met la couleur
                                                      	sprintf(someText, "Une id%ce de", -126); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(jaune, noir); // On met la couleur
                                                      	sprintf(someText, "FOVELLE Jolan"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(blanc, noir); // On met la couleur
                                                      	sprintf(someText, "Programmateur :"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(jaune, noir); // On met la couleur
                                                      	sprintf(someText, "jolfo"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(blanc, noir); // On met la couleur
                                                      	sprintf(someText, "Un projet"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(jaune, noir); // On met la couleur
                                                      	sprintf(someText, "www.strange-studio.fr.nf"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(blanc, noir); // On met la couleur
                                                      	sprintf(someText, "Remerciments :"); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(jaune, noir); // On met la couleur
                                                      	sprintf(someText, "\t%c www.siteduzero.fr", 254); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	color(grisfonce, noir); // On met la couleur
                                                      	sprintf(someText, " o%c j'ai appris %c programmer", 151, 133); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	color(jaune, noir); // On met la couleur
                                                      	sprintf(someText, "\t%c David", 254); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	color(grisfonce, noir); // On met la couleur
                                                      	sprintf(someText, " pour avoir %ct%c le premier %c tester le jeu",-126, -126, 133); // On initialise le texte de la variable
                                                      	defile(someText);
                                                      	printf("\n");
                                                      	color(blanc, noir);
                                                      
                                                      	pause();
                                                      	clearScreen();
                                                      }
                                                      
                                                      void instructions(void){
                                                      	clearScreen();
                                                      	titre();
                                                      	printf("** Instructions **\n\n");
                                                      	printf("Ceci est le jeu du morpion.\n");
                                                      	printf("Le but du jeux est de remplir 3 cases avec son symbole\n");
                                                      	printf("Vous gagnez si elle son en diagonales, horizontales ou verticales\n\n");
                                                      	pause();
                                                      }
                                                      
                                                      void color(int couleurDuTexte,int couleurDeFond) {
                                                              HANDLE H = GetStdHandle(STD_OUTPUT_HANDLE);
                                                              SetConsoleTextAttribute(H,couleurDeFond*16+couleurDuTexte);
                                                      }
                                                      
                                                      void titre(void)
                                                      {
                                                      	#ifdef __WIN32__
                                                      		color(12, 0);
                                                      		printf("\t* Morpion %s *\n\n", MORPION_VERSION);
                                                      		color(15, 0);
                                                      	#else
                                                      		printf("\t* Morpion %s * (Optimisé pour Windows)\n\n", MORPION_VERSION);
                                                      	#endif
                                                      }
                                                      
                                                      void defile(char someText[MAXTC])
                                                      {
                                                      	int i;
                                                      
                                                      	for(i=0;someText[i] != '\0'; i++) // On fait afficher le texte, caractère par caractère
                                                      	{
                                                      		printf("%c", someText[i]);
                                                      		#ifdef __WIN32__
                                                      			Sleep(100);
                                                      		#else
                                                      		#endif
                                                      	}
                                                      }
                                                      


                                                      saisie.c
                                                      #include "definitions.h"
                                                      
                                                      void viderBuffer()
                                                      {
                                                          int c = 0;
                                                          while (c != '\n' && c != EOF)
                                                          {
                                                              c = getchar();
                                                          }
                                                      }
                                                      int lire(char *chaine, int longueur)
                                                      {
                                                          char *positionEntree = NULL;
                                                       
                                                          if (fgets(chaine, longueur, stdin) != NULL)
                                                          {
                                                              positionEntree = strchr(chaine, '\n');
                                                              if (positionEntree != NULL)
                                                              {
                                                                  *positionEntree = '\0';
                                                              }
                                                              else
                                                              {
                                                                  viderBuffer();
                                                              }
                                                              return 1;
                                                          }
                                                          else
                                                          {
                                                              viderBuffer();
                                                              return 0;
                                                          }
                                                      }
                                                      long lireLong()
                                                      {
                                                          char nombreTexte[100] = {0}; // 100 cases devraient suffire
                                                       
                                                          if (lire(nombreTexte, 100))
                                                          {
                                                              // Si lecture du texte ok, convertir le nombre en long et le retourner
                                                              return strtol(nombreTexte, NULL, 10);
                                                          }
                                                          else
                                                          {
                                                              // Si problème de lecture, renvoyer 0
                                                              return 0;
                                                          }
                                                      }
                                                      
                                                      static void search(char *chaine)
                                                      {
                                                          char *p = strchr(chaine, '\n');
                                                      
                                                          if (p)
                                                          {
                                                              *p = 0;
                                                          }
                                                      }
                                                      static void purger(void)
                                                      {
                                                          int c;
                                                      
                                                          while ((c = getchar()) != '\n' && c != EOF)
                                                          {}
                                                      }
                                                      static void clean (char *chaine)
                                                      {
                                                          char *p = strchr(chaine, '\n');
                                                      
                                                          if (p)
                                                          {
                                                              *p = 0;
                                                          }
                                                      
                                                          else
                                                          {
                                                              purger();
                                                          }
                                                      }
                                                      static void getUserString(char *chaine)
                                                      {
                                                      	fgets(chaine, sizeof chaine, stdin);
                                                          /* On nettoie notre chaine et le buffer stdin. */
                                                          clean(chaine);
                                                      }
                                                      


                                                      definitions.h
                                                      #include <stdio.h>
                                                      #include <stdlib.h>
                                                      #include <string.h>
                                                      #include <time.h>
                                                      
                                                      #define __WIN32__
                                                      
                                                      #ifdef __WIN32__
                                                      	#include <conio.h>
                                                      	#include <windows.h>
                                                      	#define title(); system("title Morpion Console [x[o]x]");
                                                      	#define clearScreen(); system("cls");
                                                      	#define pause(); getch();
                                                      #else
                                                      	#define title(); printf("");
                                                      	#define clearScreen(); system("clear");
                                                      	#define pause(); getchar();
                                                      #endif
                                                      
                                                      #define MAXCARACTERENOM 20
                                                      #define MAXTC 10000
                                                      
                                                      #define noir 0
                                                      #define bleufonce 1
                                                      #define turquoise 2
                                                      #define rougefonce 4
                                                      #define violet 5
                                                      #define vertcacadoie 6
                                                      #define grisclair 7
                                                      #define grisfonce 8
                                                      #define bleufluo 9
                                                      #define vertfluo 10
                                                      #define _turquoise 11
                                                      #define rougefluo 12
                                                      #define _violet 13
                                                      #define jaune 14
                                                      #define blanc 15
                                                      



                                                      C'est pas forcement super (Je l'ai fait il y a environ 1 an...), mais ça rend bien visuellement...
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        17 juin 2011 à 23:15:18

                                                        Désolé, t'es passé entre 2, j'ai pas vu. :(
                                                        ggned2 >
                                                        Les fonctions qui ne prennent pas d'arguments on mettra 'void'
                                                        Pour tirer ton nombre aléatoire, tu peux faire plus simple, inutile de faire plein d'opérations : joueur = rand() % 2 + 1
                                                        On évitera d'utiliser des variables globales
                                                        Tu pourrais faire une fonction 'rejouer'
                                                        On évitera la macro 'ligne' ou alors on ne mettra pas de ';' à la fin et on donnera un nom plus explicite (afficheNouvelleLigne par ex.)
                                                        RIEN n'est pas déclaré
                                                        Hmm, pour ta fonction 'testerGagnant' j'ai un doute sur ta condition 'test == ROND', tu sors directement de la boucle non ?
                                                        Tu ne m'as pas donné main.h

                                                        Dans l'ensemble c'est correct. :)
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          26 juin 2011 à 22:40:08

                                                          MERCI

                                                          j'adore les variables globales c'est plus facile
                                                          sinon il faut mettre plein d'arguments et de machins ! ! :colere:

                                                          j'ai mêmee essayé de faire des SDL_Surface globales ^^
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            26 juin 2011 à 22:57:34

                                                            Citation : ggned2

                                                            j'adore les variables globales c'est plus facile
                                                            sinon il faut mettre plein d'arguments et de machins ! ! :colere:

                                                            j'ai mêmee essayé de faire des SDL_Surface globales ^^


                                                            Tu as tort de faire ça. Tu pensera que ça va te faciliter la tâche au début, mais quand tu attaquera des projets un peu plus ambitieux tu vas vite t'y perdre et ton code deviendra incompréhensible... C'est pas une habitude à prendre : utilises les seulement lorsque c'est vraiment nécessaire et qu'il n'y a pas d'autres solutions.
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            zMorp - 1ère partie

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur
                                                            • Markdown