1

slt j'voudrais faire le jeu puissance 4 en IA voila la strategie du pc
voila le noir c le pc et le blanc c moi:
*si le noir peut realiser une file horizontale diagonale ou verticale de 4 pions il la realise
*sinon si blanc peut realiser au coup suivant une file de 4 pions noir s'y oppose (en placant un pion a bout )ceci est parfois insuffisant pur eviter la defaite
*sinon si noir peut realiser une file de 3 pions il la realise
*sinon si blanc peut realiser au coup suivant une file de 3 pions noir s'y oppose en placant un pion a bout
*sinon si noir peut realiser une file de 2 pions il la realise
voila la strategie du pc
j'ai essaye de faire un carre de 4*4 (mon jeu se deroule sur une grille de 10*10) et chaque fois j'l'avance d'un cran y aura 4 carres et chaque il teste toutes les possiblites du joueur humain et s'il y a 3 pions alignes il bloque la progression et met un pion sauf qu'a mon avis y a des autres possiiblites par exemple au debut il doit aligner ses pions "normalement" en choisissant une colonne sans executer aucun test a vous de m'aider merci

2

Code :

tonguet1cable:

 
  /*algo de la strategie du pc*/ /* grille 10*10 */ 
  void strategie-puissance4( int matrice[i][j]) 
  { /*carre en haut a gauche */ 
   for(i=0;i<4:i++) 
     for(j=0;j<4;j++) 
     {    if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])|| 
                /*test vertical et horizontal*/ 
                 ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j])) 
                 setcolor();circle() 
      }   
   else 
        {if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2])) 
                setcolor();circle();
                /*test nord est*/ 
        } 
   
 for(i=3;i>=0;i--) 
      for(j=0;j<4;j++) 
   {     if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2])) 
             /*test sud est*/ 
            setcolor();circle();/*bloquer la progression en dessinat le pion du pc*/ 
   } 
  else            /*carre en haut a gauche  */ 
  {    for(i=4;i<8:i++)  
      {      for(j=4;j<8;j++)                                              /*test vertical puis hrizontal */ 
      {   if ((matrice[i][j]==matrice[i][j+1])&&matrice[i][j+1]==matrice[i][j+2])||  
               ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j])) 
                  setcolor();circle() 
   } 
     
   else 
        {  if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2])) 
                  setcolor();circle();                                                /*test nord est*/ 
        } 
  } 
 
   
  for(i=3;i>=0;i--) 
      for(j=4;j<8;j++)   /*test sud est*/ 
   {          if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2])) 
                                setcolor();circle();/*bloquer la progression*/ 
   } 
   /*carre en haut a droite*/ 
  for(i=0;i<4;i++) 
     for(j=5;j<10;j++)                             /*test vertical et horizontal*/  
     {         if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])|| 
                       matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j])) 
                setcolor();circle() 
   } 
     else /*test nord est*/ 
      { if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2])) 
                setcolor();circle();/*test nord est*/ 
      } 
  for(i=3;i>=0;i--) 
    for(j=5;j<9;j++) 
    {  if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2])) 
              setcolor();circle(); 
    } 
  }             
  /*carre a gauche en bas*/ 
   
  for(i=5;i<10;i++) 
           for(j=0;j<5;j++) 
    {           if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matrice[i][j+2]))/*test horizontal*/ 
                       || ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))  
                setcolor();circle(); 
   else                       /*test diagonale nord est */ 
      if  ((matrice[i][j]==matrice[i+1][j+1]&&matrice[i+1][j+1]==matrice[i+2][j+2])) 
    {      setcolor();circle();} 
      
    }
  else  
    {       for(i=9;i>=5;i++) 
               for(j=0;j<5;j++) 
         {        if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2])) 
                  setcolor();circle(); 
         } 
    } 
     
  /*carre a droite en bas*/ 
    for(i=5;i<10;i++) 
           for(j=5;j<10;j+) 
     {        if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matyrice[i][j+2])) 
              setcolor();circle(); 
     else
   {  if           ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))       
                    setcolor();circle(); 
     }
         
      else    if ((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2] 
          setcolor();circle(); 
          
        
     } 
   
  for(i=9;i>=5;i--) 
      for(j=5;j<10;j++)    
   {         if( matrice[i][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2] )
             setcolor();circle();          /*le pc colore le pion et le dessine  pour bloquer l'adversaire*/ 
     
      }         /*la c bon on a quadrille ou balaye toute la grille mais il etait temps j'vois flou laaa*/ 
   


