Partage
  • Partager sur Facebook
  • Partager sur Twitter

zMorp - 1ère partie

Créer un morpion

    22 décembre 2010 à 18:41:30

    Ah oui, pas bête.

    Donc voilà, en attendant la seconde partie, mon code avec le mode humain vs humain, et le monde humain vs IA :

    Code unixoïdes :

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    void Afficher(char c[]);
    int verif_fin(char c[], char car);
    int verif_case(char c[], int pos);
    int ia(char c[]);
    
    int main(void)
    {
    	int end=1, win1=0, win2=0, win3=0, j, fin, pos, possible, choix=1;
    	char c[9], car;
    
    	do {
    		system("clear");
    		printf("\n\t1 ou 2 joueurs ?\n");
    		scanf("%d", &choix);
    	} while (choix != 1 && choix != 2);
    
    	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)
    			{
    					if (pos >=1 && pos <=9 && car == 'O' && choix == 1)
    					{
    						printf("\n(l'IA a joué en %d )\n", pos);
    					}
    
    					printf("\n Joueur 1 :\t");
    					scanf("%d", &pos);
    					j = 2;
    					car = 'X';
    
    					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);
    					}
    			}
    
    			else
    			{
    				if (choix == 2)
    				{
    					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);
    					}
    				}
    
    				else
    				{
    					pos = ia(c);
    					j = 1;
    					car = 'O';
    
    					possible = verif_case(c, pos);
    
    					if (possible == 0)
    					{
    						do {
    							pos = ia(c);
    							possible = verif_case(c, pos);
    						} while (possible == 0);
    					}
    				}
    			}
    		
    			c[pos-1] = car;
    
    			system("clear");
    			Afficher(c);
    			fin = verif_fin(c, car);
    
    		} while (fin == 0);
    
    		car = ' ';
    
    		if (fin == 3)
    		{
    			printf("\nMatch nul.\n");
    			win3++;
    		}
    
    		if (fin == 1)
    		{
    			printf("\nVous avez gagné.\n");
    			win1++;
    		}
    
    		if (fin == 2)
    		{
    			printf("\nVous avez perdu.\n");
    			win2++;
    		}
    
    		printf("\n\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
    		scanf("%d", &end);
    
    	} while (end == 1);
    
    	if (win1 > win2 && choix == 2)
    	{
    		printf("\nVictoire %d à %d du joueur 1 (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	if (win1 > win2 && choix == 1)
    	{
    		printf("\nVous avez gagné %d à %d (%d match(s) nul(s)).\n\n", win1, win2, win3);
    	}
    
    	if (win1 == win2)
    	{
    		printf("\nÉgalité %d partout (%d match(s) nul(s)).\n\n", win1, win3);
    	}
    
    	if (win1 < win2 && choix == 2)
    	{
    		printf("\nVictoire %d à %d du joueur 2 (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	if (win1 < win2 && choix == 1)
    	{
    		printf("\nVictoire %d à %d de l'IA (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	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);
    }
    
    
    
    int ia(char c[])
    {
    	char pos, i, car = 'X', aleat;
    	pos = (rand() % (9 - 1 + 1)) + 1;
    	aleat = (rand() % (5 - 1 + 1)) + 1;
    
    	if (c[0] == '1' && aleat == 1)
    	{
    		pos = 1;
    	}
    	else if (c[0] != '1')
    	{
    		aleat = (rand() % (5 - 2 + 1)) + 1;
    	}
    	if (c[2] == '3' && aleat == 2)
    	{
    		pos = 3;
    	}
    	else if (c[2] != '3')
    	{
    		aleat = (rand() % (5 - 3 + 1)) + 1;
    	}
    	if (c[4] == '5' && aleat == 3)
    	{
    		pos = 5;
    	}
    	else  if (c[4] != '5')
    	{
    		aleat = (rand() % (5 - 4 + 1)) + 1;
    	}
    	if (c[6] == '7' && aleat == 4)
    	{
    		pos = 7;
    	}
    	else  if (c[5] != '7')
    	{
    		aleat = 5;
    	}	
    	if (c[8] == '9' && aleat == 5)
    	{
    		pos = 9;
    	}
    
    
    do {
    	/* lignes */
    	if (c[0] == car && c[1] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    	if (c[0] == car && c[2] == car && c[1] == '2')
    	{
    		pos = 2;
    	}
    	if (c[1] == car && c[2] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    
    	if (c[3] == car && c[4] == car && c[5] == '6')
    	{
    		pos = 6;
    	}
    	if (c[3] == car && c[5] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[4] == car && c[5] == car && c[3] == '4')
    	{
    		pos = 4;
    	}
    
    	if (c[6] == car && c[7] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[6] == car && c[8] == car && c[7] == '8')
    	{
    		pos = 8;
    	}
    	if (c[7] == car && c[8] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    
    	/* colonnes */
    	if (c[0] == car && c[3] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    	if (c[0] == car && c[6] == car && c[3] == '4')
    	{
    		pos = 4;
    	}
    	if (c[3] == car && c[6] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    
    	if (c[1] == car && c[4] == car && c[7] == '8')
    	{
    		pos = 8;
    	}
    	if (c[1] == car && c[7] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[4] == car && c[7] == car && c[1] == '2')
    	{
    		pos = 2;
    	}
    
    	if (c[2] == car && c[5] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[2] == car && c[8] == car && c[5] == '6')
    	{
    		pos = 6;
    	}
    	if (c[5] == car && c[8] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    
    	/* diagonales */
    	if (c[0] == car && c[4] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[4] == car && c[8] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    	if (c[0] == car && c[8] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    
    	if (c[6] == car && c[4] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    	if (c[6] == car && c[2] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[2] == car && c[4] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    
    	car = 'O';
    	i++;
    } while (i<2);
    
    	return (pos);
    }
    




    Code windows :

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    void Afficher(char c[]);
    int verif_fin(char c[], char car);
    int verif_case(char c[], int pos);
    int ia(char c[]);
    
    int main(void)
    {
    	int end=1, win1=0, win2=0, win3=0, j, fin, pos, possible, choix=1;
    	char c[9], car;
    
    	do {
    		//system("clear");
    		system("cls"); 
    
    		printf("\n\t1 ou 2 joueurs ?\n");
    		scanf("%d", &choix);
    	} while (choix != 1 && choix != 2);
    
    	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");
    		system("cls"); 
    
    		Afficher(c);
    
    		do {
    			if (j == 1)
    			{
    					if (pos >=1 && pos <=9 && car == 'O' && choix == 1)
    					{
    						printf("\n(l'IA a joue en %d )\n", pos);
    					}
    
    					printf("\n Joueur 1 :\t");
    					scanf("%d", &pos);
    					j = 2;
    					car = 'X';
    
    					possible = verif_case(c, pos);
    
    					if (possible == 0 || pos > 9 || pos < 1)
    					{
    						do {
    							printf("\n Case deja remplie, ou mauvais chiffre entre. Veuillez recommencer :\t");
    							scanf("%d", &pos);
    							possible = verif_case(c, pos);
    						} while (possible == 0);
    					}
    			}
    
    			else
    			{
    				if (choix == 2)
    				{
    					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 deja remplie, ou mauvais chiffre entre. Veuillez recommencer :\t");
    							scanf("%d", &pos);
    							possible = verif_case(c, pos);
    						} while (possible == 0);
    					}
    				}
    
    				else
    				{
    					pos = ia(c);
    					j = 1;
    					car = 'O';
    
    					possible = verif_case(c, pos);
    
    					if (possible == 0)
    					{
    						do {
    							pos = ia(c);
    							possible = verif_case(c, pos);
    						} while (possible == 0);
    					}
    				}
    			}
    		
    			c[pos-1] = car;
    
    			//system("clear");
    			system("cls"); 
    
    			Afficher(c);
    			fin = verif_fin(c, car);
    
    		} while (fin == 0);
    
    		car = ' ';
    
    		if (fin == 3)
    		{
    			printf("\nMatch nul.\n");
    			win3++;
    		}
    
    		if (fin == 1)
    		{
    			printf("\nVous avez gagne.\n");
    			win1++;
    		}
    
    		if (fin == 2)
    		{
    			printf("\nVous avez perdu.\n");
    			win2++;
    		}
    
    		printf("\n\tRejouer ?\t1. Oui\n\t\t\t2. Non\t\t");
    		scanf("%d", &end);
    
    	} while (end == 1);
    
    	if (win1 > win2 && choix == 2)
    	{
    		printf("\nVictoire %d a %d du joueur 1 (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	if (win1 > win2 && choix == 1)
    	{
    		printf("\nVous avez gagne %d a %d (%d match(s) nul(s)).\n\n", win1, win2, win3);
    	}
    
    	if (win1 == win2)
    	{
    		printf("\nEgalite %d partout (%d match(s) nul(s)).\n\n", win1, win3);
    	}
    
    	if (win1 < win2 && choix == 2)
    	{
    		printf("\nVictoire %d a %d du joueur 2 (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	if (win1 < win2 && choix == 1)
    	{
    		printf("\nVictoire %d a %d de l'IA (%d match(s) nul(s)).\n\n", win2, win1, win3);
    	}
    
    	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);
    }
    
    
    
    int ia(char c[])
    {
    	char pos, i, car = 'X', aleat;
    	pos = (rand() % (9 - 1 + 1)) + 1;
    	aleat = (rand() % (5 - 1 + 1)) + 1;
    
    	if (c[0] == '1' && aleat == 1)
    	{
    		pos = 1;
    	}
    	else if (c[0] != '1')
    	{
    		aleat = (rand() % (5 - 2 + 1)) + 1;
    	}
    	if (c[2] == '3' && aleat == 2)
    	{
    		pos = 3;
    	}
    	else if (c[2] != '3')
    	{
    		aleat = (rand() % (5 - 3 + 1)) + 1;
    	}
    	if (c[4] == '5' && aleat == 3)
    	{
    		pos = 5;
    	}
    	else  if (c[4] != '5')
    	{
    		aleat = (rand() % (5 - 4 + 1)) + 1;
    	}
    	if (c[6] == '7' && aleat == 4)
    	{
    		pos = 7;
    	}
    	else  if (c[5] != '7')
    	{
    		aleat = 5;
    	}	
    	if (c[8] == '9' && aleat == 5)
    	{
    		pos = 9;
    	}
    
    
    do {
    	/* lignes */
    	if (c[0] == car && c[1] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    	if (c[0] == car && c[2] == car && c[1] == '2')
    	{
    		pos = 2;
    	}
    	if (c[1] == car && c[2] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    
    	if (c[3] == car && c[4] == car && c[5] == '6')
    	{
    		pos = 6;
    	}
    	if (c[3] == car && c[5] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[4] == car && c[5] == car && c[3] == '4')
    	{
    		pos = 4;
    	}
    
    	if (c[6] == car && c[7] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[6] == car && c[8] == car && c[7] == '8')
    	{
    		pos = 8;
    	}
    	if (c[7] == car && c[8] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    
    	/* colonnes */
    	if (c[0] == car && c[3] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    	if (c[0] == car && c[6] == car && c[3] == '4')
    	{
    		pos = 4;
    	}
    	if (c[3] == car && c[6] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    
    	if (c[1] == car && c[4] == car && c[7] == '8')
    	{
    		pos = 8;
    	}
    	if (c[1] == car && c[7] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[4] == car && c[7] == car && c[1] == '2')
    	{
    		pos = 2;
    	}
    
    	if (c[2] == car && c[5] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[2] == car && c[8] == car && c[5] == '6')
    	{
    		pos = 6;
    	}
    	if (c[5] == car && c[8] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    
    	/* diagonales */
    	if (c[0] == car && c[4] == car && c[8] == '9')
    	{
    		pos = 9;
    	}
    	if (c[4] == car && c[8] == car && c[0] == '1')
    	{
    		pos = 1;
    	}
    	if (c[0] == car && c[8] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    
    	if (c[6] == car && c[4] == car && c[2] == '3')
    	{
    		pos = 3;
    	}
    	if (c[6] == car && c[2] == car && c[4] == '5')
    	{
    		pos = 5;
    	}
    	if (c[2] == car && c[4] == car && c[6] == '7')
    	{
    		pos = 7;
    	}
    
    	car = 'O';
    	i++;
    } while (i<2);
    
    	return (pos);
    }
    




    Donc l'IA est simple : l'ordinateur analyse quatre possibilités. Par ordre de priorité :

    - l'ia regarde si elle peut gagner dans ce coup. Si oui, alors elle joue dans la case correspondante.
    - il y a un danger (c-a-d l'humain peut gagner au prochain coup), alors l'ia l'empêche de gagner en jouant dans la case en question.
    - pas de danger, alors elle regarde si elle peut jouer dans un endroit "stratégique" : le milieu, ou les coins.
    - sinon, alors l'ia joue dans une case libre au pif.


    Bon, je sais, cette IA n'est pas très perfectionnée, vu qu'elle regarde juste le prochain coup, elle ne cherche pas à établir une stratégie sur le long terme, mais c'est un début, en attendant la seconde partie.

    Et je sais, mon code dans la partie ia est assez indigeste, j'essairai d'alléger tout ça plus tard.


    J'attends vos critiques/corrections/commentaires/suggestions !
    • Partager sur Facebook
    • Partager sur Twitter
      22 décembre 2010 à 19:01:40

      L'IA est imbuvable !(niveau codage)
      Par contre y a un petit soucis au niveau de ton IA:

      Citation

      - il y a un danger (c-a-d l'humain peut gagner au prochain coup), alors l'ia l'empêche de gagner en jouant dans la case en question.
      - pas de danger, alors l'ia regarde si il peut gagner dans ce coup. Si oui, alors on joue dans la case correspondante.
      - pas de danger, mais impossible de gagner en un coup. Alors l'ia joue dans une case libre au pif.


      Mieux vaux qu'elle verifi si elle peut gagner puis après si elle est en danger car si elle gagne elle est plus en danger.

      Il y a aussi un problème d'affichage avec l'IA si on joue plusieurs fois.

      (PS: J'ai gagner :p 6 à 4) mais on peut faire mieux.
      • 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 à 19:09:43

        Ouais je viens de modifier ces deux problèmes.

        Pour l'IA déjà je peux réduire de moitié la fonction.
        </barre>
        Je ferai ça plus tard :)


        EDIT : fonction ia allégée. Elle reste indigeste, mais elle est déjà deux fois plus légère :-°

        EDIT2: ia améliorée, elle m'a battu 5-2 cette racl' :colere2: Mais bon, la fonction ia reste moche.
        • Partager sur Facebook
        • Partager sur Twitter
          23 décembre 2010 à 11:32:13

          Code corrigé.

          Les matchs nuls étaient gérés avant, mais sauf que la condition n'était jamais vérifiée (un || au lieu d'un && change tout...).
          Sinon, pour l'exercice en lui même, si le joueur entre un choix invalide, on le fait rejouer, ou alors c'est tant pis pour lui et ça passe a joueur 2 ? :p

          #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(tab[entry/3][entry%3]=='.')
                  {
                      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;
          }
          
          • Partager sur Facebook
          • Partager sur Twitter
            23 décembre 2010 à 12:13:52

            Salut à tous,
            Je suis nouveau sur le site et j'ai commencé à m'intéresser au C il y a environ 2 mois. Sans y passer mes journées j'essaye de progresser.
            J'ai vous propose donc ma solution qui est loin d'être optimale. J'ai essayé de rendre le code clair même si je pense qu'il est un peu lourd.


            #include <stdio.h>
            #include <stdlib.h>
            
            void affichage (int plateau [9]);
            int saisie (void);
            int testercoup(int plateau [9], int coup);
            void jouercoup (int (*plateau)[9], int coup, int joueur);
            int testergagnant(int plateau [9]);
            
            int main(void)
            {
                int plateau [9] ;
                int i;
                int coup;
                int compteur; /*utile pour déterminer quand la boucle doit s'arreter*/
                int gagne;
                int joueur;
                int choix_fin;
                /*on initialise le plateau*/
            
                jeu : ;
                compteur = 0;
                for(i=0;i<9;i++)
                {
                    plateau [i] = 0;
                }
            
                printf("Vous allez jouer au morpion ! \nVoici le jeu \n");
                affichage(plateau);
            
                /*boucle du jeu */
                while(compteur<9)
                {
                    printf("C'est au joueur 1 de jouer \n");
                    jeu1 : ;
                    coup = saisie();
                    if (testercoup(plateau,coup)==1)
                       {
                        jouercoup (&plateau, coup, 1);
                       }
                    else
                       {
                        printf("votre coup n'est pas valide, recommencez \n");
                        goto jeu1;
                       }
                        compteur++;
                    affichage(plateau);
                    gagne=testergagnant(plateau);
                    if (gagne==0)
                    {
                        printf("\nFIN \n");
                        goto fin;
                    }
            
            
            
                    printf("C'est au joueur 2 de jouer \n");
                    jeu2 : ;
                    coup = saisie();
                    if (testercoup(plateau,coup)==1)
                       {
                        jouercoup (&plateau, coup, 2);
                       }
                    else
                       {
                        printf("votre coup n'est pas valide, recommencez \n");
                        goto jeu2;
                       }
                    compteur++;
                    affichage(plateau);
                    gagne=testergagnant(plateau);
                    if (gagne==0)
                    {
                        printf("\nFIN \n");
                        goto fin;
                    }
                }
                fin : ;
                printf("Pour rejouer rentrez 0, pour quitter rentrez 1\n");
                scanf("%d",&choix_fin);
            
                if (choix_fin == 0)
                {
                    goto jeu;
                }
                else
                {
                    return 0;
                }
            
            }
            
            
            /*cette fonction prend le tableau représentant les cases, elle affiche un X si la case contient 1 (joueur 1),
             O si elle contient 2 (joueur 2) et un . si elle contient 0 (case pas choisie) */
            
            void affichage(int plateau [9])
            {
                int i;
                int j;
                int mat [3] [3];
            
                /*on transforme le tableau en matrice*/
                for(j=0;j<3;j++)
                {
                 mat[0] [j] = plateau[j];
                }
                for(j=0;j<3;j++)
                {
                 mat[1] [j] = plateau[j+3];
                }
                for(j=0;j<3;j++)
                {
                 mat[2] [j] = plateau[j+6];
                }
            
            
            
                for(i=0;i<3;i++)
                {
                    for(j=0;j<3;j++)
                    {
                        if (mat[i] [j]==0)
                        {
                            printf(". \t");
                        }
                        if (mat[i] [j]==1)
                        {
                            printf("X \t");
                        }
                        if (mat[i] [j]==2)
                        {
                            printf("O \t");
                        }
                    }
                    printf("\n \n");
                }
            }
            /*elle afficher l'image du plateau*/
            
            /*lit la saisie et la renvoie */
            int saisie (void)
            {
                int choix;
                int coup;
            
                scanf("%d",&choix);
                coup=choix;
                return coup;
            }
            
            /*prend le plateau et la case jouée et renvoie 1 si c'est valide, 0 sinon*/
            int testercoup(int plateau [9], int coup )
            {
                if (coup<=0 || coup>9)
                {
                    return 0;
                }
                if (plateau[coup-1]== 1 || plateau[coup-1]==2 )
                {
                    return 0;
                }
                return 1;
            }
            
            /*modifie le plateau avec la case jouée*/
            void jouercoup (int (*plateau)[9], int coup, int joueur)
            {
                /*case jouée par le joueur 1*/
                if (joueur==1)
                {
                    (*plateau) [coup-1]=1;
                }
                else
                {
                    (*plateau) [coup-1]=2;
                }
                /*le - vient du decalage d'indice*/
            }
            
            
            /*renvoie 0 si un des joueurs gagne ou s'il y a match nul, et 1 sinon */
            int testergagnant(int plateau [9])
            {
                int i;
                int j;
                int Compteur ;
                int mat [3] [3];
                Compteur =0;
                 /*on transforme le tableau en matrice*/
                for(j=0;j<3;j++)
                {
                 mat[0] [j] = plateau[j];
                }
                for(j=0;j<3;j++)
                {
                 mat[1] [j] = plateau[j+3];
                }
                for(j=0;j<3;j++)
                {
                 mat[2] [j] = plateau[j+6];
                }
            
            
                for(i=0;i<3;i++)
                {
                    /* on gagne avec une ligne*/
                    if(mat [i] [1]==1 && mat [i] [0]==1 && mat [i] [2]==1)
                    {
                        printf("Le joueur 1 a gagne \n");
                        return 0;
                    }
                    /*on gagne abec une colonne*/
                    if(mat [1] [i]==1 && mat [0] [i]==1 && mat [2] [i]==1)
                    {
                        printf("Le joueur 1 a gagne \n");
                        return 0;
                    }
                }
                /*on gagne avec une diagonale*/
                if (mat[1][1]==1 && mat[0][0]==1 && mat[2][2]==1)
                {
                     printf("Le joueur 1 a gagne \n");
                     return 0;
                }
            
                /*meme chose pour le joueur 2*/
            
                for(i=0;i<3;i++)
                {
                    /* on gagne avec une ligne*/
                    if(mat [i] [1]==2 && mat [i] [0]==2 && mat [i] [2]==2)
                    {
                        printf("Le joueur 2 a gagne \n");
                        return 0;
                    }
                    /*on gagne avec une colonne*/
                    if(mat [1] [i]==2 && mat [0] [i]==2 && mat [2] [i]==2)
                    {
                        printf("Le joueur 2 a gagne \n");
                        return 0;
                    }
                }
                /*on gagne avec une diagonale*/
                if (mat[1][1]==2 && mat[0][0]==2 && mat[2][2]==2)
                {
                     printf("Le joueur 2 a gagne \n");
                     return 0;
                }
            
                /*match nul*/
                for (i=0;i<3;i++)
                {
                    for (j=0;j<3;j++)
                    {
                        if (mat [i] [j]!=0)
                        {
                            Compteur ++; /*compte le nombre de case différentes de 0*/
                        }
                    }
                }
                if (Compteur==9)
                {
                    printf("Match nul \n");
                    return 0;
                }
                return 1;
            }
            



            Bonne lecture ^^.
            Et surtout n'hésitez pas à critiquer.
            Merci d'avance.
            • Partager sur Facebook
            • Partager sur Twitter
              23 décembre 2010 à 12:24:29

              @kiffman: Pas encore parfait:
              <code type="console"">#include <stdio.h>
              #include <stdlib.h>

              void affichage (int plateau [9]);
              int saisie (void);
              int testercoup(int plateau [9], int coup);
              void jouercoup (int (*plateau)[9], int coup, int joueur);
              int testergagnant(int plateau [9]);

              int main(void)
              {
              int plateau [9] ;
              int i;
              int coup;
              int compteur; /*utile pour déterminer quand la boucle doit s'arreter*/
              int gagne;
              int joueur;
              int choix_fin;
              /*on initialise le plateau*/

              jeu : ;
              compteur = 0;
              for(i=0;i<9;i++)
              {
              plateau [i] = 0;
              }

              printf("Vous allez jouer au morpion ! \nVoici le jeu \n");
              affichage(plateau);

              /*boucle du jeu */
              while(compteur<9)
              {
              printf("C'est au joueur 1 de jouer \n");
              jeu1 : ;
              coup = saisie();
              if (testercoup(plateau,coup)==1)
              {
              jouercoup (&plateau, coup, 1);
              }
              else
              {
              printf("votre coup n'est pas valide, recommencez \n");
              goto jeu1;
              }
              compteur++;
              affichage(plateau);
              gagne=testergagnant(plateau);
              if (gagne==0)
              {
              printf("\nFIN \n");
              goto fin;
              }



              printf("C'est au joueur 2 de jouer \n");
              jeu2 : ;
              coup = saisie();
              if (testercoup(plateau,coup)==1)
              {
              jouercoup (&plateau, coup, 2);
              }
              else
              {
              printf("votre coup n'est pas valide, recommencez \n");
              goto jeu2;
              }
              compteur++;
              affichage(plateau);
              gagne=testergagnant(plateau);
              if (gagne==0)
              {
              printf("\nFIN \n");
              goto fin;
              }
              }
              fin : ;
              printf("Pour rejouer rentrez 0, pour quitter rentrez 1\n");
              scanf("%d",&choix_fin);

              if (choix_fin == 0)
              {
              goto jeu;
              }
              else
              {
              return 0;
              }

              }


              /*cette fonction prend le tableau représentant les cases, elle affiche un X si la case contient 1 (joueur 1),
              O si elle contient 2 (joueur 2) et un . si elle contient 0 (case pas choisie) */

              void affichage(int plateau [9])
              {
              int i;
              int j;
              int mat [3] [3];

              /*on transforme le tableau en matrice*/
              for(j=0;j<3;j++)
              {
              mat[0] [j] = plateau[j];
              }
              for(j=0;j<3;j++)
              {
              mat[1] [j] = plateau[j+3];
              }
              for(j=0;j<3;j++)
              {
              mat[2] [j] = plateau[j+6];
              }



              for(i=0;i<3;i++)
              {
              for(j=0;j<3;j++)
              {
              if (mat[i] [j]==0)
              {
              printf(". \t");
              }
              if (mat[i] [j]==1)
              {
              printf("X \t");
              }
              if (mat[i] [j]==2)
              {
              printf("O \t");
              }
              }
              printf("\n \n");
              }
              }
              /*elle afficher l'image du plateau*/

              /*lit la saisie et la renvoie */
              int saisie (void)
              {
              int choix;
              int coup;

              scanf("%d",&choix);
              coup=choix;
              return coup;
              }

              /*prend le plateau et la case jouée et renvoie 1 si c'est valide, 0 sinon*/
              int testercoup(int plateau [9], int coup )
              {
              if (coup<=0 || coup>9)
              {
              return 0;
              }
              if (plateau[coup-1]== 1 || plateau[coup-1]==2 )
              {
              return 0;
              }
              return 1;
              }

              /*modifie le plateau avec la case jouée*/
              void jouercoup (int (*plateau)[9], int coup, int joueur)
              {
              /*case jouée par le joueur 1*/
              if (joueur==1)
              {
              (*plateau) [coup-1]=1;
              }
              else
              {
              (*plateau) [coup-1]=2;
              }
              /*le - vient du decalage d'indice*/
              }


              /*renvoie 0 si un des joueurs gagne ou s'il y a match nul, et 1 sinon */
              int testergagnant(int plateau [9])
              {
              int i;
              int j;
              int Compteur ;
              int mat [3] [3];
              Compteur =0;
              /*on transforme le tableau en matrice*/
              for(j=0;j<3;j++)
              {
              mat[0] [j] = plateau[j];
              }
              for(j=0;j<3;j++)
              {
              mat[1] [j] = plateau[j+3];
              }
              for(j=0;j<3;j++)
              {
              mat[2] [j] = plateau[j+6];
              }


              for(i=0;i<3;i++)
              {
              /* on gagne avec une ligne*/
              if(mat [i] [1]==1 && mat [i] [0]==1 && mat [i] [2]==1)
              {
              printf("Le joueur 1 a gagne \n");
              return 0;
              }
              /*on gagne abec une colonne*/
              if(mat [1] [i]==1 && mat [0] [i]==1 && mat [2] [i]==1)
              {
              printf("Le joueur 1 a gagne \n");
              return 0;
              }
              }
              /*on gagne avec une diagonale*/
              if (mat[1][1]==1 && mat[0][0]==1 && mat[2][2]==1)
              {
              printf("Le joueur 1 a gagne \n");
              return 0;
              }

              /*meme chose pour le joueur 2*/

              for(i=0;i<3;i++)
              {
              /* on gagne avec une ligne*/
              if(mat [i] [1]==2 && mat [i] [0]==2 && mat [i] [2]==2)
              {
              printf("Le joueur 2 a gagne \n");
              return 0;
              }
              /*on gagne avec une colonne*/
              if(mat [1] [i]==2 && mat [0] [i]==2 && mat [2] [i]==2)
              {
              printf("Le joueur 2 a gagne \n");
              return 0;
              }
              }
              /*on gagne avec une diagonale*/
              if (mat[1][1]==2 && mat[0][0]==2 && mat[2][2]==2)
              {
              printf("Le joueur 2 a gagne \n");
              return 0;
              }

              /*match nul*/
              for (i=0;i<3;i++)
              {
              for (j=0;j<3;j++)
              {
              if (mat [i] [j]!=0)
              {
              Compteur ++; /*compte le nombre de case différentes de 0*/
              }
              }
              }
              if (Compteur==9)
              {
              printf("Match nul \n");
              return 0;
              }
              return 1;
              }
              </code>



              Si ça ne fais que 2 mois que tu fais de la programmation évite les goto. Préfère les fonctions.

              Je comprend pas le prototype de la fonction void jouercoup (int (*plateau)[9], int coup, int joueur)
              Cela montre que tu as compris l'interes des pointeurs, c'est bien, mais que tu n'as pas encore bien compris les tableaux.
              Tu peux directement faire :
              void jouercoup (int plateau[9], int coup, int joueur)
              {
                  /*case jouée par le joueur 1*/
                  if (joueur==1)
                  {
                      plateau[coup-1]=1;
                  }
                  else
                  {
                      plateau[coup-1]=2;
                  }
                  /*le - vient du decalage d'indice*/
              }
              
              • Partager sur Facebook
              • Partager sur Twitter
              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                23 décembre 2010 à 13:37:37

                Je sais pas. Ca me paraît un peu bizarre. Parce que si je lui passe pas un pointeur sur le tableau il ne va pas me modifier mon tableau.
                Je vais essayer pour voir.
                • Partager sur Facebook
                • Partager sur Twitter
                  23 décembre 2010 à 13:44:56

                  Citation : @che

                  Tu peux directement faire :


                  void jouercoup (int plateau[9], int coup, int joueur)
                  

                  par exemple, même si ce n'est pas la manière la plus commune.

                  Les tableaux sont convertis en pointeur vers leur premier élément lors du passage à une fonction, donc, les prototypes:
                  void jouercoup (int plateau[9], int coup, int joueur); /* inutile */
                  void jouercoup (int plateau[], int coup, int joueur);
                  void jouercoup (int *plateau, int coup, int joueur);
                  

                  sont identiques.

                  Citation : kiffman

                  Je sais pas. Ca me paraît un peu bizarre. Parce que si je lui passe pas un pointeur sur le tableau il ne va pas me modifier mon tableau.


                  Ce n'est pas le pointeur sur ton tableau que tu pourras modifier, mais le tableau en lui-même.

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

                    Je viens de modifier le code et ça marche bien. Effectivement, je n'avais pas bien compris le fait qu'un tableau est aussi un pointeur.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      27 décembre 2010 à 0:07:40

                      @moliplate : Non, tu n'as pas pris en compte tout ce que je t'ai dis. :-°

                      @th-p :
                      Tu peux faire plus simple pour initialiser ton tableau (strncpy).
                      Tu appelles srand à chaque tour de boucle.
                      j = (rand() % (2 - 1 + 1)) + 1; => Tu es sûr que faire 2 - 1 + 1 est super ?
                      system("clear"); on s'en fou
                      if (pos >=1 && pos <=9 && car == 'O' && choix == 1) => Au premier passage de la boucle, tes variables car et pos ne sont pas initialisées
                      Tu pourrais améliorer ta saisie pour éviter les répétitions
                      Tu pourrais créer une fonction pour ta saisie
                      Tu fais 2 fois la même chose pour joueur 1 et joueur 2, tu peux réduire
                      L'IA n'est pas le but de l'exercice donc je ne l'ai pas reagardé, mais à vue de nez comme ça tu peux largement réduire ta fonction
                      Tu pourrais utiliser un tableau plut^lot qu'utiliser les variables win1-2-3
                      Tu pourrais faire une fonction et simplifier tes conditions qui disent qui a gagner et combien de fois
                      Dans ta fonction verif_fin tu pourrais faire un else if pour enlever la condition && fin !=1 && fin !=2
                      Dans ta fonction verif_case tu peux faire un accès direct au tableau
                      Tu as fait 2 codes, 1 pour win et l'autre pour *nix, le préprocesseur te serait d'une grande aide pour éviter ça

                      @baki :
                      Tu fais appel à la fonction srand à chaque fois que tu fais une nouvelle partie
                      Tu pourrais faire en sorte que l'utilisateur ne joue pas 2 fois au même endroit ; càd que si je joue la même case que ce soit le même joueur qui rejoue pas le joueur suivant
                      }while(end_game(tab));/*Tant que la partie n'est pas finie*/ => Hmm, tu pourrais choisir un autre nom pour ta fonction ou alors faire !end_game, ce n'est pas cohérent : tant que c'est la fin du jeu on boucle

                      @kiffman :
                      Ta variable joueur n'est pas utilisée
                      Les goto ne sont pas très appréciés en C, tu peux les enlever très facilement. D'ailleurs, tous tes points virgule après les ':' sont inutiles
                      Tu peux améliorer ta fonction affichage, tu n'as pas besoin de convertir ton tableau, un simple if sur le tableau d'origine suffit
                      Dans ta fonction saisie, pourquoi tu utilises une 2ème variable ? tu peux simplement retourner la première
                      Tu fais 2 fois la même chose pour joueur 1 et 2, tu peux simplifier
                      Pourquoi envoyer un pointeur sur plateau a ta fonction jouercoup ? le tableau en lui-même suffit
                      Tu n'as pas besoin de faire de if...else dans cette même fonction, une simple affectation suffit
                      Tu fais plein de répétitions dans ta fonction testergagnant tu peux simplifier


                      Merci de votre participation. :)
                      • Partager sur Facebook
                      • Partager sur Twitter
                        27 décembre 2010 à 5:43:37

                        Citation : kiffman

                        Je viens de modifier le code et ça marche bien. Effectivement, je n'avais pas bien compris le fait qu'un tableau est aussi un pointeur.



                        Non, un tableau n'est pas un pointeur. Vas voir le tuto de Marc Mongenet: La vérité sur les pointeurs.
                        • Partager sur Facebook
                        • Partager sur Twitter
                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                          31 décembre 2010 à 13:18:07

                          Pour tout ceux qui ont fait le morpion en console, je vous invite à venir nous rejoindre pour le faire en graphique (avec SDL ou autre) : http://www.siteduzero.com/forum-83-594 [...] morp-sdl.html
                          C'est à ce moment que vous verrez si votre programme est bien découpé. Si vous regardez mon code, j'ai eu juste à modifier les fonctions d'affichage et de saisie. Tout le reste du jeu (le fond) n'a pas bougé d'un poil. ;)

                          Essayez, c'est vraiment rapide vous verrez. :)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            7 janvier 2011 à 19:14:00

                            Bonjour à vous tous, je pense que c'est un peu tard, mais avant de participer a la version SDL, je voudrais savoir ce que vous pensiez de mon code, et surtout si vous trouvez des erreurs(warning, segfault, erreur dans le jeu).
                            J'ai essayer de faire en sorte que tout sois paramètrable, longueur largeur, et nombre de pion a aligné, normalement ça marche, mais bon, on est jamais a l'abri, voici la bête ^^

                            #include <stdio.h>
                            #include <stdlib.h>
                            
                            typedef unsigned int Uint32, size_t;
                            typedef unsigned char Uint8;
                            typedef unsigned short Uint16;
                            
                            typedef signed int Sint32;
                            typedef signed short Sint16;
                            
                            typedef Uint8 bool;
                            enum{false, true};
                            
                            enum{J1 = -1, J2 = -2};
                            
                            typedef struct
                            {
                                Sint16 *grid;
                                Uint16 width, height, align;
                                bool *play;/*Case playing??*/
                            }Grid;
                            
                            void *my_malloc(size_t n);/*Malloc verificate*/
                            void my_scanf(Uint32 *place, char const *print);/*Scanf checked*/
                            
                            Grid *create_Grid(Uint16 width, Uint16 height, Uint16 align);
                            void delete_Grid(Grid *(*grid));
                            void print_Grid(Grid *grid);
                            void play(Grid *grid);
                            bool test_Case(Grid *grid, Uint32 numCase);
                            bool win(Grid *grid, Uint32 numCase, Sint16 player);
                            bool end_Play(Grid *grid);
                            
                            void my_scanf(Uint32 *place, char const *print)
                            {
                                int c;
                            
                                do
                                {
                                    printf("%s", print);
                                    c = scanf("%u", place);
                                }while (c != 1);
                            }
                            
                            void *my_malloc(size_t n)
                            {
                                void *p;
                            
                                if((p = malloc(n)) == NULL)
                                    fprintf(stderr, "Erreur sur le malloc"), exit(1);
                            
                                return p;
                            }
                            
                            Grid *create_Grid(Uint16 width, Uint16 height, Uint16 align)
                            {
                                Uint16 x, y;
                                Sint16 n = 0;
                                Grid *grid = (Grid*) my_malloc(sizeof *grid);
                                grid->grid = (Sint16*) my_malloc(sizeof *(grid->grid) * width * height);
                                grid->play = (bool*) my_malloc(sizeof *(grid->play) * width * height);
                            
                                grid->width = width;
                                grid->height = height;
                                grid->align = align;
                            
                                for(y = 0; y < height; y++)
                                {
                                    for(x = 0; x < width; x++)
                                    {
                                        grid->grid[y * width + x] = ++n;
                                        grid->play[y * width + x] = false;
                                    }
                                }
                            
                                return grid;
                            }
                            
                            void delete_Grid(Grid *(*grid))
                            {
                                free((*grid)->grid);
                                free((*grid)->play);
                                free(*grid);
                                *grid = NULL;
                            }
                            
                            void print_Grid(Grid *grid)
                            {
                                Uint16 x, y;
                            
                                for(y = 0; y < grid->height; y++)
                                {
                                    for(x = 0; x < grid->width; x++)
                                        printf("___");
                            
                                    putchar('\n');
                            
                                    for(x = 0; x < grid->width; x++)
                                    {
                                        if(grid->play[y * grid->width + x] == false)
                                            printf("%2u|", grid->grid[y * grid->width + x]);
                            
                                        else
                                            printf("%2c|", (grid->grid[y * grid->width + x] == J1) ? 'X' : 'O');
                                    }
                            
                                    putchar('\n');
                                }
                            }
                            
                            bool win(Grid *grid, Uint32 numCase, Sint16 player)
                            {
                                Sint32 x, y, xMin, xMax, yMin, yMax, xBase, yBase;
                                Uint16 n = 0;
                            
                                x = (Sint32) (numCase % grid->width);
                                y = (Sint32) (numCase / grid->width);/*Because its signed number*/
                            
                                xMin = (Sint32) (x - grid->align + 1);
                                xMax = (Sint32) (x + grid->align);
                                yMin = (Sint32) (y - grid->align + 1);
                                yMax = (Sint32) (y + grid->align);
                            
                                if(xMin < 0)
                                    xMin = 0;
                            
                                if(yMin < 0)
                                    yMin = 0;
                            
                                if(xMax >= grid->width)
                                    xMax = (Sint32) grid->width;
                            
                                if(yMax >= grid->height)
                                    yMax = (Sint32) grid->height;
                            
                                xBase = x;
                                yBase = y;
                            
                                for(x = xMin; x < xMax; x++)
                                {
                                    if(grid->grid[y * grid->width + x] == player)
                                        n++;
                                    else
                                        n = 0;
                                    if(n == grid->align)
                                        return true;
                                }/*Line*/
                            
                                x = xBase;
                                n = 0;
                            
                                for(y = yMin; y < yMax; y++)
                                {
                                    if(grid->grid[y * grid->width + x] == player)
                                        n++;
                                    else
                                        n = 0;
                                    if(n == grid->align)
                                        return true;
                                }/*Col*/
                            
                                x = xMin;
                                n = 0;
                            
                                for(y = yMin; y < yMax; y++)
                                {
                                    if(grid->grid[y * grid->width + x] == player)
                                        n++;
                                    else
                                        n = 0;
                                    if(n == grid->align)
                                        return true;
                            
                                    x++;
                                    if(x >= grid->width)
                                        x = xMax - 1;
                                }/*left right*/
                            
                                x = xMax - 1;
                                n = 0;
                            
                                for(y = yMin; y < yMax; y++)
                                {
                                    if(grid->grid[y * grid->width + x] == player)
                                        n++;
                                    else
                                        n = 0;
                                    if(n == grid->align)
                                        return true;
                            
                                    x--;
                                    if(x < 0)
                                        x = xMin;
                                }/*right left*/
                            
                                return false;/*Else not win, return 0;*/
                            }
                            
                            void play(Grid *grid)
                            {
                                Uint32 numCase;
                                Uint8 player = 1;
                                Uint16 x, y;
                            
                                while(1)
                                {
                                    print_Grid(grid);
                            
                                    printf("\nA vous de jouez joueur %u\n", player);
                            
                                    do
                                    {
                                        my_scanf(&numCase, "Entrez le numero de case :\n");
                                    }while(test_Case(grid, numCase) == false);/*If number is wrong*/
                            
                                    numCase--;/*first Case is one, not null*/
                            
                                    x = (Uint16) (numCase % grid->width);
                                    y = (Uint16) (numCase / grid->width);
                            
                                    grid->grid[y * grid->width + x] = (player == 1) ? J1 : J2;
                                    grid->play[y * grid->width + x] = true;
                            
                                    if(win(grid, numCase, (player == 1) ? J1 : J2) == true)
                                    {
                                        print_Grid(grid);
                                        printf("\nLe joueur %u a gagner\n", player);
                                        break;
                                    }
                            
                                    if(end_Play(grid) == true)
                                    {
                                        print_Grid(grid);
                                        printf("\nIl y a match nul\n");
                                        break;
                                    }
                            
                                    if(player == 1)
                                        player = 2;
                            
                                    else
                                        player = 1;
                                }
                            }
                            
                            bool test_Case(Grid *grid, Uint32 numCase)
                            {
                                Uint16 x, y;
                                numCase--;
                            
                                x = (Uint16) (numCase % grid->width);
                                y = (Uint16) (numCase / grid->width);
                            
                                return (grid->play[y * grid->width + x] == false);
                            }
                            
                            bool end_Play(Grid *grid)
                            {
                                bool end = true;
                                Uint16 x, y;
                            
                                for(y = 0; y < grid->height; y++)
                                {
                                    for(x = 0; x < grid->width; x++)
                                    {
                                        if(grid->play[y * grid->width + x] == false)
                                        {
                                            end = false;
                                            break;
                                        }
                                    }
                                }
                                return end;
                            }
                            
                            int main(void)
                            {
                                Grid *grid = create_Grid(3, 3, 3);
                            
                                play(grid);
                            
                                delete_Grid(&grid);
                            
                                return 0;
                            }
                            


                            @GurneyH, ce soir je m'attaque a ton morpion en SDl ;-)

                            Cordialement un nouveau parmis les Zexos
                            • Partager sur Facebook
                            • Partager sur Twitter
                            http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                              7 janvier 2011 à 20:04:38

                              Sans avoir regardé le code, juste le début, je te dis que l'utilisation que tu fais des macros est justement celle qu'il ne faut pas faire. :-°
                              Fais une fonction ou mets ça en dur dans ton code.
                              Je regarderai ton code plus tard. :)

                              Merci pour ta participation. :)
                              • Partager sur Facebook
                              • Partager sur Twitter
                                7 janvier 2011 à 20:34:17

                                Pareil que Pouet pour les macros. :(

                                Pour la série de typedef qui suit, tu as voulu singer les types de la SDL, j'imagine en prévision.
                                Mais, le type int suffit dans tout les cas, et tu t'obliges à faire des casts, nombreux, non nécessaires, laids. :(

                                Pour l'utilisation d'un tableau dynamique, soit.

                                En gros, tu es dans l'éxcès, on y est tous passé.
                                Tu commences à maîtriser certaines constructions du C, et tu en abuses(on l'a tous fait... :-° ).
                                Mais à coté, reste des choses étranges
                                printf("\n");
                                

                                Un bazooka, pour tuer une mouche...

                                Grid *grid = (Grid*) my_malloc(sizeof *grid);
                                

                                Bon, d'accord, tu aimes les casts...

                                Aussi, cette manie de déclarer les fonctions systématiquement avant le main, je n'aime pas.
                                Si tu définis les fonctions dans le bon ordre, ce n'est pas utile(ça alourdit...)


                                Après, les bons points:
                                -L'utilisation d'un tableau 1d est très naturelle, je trouve.
                                -...

                                Après, je n'ai pas testé.
                                ;)

                                Je pense que tu devrais faire plus simple, naturel, en fait...
                                • Partager sur Facebook
                                • Partager sur Twitter
                                Zeste de Savoir, le site qui en a dans le citron !
                                  7 janvier 2011 à 20:47:32

                                  Pour Pouet et Gurney, Okay pour les macros, mais j'aimerais tout de même savoir pourquoi ^^(Car cela ne marche que si on a une variable x, y, et numCase??)

                                  Citation : GurneyH

                                  Pour la série de typedef qui suit, tu as voulu singer les types de la SDL, j'imagine en prévision.
                                  Mais, le type int suffit dans tout les cas, et tu t'obliges à faire des casts, nombreux, non nécessaires, laids.



                                  En effet, c'est pour la dîtes SDL ^^. Je trouve cela plus juste d'utiliser celon moi les unsigneds et les signeds ^^

                                  Citation : GurneyH

                                  Aussi, cette manie de déclarer les fonctions systématiquement avant le main, je n'aime pas.
                                  Si tu définis les fonctions dans le bon ordre, ce n'est pas utile(ça alourdit...)



                                  La, je dois avouer ne pas t'avoir compris. Il ne faut pas je mette mes fonctions l'ordre? Ou il faut je les mette?

                                  Ensuite, pour le printf, effectivement, il est peut être plus adapter d'utiliser putchar() ^^.

                                  Pour le cast des mallocs, celà m'aide a m'éviter quelques bugs(ici inutile soit), je me sers de la petite astuce de "Uknow", cela permet de bien se reconnaitre le bon pointeur, une étoile de différence ^^.

                                  Cordialement
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                    7 janvier 2011 à 22:07:16

                                    Pour les macros ça doit rester exeptionnel.

                                    Citation : qnope


                                    En effet, c'est pour la dîtes SDL ^^. Je trouve cela plus juste d'utiliser celon moi les unsigneds et les signeds


                                    Jamais!
                                    Tu vas être etre emmener en faisant cela, à mélangé les signed et unsigned, et c'est juste une source de bordel.

                                    Utilises le type int, point...

                                    Citation : qnope


                                    Ensuite, pour le printf, effectivement, il est peut être plus adapter d'utiliser putchar() ^^.


                                    ou
                                    puts("");
                                    




                                    Citation : qnope

                                    Pour le cast des mallocs, celà m'aide a m'éviter quelques bugs(ici inutile soit)


                                    Non, ça sert juste à en créer, si tu compiles bien en C...
                                    Genre, tu n'inclues pas <stdlib.h>, ta fonction retourne un entier, et, avec ton cast, tu fais taire le compilateur...

                                    edit:

                                    Citation : qnope


                                    La, je dois avouer ne pas t'avoir compris. Il ne faut pas je mette mes fonctions l'ordre? Ou il faut je les mette?


                                    C'est la déclaration qui est inutile...
                                    Si tes fonctions sont dans le bon ordre, et que tu ne fais pas de récursivité croisée... ;)
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Zeste de Savoir, le site qui en a dans le citron !
                                      8 janvier 2011 à 0:25:22

                                      qnope >
                                      Pourquoi tu redéfinis size_t ? les headers standard ne te suffisent pas ? :-° de plus, tu forces le type à unsigned int, chez moi c'est pas un int. :-°
                                      L'utilisation de malloc et cie n'est pas nécessaire, des tableaux statiques auraient suffit
                                      Les casts malloc sont inutiles
                                      Je pense que tu peux faire mieux qu'une boucle infinie dans ta fonction 'play'
                                      Pourquoi tu utilises 2 tableaux ? tu pourrais n'en utiliser qu'un seul
                                      Les commentaires sont inutiles, ils doivent servir à éclaircir le code, pas l'alourdir
                                      Dans ta fonction test_Case, tu ne vérifies pas si la case entrée est bien dans le tableau
                                      Tu fais trop de cast inutiles
                                      Pourquoi tu ne donnes pas à ta variable 'player' la valeur J1 ou J2 en fonction du joueur ? ça t'éviterais les ternaires abusifs
                                      Dans ta fonction end_Play, ton break te fait sortir de la boucle la plus imbriquée, pas la première
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        8 janvier 2011 à 12:47:18

                                        Citation : Pouet_forever

                                        Pourquoi tu ne donnes pas à ta variable 'player' la valeur J1 ou J2 en fonction du joueur ? ça t'éviterais les ternaires abusifs



                                        Ceci est fait exprès, imagine un morpion de 100 cases ^^. Le X pourrait etre confondu ^^.

                                        Cependant, je vais essayer d'améliorer le code, eviter les cast, eviter les segfault etc ;-).

                                        Cordialement, Qnope, Merci de vos commentaires
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                          8 janvier 2011 à 13:05:01

                                          Citation : qnope

                                          Ceci est fait exprès, imagine un morpion de 100 cases ^^. Le X pourrait etre confondu ^^.


                                          Tes valeurs de J1 et J2 sont négatives donc il n'y a aucun risque de conflit. :-°
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            8 janvier 2011 à 13:09:06

                                            Donc je n'ai pas compris exactement ce que tu as voulu dire ^^, je suis en train de modifier mes casts etc, je regarderais dans mon code ce que tu as voulu dire exactement ^^


                                            EDIT : c'est bon j'ai compris ^^

                                            Voilà le nouveau code

                                            #include <stdio.h>
                                            #include <stdlib.h>
                                            #include <stddef.h>
                                            
                                            typedef unsigned char bool;
                                            enum{false, true};
                                            
                                            enum{J1 = -1, J2 = -2};
                                            
                                            typedef struct
                                            {
                                                int *grid;
                                                int width, height, align;
                                            }Grid;
                                            
                                            void *my_malloc(size_t n);/*Malloc verificate*/
                                            void my_scanf(int *place, char const *print);/*Scanf checked*/
                                            
                                            Grid *create_Grid(unsigned width, unsigned height, unsigned align);
                                            void delete_Grid(Grid *(*grid));
                                            void print_Grid(Grid *grid);
                                            void play(Grid *grid);
                                            bool test_Case(Grid *grid, int numCase);
                                            bool win(Grid *grid, int numCase, int player);
                                            bool end_Play(Grid *grid);
                                            
                                            void my_scanf(int *place, char const *print)
                                            {
                                                int c;
                                            
                                                do
                                                {
                                                    printf("%s", print);
                                                    c = scanf("%d", place);
                                                    while(getchar() != '\n');
                                                }while (c != 1);
                                            }
                                            
                                            void *my_malloc(size_t n)
                                            {
                                                void *p;
                                            
                                                if((p = malloc(n)) == NULL)
                                                    fprintf(stderr, "Erreur sur le malloc"), exit(1);
                                            
                                                return p;
                                            }
                                            
                                            Grid *create_Grid(unsigned width, unsigned height, unsigned align)
                                            {
                                                unsigned x, y;
                                                int n = 0;
                                            
                                                Grid *grid =  my_malloc(sizeof *grid);
                                                grid->grid =  my_malloc(sizeof *(grid->grid) * width * height);
                                            
                                                grid->width = (int) width;
                                                grid->height = (int) height;
                                                grid->align = (int) align;
                                            
                                                for(y = 0; y < height; y++)
                                                    for(x = 0; x < width; x++)
                                                        grid->grid[y * width + x] = ++n;
                                            
                                                return grid;
                                            }
                                            
                                            void delete_Grid(Grid *(*grid))
                                            {
                                                free((*grid)->grid);
                                                free(*grid);
                                                *grid = NULL;
                                            }
                                            
                                            void print_Grid(Grid *grid)
                                            {
                                                int x, y;
                                            
                                                for(y = 0; y < grid->height; y++)
                                                {
                                                    for(x = 0; x < grid->width; x++)
                                                        printf("___");
                                            
                                                    putchar('\n');
                                            
                                                    for(x = 0; x < grid->width; x++)
                                                    {
                                                        if(grid->grid[y * grid->width + x] > 0)
                                                            printf("%2d|", grid->grid[y * grid->width + x]);
                                            
                                                        else
                                                            printf("%2c|", (grid->grid[y * grid->width + x] == J1)
                                                                   ? 'X' : 'O');
                                                    }
                                            
                                                    putchar('\n');
                                                }
                                            }
                                            
                                            bool win(Grid *grid, int numCase, int player)
                                            {
                                                int xMin, xMax, yMin, yMax, x, y, xBase, yBase,
                                                    n = 0;
                                            
                                                x = numCase % grid->width;
                                                y = numCase / grid->width;
                                            
                                                xMin = (x - grid->align + 1);
                                                xMax = (x + grid->align);
                                                yMin = (y - grid->align + 1);
                                                yMax = (y + grid->align);
                                            
                                                if(xMin < 0)
                                                    xMin = 0;
                                            
                                                if(yMin < 0)
                                                    yMin = 0;
                                            
                                                if(xMax >= grid->width)
                                                    xMax = grid->width;
                                            
                                                if(yMax >= grid->height)
                                                    yMax = grid->height;
                                            
                                                xBase = x;
                                                yBase = y;
                                            
                                                for(x = xMin; x < xMax; x++)
                                                {
                                                    if(grid->grid[y * grid->width + x] == player)
                                                        n++;
                                                    else
                                                        n = 0;
                                                    if(n == grid->align)
                                                        return true;
                                                }/*Line*/
                                            
                                                x = xBase;
                                                n = 0;
                                            
                                                for(y = yMin; y < yMax; y++)
                                                {
                                                    if(grid->grid[y * grid->width + x] == player)
                                                        n++;
                                                    else
                                                        n = 0;
                                                    if(n == grid->align)
                                                        return true;
                                                }/*Col*/
                                            
                                                x = xMin;
                                                n = 0;
                                            
                                                for(y = yMin; y < yMax; y++)
                                                {
                                                    if(grid->grid[y * grid->width + x] == player)
                                                        n++;
                                                    else
                                                        n = 0;
                                                    if(n == grid->align)
                                                        return true;
                                            
                                                    x++;
                                                    if(x >= grid->width)
                                                        x = xMax - 1;
                                                }/*left right*/
                                            
                                                x = xMax - 1;
                                                n = 0;
                                            
                                                for(y = yMin; y < yMax; y++)
                                                {
                                                    if(grid->grid[y * grid->width + x] == player)
                                                        n++;
                                                    else
                                                        n = 0;
                                                    if(n == grid->align)
                                                        return true;
                                            
                                                    x--;
                                                    if(x < 0)
                                                        x = xMin;
                                                }/*right left*/
                                            
                                                return false;/*Else not win, return 0;*/
                                            }
                                            
                                            void play(Grid *grid)
                                            {
                                                int numCase;
                                                int player = J1;
                                                int x, y;
                                            
                                                while(1)
                                                {
                                                    print_Grid(grid);
                                            
                                                    printf("\nA vous de jouez joueur %d\n", -player);
                                            
                                                    do
                                                    {
                                                        my_scanf(&numCase, "Entrez le numero de case :\n");
                                                    }while(test_Case(grid, numCase) == false);
                                            
                                                    numCase--;
                                            
                                                    x = numCase % grid->width;
                                                    y = numCase / grid->width;
                                            
                                                    grid->grid[y * grid->width + x] = player;
                                            
                                                    if(win(grid, numCase, player) == true)
                                                    {
                                                        print_Grid(grid);
                                                        printf("\nLe joueur %d a gagner\n", -player);
                                                        break;
                                                    }
                                            
                                                    if(end_Play(grid) == true)
                                                    {
                                                        print_Grid(grid);
                                                        printf("\nIl y a match nul\n");
                                                        break;
                                                    }
                                            
                                                    if(player == J1)
                                                        player = J2;
                                            
                                                    else
                                                        player = J1;
                                                }
                                            }
                                            
                                            bool test_Case(Grid *grid, int numCase)
                                            {
                                                int x, y;
                                                numCase--;
                                            
                                                x = numCase % grid->width;
                                                y = numCase / grid->width;
                                            
                                                if(x < 0 || x >= grid->width || y < 0 || y >= grid->height)
                                                    return false;
                                            
                                                return (grid->grid[y * grid->width + x] > 0);
                                            }
                                            
                                            bool end_Play(Grid *grid)
                                            {
                                                bool end = true;
                                                int x, y;
                                            
                                                for(y = 0; y < grid->height; y++)
                                                {
                                                    for(x = 0; x < grid->width; x++)
                                                    {
                                                        if(grid->grid[y * grid->width + x] > 0)
                                                        {
                                                            end = false;
                                                            return end;
                                                        }
                                                    }
                                                }
                                            
                                                return end;
                                            }
                                            
                                            int main(void)
                                            {
                                                Grid *grid = create_Grid(3, 3, 3);
                                            
                                                play(grid);
                                            
                                                delete_Grid(&grid);
                                            
                                                return 0;
                                            }
                                            

                                            Merci
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                              8 janvier 2011 à 14:39:22

                                              Salut,

                                              #include <stdio.h>
                                              #include <stdlib.h>
                                              
                                              void affichage(char* tableau);
                                              int saisie(int joueur);
                                              int testerCoup(int coord, char* tableau); // Si le coup est bon, il renvoie 1
                                              void jouerCoup(char* tableau, int coord, int joueur);
                                              void gagner(char* tableau, int* gagne);
                                              
                                              int main(void)
                                              {
                                              	char jouer = 'O';
                                              	
                                              	while (jouer != 'N')
                                              	{
                                              		int coord = 0;
                                              		int i = 0;
                                              		int gagne = 0;
                                              		char tableau[10];
                                              		int joueur = 1; //1 : joueur 1, 2 : joueur 2
                                              		
                                              		//Initialisation de toutes les cellules du tableau avec un point (.)
                                              		for (i = 0 ; i <= 8 ; i++)
                                              		{
                                              			tableau[i] = '.';
                                              		}
                                              		
                                              		while (!gagne)
                                              		{
                                              			//Affichage du tableau
                                              			affichage (tableau);
                                              			//Saisie des coordonnées et tester si le coup est permis
                                              			while(testerCoup(coord, tableau) == 0)
                                              				coord = saisie(joueur);
                                              			//On inscrit le coup dans le tableau
                                              			jouerCoup(tableau, coord, joueur);
                                              			
                                              			//On change de joueur
                                              			if (joueur == 1)
                                              				joueur++;
                                              			else if (joueur == 2)
                                              				joueur--;
                                              			
                                              			//Un joueur a gagné ?	
                                              			gagner(tableau, &gagne);
                                              		}
                                              		
                                              		printf("\n\nRejouer ? (O/N)\n");
                                              		scanf("%c", &jouer);
                                              	}
                                              	
                                              	return 0;
                                              }
                                              
                                              void affichage(char* tableau)
                                              {
                                              		printf("\n ___ ___ ___\n");
                                              		printf("| %c | %c | %c |\n", tableau[0], tableau[1], tableau[2]);
                                              		printf(" ___ ___ ___\n");
                                              		printf("| %c | %c | %c |\n", tableau[3], tableau[4], tableau[5]); 
                                              		printf(" ___ ___ ___\n");
                                              		printf("| %c | %c | %c |\n", tableau[6], tableau[7], tableau[8]);
                                              		printf(" ___ ___ ___\n\n"); 
                                              }
                                              
                                              int saisie(int joueur)
                                              {
                                              	int coord2 = 0;
                                              	printf("\n\nJoueur n° %d : ", joueur);
                                              	scanf("%d", &coord2);
                                              	
                                              	return coord2;
                                              }
                                              
                                              void gagner(char* tableau, int* gagne)
                                              {
                                              	if (tableau[0] == 'X' && tableau[1] == 'X' && tableau[2] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	} 
                                              	else if (tableau[3] == 'X' && tableau[4] == 'X' && tableau[5] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[6] == 'X' && tableau[7] == 'X' && tableau[8] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[0] == 'X' && tableau[3] == 'X' && tableau[6] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[1] == 'X' && tableau[4] == 'X' && tableau[7] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[2] == 'X' && tableau[5] == 'X' && tableau[8] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[0] == 'X' && tableau[4] == 'X' && tableau[8] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[2] == 'X' && tableau[4] == 'X' && tableau[6] == 'X')
                                              	{
                                              		printf("Joueur 1, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	
                                              	else if (tableau[0] == 'O' && tableau[1] == 'O' && tableau[2] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if	(tableau[3] == 'O' && tableau[4] == 'O' && tableau[5] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[6] == 'O' && tableau[7] == 'O' && tableau[8] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[0] == 'O' && tableau[3] == 'O' && tableau[6] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[1] == 'O' && tableau[4] == 'O' && tableau[7] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[2] == 'O' && tableau[5] == 'O' && tableau[8] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[0] == 'O' && tableau[4] == 'O' && tableau[8] == 'O' )
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else if (tableau[2] == 'O' && tableau[4] == 'O' && tableau[6] == 'O')
                                              	{
                                              		printf("Joueur 2, vous avez gagné !!");
                                              		*gagne = 1;
                                              	}
                                              	else
                                              		*gagne = 0;
                                              }
                                              
                                              int testerCoup(int coord, char* tableau)
                                              {
                                              	if (tableau[coord-1] != '.')
                                              		return 0;
                                              	else
                                              		return 1;
                                              }
                                              
                                              void jouerCoup(char* tableau, int coord, int joueur)
                                              {
                                              	if (joueur == 1)
                                              	{
                                              		tableau[coord-1] = 'X';
                                              	}
                                              	else if (joueur == 2)
                                              	{
                                              		tableau[coord-1] = 'O';
                                              	}
                                              }
                                              


                                              Alors il y a une seule chose qui ne fonctionne pas : c'est que le scanf à la ligne n° 49 ne veux pas être executé : il ne me demande rien à entrer. Du coup, je ne peux pas indiquer si je veux rejouer ou non, et le programme continuer de tourner.
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                8 janvier 2011 à 14:53:48

                                                Salut, il faut que tu vides le buffer ^^:
                                                while(getchar() != '\n');
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                  8 janvier 2011 à 15:34:10

                                                  Corrigé !

                                                  #include <stdio.h>
                                                  #include <stdlib.h>
                                                  #include <ctype.h>
                                                  
                                                  void affichage(char* tableau);
                                                  int saisie(int joueur);
                                                  int testerCoup(int coord, char* tableau); // Si le coup est bon, il renvoie 1
                                                  void jouerCoup(char* tableau, int coord, int joueur);
                                                  void gagner(char* tableau, int* gagne); //teste si un joueur a gagné, mais aussi si le tabealu est plein.
                                                  
                                                  int main(void)
                                                  {
                                                  	char jouer = 'O';
                                                  	
                                                  	while (jouer != 'N')
                                                  	{
                                                  		int coord = 0;
                                                  		int i = 0;
                                                  		int gagne = 0;
                                                  		char tableau[9];
                                                  		int joueur = 1; //1 : joueur 1, 2 : joueur 2
                                                  		
                                                  		//Initialisation de toutes les cellules du tableau avec un point (.)
                                                  		for (i = 0 ; i <= 8 ; i++)
                                                  		{
                                                  			tableau[i] = '.';
                                                  		}
                                                  		
                                                  		while (!gagne)
                                                  		{
                                                  			//Affichage du tableau
                                                  			affichage (tableau);
                                                  			//Saisie des coordonnées et tester si le coup est permis
                                                  			while(testerCoup(coord, tableau) == 0)
                                                  				coord = saisie(joueur);
                                                  			//On inscrit le coup dans le tableau
                                                  			jouerCoup(tableau, coord, joueur);
                                                  			
                                                  			//On change de joueur
                                                  			if (joueur == 1)
                                                  				joueur++;
                                                  			else if (joueur == 2)
                                                  				joueur--;
                                                  			
                                                  			//Un joueur a gagné ?	
                                                  			gagner(tableau, &gagne);
                                                  		}
                                                  		
                                                  		printf("\n\nRejouer ? (O/N)\n");
                                                  		while (getchar() != '\n');
                                                  		scanf("%c", &jouer);
                                                  		jouer = toupper(jouer);
                                                  	}
                                                  	
                                                  	return 0;
                                                  }
                                                  
                                                  void affichage(char* tableau)
                                                  {
                                                  		printf("\n ___ ___ ___\n");
                                                  		printf("| %c | %c | %c |\n", tableau[0], tableau[1], tableau[2]);
                                                  		printf(" ___ ___ ___\n");
                                                  		printf("| %c | %c | %c |\n", tableau[3], tableau[4], tableau[5]); 
                                                  		printf(" ___ ___ ___\n");
                                                  		printf("| %c | %c | %c |\n", tableau[6], tableau[7], tableau[8]);
                                                  		printf(" ___ ___ ___\n\n"); 
                                                  }
                                                  
                                                  int saisie(int joueur)
                                                  {
                                                  	int coord2 = 0;
                                                  	printf("\n\nJoueur n° %d : ", joueur);
                                                  	scanf("%d", &coord2);
                                                  	
                                                  	return coord2;
                                                  }
                                                  
                                                  void gagner(char* tableau, int* gagne)
                                                  {
                                                  	int i = 0;
                                                  	int casesPl = 0; //Nb cases pleines
                                                  	
                                                  	if (tableau[0] == 'X' && tableau[1] == 'X' && tableau[2] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	} 
                                                  	else if (tableau[3] == 'X' && tableau[4] == 'X' && tableau[5] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[6] == 'X' && tableau[7] == 'X' && tableau[8] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[0] == 'X' && tableau[3] == 'X' && tableau[6] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[1] == 'X' && tableau[4] == 'X' && tableau[7] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[2] == 'X' && tableau[5] == 'X' && tableau[8] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[0] == 'X' && tableau[4] == 'X' && tableau[8] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[2] == 'X' && tableau[4] == 'X' && tableau[6] == 'X')
                                                  	{
                                                  		printf("Joueur 1, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	
                                                  	else if (tableau[0] == 'O' && tableau[1] == 'O' && tableau[2] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if	(tableau[3] == 'O' && tableau[4] == 'O' && tableau[5] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[6] == 'O' && tableau[7] == 'O' && tableau[8] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[0] == 'O' && tableau[3] == 'O' && tableau[6] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[1] == 'O' && tableau[4] == 'O' && tableau[7] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[2] == 'O' && tableau[5] == 'O' && tableau[8] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[0] == 'O' && tableau[4] == 'O' && tableau[8] == 'O' )
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	else if (tableau[2] == 'O' && tableau[4] == 'O' && tableau[6] == 'O')
                                                  	{
                                                  		printf("Joueur 2, vous avez gagné !!");
                                                  		*gagne = 1;
                                                  	}
                                                  	
                                                  	else
                                                  		*gagne = 0;
                                                  	
                                                  	for (i = 0; i <= 8; i++)
                                                  	{
                                                  		if (tableau[i] != '.')
                                                  			casesPl++;
                                                  			
                                                  		if (casesPl == 9)
                                                  		{
                                                  			*gagne = 1;
                                                  			printf("Personne n'a gagné");
                                                  		}
                                                  	}
                                                  }
                                                  
                                                  int testerCoup(int coord, char* tableau)
                                                  {
                                                  	if (tableau[coord-1] != '.')
                                                  		return 0;
                                                  	else
                                                  		return 1;
                                                  }
                                                  
                                                  void jouerCoup(char* tableau, int coord, int joueur)
                                                  {
                                                  	if (joueur == 1)
                                                  	{
                                                  		tableau[coord-1] = 'X';
                                                  	}
                                                  	else if (joueur == 2)
                                                  	{
                                                  		tableau[coord-1] = 'O';
                                                  	}
                                                  }
                                                  


                                                  Mon code gère maintenant le cas où le tableau est plein.
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    8 janvier 2011 à 16:25:07

                                                    Salut, pourquoi n'essaie tu pas de gérer un morpion ou tu choisis le nombre de pion a améliorer la taille de la grille etc ^^
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                      8 janvier 2011 à 16:35:28

                                                      @ sydzero avant de faire ce que dit qnope change ta fonction gagner.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        8 janvier 2011 à 17:35:21

                                                        Citation : qnope

                                                        Salut, pourquoi n'essaie tu pas de gérer un morpion ou tu choisis le nombre de pion a améliorer la taille de la grille etc ^^



                                                        Je vais essayer.

                                                        Et effectivement avec une fonction gagner comme celle que j'ai, je ne vais pas aller loin...
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          8 janvier 2011 à 18:04:13

                                                          Je vous présente mon projet de morpion avec option 1 ou 2 joueur (utilisable uniquement sous windows a cause des couleurs)
                                                          #include <stdlib.h>
                                                          #include <stdio.h>
                                                          #include <windows.h>
                                                          #include <time.h>
                                                          
                                                          void textcolor(int couleurDuTexte,int couleurDeFond);
                                                          void actualiser(int table[9]);
                                                          int caseVide(int enter, int table[9]);
                                                          int matchNul(int table[]);
                                                          int win(int tableau[9]);
                                                          int ia(int table[9], int coups);
                                                          void initTable(int table[9]);
                                                          
                                                          enum{VIDE = 0, CROIX = 1, ROND = 2};
                                                          
                                                          void textcolor(int couleurDuTexte,int couleurDeFond) // fonction d'affichage de couleurs
                                                          {
                                                                  HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
                                                                  SetConsoleTextAttribute(H,couleurDeFond*16+couleurDuTexte);
                                                          }
                                                          
                                                          void actualiser(int table[9]) // Affiche la progression de la grille de morpion
                                                          {
                                                          	int i = 0, j = 0;
                                                          	for(i=0;i<3;i++)
                                                          	{
                                                          		for(j=0;j<3;j++)
                                                          		{
                                                          			if(table[i*3+j]==VIDE)
                                                          			{
                                                          				textcolor(15,0); // Blanc
                                                          				printf("%d ",i*3+j+1);
                                                          			}
                                                          			else if(table[i*3+j]==CROIX)
                                                          			{
                                                          				textcolor(2,0); // Vert
                                                          				printf("X ");
                                                          			}
                                                          			else if(table[i*3+j]==ROND)
                                                          			{
                                                          				textcolor(4,0); // Rouge
                                                          				printf("O ");
                                                          			}
                                                          		}
                                                          		printf("\n");
                                                          	}
                                                          	textcolor(15,0);
                                                          	printf("\n");
                                                          }
                                                          
                                                          int caseVide(int enter, int table[9]) // Test une case vide
                                                          {
                                                          	if((enter>=1&&enter<=9) && table[enter-1]==VIDE)
                                                          		return 1;
                                                          	else
                                                          		return 0;
                                                          }
                                                          
                                                          int matchNul(int table[]) // Test un match nul
                                                          { 
                                                          	int i;
                                                          	for(i=0;i<9;i++)
                                                          	{
                                                          		if(table[i]==0)
                                                          			break;
                                                          	}
                                                          	return (i!=9) ? 0 : 1;
                                                          }
                                                          
                                                          int win(int tableau[9]) // Test une victoire
                                                          {
                                                              if ((tableau[0] == tableau[1] && tableau[0] == tableau[2] && tableau[2] != VIDE)||
                                                                      (tableau[3] == tableau[4] && tableau[3] == tableau[5] && tableau[5] != VIDE)||
                                                                      (tableau[6] == tableau[7] && tableau[6] == tableau[8] && tableau[8] != VIDE)||
                                                                      (tableau[0] == tableau[3] && tableau[0] == tableau[6] && tableau[6] != VIDE)||
                                                                      (tableau[1] == tableau[4] && tableau[1] == tableau[7] && tableau[7] != VIDE)||
                                                                      (tableau[2] == tableau[5] && tableau[2] == tableau[8] && tableau[8] != VIDE)||
                                                                      (tableau[0] == tableau[4] && tableau[0] == tableau[8] && tableau[8] != VIDE)||
                                                                      (tableau[2] == tableau[4] && tableau[2] == tableau[6] && tableau[6] != VIDE))
                                                          			return 1;
                                                          	return 0;
                                                          }
                                                          
                                                          int ia(int table[9], int coups) // L'IA
                                                          {
                                                          	int i;
                                                          	if(coups==8)
                                                          		for(i=0;i<9;i++)
                                                          			if(table[i]==VIDE)
                                                          				return i;
                                                          	if(coups==1&&table[4]==VIDE)return 4;
                                                          
                                                          	// L'IA tente de gagner sur ce coups
                                                          		// Test lignes
                                                          	else if(table[6]==ROND&&table[7]==ROND&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[6]==ROND&&table[8]==ROND&&table[7]==VIDE)return 7; // 3
                                                          	else if(table[7]==ROND&&table[8]==ROND&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[3]==ROND&&table[4]==ROND&&table[5]==VIDE)return 5; // 2
                                                          	else if(table[3]==ROND&&table[5]==ROND&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[4]==ROND&&table[5]==ROND&&table[3]==VIDE)return 3; // 2
                                                          	else if(table[0]==ROND&&table[1]==ROND&&table[2]==VIDE)return 2; // 1
                                                          	else if(table[0]==ROND&&table[2]==ROND&&table[1]==VIDE)return 1; // 1
                                                          	else if(table[1]==ROND&&table[2]==ROND&&table[0]==VIDE)return 0; // 1
                                                          
                                                          		// Test colonnes
                                                          	else if(table[2]==ROND&&table[5]==ROND&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[1]==ROND&&table[4]==ROND&&table[7]==VIDE)return 7; // 3
                                                          	else if(table[0]==ROND&&table[3]==ROND&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[2]==ROND&&table[8]==ROND&&table[5]==VIDE)return 5; // 2
                                                          	else if(table[1]==ROND&&table[7]==ROND&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[0]==ROND&&table[6]==ROND&&table[3]==VIDE)return 3; // 2
                                                          	else if(table[5]==ROND&&table[8]==ROND&&table[2]==VIDE)return 2; // 1
                                                          	else if(table[4]==ROND&&table[7]==ROND&&table[1]==VIDE)return 1; // 1
                                                          	else if(table[3]==ROND&&table[6]==ROND&&table[0]==VIDE)return 0; // 1
                                                          
                                                          		// Test diagonales
                                                          	else if(table[0]==ROND&&table[4]==ROND&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[2]==ROND&&table[4]==ROND&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[0]==ROND&&table[8]==ROND&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[2]==ROND&&table[6]==ROND&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[4]==ROND&&table[6]==ROND&&table[2]==VIDE)return 2; // 2
                                                          	else if(table[4]==ROND&&table[8]==ROND&&table[0]==VIDE)return 0; // 2
                                                          
                                                          	// L'IA regarde si le joueur peux gagner
                                                          		// Test lignes
                                                          	else if(table[6]==CROIX&&table[7]==CROIX&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[6]==CROIX&&table[8]==CROIX&&table[7]==VIDE)return 7; // 3
                                                          	else if(table[7]==CROIX&&table[8]==CROIX&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[3]==CROIX&&table[4]==CROIX&&table[5]==VIDE)return 5; // 2
                                                          	else if(table[3]==CROIX&&table[5]==CROIX&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[4]==CROIX&&table[5]==CROIX&&table[3]==VIDE)return 3; // 2
                                                          	else if(table[0]==CROIX&&table[1]==CROIX&&table[2]==VIDE)return 2; // 1
                                                          	else if(table[0]==CROIX&&table[2]==CROIX&&table[1]==VIDE)return 1; // 1
                                                          	else if(table[1]==CROIX&&table[2]==CROIX&&table[0]==VIDE)return 0; // 1
                                                          
                                                          		// Test colonnes
                                                          	else if(table[2]==CROIX&&table[5]==CROIX&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[1]==CROIX&&table[4]==CROIX&&table[7]==VIDE)return 7; // 3
                                                          	else if(table[0]==CROIX&&table[3]==CROIX&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[2]==CROIX&&table[8]==CROIX&&table[5]==VIDE)return 5; // 2
                                                          	else if(table[1]==CROIX&&table[7]==CROIX&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[0]==CROIX&&table[6]==CROIX&&table[3]==VIDE)return 3; // 2
                                                          	else if(table[5]==CROIX&&table[8]==CROIX&&table[2]==VIDE)return 2; // 1
                                                          	else if(table[4]==CROIX&&table[7]==CROIX&&table[1]==VIDE)return 1; // 1
                                                          	else if(table[3]==CROIX&&table[6]==CROIX&&table[0]==VIDE)return 0; // 1
                                                          
                                                          		// Test diagonales
                                                          	else if(table[0]==CROIX&&table[4]==CROIX&&table[8]==VIDE)return 8; // 3
                                                          	else if(table[2]==CROIX&&table[4]==CROIX&&table[6]==VIDE)return 6; // 3
                                                          	else if(table[0]==CROIX&&table[8]==CROIX&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[2]==CROIX&&table[6]==CROIX&&table[4]==VIDE)return 4; // 2
                                                          	else if(table[4]==CROIX&&table[6]==CROIX&&table[2]==VIDE)return 2; // 2
                                                          	else if(table[4]==CROIX&&table[8]==CROIX&&table[0]==VIDE)return 0; // 2
                                                          
                                                          	// L'IA joue autre part
                                                          	do
                                                          	{
                                                          		i = rand() % 8;
                                                          	}while(table[i]!=VIDE);
                                                          	return i;
                                                          }
                                                          
                                                          void initTable(int table[9]) // Initialise le tableau int[9]
                                                          {
                                                          	table[0] = table[1] = table[2] = table[3] = table[4] = table[5] = table[6] = table[7] = table[8] = VIDE;
                                                          }
                                                          
                                                          int main(int argc, char *argv[])
                                                          {
                                                          	int table[9] = {0};
                                                          	int game = 1;
                                                          	int player = 1;
                                                          	int numCase = 0;
                                                          	int coups=0;
                                                          	int forIA=0;
                                                          	char caract = 'C';
                                                          
                                                          	system("title Morpion - By Crushing");
                                                          	printf("Bienvenue dans le jeu du morpion !\n\n");
                                                          	printf("Les cases avec des '.' sont vide\nEntrez le numero de la case pour y mettre votre signe\nLes numeros sont :\n");
                                                          	actualiser(table);
                                                          
                                                          	while(caract!='y'&&caract!='Y'&&caract!='N'&&caract!='n') // 1 ou 2 joueurs
                                                          	{
                                                          		printf("\nVoulez-vous jouez a 1 joueur (Y/N) : ");
                                                          		caract = fgetc(stdin);
                                                          	}
                                                          	if(caract=='Y'||caract=='y')forIA=1;
                                                          	caract = ' ';
                                                          
                                                          	printf("\nLe joueur 1 commence\n");
                                                          
                                                          	while(1)
                                                          	{
                                                          		initTable(table);
                                                          	while(game)
                                                          	{
                                                          		if(player==1)
                                                          		{
                                                          			textcolor(2,0); // Vert 
                                                          			printf("Joueur 1");
                                                          			textcolor(15,0); // Blanc
                                                          			printf("veuillez entrer le numero de la case : ");
                                                          			textcolor(2,0); // Vert 
                                                          			scanf("%d", &numCase);
                                                          			textcolor(15,0); // Blanc
                                                          		}
                                                          		else
                                                          		{
                                                          			textcolor(4,0); // Rouge
                                                          			printf("Joueur 2");
                                                          			textcolor(15,0); // Blanc
                                                          			printf("veuillez entrer le numero de la case : ");
                                                          			textcolor(4,0); // Rouge
                                                          			if(forIA==1) // Si l'IA joue
                                                          			{
                                                          				numCase=ia(table,coups)+1;
                                                          				printf("%d\n",numCase);
                                                          			}
                                                          			else // Sinon un autre joueur joue
                                                          				scanf("%d", &numCase);
                                                          			textcolor(15,0); // Blanc
                                                          		}
                                                          		if(!caseVide(numCase, table))
                                                          		{
                                                          			printf("Erreur dans la case entrer\n");
                                                          			continue;
                                                          		}
                                                          		else
                                                          		{
                                                          			coups++;
                                                          			table[numCase-1]=player;
                                                          			actualiser(table);
                                                          			if(win(table)) // Gagné ?
                                                          			{
                                                          				game=0;
                                                          				printf("\nLe joueur %d a gagner, bravo a lui !\n\n", player);
                                                          			}
                                                          			else if(matchNul(table)) // Match nul ?
                                                          			{
                                                          				game=0;
                                                          				printf("Quel dommage ! Un match nul entre nos 2 joueurs !\n\n");
                                                          			}
                                                          			else // Sinon changement de joueur
                                                          			{
                                                          				if(player==1)player=2;
                                                          				else player=1;
                                                          			}
                                                          		}
                                                          	}
                                                          	while(caract!='y'&&caract!='Y'&&caract!='N'&&caract!='n')
                                                          	{
                                                          		printf("Voulez-vous faire une autre partie ? (Y/N) : ");
                                                          		caract = fgetc(stdin);
                                                          	}
                                                          	if(caract=='y'||caract=='Y')
                                                          		game = 1;
                                                          	else
                                                          		break;
                                                          	}
                                                          
                                                          	system("pause");
                                                          	return 0;
                                                          }
                                                          


                                                          Désolé, mais j'ai très peu espacé mes calculs mais j'espère que cela reste lisible :)

                                                          Voilà ce que fait mon IA :
                                                          • Si 8 coups on déjà été joué, elle joue la dernière case
                                                          • Sinon si il n'y a eu qu'un seul coup joué, elle joue au milieu
                                                          • Sinon si l'IA peut gagné a ce coups, elle joue à la bonne case
                                                          • Sinon si le joueur peut gagné, l'IA l'en empêche
                                                          • Sinon elle joue au hasard
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            8 janvier 2011 à 19:00:08

                                                            Pas très efficace ton IA si tu choisis une grille de 100 par 100 ^^

                                                            Sinon, dommage que ton code n'est pas portable? Rend le portable en utilisant les couleurs UNIX ou (ncurses?)
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                              8 janvier 2011 à 19:07:20

                                                              Citation : qnope

                                                              Pas très efficace ton IA si tu choisis une grille de 100 par 100 ^^


                                                              Je suis d'accord avec toi ^^ , mais je ne trouvais pas d'autre solution

                                                              Et j'essaierais de le rendre portable après avoir perfectionner l'IA
                                                              • 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