Partage
  • Partager sur Facebook
  • Partager sur Twitter

zMorp - 1ère partie

Créer un morpion

    10 décembre 2010 à 16:11:27

    Voici mon programmes :

    (J'ai pas essayé d'optimiser ni rien)
    C'était juste pour m'amuser avec des goto que je l'ai fait ^^

    Merci @c159 (j'ai piqué ta condition pour tester si quelqu'un avait gagné).
    J'avais pas le courage de la réécrire.

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <windows.h>
    
    char tableau[9] = {'1','2','3','4','5','6','7','8','9'};
    int pion = 1;
    
    
    void afficher_tableau(void){
        int i=0;
        debut:
         if(i%3 ==0)
            printf("\n");
    
         printf("%c",tableau[i]);
         i++;
        if(i <10)
            goto debut;
    }
    
    int joueur(){
    
        pion =  (pion == 1) ? 0:1;
        return (pion == 1) ? 'O':'X';
    }
    
    int test(void){
        if ((tableau[0] == tableau[1] && tableau[0] == tableau[2])||
                (tableau[3] == tableau[4] && tableau[3] == tableau[5])||
                (tableau[6] == tableau[7] && tableau[6] == tableau[8])||
                (tableau[0] == tableau[3] && tableau[0] == tableau[6])||
                (tableau[1] == tableau[4] && tableau[1] == tableau[7])||
                (tableau[2] == tableau[5] && tableau[2] == tableau[8])||
                (tableau[0] == tableau[4] && tableau[0] == tableau[8])||
                (tableau[2] == tableau[4] && tableau[2] == tableau[6])){
    
                return 1;
                }
    
        return 0;
    }
    
    int main(void){
       int numero,coup=0,win=0;
    srand(time(NULL));
    
    jeux:
    system("cls");
    afficher_tableau();
    printf("Votre numero :");
    scanf("%d",&numero);
    if(tableau[numero-1] > '0' && tableau[numero-1] <= '9'){
        tableau[numero-1] = joueur();
        coup++;
    }
    else{
        printf("Erreur on a deja joue la case");
        Sleep(500);
    }
    win = test();
    
    if(coup <= 8 && win == 0)
        goto jeux;
    
        system("cls");
    afficher_tableau();
    win = test();
    if(win ==1)
        printf("le joueur : %c a gagner\n",(pion == 1) ? 'O':'X');
    else
        printf("Egalite\n");
    
    return 0;
    }
    


    J'ai pas pris mon temps pour mettre des commentaires et espacer tout ça dsl :euh:
    • Partager sur Facebook
    • Partager sur Twitter
      10 décembre 2010 à 17:53:32

      Citation : frdemahieu

      Merci @c159 (j'ai piqué ta condition pour tester si quelqu'un avait gagné).
      J'avais pas le courage de la réécrire.

      :euh: de rien tu as pensé a me verser 10 000€ pour les droit d'auteur ? ;)
      • Partager sur Facebook
      • Partager sur Twitter
        10 décembre 2010 à 17:57:27

        Ben donne moi ton numéro de carte de crédit ave la date de péremption et je te verserais 10 000 € ^^
        • Partager sur Facebook
        • Partager sur Twitter
          10 décembre 2010 à 18:13:47

          ok merci, mais comme je débute, j'en suis content, je vais essayer de le corriger
          • Partager sur Facebook
          • Partager sur Twitter
            10 décembre 2010 à 21:34:35

            Citation : frdemahieu

            C'était juste pour m'amuser avec des goto que je l'ai fait ^^
            [...]
            J'ai pas pris mon temps pour ... espacer tout ça dsl :euh:


            De ce fait, je ne le commenterai pas.

            @ GurneyH : Fan ! Image utilisateur
            Tu pourrais expliquer ça pour les débutants par contre : putchar(" 0X"[grid[i * W + j]]);
            Tu pourrais aussi expliquer ça : while((unsigned)i < H && (unsigned)j < W)

            Merci pour votre participation. :)
            • Partager sur Facebook
            • Partager sur Twitter
              10 décembre 2010 à 21:39:45

              Citation : Pouet_forever

              Citation : frdemahieu

              C'était juste pour m'amuser avec des goto que je l'ai fait ^^
              [...]
              J'ai pas pris mon temps pour ... espacer tout ça dsl :euh:


              De ce fait, je ne le commenterai pas.



              Le prends pas mal c'est juste pour m'amuser que j'ai fait ce code.
              Je te demande pas de le commenter puisque moi-même je sais qu'il est mauvais.
              • Partager sur Facebook
              • Partager sur Twitter
                10 décembre 2010 à 23:47:04

                @ GuyneyH: Moi aussi j'aime bien ton code. Cependant :
                Joueur 1 (ligne colonne) -> 3 3
                 - - -
                |X|0|0|
                 - - -
                |X|X|0|
                 - - -
                |0|X|0|
                 - - -
                Match Nul !Une autre partie (o/n) ?

                Bon rien de grave hein.
                • Partager sur Facebook
                • Partager sur Twitter
                🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                  11 décembre 2010 à 14:15:15

                  Citation : @che


                  Bon rien de grave hein.


                  Tout de même un peu. :-°
                  Je vais regarder ça. Merci pour le retour.

                  edit: c'est corrigé.

                  Citation : Pouet


                  Tu pourrais expliquer ça pour les débutants par contre : putchar(" 0X"[grid[i * W + j]]);
                  Tu pourrais aussi expliquer ça : while((unsigned)i < H && (unsigned)j < W)



                  pour
                  putchar(" 0X"[grid[i * W + j]])
                  

                  La grille contient 0(case vide), 1 ou 2(le joueur qui occupe la case).
                  J'ai choisi de stocker ma grille sous la forme d'un tableau à 1 dimension.
                  A partir d'une ligne(i) et d'une colonne donnée(j), pour récupèrer l'indice de la case je fais
                  i * W + j
                  (faire un dessin pour visualiser si ce n'est pas clair)
                  Ensuite" OX", c'est une chaîne de caractère.
                  On peut accèder à chaque caractère la composant à partir d'un indice
                  " OX"[0] = ' '
                  " OX"[1] = 'O'
                  " OX"[2] = '1'

                  Pour
                  while((unsigned)i < H && (unsigned)j < W)
                  

                  c'est équivalent à
                  while(i >= 0 && i < H && j >= 0 && j < W)
                  

                  Si i(par exemple) est négatif (-1 encore pour exemple), après cast en unsigned
                  i aura pour valeur UINT_MAX(défini dans limits.h)
                  si i = -2 -> (unsigned)i == UINT_MAX - 1
                  Ainsi on a à tester qu'une borne, la borne supérieure.

                  • Partager sur Facebook
                  • Partager sur Twitter
                  Zeste de Savoir, le site qui en a dans le citron !
                    11 décembre 2010 à 14:26:07

                    Salut,

                    Voici mon code :

                    main.c

                    #include <stdio.h>
                    #include <stdlib.h>
                    #include <time.h>
                    
                    #ifndef principal
                    #include "grille.h"
                    #define principal
                    #endif
                    
                    int main (void)
                    {
                    	Case grille[LONGUEUR][LARGEUR];
                    	int ligne = 0;
                    	int colonne = 0;
                    	int joueur = 1;
                    	int continuer = 1;
                    	int nbCoups = 0;
                    	int gagne = 0;
                        int coupPasJoue = 1;
                    
                        srand(time(NULL));
                    
                    	printf("Jeu du morpion. Pour jouer entrez une ligne et une colonne,\n");
                    	printf("au format suivant x,y[entree], x étant la ligne et y la colonne\n");
                    	printf("ces deux chiffres étant compris entre 1 et 3.");
                    	printf("\n");
                    
                    	while (continuer == 1)
                    	{
                    		gagne = 0;
                            nbCoups = 0;
                    		prepare_Grille(grille);
                    	
                    		while (nbCoups < 9 && gagne != 1)
                    		{
                    			afficherGrille(grille);
                                if (nbCoups == 0)
                                {
                                    joueur = rand();
                                    if ((joueur % 2) == 0)
                                    {
                                        joueur = 1;
                                    }
                                    else
                                    {
                                        joueur = 2;
                                    }
                                }
                    			else if ((nbCoups % 2) == 0)
                    			{
                    				joueur = 1;
                    			}
                    			else
                    			{
                    				joueur = 2;
                    			}
                                coupPasJoue = 1;
                                while (coupPasJoue)
                                {
                                   printf("Joueur %d, jouez : ", joueur);
                                   scanf("%d,%d", &ligne, &colonne);
                                   vider_Buffer();
                    			   coupPasJoue = placerPion(joueur, grille, ligne, colonne);
                                }
                    			nbCoups++;
                    			printf("Nb de coups joues : %d\n", nbCoups);
                    			gagne = verifierGrille(grille, ligne, colonne, joueur);
                    		}
                    
                    		if (gagne)
                    		{
                    			printf("Le joueur %d a gagne !\n", joueur);
                    		}
                    		else
                    		{
                    			printf("Egalite ! \n");
                    		}
                    		afficherGrille(grille);
                    		printf("Une autre partie ?(0 = Non, 1 = oui)");
                    		scanf("%d", &continuer);
                    		vider_Buffer();
                    	}
                    	return 0;
                    }
                    


                    grille.h

                    enum Case
                    	 {
                    		VIDE,
                    		PIONJOUEUR1,
                    		PIONJOUEUR2
                    	 };
                    typedef enum Case Case;
                    
                    #define LONGUEUR 3
                    #define LARGEUR 3
                    #define NBPIONS 3
                    
                    void vider_Buffer(void);
                    int placerPion (int joueur, Case grille[LONGUEUR][LARGEUR], int ligne, int colonne);
                    void prepare_Grille(Case Grille[LONGUEUR][LARGEUR]);
                    void afficher_ligne(void);
                    int verifierLigne(Case Grille[LONGUEUR][LARGEUR], int ligne, unsigned int pion);
                    int verifierColonne(Case Grille[LONGUEUR][LARGEUR], int colonne, unsigned int pion);
                    int verifierDiagonales(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                    int verifierGrille(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, int joueur);
                    void afficherGrille (Case grille[LONGUEUR][LARGEUR]);
                    


                    grille.c
                    #ifndef grid
                    #include "grille.h"
                    #define grid
                    #endif
                    #include <stdio.h>
                    
                    void vider_Buffer(void)
                    {
                    	int c = 0;
                    	c = getchar();
                    	while (c != '\n')
                    	{
                    		c = getchar();
                    	}
                    }
                    
                    int placerPion (int joueur, Case grille[LONGUEUR][LARGEUR], int ligne, int colonne)
                    {
                        int pasPlace = 1;
                    
                        ligne--;
                        colonne--;
                        if (grille[ligne][colonne] != VIDE)
                        {
                            printf("Case déjà occupée, choisissez une autre case !\n");
                            pasPlace = 1;
                        }
                        else
                        {
                            if (joueur == 1)
                            {
                                grille[ligne][colonne] = PIONJOUEUR1;
                            }
                            else
                            {
                                grille[ligne][colonne] = PIONJOUEUR2;
                            }
                            pasPlace = 0;
                        }
                        return pasPlace;
                    }
                    
                    void prepare_Grille(Case Grille[LONGUEUR][LARGEUR])
                    {
                    	int i = 0;
                    	int j = 0;
                    
                    	while (i < LONGUEUR)
                    	{
                    		while (j < LARGEUR)
                    		{
                    			Grille[i][j] = VIDE;
                    			j++;
                    		}
                    		i++;
                    		j = 0;
                    	}
                    }
                    
                    void afficher_ligne(void)
                    {
                    	int nbTirets = 0;
                    	while (nbTirets < 2 * LONGUEUR)
                    	{
                    		printf("-");
                    		nbTirets++;
                    	}
                    }
                    
                    int verifierLigne(Case Grille[LONGUEUR][LARGEUR], int ligne, unsigned int pion)
                    {
                    	int colonne = 0;
                    	int alignes = 0;
                    	
                    	while (colonne != LARGEUR && alignes != NBPIONS)
                    	{
                    		if (Grille[ligne][colonne] == pion)
                    		{
                    			alignes++;
                    		}
                    		else
                    		{
                    			alignes = 0;
                    		}
                    		colonne++;
                    	}
                    	return alignes;
                    }
                    
                    int verifierColonne(Case Grille[LONGUEUR][LARGEUR], int colonne, unsigned int pion)
                    {
                    	int ligne = 0;
                    	int alignes = 0;
                    
                    	while (ligne != LONGUEUR && alignes != NBPIONS)
                    	{
                    		if (Grille[ligne][colonne] == pion)
                    		{
                    			alignes++;
                    		}
                    		else
                    		{
                    			alignes = 0;
                    		}
                    		ligne++;
                    	}
                    	return alignes;
                    }
                    
                    int verifierDiagonales(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                    {
                        int alignes = 0;
                        int ligneDiagonale;
                        int colonneDiagonale;
                    
                        /* Verification vers la droite */
                    
                        ligneDiagonale = ligne;
                        colonneDiagonale = colonne;
                    
                        while (Grille[ligneDiagonale][colonneDiagonale] == pion && alignes != NBPIONS)
                        {
                            alignes++;
                            ligneDiagonale++;
                            colonneDiagonale++;
                            if (ligneDiagonale == LONGUEUR || colonneDiagonale == LARGEUR)
                            {
                                break;
                            }
                        }
                    
                        ligneDiagonale = ligne;
                        colonneDiagonale = colonne;
                    
                        if (alignes != NBPIONS)
                        {
                            alignes = 0;
                        }
                    
                        /* Puis vers la gauche si on n'a pas trouvé */
                    
                        while (Grille[ligneDiagonale][colonneDiagonale] == pion && alignes != NBPIONS)
                        {
                            alignes++;
                            ligneDiagonale++;
                            colonneDiagonale--;
                            if (ligneDiagonale == LONGUEUR || colonneDiagonale < 0)
                            {
                                break;
                            }
                        }
                    
                        if (alignes != NBPIONS)
                        {
                            alignes = 0;
                        }
                    
                        /* Verification vers le bas à gauche */
                    
                        ligneDiagonale = ligne;
                        colonneDiagonale = colonne;
                    
                        while (Grille[ligneDiagonale][colonneDiagonale] == pion && alignes != NBPIONS)
                        {
                            alignes++;
                            ligneDiagonale--;
                            colonneDiagonale--;
                            if (ligneDiagonale < 0 || colonneDiagonale < 0)
                            {
                                break;
                            }
                        }
                        
                        ligneDiagonale = ligne;
                        colonneDiagonale = colonne;
                    
                        if (alignes != NBPIONS)
                        {
                            alignes = 0;
                        }
                    
                        /* Puis à droite */
                    
                        while (Grille[ligneDiagonale][colonneDiagonale] == pion && alignes != NBPIONS)
                        {
                            alignes++;
                            ligneDiagonale--;
                            colonneDiagonale++;
                            if (ligneDiagonale < 0 || colonneDiagonale == LARGEUR)
                            {
                                break;
                            }
                        }
                        return alignes;
                    }
                    
                    int verifierGrille(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, int joueur)
                    {
                    	int gagne = 0;
                    	int alignes = 0;
                    	unsigned int pion;
                    
                    	ligne--;
                    	colonne--;
                        if (joueur == 1)
                        {
                            pion = PIONJOUEUR1;
                        }
                        else
                        {
                            pion = PIONJOUEUR2;
                        }
                    	alignes = verifierLigne(Grille, ligne, pion);
                    
                    	if (alignes == NBPIONS)
                    	  {
                    		  gagne = 1;
                    	  }
                    	else
                    	  {
                    		  alignes = verifierColonne(Grille, colonne, pion);
                    		  if (alignes == NBPIONS)
                    		  {
                    			  gagne = 1;
                    		  }
                              else
                              {
                                alignes = verifierDiagonales(Grille, ligne, colonne, pion);
                                if (alignes == NBPIONS)
                                {
                                    gagne = 1;
                                }
                              }
                    	  }
                    	return gagne; 
                    }
                    
                    void afficherGrille (Case grille[LONGUEUR][LARGEUR])
                    {
                    	int nbBarresVerticales = 0;
                    	int nbLignesHorizontales = 0;
                    
                    	while (nbLignesHorizontales < LONGUEUR)
                    	{
                    		afficher_ligne();
                    		printf("\n");
                    		while (nbBarresVerticales < LARGEUR)
                    		{
                    			printf("|");
                    			if (grille[nbLignesHorizontales][nbBarresVerticales] == VIDE)
                    			{
                    				printf(" ");
                    			}
                    			else if (grille[nbLignesHorizontales][nbBarresVerticales] == PIONJOUEUR1)
                    			{
                    				printf("O");
                    			}
                    			else
                    			{
                    				printf("X");
                    			}
                    			nbBarresVerticales++;
                    		}
                    		nbBarresVerticales = 0;
                    		nbLignesHorizontales++;
                    		printf("|");
                    		printf("\n");
                    	}
                    }
                    




                    Quelques petites choses à propos de ce code :

                    - Un problème avec la saisie d'une ligne. Si on saisit plus de quinze ou seize caractères le programme sort une erreur de segmentation. Gdb n'arrive pas à m'indiquer d'où elle vient malgré plusieurs essais.
                    - Si on saisit moins de trois caractères il faut appuyer plusieurs fois sur Entrée pour avoir la possibilité de recommencer la saisie.
                    - L'algorithme qui se contente de tester toutes les combinaisons et n'est pas évolutif. J'essaierai d'en poster une meilleure version, surtout concernant les diagonales.


                    Edit : code modifié en prenant en compte les remarques de Pouet_Forever en dessous. En espérant que le code soit mieux découpé.

                    Si vous avez des remarques à faire, je veux bien. :p
                    • Partager sur Facebook
                    • Partager sur Twitter
                      11 décembre 2010 à 15:21:31

                      Tu t'emmerde trop la vie avec la saisie utilisateur. Fais un scanf("%d%d", &i, &j); et le tour est joué.
                      Le but de l'exo c'est pas la saisie utilisateur. :)

                      Pourquoi tu fais des pointeurs directement sur tes variables ?
                      J'ai pas regardé en profondeur, mais tu pourrais déjà gérer ton header par rapport à l'inclusion multiple.
                      Découper un peu plus ton code.

                      Merci pour ta participation. :)
                      • Partager sur Facebook
                      • Partager sur Twitter
                        14 décembre 2010 à 16:14:00

                        salut, en lisent le sujet j ai u tout de suite envie de le faire (donc merci a se lui qui a lance l'exo)

                        donc j ai fait sa ( je suis encore un débutant s est donc pas très propre):
                        /*  Par : Coyote
                        	Jeux du morpion en console (exo pour le site du zero)
                        */
                        #include <stdio.h>
                        #include <stdlib.h>
                        //taille de la grille
                        #define NOMBRE_DE_LIGNE 3
                        #define NOMBRE_DE_CASE (NOMBRE_DE_LIGNE * NOMBRE_DE_LIGNE)
                        
                        //pour OS
                        #define WINDOWS
                        //#define LINUX
                        
                        //initialisation des variable 
                        void initialisation(int *Pjoueur, int *grille)
                        {
                        	int i = 0;
                        
                        	//mise a zéro de la grille
                        	for(i=0;i<NOMBRE_DE_CASE;i++)
                        		{
                        			grille[i] = 0;
                        		}
                        
                        	*Pjoueur = 0;
                        }
                        
                        void quelleJoueur(int *Pjoueur)
                        {
                        	//pour os
                        	#ifdef WINDOWS
                        		system("cls");
                        	#endif
                        
                        	//pour os
                        	#ifdef LINUX
                        		system("clear");
                        	#endif
                        
                        	switch(*Pjoueur)
                        	{
                        	case 0:
                        		*Pjoueur = (rand() % (2 - 1 + 1)) + 1;
                        		printf("joueur %d commence !\n",*Pjoueur);
                        		break;
                        	case 1:
                        		*Pjoueur = 2;
                        		break;
                        	case 2:
                        		*Pjoueur = 1;
                        		break;
                        	}
                        }
                        
                        void affichage(const int grille[], int joueur)
                        {
                        	int i = 0, ligne = 0;
                        	
                        	
                        	for(i=0;i<NOMBRE_DE_CASE;i++)
                        	{
                        		switch(grille[i])
                        		{
                        			case 0:
                        				printf(".");
                        				break;
                        			case 1:
                        				printf("x");
                        				break;
                        			case 2:
                        				printf("o");
                        				break;
                        		}
                        		ligne++;
                        		if(ligne == NOMBRE_DE_LIGNE)
                        		{
                        			printf("\n");
                        			ligne = 0;
                        		}
                        	}
                        	printf("joueur %d:",joueur);
                        }
                        
                        //verifie si le coup est jouable est le pace dans la grille
                        void jouerCoup(int *grille[],const int joueur)
                        {
                        	int coup = 0, coupBon = 0;
                        
                        	do
                        	{
                        		//-1 pour ratrapé le 0 du tableau 
                        		coup = (saisie() - 1);
                        		//verifie si le coup est jouable et le place dans la grille
                        		if(grille[coup] == 0)
                        		{
                        			coupBon = 0;
                        			if(joueur == 1)
                        			{
                        				grille[coup] = 1;
                        			}
                        			if(joueur == 2)
                        			{
                        				grille[coup] = 2;
                        			}
                        		}
                        		else
                        		{
                        			coupBon = 1;
                        			printf("\nvous ne pouvait pas jouer set case choisisé une autre case :");
                        		}
                        	}while(coupBon);
                        
                        }
                        
                        //recupére la saisie du joueur
                        int saisie()
                        {
                        	int coupJouer = 0, coupValide = 1;
                        
                        	do
                        	{
                        		scanf("%d",&coupJouer);
                        
                        		if((coupJouer > 0 )&&(coupJouer <= NOMBRE_DE_CASE))
                        		{
                        			coupValide = 0;
                        		}
                        		else
                        		{
                        			printf("\nle nombre n'est pas valide choisi un autre nombre :");
                        		}
                        
                        	}while(coupValide);
                        	return coupJouer;
                        }
                        
                        
                        int testerGagnant(const int grille[],const int joueur)
                        {
                        	int i = 0,l = 0,
                        		gagne[4] = {0}, partieNul = 0;
                        
                        	for(i=0;i<NOMBRE_DE_LIGNE;i++)
                        	{
                        		for(l=0;l<NOMBRE_DE_LIGNE;l++)
                        		{
                        			//test les lignes horizontal
                        			if ((grille[(NOMBRE_DE_LIGNE * i)] != 0) && (grille[(NOMBRE_DE_LIGNE * i)] == grille[(l+(NOMBRE_DE_LIGNE * i))]))
                        			{
                        				gagne[0]++;
                        				
                        			}
                        			//.........
                        			//test les vertival
                        			if ((grille[i] != 0) && (grille[i] == grille[(l * NOMBRE_DE_LIGNE + i)]))
                        			{
                        				gagne[1]++;
                        				
                        			}
                        			//........
                        			// test des diagonals
                        			if(i == 0)
                        			{
                        				if((grille[i] !=0) && (grille[i] == grille[(l * NOMBRE_DE_LIGNE)+ l]))
                        				{
                        					gagne[2]++;
                        				}
                        				if((grille[NOMBRE_DE_LIGNE -1] !=0) && (grille[NOMBRE_DE_LIGNE - 1] == grille[(NOMBRE_DE_LIGNE - 1) + (l*(NOMBRE_DE_LIGNE - 1))]))
                        				{
                        					gagne[3]++;
                        				}
                        			}
                        			//............
                        			//test si la partie nai pas nul
                        			if (grille[(l+(NOMBRE_DE_LIGNE * i))] == 0)
                        			{
                        				partieNul++;
                        			}
                        		}
                        		//verifie si il y a une ligne gagniente
                        		for(l=0;l<4;l++)
                        		{
                        			if(gagne[l] >= NOMBRE_DE_LIGNE)
                        			{
                        				affichage(grille,joueur);
                        				printf("\nle joueur %d a gagnée !",joueur);
                        				return 0;
                        			}
                        			else //si non remis a 0
                        			{
                        				gagne[l] = 0;
                        			}
                        		}
                        	}
                        	//...............
                        
                        	if(partieNul > 0)
                        	{
                        		return 1;
                        	}
                        	//si match nul
                        	else
                        	{
                        		printf("\nmatch nul !");
                        		return 0;
                        	}
                        			
                        }
                        
                        int main()
                        {
                        	//joueur definie a qui est le toure 
                        	int joueur = 0,i = 0,
                        		continu = 0,rejouer = 0,
                        		coupJouer = 0,
                        		grille[NOMBRE_DE_CASE];
                        	
                        	srand(time(NULL));
                        
                        	//boucle pour rejouer
                        	do
                        	{		
                        		//installation pour rejouer
                        		installation(&joueur, grille);	
                        		//boucle du jeux
                        		do
                        		{
                        						
                        			quelleJoueur(&joueur);
                        
                        			affichage(grille,joueur);
                        									
                        			jouerCoup(grille, joueur);
                        			
                        			continu = testerGagnant(grille,joueur);
                        						
                        		}while(continu);
                        
                        	printf("\nvoule vous rejouer 1.NON 2.OUI ?:");
                        	switch(saisie())
                        	{	
                        		case 1:
                        			rejouer = 0;
                        			break;
                        		default:
                        			rejouer = 1;
                        			break;
                        	}
                        	}while(rejouer);
                            
                        	return 0;
                        }
                        


                        j ai qu'elle que warning , le code est évolutif je les test avec une grille de 4x4 sa marche (par contre le système de saisie est pas terrible, mai comme précisé s est pas le plus important )

                        ps : jai pence au utilisateur de linux !
                        • Partager sur Facebook
                        • Partager sur Twitter
                          14 décembre 2010 à 16:46:57

                          @coyote60: Je n'ai pas regardé le code mais déjà, stp corrige les fautes d'orthographes, il y en a plein.

                          J'aime pas trop les switch qui font lourd et qui pourraient être remplacés par un if ou même en une ligne(par les ternaires).
                          Comme dis précédemment, tu testes toutes les possibilités alors que l'on peut ne pas tout vérifier.
                          Je pense pas que tu sois obligé d'effacer l'écran.
                          (rand() % (2 - 1 + 1)) + 1; Tu peux aussi faire les calculs tout seul non ?
                          int joueur = 0,i = 0; Je ne vois pas oû est utiliser i.
                          Il ne te manquerait pas un/des include(s) ?

                          Après je que regardé le code de loin, j'ai pas testé.
                          • Partager sur Facebook
                          • Partager sur Twitter
                          🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                            15 décembre 2010 à 4:14:44

                            - désolé pour les fautes d'orthographes (j ai malheureusement un gros problème avec sa :( ).

                            - les ternaires ? je s est même pas se que s est o_O

                            - pour les teste oui j ai vu mai trop tare , je vais voir pour changé sa.

                            - pour le rand oui il est vrais j ai fait un copier collé sa sur le cour de matheo sen réfléchire :-°

                            - est pour le "i = 0" oups un reste d'un aisé que j ai oublier d enlevé
                            • Partager sur Facebook
                            • Partager sur Twitter
                              15 décembre 2010 à 10:06:41

                              rebonjour, j'essay actuellement de corigé mon code mais la sa plante et je ne sais pas pourquoi, quand je vuex jou sur la case 1, il ne joue pas et sur la 2 il m'affiche la 3 o_O
                              voila mon code :
                              #include <stdio.h>
                              #include <stdlib.h>
                              #include <time.h>
                              
                              void affichage(char grille[]);
                              int demande(void);
                              int teste_Case(int choix, char grille[]);
                              
                              int main(int argv, char *argc[])
                              {
                              	srand(time(NULL));
                              	char grille[9] = {'.','.','.','.','.','.','.','.','.'};
                              	int c = 2;
                              	int gagnant = 1;
                              	int joueur = rand() % c + 1;
                              	int choix;
                              	int ok = 1;
                              
                              	printf("\t\t\t===MORPION===\n\n");
                              
                              
                              	while(gagnant)
                              	{
                              		do
                              		{
                              			printf("A toi, JOUEUR %d : Ou veut tu jouer ?\n", joueur);
                              			choix = demande();
                              			ok = teste_Case(choix, grille);
                              			affichage(grille);
                              		}while(ok);
                              
                              		if(joueur == 1)
                              		{
                              			grille[choix] = 'o';
                              		        joueur++;
                                              }        
                              		else if(joueur == 2)
                              		{
                              			grille[choix] = 'x';
                              		        joueur--;
                                              }
                              	}
                              
                              	return 0;
                              }
                              
                              void affichage(char grille[])
                              {
                              	printf("%c %c %c\n", grille[0] ,grille[1], grille[2]);
                              	printf("%c %c %c\n", grille[3] ,grille[4], grille[5]);
                              	printf("%c %c %c\n", grille[6] ,grille[7], grille[8]);
                              }
                              
                              int demande(void)
                              {
                              	int choix;
                              	printf("Je joue sur le case : n°");
                              	scanf("%d", &choix);
                              	return choix;
                              }
                              
                              int teste_Case(int choix, char grille[])
                              {
                              	int ok;
                              	char testeur[] = {'.'};
                              
                              	if(grille[choix] != testeur[0])
                              	{
                              		printf("C'est pri, joue ailleur\n\n");
                              		ok = 1;
                              	}
                              	else if(grille[choix] == testeur[0])
                              	{
                              		ok = 0;
                              	}
                              	return ok;
                              }
                              
                              , il nest pas encore terminé
                              • Partager sur Facebook
                              • Partager sur Twitter
                                15 décembre 2010 à 19:18:04

                                salut j ai u un problème comme sa, qui venait du faite que tu commence ta grille a "0" est mon a "1". donc la case 1 est en fait grille[0].
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  15 décembre 2010 à 22:30:30

                                  @coyote60 :
                                  ligne 224 : fonction installation ? je connais pas, le compilateur non plus
                                  Les variables i et coupJouer sont à supprimer, elles ne sont pas utilisées
                                  Tu n'as pas inclus time.h
                                  Tes fonctions qui ne prennent aucun argument devraient avoir 'void' en argument
                                  Osef des fonctions de suppression d'affichage
                                  (rand() % (2 - 1 + 1)) + 1 --> Tu penses pas que tu peux supprimer les calculs inutiles T_T
                                  Ta fonction quelleJoueur n'a pas un nom très explicite non plus
                                  Ta fonction jouerCoup attend int *grille et non int *grille[]
                                  Ta fonction de saisie est appelée avant d'être déclarée
                                  Je pense que tu peux simplifier ces instructions :

                                  .
                                        if(joueur == 1)
                                        {
                                          grille[coup] = 1;
                                        }
                                        if(joueur == 2)
                                        {
                                          grille[coup] = 2;
                                        }
                                  

                                  Ta fonction testerGagnant fait aussi de l'affichage, une chose par fonction
                                  Les switch pour tester 1 ou 2 conditions ne sont pas utiles, ils allourdissent le code inutilement
                                  Une chose très importante à mes yeux T_T : corrige les fautes d'orthographe, il existe des dictionnaires, des bescherelles pour ça, utilises les par pitié... T_T T_T

                                  @molipate : Mets ton code entre balises 'secret' stp
                                  Pour ton problème, affiche ta grille après que le joueur aie joué la case, je pense que ça devrait résoudre ton problème. :-°
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    15 décembre 2010 à 22:51:36

                                    Génial! Je participe! ^^
                                    ( je poste pour avoir un suivi )
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      16 décembre 2010 à 19:22:06

                                      j ai essayer d'appliquer tous vous modification ( a par s elle du "testGagnant" pour test que le coup jouer il faut que je la refasse sa va me prendre plus de temps :euh:)

                                      j ai aussi essayer de corrige mai faute :euh: (il en a sûrement encore désolé )

                                      par contre le "scanf" me renvoi un warning, est je s est pas pour quoi ?


                                      /*  Par : Coyote
                                      	Jeux du morpion en console (exo pour le site du zéro)
                                      */
                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      #include <time.h>
                                      
                                      //taille de la grille
                                      #define NOMBRE_DE_LIGNE 3
                                      #define NOMBRE_DE_CASE (NOMBRE_DE_LIGNE * NOMBRE_DE_LIGNE)
                                      
                                      
                                      
                                      //initialisation des variables 
                                      void initialisation(int *Pjoueur, int *grille)
                                      {
                                      	int i = 0;
                                      
                                      	//mise a zéro de la grille
                                      	for(i=0;i<NOMBRE_DE_CASE;i++)
                                      		{
                                      			grille[i] = 0;
                                      		}
                                      
                                      	*Pjoueur = 0;
                                      }
                                      
                                      void choixDuJoueur(int *Pjoueur)
                                      {
                                      	if(!*Pjoueur)
                                      	{
                                      		*Pjoueur = rand() % 2 + 1;
                                      		printf("joueur %d commence !\n",*Pjoueur);
                                      	}
                                      	if(*Pjoueur == 1)
                                      	{
                                      		*Pjoueur = 2;
                                      	}
                                      	else
                                      	{
                                      		*Pjoueur = 1;
                                      	}
                                      	
                                      }
                                      
                                      void affichage(const int grille[], int joueur)
                                      {
                                      	int i = 0, ligne = 0;
                                      	
                                      	
                                      	for(i=0;i<NOMBRE_DE_CASE;i++)
                                      	{
                                      		switch(grille[i])
                                      		{
                                      			case 0:
                                      				printf(".");
                                      				break;
                                      			case 1:
                                      				printf("x");
                                      				break;
                                      			case 2:
                                      				printf("o");
                                      				break;
                                      		}
                                      		ligne++;
                                      		if(ligne == NOMBRE_DE_LIGNE)
                                      		{
                                      			printf("\n");
                                      			ligne = 0;
                                      		}
                                      	}
                                      	printf("joueur %d:",joueur);
                                      }
                                      
                                      int saisie(void)
                                      {
                                      	int coupJouer = 0;
                                      
                                      	do
                                      	{
                                      		scanf("%d",&coupJouer);
                                      
                                      		if((coupJouer > 0 )&&(coupJouer <= NOMBRE_DE_CASE))
                                      		{
                                      			return coupJouer;
                                      		}
                                      		else
                                      		{
                                      			printf("\nle nombre n'est pas valide choisi un autre nombre :");
                                      		}
                                      
                                      	}while(1);
                                      	
                                      }
                                      
                                      void jouerCoup(int *grille,const int joueur)
                                      {
                                      	int coup = 0, coupBon = 0;
                                      
                                      	do
                                      	{
                                      		//-1 pour rattraper 
                                       		coup = (saisie() - 1);
                                      		//vérifié si le coup est jouable et le place dans la grille
                                      		if(grille[coup] == 0)
                                      		{
                                      			coupBon = 0;
                                      			grille[coup] = joueur;
                                      		}
                                      		else
                                      		{
                                      			coupBon = 1;
                                      			printf("\nvous ne pouvez pas jouez cet case choisissez une autre case :");
                                      		}
                                      	}while(coupBon);
                                      
                                      }
                                      
                                      int testGagnant(const int grille[],const int joueur)
                                      {
                                      	int i = 0,l = 0,
                                      		gagne[4] = {0}, partieNul = 0;
                                      
                                      	for(i=0;i<NOMBRE_DE_LIGNE;i++)
                                      	{
                                      		for(l=0;l<NOMBRE_DE_LIGNE;l++)
                                      		{
                                      			//test les horizontal
                                      			if ((grille[(NOMBRE_DE_LIGNE * i)] != 0) && (grille[(NOMBRE_DE_LIGNE * i)] == grille[(l+(NOMBRE_DE_LIGNE * i))]))
                                      			{
                                      				gagne[0]++;
                                      				
                                      			}
                                      			//.........
                                      			//test les vertical
                                      			if ((grille[i] != 0) && (grille[i] == grille[(l * NOMBRE_DE_LIGNE + i)]))
                                      			{
                                      				gagne[1]++;
                                      				
                                      			}
                                      			//........
                                      			// test des diagonal
                                      			if(i == 0)
                                      			{
                                      				if((grille[i] !=0) && (grille[i] == grille[(l * NOMBRE_DE_LIGNE)+ l]))
                                      				{
                                      					gagne[2]++;
                                      				}
                                      				if((grille[NOMBRE_DE_LIGNE -1] !=0) && (grille[NOMBRE_DE_LIGNE - 1] == grille[(NOMBRE_DE_LIGNE - 1) + (l*(NOMBRE_DE_LIGNE - 1))]))
                                      				{
                                      					gagne[3]++;
                                      				}
                                      			}
                                      			//............
                                      			//test si partie nul
                                      			if (grille[(l+(NOMBRE_DE_LIGNE * i))] == 0)
                                      			{
                                      				partieNul++;
                                      			}
                                      		}
                                      		//verifie si une ligne gagnant
                                      		for(l=0;l<4;l++)
                                      		{
                                      			if(gagne[l] >= NOMBRE_DE_LIGNE)
                                      			{
                                      				printf("\nle joueur %d a gagner !",joueur);
                                      				return 0;
                                      			}
                                      			else //si non remis a 0
                                      			{
                                      				gagne[l] = 0;
                                      			}
                                      		}
                                      	}
                                      	//...............
                                      
                                      	if(partieNul > 0)
                                      	{
                                      		return 1;
                                      	}
                                      	//si match nul
                                      	else
                                      	{
                                      		printf("\nmatch nul !");
                                      		return 0;
                                      	}
                                      			
                                      }
                                      
                                      int main(void)
                                      {
                                      	int joueur = 0,
                                      		grille[NOMBRE_DE_CASE];
                                      	
                                      	srand(time(NULL));
                                      
                                      	//boucle pour rejouer
                                      	do
                                      	{		
                                      		initialisation(&joueur, grille);	
                                      		//boucle du jeux
                                      		do
                                      		{
                                      						
                                      			choixDuJoueur(&joueur);
                                      
                                      			affichage(grille,joueur);
                                      									
                                      			jouerCoup(grille, joueur);
                                      									
                                      		}while(testGagnant(grille,joueur));
                                      
                                      	printf("\nvous rejouez 1.NON 2.OUI ?:");
                                      	}while(saisie() != 1);
                                          
                                      	return 0;
                                      }
                                      



                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        16 décembre 2010 à 23:24:10

                                        Tiens je me rends compte que je n'ai pas publier mon dernier code.

                                        Améliorer grâce à Pouet_forever.
                                        #include <stdio.h>
                                        #include <stdlib.h>
                                        
                                        #define TAILLE_X 3
                                        #define TAILLE_Y 3
                                        
                                        #define verifY(x) if(x==TAILLE_Y) return 1
                                        #define verifX(x) if(x==TAILLE_X) return 1
                                        
                                        
                                        int	testerCoup(int, int[][TAILLE_X]);
                                        void	jouerCoup(int, char, int[][TAILLE_X]);
                                        void	tourJoueur(int, int[][TAILLE_X], int*);
                                        int	testerGagnant(int[][TAILLE_X], int);
                                        int	diagonale(int[][TAILLE_X]);
                                        void	show(int [][TAILLE_X]);
                                        void	jouer();
                                        
                                        
                                        int	testerCoup(int entrerUser, int tab[][TAILLE_X])
                                        {
                                        	return entrerUser <= (TAILLE_X * TAILLE_Y) && entrerUser >= 0 && !tab[entrerUser / TAILLE_X][entrerUser % TAILLE_X];
                                        }
                                        void	jouerCoup(int entrerUser, char c, int tab[][TAILLE_X])
                                        {
                                        	tab[entrerUser / TAILLE_X][entrerUser % TAILLE_X] = c;
                                        }
                                        void	tourJoueur(int qui, int tab[][TAILLE_X], int* carac)
                                        {
                                        	printf("Joueur %d :", qui);
                                        	do
                                        	{
                                        		scanf("%d", carac);
                                        		(*carac)--;
                                        	}while(!testerCoup(*carac, tab));
                                        	jouerCoup(*carac, ((qui-1)?'O':'X'), tab); // Affiche 'O' pour le joueur 2 et 'X' pour le joueur 1
                                        	show(tab);
                                        }
                                        int	diagonale(int tab[][TAILLE_X])
                                        {
                                        
                                        	/* On vérifie une diagonale (gauche-haut jusqu'à droite-bas)*/
                                        	int i = 0;
                                        	char c = 0;
                                        	if(tab[0][0])
                                        		for(i = 1,c = tab[0][0];i < TAILLE_Y;i++)
                                        			if(c != tab[i][i])
                                        				break;
                                        	verifY(i);
                                        
                                        	/* On vérifie l'autre diagonale (droit-haut jusqu'à gauche-bas)*/
                                        	if(tab[0][TAILLE_X-1])
                                        		for(i = 1,c = tab[0][TAILLE_X-1];i < TAILLE_Y;i++)
                                        			if(c != tab[i][TAILLE_X - i - 1])
                                        				break;
                                        	verifY(i);
                                        	return 0;
                                        }
                                        
                                        int	testerGagnant(int tab[][TAILLE_X], int entrerUser)
                                        {
                                        	int i=0;
                                        	char c = 0;
                                        
                                        	if(TAILLE_Y == TAILLE_X)
                                        		if(diagonale(tab))
                                        			return 1;
                                        
                                        	/*On vérifie toutes les collones*/
                                        	for(i = 1, c = tab[entrerUser / TAILLE_X][0];i < TAILLE_X;i++) // Je vais laissez en une seule boucle car 1 boucles serait trop nuisible à la lisibilité du code
                                        		if(c != tab[entrerUser / TAILLE_X][i])
                                        			break;
                                        	verifX(i);
                                        
                                        	/* De la même manière on vérifie les lignes */
                                        	for(i = 1, c = tab[0][entrerUser % TAILLE_X];i < TAILLE_Y;i++)
                                        		if(c != tab[i][entrerUser % TAILLE_X])
                                        			break;
                                        	verifY(i);
                                        
                                        	return 0;
                                        
                                        }
                                        void	show(int tab[][TAILLE_X])
                                        {
                                        	int x, y;
                                        	
                                        	for(y = 0;y < TAILLE_Y;y++, printf("\n"))
                                        		for(x = 0;x < TAILLE_X;x++) // Parcour de toute la grille
                                        			printf("%c",(tab[y][x]) ? tab[y][x] : '.');/* Si un joueur à utiliser une case on affiche ce qu'il a entrer sinon on affiche un point*/
                                        }
                                        void	jouer()
                                        {
                                        	int carac = 0, null = 0;
                                        	int tab[TAILLE_Y][TAILLE_X] = {0};// Grille du morpion
                                        
                                        	do
                                        		tourJoueur( (null++) % 2 + 1 /*On cherche le tour du joueur*/, tab, &carac);
                                        	while(!testerGagnant(tab, carac) && null != (TAILLE_X * TAILLE_Y));
                                        	if(testerGagnant(tab, carac))
                                        		printf("Joueur %d a gagne\n", (null-1) % 2 + 1);
                                        		
                                        	else 
                                        		printf("Match nul\n");
                                        	
                                        }
                                        int	main(void)
                                        {
                                        	int c = 0;
                                        	do
                                        	{
                                        		jouer();
                                        		puts("Voulez-vous rejouer ? 0 pour non :");
                                        		scanf("%d", &c);
                                        	}while(c);
                                        
                                        	return EXIT_SUCCESS;
                                        }
                                        
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                          17 décembre 2010 à 18:31:46

                                          Voila , comme promis, un examplaire du code terminé et remixé, le voila :

                                          #include <stdio.h>
                                          #include <stdlib.h>
                                          #include <time.h>
                                          
                                          void affichage(char grille[]);
                                          int demande(void);
                                          int teste_Case(int choix, char grille[]);
                                          int teste_Case(int choix, char grille[]);
                                          int teste_Gagnant(int compteur, char grille[], int joueur);
                                          
                                          int main(int argv, char *argc[])
                                          {
                                          	srand(time(NULL));
                                          	int gagne = 1;
                                          	int choix;
                                          	int c = 2;
                                          	int compteur = 0;
                                          	int ok;
                                          	int joueur = rand() % c + 1;
                                          	char grille[9] = {'0', '1', '2', '3','4', '5', '6', '7', '8'};
                                          
                                          	printf("\t\t\t===MORPION===\n\n");
                                          
                                          	while(gagne)
                                          	{
                                          		compteur++;
                                          		do
                                          		{
                                          			printf("Ou veux tu jouer, JOUEUR%d ?\n", joueur);
                                          			choix = demande();
                                          			ok = teste_Case(choix, grille);
                                          		}while(ok);
                                          
                                          		if(joueur == 1)
                                          		{
                                          			grille[choix] = 'o';
                                          			affichage(grille);
                                          			gagne = teste_Gagnant(compteur, grille, joueur);
                                          			joueur++;
                                          		}
                                          		else if(joueur == 2)
                                          		{
                                          			grille[choix] = 'x';
                                          			affichage(grille);
                                          			gagne = teste_Gagnant(compteur, grille, joueur);
                                          			joueur--;
                                          		}
                                          
                                          
                                          
                                          	}
                                          
                                          	return 0;
                                          }
                                          
                                          void affichage(char grille[])
                                          {
                                          	printf("%c  %c  %c\n\n", grille[0], grille[1], grille[2]);
                                          	printf("%c  %c  %c\n\n", grille[3], grille[4], grille[5]);
                                          	printf("%c  %c  %c\n\n", grille[6], grille[7], grille[8]);
                                          }
                                          
                                          int demande(void)
                                          {
                                          	int choix;
                                          	printf("Je joue sur la case n°");
                                          	scanf("%d", &choix);
                                          	printf("\n\n");
                                          	return choix;
                                          }
                                          
                                          int teste_Case(int choix, char grille[])
                                          {
                                          	char test[9] = {'0', '1', '2', '3','4', '5', '6', '7', '8'};
                                          	int ok = 0;
                                          
                                          	if(grille[choix] != test[choix])
                                          	{
                                          		printf("Haha, tricheur, case prise, Haha, rejoue\n\n");
                                          		ok = 1;
                                          	}
                                          
                                          
                                          	return ok;
                                          }
                                          
                                          int teste_Gagnant(int compteur, char grille[], int joueur)
                                          {
                                          	int gagne = 1;
                                          	if(compteur == 9)
                                          	{
                                          		printf("Match null ...\n");
                                          		gagne = 0;
                                          	}
                                          	else if(grille[0] == grille[1] && grille[1] == grille[2] || grille[3] == grille[4] && grille[4] == grille[5] ||
                                          			grille[6] == grille[7] && grille[7] == grille[8] || grille[0] == grille[3] && grille[3] == grille[6] ||
                                          			grille[1] == grille[4] && grille[4] == grille[7] || grille[2] == grille[5] && grille[5] == grille[8] ||
                                          			grille[0] == grille[4] && grille[4] == grille[8] || grille[2] == grille[4] && grille[4] == grille[6])
                                          	{
                                          		printf("JOUEUR%d a gagne, Bravo", joueur);
                                          		gagne = 0;
                                          	}
                                          
                                          	return gagne;
                                          }
                                          


                                          edit: désoler de pas l'avoir mis en secret
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            17 décembre 2010 à 19:03:34

                                            Citation : Pouet_forever

                                            @molipate : Mets ton code entre balises 'secret' stp

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              20 décembre 2010 à 0:52:05

                                              @moliplate :
                                              Tu n'utilises pas les argc et argv, inutile de les déclarer dans le main. D'ailleurs tu as inversé argc et argv. argc sert à compter le nombre d'arguments : ARGument Count et argv ARGument Vector.
                                              On préfèrera appeler les fonctions après les déclarations de variables (srand).
                                              Ton nom de variable pour la boucle est mal choisi je trouve. Si je traduit ta boucle ça fait : Tant que j'ai 'gagne' je boucle. :-°
                                              J'ai pas bien saisi pourquoi tu crée un tableau dans ta fonction teste_Case. :euh:
                                              Tu pourrais améliorer ton if...else dans ta boucle principale histoire d'éviter tes répétitions.
                                              Dans ta fonction teste_Gagnant tu devrais mettre des parenthèses.
                                              Ta condition d'arrêt est fausse :

                                              o  x  o
                                              
                                              o  x  x
                                              
                                              o  o  x
                                              
                                              Match null ...


                                              @@che : (trop fort le @@)
                                              Comme je t'ai dis, à mon goût ya encore des choses à améliorer. :)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                20 décembre 2010 à 1:10:21

                                                Citation : Pouet_forever

                                                @@che : (trop fort le @@)
                                                Comme je t'ai dis, à mon goût ya encore des choses à améliorer. :)


                                                Ouais mais bon pour moi c'est convenable. Au pire je peux mettre void comme paramètre à jouer(), mais bon pfff... J'ai la flemme.

                                                <hs> @@ enfin quelqu'un qui mets les deux @@ y avais sofEvans qui l'avait fais aussi, il avait mit un espace entre les deux.. :p </hs>
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                                  21 décembre 2010 à 18:13:40

                                                  Comme promis, voici ma contribution au zMorp :

                                                  #include <stdio.h>
                                                  #include <stdlib.h>
                                                  #include <time.h>
                                                  
                                                  int end_game(char tab[][3])
                                                  {
                                                      int i;
                                                  
                                                      for(i=0;i<3;i++)/*On vérifie les lignes et les colonnes*/
                                                      {
                                                          if(tab[0][i] != '.' && tab[0][i] == tab[1][i] && tab[1][i] == tab[2][i])
                                                          {
                                                              printf("\nLe joueur %d a gagné", (tab[0][i]=='X')+1);
                                                              return 0;
                                                          }
                                                          else if(tab[i][0] != '.' && tab[i][0]==tab[i][1] && tab[i][1]==tab[i][2])
                                                          {
                                                              printf("\nLe joueur %d a gagné", (tab[i][0]=='X')+1);
                                                              return 0;
                                                          }
                                                      }
                                                  
                                                      if(tab[0][0] != '.' && tab[0][0]==tab[1][1] && tab[1][1]==tab[2][2])/*On vérifie une diagonale*/
                                                      {
                                                          printf("\nLe joueur %d a gagné", (tab[1][1]=='X')+1);
                                                          return 0;
                                                      }
                                                      else if(tab[0][2] != '.' && tab[0][2]==tab[1][1] && tab[1][1]==tab[2][0])/*On vérifie l'autre*/
                                                      {
                                                          printf("\nLe joueur %d a gagné", (tab[1][3]=='X')+1);
                                                          return 0;
                                                      }
                                                  
                                                      for(i=0;i<9;i++)/*On vérifie si il n'y a pas de match nul*/
                                                      {
                                                          if(tab[i/3][i%3]!='X' || tab[i/3][i%3]!='O')
                                                              return 1;
                                                  
                                                          if(i==8)
                                                              printf("\nMatch nul !");
                                                      }
                                                  
                                                      return 0;
                                                  }
                                                  
                                                  void treat_input(char tab[][3], int entry, int player)
                                                  {
                                                      if(entry<9 && entry>=0)
                                                      {
                                                          if(player==1)
                                                              tab[entry/3][entry%3]='O';
                                                          else
                                                              tab[entry/3][entry%3]='X';
                                                      }
                                                  }
                                                  
                                                  void display_tab(char tab[][3])
                                                  {
                                                      int i;
                                                  
                                                      for(i=0;i<9;i++)
                                                      {
                                                          if(!(i%3))
                                                              printf("\n\n");
                                                          printf("%c ", tab[i/3][i%3]);
                                                      }
                                                  }
                                                  
                                                  int game(void)
                                                  {
                                                      int entry=0, player=0;
                                                      char tab[3][3]={{'.', '.', '.'}, {'.', '.', '.'}, {'.', '.', '.'}};
                                                  
                                                      srand(time(NULL));
                                                      player=rand()%2+1; /*détermine quel est le joueur qui joue le premier*/
                                                  
                                                      printf("Au joueur %d de commencer\n", player);
                                                      display_tab(tab);
                                                  
                                                      do
                                                      {
                                                  
                                                          printf("\nJoueur %d : ", player);
                                                          scanf("%d", &entry);
                                                          entry--;/*On décrémente d'un pour faire correspondre l'entrée avec les indices du tableau*/
                                                  
                                                          treat_input(tab, entry, player);
                                                  
                                                          display_tab(tab);
                                                  
                                                          player=(player)%2+1; /*on change le joueur*/
                                                      }while(end_game(tab));/*Tant que la partie n'est pas finie*/
                                                  
                                                      return 0;
                                                  }
                                                  
                                                  int main(void)
                                                  {
                                                      char c;
                                                  
                                                      do
                                                      {
                                                          game();
                                                          while(getchar()!='\n');/*On vide le buffer*/
                                                          printf("Voulez vous rejouer ? (o/n) : ");
                                                          scanf("%c", &c);
                                                      }while(c!='n');
                                                  
                                                      return 0;
                                                  }
                                                  


                                                  J'ai également plusieurs questions du coup :
                                                  - Est-ce qu'il est mieux de mettre mon tableau en variable globale, et de l'initialiser à cha<ue début de partie, ou bien comme je fais actuellement ?
                                                  - Dans certaines fonctions, je fais plusieurs fois le même calcul (entry/3 et entry%3 par exemple). Le mieux est-il de laisser tel quel ou de créer une variable, faire le calcul une bonne fois pour toutes, puis d'utiliser ces variables pour accéder aux éléments de mon tableau ?
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    21 décembre 2010 à 21:14:24

                                                    Citation : baki

                                                    Comme promis, voici ma contribution au zMorp :


                                                    Bien je l'attendais . :diable:

                                                    Citation : baki

                                                    - Est-ce qu'il est mieux de mettre mon tableau en variable globale, et de l'initialiser à cha<ue début de partie, ou bien comme je fais actuellement ?


                                                    Non car tu vas te faire réprimander par Pouet_Forever. :p


                                                    Citation : baki

                                                    - Dans certaines fonctions, je fais plusieurs fois le même calcul (entry/3 et entry%3 par exemple). Le mieux est-il de laisser tel quel ou de créer une variable, faire le calcul une bonne fois pour toutes, puis d'utiliser ces variables pour accéder aux éléments de mon tableau ?


                                                    Je sais pas moi j'aurais mis une define. A mon avis c'est toi qui vois.

                                                    Sinon petite erreur dans ton code, un joueur peut remplacer une croix par un rond. Facile si on a envi de gagner :lol:
                                                    Joueur 1 : 1
                                                    
                                                    
                                                    O . . 
                                                    
                                                    . . . 
                                                    
                                                    . . . 
                                                    Joueur 2 : 1
                                                    
                                                    
                                                    X . . 
                                                    
                                                    . . . 
                                                    
                                                    . . .

                                                    Sinon aussi tu ne gères pas les match nul (et c'est la que j'ai remarquer le bug précédents qui m'a permis de terminer la partie)
                                                    Joueur 1 : 9
                                                    
                                                    
                                                    X O X 
                                                    
                                                    . O X 
                                                    
                                                    O X O 
                                                    Joueur 2 : 4
                                                    
                                                    
                                                    X O X 
                                                    
                                                    X O X 
                                                    
                                                    O X O 
                                                    Joueur 1 : 1
                                                    
                                                    
                                                    O O X 
                                                    
                                                    X O X 
                                                    
                                                    O X O 
                                                    Le joueur 1 a gagnéVoulez vous rejouer ? (o/n) :
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                                      22 décembre 2010 à 13:39:39

                                                      Voici mon programme en mode Joueur contre Joueur :

                                                      #include <stdio.h>
                                                      #include <stdlib.h>	// pour l19/20 (srand)
                                                      #include <time.h>	// pour l19/20 (time)
                                                      
                                                      void Afficher(char c[]);
                                                      int verif_fin(char c[], char car);
                                                      int verif_case(char c[], int pos);
                                                      
                                                      int main(void)
                                                      {
                                                      	int end=1, win1=0, win2=0, j, fin, pos, possible;
                                                      	char c[9], car;
                                                      
                                                      	do {
                                                      		c[0] = '1', c[1] = '2', c[2] = '3', c[3] = '4', c[4] = '5', c[5] = '6', c[6] = '7', c[7] = '8', c[8] = '9';
                                                      		fin=0;
                                                      		possible=1;
                                                      
                                                      		srand(time(NULL));
                                                      		j = (rand() % (2 - 1 + 1)) + 1;
                                                      
                                                      		system("clear");
                                                      		Afficher(c);
                                                      
                                                      		do {
                                                      			if (j == 1)
                                                      			{
                                                      					printf("\n Joueur 1 :\t");
                                                      					scanf("%d", &pos);
                                                      					j = 2;
                                                      					car = 'X';
                                                      			}
                                                      
                                                      			else
                                                      			{
                                                      					printf("\n Joueur 2 :\t");
                                                      					scanf("%d", &pos);
                                                      					j = 1;
                                                      					car = 'O';
                                                      			}
                                                      
                                                      					possible = verif_case(c, pos);
                                                      
                                                      					if (possible == 0 || pos > 9 || pos < 1)
                                                      					{
                                                      						do {
                                                      							printf("\n Case déjà remplie, ou mauvais chiffre entré. Veuillez recommencer :\t");
                                                      							scanf("%d", &pos);
                                                      							possible = verif_case(c, pos);
                                                      						} while (possible == 0);
                                                      					}
                                                      			
                                                      			c[pos-1] = car;
                                                      
                                                      			system("clear");
                                                      			Afficher(c);
                                                      			fin = verif_fin(c, car);
                                                      
                                                      		} while (fin == 0);
                                                      
                                                      		if (fin == 3)
                                                      		{
                                                      			printf("\n\nMatch nul.\n\n");
                                                      		}
                                                      
                                                      		else
                                                      		{
                                                      			printf("\n\nVictoire du joueur %d.\n\n", fin);
                                                      		}
                                                      
                                                      		if (fin == 1)
                                                      		{
                                                      			win1++;
                                                      		}
                                                      
                                                      		if (fin == 2)
                                                      		{
                                                      			win2++;
                                                      		}
                                                      
                                                      		printf("\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
                                                      		scanf("%d", &end);
                                                      
                                                      	} while (end == 1);
                                                      
                                                      	if (win1 > win2)
                                                      	{
                                                      		printf("Victoire %d à %d du joueur 1.\n\n", win1, win2);
                                                      	}
                                                      
                                                      	if (win1 == win2)
                                                      	{
                                                      		printf("Égalité %d partout.\n\n", win1);
                                                      	}
                                                      
                                                      	if (win1 < win2)
                                                      	{
                                                      		printf("\nVictoire %d à %d du joueur 2.\n\n", win2, win1);
                                                      	}
                                                      
                                                      	return 0;
                                                      }
                                                      
                                                      
                                                      
                                                      ////////////////////////////////////////////////////////////////
                                                      void Afficher(char c[])
                                                      {
                                                      	printf("\n\t\t ___________");
                                                      	printf("\n\t\t|   |   |   |");
                                                      	printf("\n\t\t| %c | %c | %c |", c[0], c[1], c[2]);
                                                      	printf("\n\t\t|___|___|___|");
                                                      	printf("\n\t\t|   |   |   |");
                                                      	printf("\n\t\t| %c | %c | %c |", c[3], c[4], c[5]);
                                                      	printf("\n\t\t|___|___|___|");
                                                      	printf("\n\t\t|   |   |   |");
                                                      	printf("\n\t\t| %c | %c | %c |", c[6], c[7], c[8]);
                                                      	printf("\n\t\t|___|___|___|\n");
                                                      }
                                                      
                                                      
                                                      
                                                      int verif_fin(char c[], char car)
                                                      {
                                                      	int fin = 0;
                                                      
                                                      	if ( (c[0] == c[1] && c[1] == c[2]) || (c[3] == c[4] && c[4] == c[5]) || (c[6] == c[7] && c[7] == c[8]) || (c[0] == c[3] && c[3] == c[6]) || (c[1] == c[4] && c[4] == c[7]) || (c[2] == c[5] && c[5] == c[8]) || (c[0] == c[4] && c[4] == c[7]) || (c[2] == c[4] && c[4] == c[6]))
                                                      	{
                                                      		if (car == 'X')
                                                      		{
                                                      			fin = 1;
                                                      		}
                                                      
                                                      		else
                                                      		{
                                                      			fin = 2;
                                                      		}
                                                      	}
                                                      
                                                      	if ( c[0] != '1' && c[1] != '2' && c[2] != '3' && c[3] != '4' && c[4] != '5' && c[5] != '6' && c[6] != '7' && c[7] != '8' && c[8] != '9' && fin !=1 && fin !=2 )
                                                      	{
                                                      		fin = 3;
                                                      	}
                                                      
                                                      	return(fin);
                                                      }
                                                      
                                                      
                                                      
                                                      int verif_case(char c[], int pos)
                                                      {
                                                      	int res;
                                                      
                                                      	if ( (pos==1 && c[0]!='1') || (pos==2 && c[1]!='2') || (pos==3 && c[2]!='3') || (pos==4 && c[3]!='4') || (pos==5 && c[4]!='5') || (pos==6 && c[5]!='6') || (pos==7 && c[6]!='7') || (pos==8 && c[7]!='8') || (pos==9 && c[8]!='9') || pos > 9 || pos < 1 )
                                                      	{
                                                      		res=0;
                                                      	}
                                                      
                                                      	else
                                                      	{
                                                      		res=1;
                                                      	}
                                                      
                                                      	return(res);
                                                      }
                                                      



                                                      Il y a sans doutes des choses à améliorer, mais bon j'en suis assez satisfait.

                                                      Je vais maintenant essayer de me lancer dans une IA.


                                                      Si vous avez des remarques/conseils/corrections à apporter, n'hésitez pas !
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        22 décembre 2010 à 14:19:01

                                                        J'ai bien la gestion du nombre de parti gagner, l'affichage bof(j'aime plutôt les affichages classiques) mais celui-ci est pas mal, main un peu surcharger.

                                                        Sinon dans l'ensemble pas mal, parcontre mauvaise gestion de qui à gagner:
                                                                        |   |   |   |
                                                                        | X | O | X |
                                                                        |___|___|___|
                                                                        |   |   |   |
                                                                        | O | X | O |
                                                                        |___|___|___|
                                                                        |   |   |   |
                                                                        | 7 | X | 9 |
                                                                        |___|___|___|
                                                        
                                                        
                                                        Victoire du joueur 1.
                                                        
                                                                Rejouer ?        1. Oui
                                                                                2. Non
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                                          22 décembre 2010 à 14:52:47

                                                          @ Pouet_forever : merci de tes conseil, j'ai tout changé ce que tu ma dis et voila mon code :
                                                          #include <stdio.h>
                                                          #include <stdlib.h>
                                                          #include <time.h>
                                                          
                                                          void affichage(char grille[]);
                                                          int demande(void);
                                                          int teste_Case(int choix, char grille[]);
                                                          int teste_Case(int choix, char grille[]);
                                                          int teste_Gagnant(int compteur, char grille[], int joueur);
                                                          
                                                          int main(void)
                                                          {
                                                          	srand(time(NULL));
                                                          	int Pasgagner = 1;
                                                          	int choix;
                                                          	int c = 2;
                                                          	int compteur = 0;
                                                          	int ok;
                                                          	int joueur;
                                                          	char grille[9] = {'0', '1', '2', '3','4', '5', '6', '7', '8'};
                                                          
                                                          	printf("\t\t\t===MORPION===\n\n");
                                                          	joueur = rand() % c + 1;
                                                          
                                                          	while(Pasgagner)
                                                          	{
                                                          		compteur++;
                                                          		do
                                                          		{
                                                          			printf("Ou veux tu jouer, JOUEUR%d ?\n", joueur);
                                                          			choix = demande();
                                                          			ok = teste_Case(choix, grille);
                                                          		}while(ok);
                                                          
                                                          		if(joueur == 1)
                                                          		{
                                                          			grille[choix] = 'o';
                                                          			affichage(grille);
                                                          			Pasgagner = teste_Gagnant(compteur, grille, joueur);
                                                          			joueur++;
                                                          		}
                                                          		else if(joueur == 2)
                                                          		{
                                                          			grille[choix] = 'x';
                                                          			affichage(grille);
                                                          			Pasgagner = teste_Gagnant(compteur, grille, joueur);
                                                          			joueur--;
                                                          		}
                                                          
                                                          
                                                          
                                                          	}
                                                          
                                                          	return 0;
                                                          }
                                                          
                                                          void affichage(char grille[])
                                                          {
                                                          	printf("%c  %c  %c\n\n", grille[0], grille[1], grille[2]);
                                                          	printf("%c  %c  %c\n\n", grille[3], grille[4], grille[5]);
                                                          	printf("%c  %c  %c\n\n", grille[6], grille[7], grille[8]);
                                                          }
                                                          
                                                          int demande(void)
                                                          {
                                                          	int choix;
                                                          	printf("Je joue sur la case n°");
                                                          	scanf("%d", &choix);
                                                          	printf("\n\n");
                                                          	return choix;
                                                          }
                                                          
                                                          int teste_Case(int choix, char grille[])
                                                          {
                                                          	char test[9] = {'0', '1', '2', '3','4', '5', '6', '7', '8'};
                                                          	int ok = 0;
                                                          
                                                          	if(grille[choix] != test[choix])
                                                          	{
                                                          		printf("Haha, tricheur, case prise, Haha, rejoue\n\n");
                                                          		ok = 1;
                                                          	}
                                                          
                                                          
                                                          	return ok;
                                                          }
                                                          
                                                          int teste_Gagnant(int compteur, char grille[], int joueur)
                                                          {
                                                          	int gagne = 1;
                                                          
                                                          	//teste horizontal:
                                                          	if((grille[0] == grille[1] && grille[1] == grille[2]) || (grille[3] == grille[4] && grille[4] == grille[5]) ||
                                                          			(grille[6] == grille[7] && grille[7] == grille[8]))
                                                          	{
                                                          		printf("JOUEUR%d a gagne, Bravo", joueur);
                                                          		gagne = 0;
                                                          	}
                                                          	//test vertical:
                                                          	else if((grille[0] == grille[3] && grille[3] == grille[6]) || (grille[1] == grille[4] && grille[4] == grille[7]) ||
                                                          			(grille[2] == grille[5] && grille[5] == grille[8]))
                                                          	{
                                                          		printf("JOUEUR%d a gagne, Bravo", joueur);
                                                          		gagne = 0;
                                                          	}
                                                          	//test diagonal:
                                                              else if((grille[0] == grille[4] && grille[4] == grille[8]) || (grille[2] == grille[4] && grille[4] == grille[6]))
                                                              {
                                                          		printf("JOUEUR%d a gagne, Bravo", joueur);
                                                          		gagne = 0;
                                                          	}
                                                          
                                                          	else if(compteur == 9)
                                                          	{
                                                          		printf("Match null ...\n");
                                                          		gagne = 0;
                                                          	}
                                                          	return gagne;
                                                          }
                                                          
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            22 décembre 2010 à 15:06:33

                                                            Erreur rectifiée :

                                                            #include <stdio.h>
                                                            #include <stdlib.h>	// pour l19/20 (srand)
                                                            #include <time.h>	// pour l19/20 (time)
                                                            
                                                            void Afficher(char c[]);
                                                            int verif_fin(char c[], char car);
                                                            int verif_case(char c[], int pos);
                                                            
                                                            int main(void)
                                                            {
                                                            	int end=1, win1=0, win2=0, j, fin, pos, possible;
                                                            	char c[9], car;
                                                            
                                                            	do {
                                                            		c[0] = '1', c[1] = '2', c[2] = '3', c[3] = '4', c[4] = '5', c[5] = '6', c[6] = '7', c[7] = '8', c[8] = '9';
                                                            		fin=0;
                                                            		possible=1;
                                                            
                                                            		srand(time(NULL));
                                                            		j = (rand() % (2 - 1 + 1)) + 1;
                                                            
                                                            		system("clear");
                                                            		Afficher(c);
                                                            
                                                            		do {
                                                            			if (j == 1)
                                                            			{
                                                            					printf("\n Joueur 1 :\t");
                                                            					scanf("%d", &pos);
                                                            					j = 2;
                                                            					car = 'X';
                                                            			}
                                                            
                                                            			else
                                                            			{
                                                            					printf("\n Joueur 2 :\t");
                                                            					scanf("%d", &pos);
                                                            					j = 1;
                                                            					car = 'O';
                                                            			}
                                                            
                                                            					possible = verif_case(c, pos);
                                                            
                                                            					if (possible == 0 || pos > 9 || pos < 1)
                                                            					{
                                                            						do {
                                                            							printf("\n Case déjà remplie, ou mauvais chiffre entré. Veuillez recommencer :\t");
                                                            							scanf("%d", &pos);
                                                            							possible = verif_case(c, pos);
                                                            						} while (possible == 0);
                                                            					}
                                                            			
                                                            			c[pos-1] = car;
                                                            
                                                            			system("clear");
                                                            			Afficher(c);
                                                            			fin = verif_fin(c, car);
                                                            
                                                            		} while (fin == 0);
                                                            
                                                            		if (fin == 3)
                                                            		{
                                                            			printf("\n\nMatch nul.\n\n");
                                                            		}
                                                            
                                                            		else
                                                            		{
                                                            			printf("\n\nVictoire du joueur %d.\n\n", fin);
                                                            		}
                                                            
                                                            		if (fin == 1)
                                                            		{
                                                            			win1++;
                                                            		}
                                                            
                                                            		if (fin == 2)
                                                            		{
                                                            			win2++;
                                                            		}
                                                            
                                                            		printf("\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
                                                            		scanf("%d", &end);
                                                            
                                                            	} while (end == 1);
                                                            
                                                            	if (win1 > win2)
                                                            	{
                                                            		printf("Victoire %d à %d du joueur 1.\n\n", win1, win2);
                                                            	}
                                                            
                                                            	if (win1 == win2)
                                                            	{
                                                            		printf("Égalité %d partout.\n\n", win1);
                                                            	}
                                                            
                                                            	if (win1 < win2)
                                                            	{
                                                            		printf("\nVictoire %d à %d du joueur 2.\n\n", win2, win1);
                                                            	}
                                                            
                                                            	return 0;
                                                            }
                                                            
                                                            
                                                            
                                                            ////////////////////////////////////////////////////////////////
                                                            void Afficher(char c[])
                                                            {
                                                            	printf("\n\t\t ___________");
                                                            	printf("\n\t\t|   |   |   |");
                                                            	printf("\n\t\t| %c | %c | %c |", c[0], c[1], c[2]);
                                                            	printf("\n\t\t|___|___|___|");
                                                            	printf("\n\t\t|   |   |   |");
                                                            	printf("\n\t\t| %c | %c | %c |", c[3], c[4], c[5]);
                                                            	printf("\n\t\t|___|___|___|");
                                                            	printf("\n\t\t|   |   |   |");
                                                            	printf("\n\t\t| %c | %c | %c |", c[6], c[7], c[8]);
                                                            	printf("\n\t\t|___|___|___|\n");
                                                            }
                                                            
                                                            
                                                            
                                                            int verif_fin(char c[], char car)
                                                            {
                                                            	int fin = 0;
                                                            
                                                            	if ( (c[0] == c[1] && c[1] == c[2]) || (c[3] == c[4] && c[4] == c[5]) || (c[6] == c[7] && c[7] == c[8]) || (c[0] == c[3] && c[3] == c[6]) || (c[1] == c[4] && c[4] == c[7]) || (c[2] == c[5] && c[5] == c[8]) || (c[0] == c[4] && c[4] == c[8]) || (c[2] == c[4] && c[4] == c[6]))
                                                            	{
                                                            		if (car == 'X')
                                                            		{
                                                            			fin = 1;
                                                            		}
                                                            
                                                            		else
                                                            		{
                                                            			fin = 2;
                                                            		}
                                                            	}
                                                            
                                                            	if ( c[0] != '1' && c[1] != '2' && c[2] != '3' && c[3] != '4' && c[4] != '5' && c[5] != '6' && c[6] != '7' && c[7] != '8' && c[8] != '9' && fin !=1 && fin !=2 )
                                                            	{
                                                            		fin = 3;
                                                            	}
                                                            
                                                            	return(fin);
                                                            }
                                                            
                                                            
                                                            
                                                            int verif_case(char c[], int pos)
                                                            {
                                                            	int res;
                                                            
                                                            	if ( (pos==1 && c[0]!='1') || (pos==2 && c[1]!='2') || (pos==3 && c[2]!='3') || (pos==4 && c[3]!='4') || (pos==5 && c[4]!='5') || (pos==6 && c[5]!='6') || (pos==7 && c[6]!='7') || (pos==8 && c[7]!='8') || (pos==9 && c[8]!='9') || pos > 9 || pos < 1 )
                                                            	{
                                                            		res=0;
                                                            	}
                                                            
                                                            	else
                                                            	{
                                                            		res=1;
                                                            	}
                                                            
                                                            	return(res);
                                                            }
                                                            



                                                            Pour l'IA je bug un peu pour l'instant, mais bon, ça va le faire :-°
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              22 décembre 2010 à 16:52:47

                                                              Citation : th-p

                                                              Pour l'IA je bug un peu pour l'instant, mais bon, ça va le faire :-°

                                                              Il faut vérifier si 2 croix (ou cercle) sont aligné et si oui lordi joue sur la derniere case de l'alignement.

                                                              il faut aussi voir si l'IA peux gagner avec cette contion puis de verifier si le joueur ne reisque pas de gagner avec la meme contion donc boucle
                                                              • 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