3

j'ai essaye de faire un carre de 4*4 (mon jeu se deroule sur une grille de 10*10) et chaque fois j'l'avance d'un cran y aura 4 carres et chaque il teste toutes les possiblites du joueur humain et s'il y a 3 pions alignes il bloque la progression et met un pion sauf qu'a mon avis y a des autres possiiblites par exemple au debut il doit aligner ses pions "normalement" en choisissant une colonne sans executer aucun test a vous de m'aider merci

Rien compris à ce qui est en gras : ce serait mieux si tu mettais des signes de ponctuation, et que tu te relisais pour vérifier s'il ne manque pas des mots ("et chaque il teste")... Je ne vois pas non plus ce que tu veux dire par "aligner les pions normalement"...


Sinon pour ce qui est du code, essaye d'indenter systématiquement : là, tu as des indentations dont la longueur varie entre 1 et 4 caractères, et les accolades sont un peu placées n'importe où...

Et j'imagine que ton code ne compile pas ("if matrice[i ][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2]"), donc ce serait bien si tu nous disais aussi quel est ton pb précisement embarrassed


[EDIT : corrigé le [i ] qui faisait bugger le post]

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

4

dsl mais j'ai mis if matrice[i][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2] ok c toi .......
sinon j'essaie d'etre + clair j'essaie de jouer contre le pc donc on fait appel a l'IA par consequent j'dois trouver une procedure qui cerne la strategie du pc .
le code que j'ai mis ci dessus c pour le cas ou le joueur humain a aligne 3 pions a la file donc l'pc va bloquer sa progression et pour ca l'idee (en gros) est de faire un carre 4*4 qui balaye toute la grille ou l'aire de jeu en le deplacant d'un cran a chaque fois et chaque carre teste toutes les possiblites horizontal vertical et diagonale ok..sinon a part ca faudra une batterie de tests et c pa court meme ici ca l'est pa ....
maiscette procedure ne suffit pa .. il reste des cas a tester et citer pour que l'IA soirt complete par exemple au debut du jeu le pc joue(normalemnt comme un humain) en mettant son pion dans la colonne choisie y a pa n possibilites c tout (n colonnes)
ok monsieur pollux dsl un bon cafe serre m'a remis la tete en place

5

Bon, j'ai pris mon courage à deux mains et j'ai jeté un oeil sur ton code...

Déjà, ce qu'il faut savoir, c'est qu'il faut éviter (au moins dans un premier temps, après on peut optimiser, mais seulement si on a une idée très claire de ce qu'on veut faire), c'est de dupliquer du code. Pourquoi? Parce que ça rend le code :
* difficile à lire : on ne voit pas du premier coup d'oeil ce qui change entre deux versions (c'est encore pire étant donné que tu n'indentes pas ton code correctement : [google]indentation[/google] si qqun n'a pas de bon tuto dessus)
* difficile à maintenir : si tu veux faire une modification à l'un des bouts de code dupliqué, il faut passer du temps à répercuter la modif sur les autres bouts de codes, et si tu oublies de le faire, tu te retrouves avec des bugs bizarres.

Donc ici, tu peux déjà envisager de faire une boucle for qui sera exécutée 4 fois, une fois pour chaque direction.

Ensuite, il faudrait éviter le plus possible de faire appel à des constantes numériques : pour le 4 des 4 directions, tu n'as pas vraiment le choix donc tu peux t'en servir, mais pour la largeur, la hauteur et le nombre de pions à aligner, le mieux serait de faire un #define pour chacun de ces trucs et de ne _jamais_ utiliser de constantes numériques autre que 0 ou 1...

En plus ton programme ne sera pas plus lent si tu mets WIDTH-1 (avec #define WIDTH 10) à la place de 9 smile

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

6

ok franchement merci j'suis qu'un debutant sinon pollux en fait pour la strategie j'fais deux autres fonctions a mon avis sinon la procedure pion que j'ai deja faite
sinon stp une kestion pour le test de la diagonale sud est :est ce que ca revient au meme de faire:
for(i=taille-1;i>=5;i--)
for(j=5;j<taille;j++)
{ if matrice[i][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2])) .....
ou
for(i=taille-1;i>=5;i--)
for(j=taille-1;j>=5;j--)
if((matrice[i][j]==matrice[i-1][j-1]
&&matrice[i-1][j-1]==matrice[i-2][j-2])).....

7

pour écrire ton code, tape [pre]mon_code[/pre] au lieu de mon_code tout court...

pour ton truc déjà tu testes pas la même diagonale embarrassed et sinon j'imagine que ta question porte sur la direction des boucles, non?

et essaye de reprogrammer comme je te l'ai dit dans le post 4, ça clarifiera les choses smile

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

8

ouais j't'ai dit pour les deux boucles que j'ai mise en haut ca revient au meme ou non amon avis oui car en verifiant au style c la meme chsose quoi mais l'une descendante l'autre..........
sinon j'arrive pa a finaliser la strategie du pc il reste le cas ou y a pa encore 3 pions a la file

9

Essaye déjà de faire une boucle propre pour détecter s'il y a 'n' pions alignés dans une direction, avec n quelconque, ça devrait pas mal t'aider...

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

10

ouais si y a 3 cases qui ont la meme valeur 1 alors c les 3 pions du jouer c ca ca marche c la boucle for
mais le bleme c les autres cas a mon avis j'fais la fonction pion tant qu'il y pa 3 pions alignes le pc aligne ses pionset de meme pour l'humain ....chacun choisit sa colonne et c bon

11

en fait un break apres chaque if c conseille aussi ? pour gagner du temps et passer a l'autre condition

12

/*algo de la strategie du pc*/ /* grille 10*10 */ 
# define width=4; 

void strategie-puissance4( int matrice[i][j])
{ /*carre en haut a gauche */
 for(i=0;i<width:i++)
   for(j=0;j<width;j++) /*test vertical et horizontal*/ 
   { if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])||
         ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
           { 
           setcolor();
            circle()
           }
   }
 else
   { if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
            
 {  setcolor();
    circle();                                   /*test nord est*/
 }

for(i=width-1;i>=0;i--)
    for(j=0;j<width;j++)                   /*test sud est*/
     { if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
		{  
                                     setcolor();
                                      circle();                                                  /*bloquer la progression en dessinant le pion du pc */
                                  }
	}
else            /*carre en haut a gauche  */
{ for(i=width;i<8:i++) 
  {    for(j=width;j<8;j++)  /*test vertical puis hrizontal */
  {         if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])|| 
                  ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
{   	 setcolor();
                circle();
 }

       else
	   {  if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
                           {  
                           setcolor();
                            circle();                                   /*test nord est*/
	   }
}
} 

for(i=width-1;i>=0;i--)
    for(j=width;j<8;j++)
	{if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
	/*test sud est*/
	      setcolor();circle();/*bloquer la progression*/
	}
	/*carre en haut a droite*/
for(i=0;i<width;i++)
   for(j=width+1;j<10;j++)
   { if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])||
   /*test vertical et horizontal*/
         ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
           { 
            setcolor();
            circle();
            }
   else /*test nord est*/
	   { if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
   {     
	   setcolor();
                    circle();                                     /*test nord est*/
   }
  }
for(i=width-1;i>=0;i--)
  for(j=width+1;j<9;j++)
  {  if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
  { 
          setcolor();
          circle();
  }
}            
/*carre a gauche en bas*/

for(i=width+1;i<10;i++)
  for(j=0;j<width-1;j++)       /*test horizontal*/
  {   if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matrice[i][j+2]))
     || ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j])) 
             {	 
                setcolor();
                 circle();
              }
 else                  /*test diagonale nord est */
	 if ((matrice[i][j]==matrice[i+1][j+1]&&matrice[i+1][j+1]==matrice[i+2][j+2]))
	 {    setcolor(); 
	       circle();
	 }


  } else 
	 { for(i=9;i>=width+1;i++)
                           for(j=0;j<width-1;j++)
		   {  if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
		   {
			   setcolor();
			    circle();
		   }
  }


/*carre a droite en bas*/
  for(i=width+1;i<10;i++)
	  for(j=width+1;j<10;j+)
	  { if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matyrice[i][j+2]))
	  {       
	         setcolor();
	         circle();
	  }
         else if ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))      
		 { setcolor();
		     circle();
		 }
	   
	 else   if ((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]
	 { 
		 setcolor();
	                   circle();
	 }	  
	  
	  }

for(i=9;i>=width+1;i--)
    for(j=width+1;j<10;j++)	  
	{ if matrice[i][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2]
	  
	{    setcolor();
	      circle();
	}      /******le pc colore le pion et le dessine  pour bloquer l'adversaire*/

  }
}
	
     
         
	 

13

avec le define c + clair ds ma tete sinon c pa mieux de faire if et un break a chaque fois que faire else .....if ........

14

/*algo de la strategie du pc*/ /* grille 10*10 */ 
# define width=4; 

void strategie-puissance4( int matrice[i][j])
{ /*carre en haut a gauche */
 for(i=0;i<width:i++)
   for(j=0;j<width;j++) /*test vertical et horizontal*/ 
   { if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])||
         ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
           { 
           setcolor();
            circle()
           }
   }
 else
   { if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
            
 {  setcolor();
    circle();                                   /*test nord est*/
 }

for(i=width-1;i>=0;i--)
    for(j=0;j<width;j++)                   /*test sud est*/
     { if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
		{  
                                     setcolor();
                                      circle();                                                  /*bloquer la progression en dessinant le pion du pc */
                                  }
	}
else            /*carre en haut a gauche  */
{ for(i=width;i<8:i++) 
  {    for(j=width;j<8;j++)  /*test vertical puis hrizontal */
  {         if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])|| 
                  ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
{   	 setcolor();
                circle();
 }

       else
	   {  if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
                           {  
                           setcolor();
                            circle();                                   /*test nord est*/
	   }
}
} 

for(i=width-1;i>=0;i--)
    for(j=width;j<8;j++)
	{if (matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
	/*test sud est*/
	      setcolor();circle();/*bloquer la progression*/
	}
	/*carre en haut a droite*/
for(i=0;i<width;i++)
   for(j=width+1;j<10;j++)
   { if (matrice[i][j]==matrice[i][j+1]&&matrice[i][j+1]==matrice[i][j+2])||
   /*test vertical et horizontal*/
         ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))
           { 
            setcolor();
            circle();
            }
   else /*test nord est*/
	   { if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]))
   {     
	   setcolor();
                    circle();                                     /*test nord est*/
   }
  }
for(i=width-1;i>=0;i--)
  for(j=width+1;j<9;j++)
  {  if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
  { 
          setcolor();
          circle();
  }
}            
/*carre a gauche en bas*/

for(i=width+1;i<10;i++)
  for(j=0;j<width-1;j++)       /*test horizontal*/
  {   if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matrice[i][j+2]))
     || ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j])) 
             {	 
                setcolor();
                 circle();
              }
 else                  /*test diagonale nord est */
	 if ((matrice[i][j]==matrice[i+1][j+1]&&matrice[i+1][j+1]==matrice[i+2][j+2]))
	 {    setcolor(); 
	       circle();
	 }


  } else 
	 { for(i=9;i>=width+1;i++)
                           for(j=0;j<width-1;j++)
		   {  if ((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2]))
		   {
			   setcolor();
			    circle();
		   }
  }


/*carre a droite en bas*/
  for(i=width+1;i<10;i++)
	  for(j=width+1;j<10;j+)
	  { if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matyrice[i][j+2]))
	  {       
	         setcolor();
	         circle();
	  }
         else if ((matrice[i][j]==matrice[i+1][j])&&(matrice[i+1][j]==matrice[i+2][j]))      
		 { setcolor();
		     circle();
		 }
	   
	 else   if ((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2]
	 { 
		 setcolor();
	                   circle();
	 }	  
	  
	  }

for(i=9;i>=width+1;i--)
    for(j=width+1;j<10;j++)	  
	{ if matrice[i][j]==matrice[i-1][j+1]&&matrice[i-1][j+1]==matrice[i-2][j+2]
	  
	{    setcolor();
	      circle();
	}      /******le pc colore le pion et le dessine  pour bloquer l'adversaire*/

  }
}

Il faut mettre ton code entre les balises PRE. Quand tu as collé ton code dans ton post, tu le sélectionnes et tu cliques sur pre à droite du cadre de saisie.
avatar
Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

15

en fait pour le test diagonale par exemple j'voudrais faire une fonction ;
int test diagonale_nord_est (int matrice[i][j])
{
int puissance;
int i,j;
for(i=0;i<taille-3;i++)
{  for(j=0;j<taille-3;j++)
      if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2])
        &&(matrice[i+2][j+2]==matrice[i+3][j+3]))    /*return(4); */
	  {
		  puissance=4;
	  }
return(puissance);
}

sauf qu'en parametre formels j'sais pa si j'dois mettre (int matrice[i][j]) ou (int i,int j) sachant que pour le deuxieme choix ca compile et la seule erreur c dans l'aleternace des joueurs ca doit marcher avec quelques bricoles sauf que la c a deux joueurs
il me reste l'IA j'ai pa trop l'inspi a part l'idee du carre)

16

Utilise [pre] !
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

17

merci de m'expliker clairement comment savoir sans se tromper ce qu'il fo passer en parametre formel ,ce qu'il faut mettre dans l'entete de la fonction ..merci d'avance

18

Merci de prendre en considération nos posts !
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

19

car la c la seule erreur mdrrrrrrrr sinon la c a deux joueurs
le reste on verra cette IA

20

C'est "int test_diagonale_nord_est(int matrice[10][10])" qu'il faudrait mettre... Et comme je te l'ai dit, ce serait plus lisible si tu faisais une seule boucle pour gérer les 4 directions...

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

21

ouais donc il faudra mettre les deux for que j'ai ci dessus et chaque fois if........................break;

22

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<alloc.h>
int matrice[10][10];
# define taille 10
int tour_joueur;
int x;
int y;
int r;
int i;
int j;
int puissance;
int joueur;
int x1,y1,x2,y2;

/*******************************************************************************************/

void affichage (int x1,int y1,int x2)
{ int j,m;
  int i,k;
 m=0;
 k=0;
for(j=0;j<taille;j=j+1)
{line(x1,y1+m,x2,y1+m);
m=m+40;
}

for(i=0;i<taille;i=i+1)
  {line(x1+k,y1,x1+k,y2);
   k=k+40;
  }
}
/***********************************************************************************/
/*m---->nombre de lignes */     /*n-->nombre d colonnes*/
void init(int i,int j)
/*initialisation a vide la matrice*/
{ for(i=0;i<10;i++)/*i=0--->matrice[0][j] cases 1ere ligne */
       for(j=0;j<10;j++)
	   {matrice[i][j]==0;}
}
/************************************************************************************/
void pion( int x,int y,int r)
/*specif:cette procedure dessine le jeton et le place dans la colonne correspondante  */
{
  int i,ligne;
  int col;
  i=taille-1;            /******************i=9**********/
  do {
	clrscr();
	printf("choisir la colonne");
	scanf("%d",&col);
 }
 while((col<0)&&(col>taille));
 while (matrice[i][j]!=0)
 {
  i--;
 }
  ligne=i;
  if(joueur==1)
  {	  matrice[i][j]=2;
	  setcolor(0);
      circle(x+(col*20),y+(ligne*20),r);/*on place le jeton dans la premiere case vide de la colonne choisie*/
  }
  else { matrice[i][j]=1;
	     setcolor(15);
         circle(x+(col*20),y+(ligne*20),r);
		}



}
/**********************************************************************************/
int test_vertical()
/*specif:matrice[i][j]==1-->coup du joueur 1 sinon matrice[i][j]=2 alors coup du joueur 2(pc)*/
{
int puissance;
for(i=0;i<=taille-3;i++)
  for(j=0;j<=taille-1;j++)
  {  if ((matrice[i][j]==matrice[i+1][j]) &&( matrice[i+1][j]==matrice[i+2][j])
          && (matrice[i+2][j]==matrice[i+3][j]))
      {
	     puissance=4;
      }                       /*puissance 4*/
   /*  else puissance=0 */
  }
return(puissance);

}

/************************************************************************************/
int test diagonale_nord_est()
{
int puissance;
for(i=0;i<taille-3;i++)
{  for(j=0;j<taille-3;j++)
      if((matrice[i][j]==matrice[i+1][j+1])&&(matrice[i+1][j+1]==matrice[i+2][j+2])
        &&(matrice[i+2][j+2]==matrice[i+3][j+3]))    /*return(4); */
	  {
		  puissance=4;
	  }
/*else puissance=0;*/
return(puissance);

}

/***********************************************************************************/
int test diagonale_sud_est()
{
int puissance;
for(i=taille-1;i>=3 ;i--)
   for(j=0;j<taille-3;j++)
	   if((matrice[i][j]==matrice[i-1][j+1])&&(matrice[i-1][j+1]==matrice[i-2][j+2])
		   &&(matrice[i-2][j+2]==matrice[i-3][j+3])) /*return(4);*/
	   { puissance=4;}
	   else puissance=0;
return(puissance);

}
/***********************************************************************************/
int test_horizontal()
{
int puissance;
for(i=0;i<=taille-1;i++)
{  for(j=0;j<=3;j++)
     if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matrice[i][j+2])
		 &&(matrice[i][j+2]==matrice[i][j+3]))
	 {
		 puissance=4;
	 }
	else puissance=0;

}
return(puissance);

}
/***********************************************************************************/
int remplie(int matrice[i][j])
{ int i,j;
 int remplie;
for(i=0;i<=taille-1;i++)
{  for(j=0;j<taille-1;j++)
{    if(matrice[i][j]!=0)
{      remplie=remplie+1;
	/*remplie==0;*/

}
}
return(remplie);
}
/****************************************************************************************/
main()
{
int x1,y1,x2,y2;
int pilote,mode;
clrscr();                    /*efface l'ecran*/
x1=100;
y1=50;
x2=500;
y2=450;
r=20;
detectgraph(&pilote,&mode);
initgraph(&pilote,&mode,"i:\tc");
rectangle(x1,y1,x2,y2);
                                    /*********grille_vert(x1,y1,x2,y2);***********/
                                    /*grille_hor(x1,y1,x2);**********************/
affichage(x1,y1,x2,y2);
                                                 /*les deux joueurs jouent a tour de role 1 pour l'humain 2 pour l'ordinateur */
                                                /*joueur 1 matrice[i][j]==1 et joueur 2 matrice[i][j]==2*/
setcolor(0);                          /*noir--PC*/
circle(x1+20,y1+20,10);              /*jeton dans la premiere case*/
init(i,j);
joueur=1;
tour_joueur=1;
do
{ clrscr();/*efface l'ecran*/
while (puissance!=4)
 {
  pion(x,y,r);                                       /***************clrscr();***************/
  joueur=joueur-3;/*alterner les joueurs*/
  /*coup joueur();*/
  test_vertical();
  test diagonale_sud_est();
  test_horizontal();
  test diagonale_nord_est();
  
}   
clrscr();                                 /*closegraph();*/
printf("%d",joueur);  
}
while ((remplie(matrice[i][j])==0);
clrscr();
printf("match nul");
getch();

}

23

voila le code qui me rend fou reste a faire une boucle + lisible pour les tests mais ca c'et pour les retouches mais la ca bugue dans la fonction test diagonale sud est
shai pa ou est l'erreur elle est dans l'entete apparemment j'ai mis en globale et ca n'a pa tro change la donne j'my remets ce soir mad
merci de prendre votre courage a deux mains

24

Ton code est encore bcp trop long...

Par exemple, rien qu'en se restreignant aux trucs horizontaux :
 int test_horizontal() 
 { 
 int puissance; 
 for(i=0;i<=taille-1;i++) 
 {  for(j=0;j<=3;j++) 
      if ((matrice[i][j]==matrice[i][j+1])&&(matrice[i][j+1]==matrice[i][j+2]) 
 		 &&(matrice[i][j+2]==matrice[i][j+3])) 
 	 { 
 		 puissance=4; 
 	 } 
 	else puissance=0; 
  
 } 
 return(puissance); 
  
 } 

-> pb, ça ne teste que les puissance 4... (et pas les autres alignements, par exemple de 3 pions) Comment le modifier pour tester les autres ? (en ayant la possibilité de faire des puissances 100 sans aucun code supplémentaire par exemple, pourvu que la matrice soit assez grande)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

25

non la le code que j'ai mis ce matin c'est pour la puissance 4 a deux joueurs humains et ca bugue com j'ai dit ci dessus au niveau de l'ente de test diagonale sud est ...
quant a l'ia (j'la ferai + tard l'idee du carre traite les 3 pions alignes si y en 4 c fini sinon y en moins de 3 on joue normalement chacun aligne son pion)

26

erf le coup du "débuggez mon code je sais pas où est l'erreur" en général ça marche pas, mais dommage c'était bien essayé trigni

sinon tes indices ne vont pas, en général : c'est taille-4 et pas taille-3 ...

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

27

non c'est pa ca serieux mais ce pc dit l'entete est fausse(syntax) alors que com les autres test diagonale a la meme entete ...
sinon c taille - 3 parceque les indices c'est de 0 a taille -1 donc ( < taille -3 )<==>(<7 ou <=6) ceci +3 ca fait 9 la derniere case quoi c bon.mais le bleme n'est pa la
et sinon pour l'IA pollux a ton avis a part le carre j'dois ajoueter une autre fonction qui place mon pion tant que le nombrede pions alignes est inferieur a 3

28

Petite remarque : un nom de fonction ne peut pas avoir d'espace gol
Et la prochaine fois, donne-nous le message d'erreur précis et l'endroit correspondant, sinon on ne peut rien pour toi...

Et oui j'ai dit n'importe quoi pour le taille-3 (faudrait que j'aille dormir ^^)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

29

ok il me dit declaratin syntax error dans la fonction diagonale nord est et j'ai essaye sans espaces ca change rien la suis space vais dormir et on verra
merci ...

30

tu aurais pas oublié de refermer une accolade ?

(et si tu utilises VS, il y a une fonction pour réindenter ton code, ça te permettrait de détecter ces erreurs plus facilement...)

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)