Puissance 4 [bc++, dev-c++]

Contenu du snippet

Tout le monde c'est ce qu'est un puissance 4 !!! NON !!!!!

Source / Exemple :


////////////////////////////////////////////////////////////////////////////////
//      Puissance 4 : JEUX              Réalisé par DEQUEKER MANUEL   //
//                                                                                               //
//      e-mail : ManDeq59@aol.com    http://www.textoagogo.fr.st    //
//                                                                                               //
//   Commencé le 09 Mai 2002 et Terminé le 12 Mai 2002 à 23h43   //
////////////////////////////////////////////////////////////////////////////////

#include <iostream.h>                              /////////////////////////////
#include <stdio.h>                                   //      Déclaration des   //
#include <conio.h>                                  //        Librairies          //
#include <time.h>                                   /////////////////////////////

char pion = 'X';                                 /////////////////////////////
char prenom1[13];                            //      Déclaration des   //
char prenom2[13];                            //         Variables         //
int tableau[10][12];                           //                               //
int nbre_coup = 0;                            /////////////////////////////

void presentation(char prenom1[10], char prenom2[10])
{
	time_t t;

	clrscr();       // Efface l'écran
	printf("                       Puissance 4 par DEQUEKER MANUEL\n\n\n");       // Titre

	for (int i=0; i<10; i++)                        /////////////////////////////
	{                                               //                         //
		printf("\n");                                //      Representation     //
		for (int j=0; j<10; j++)                     //                         //
			printf(" |  ");                           //                         //
	}					       								   //           Du            //
	printf("\n ");                                  //                         //
	for (int k=0; k<9; k++)                         //                         //
	{                                               //         Tableau         //
		printf("+===");                              //                         //
	}                                               //                         //
	printf("+");                                    /////////////////////////////

	gotoxy(45,4);                						   /////////////////////////////
	time(&t);                      						//    Heure et la Date     //
	printf("%s\n", ctime(&t));    				  	   /////////////////////////////

	gotoxy(50,8);                                   /////////////////////////////
	printf("Joueur 1 (O) : %s", prenom1);           //   Affichage des prénoms //
	gotoxy(50,10);                                  // Des joueurs et des pions//
	printf("Joueur 2 (X) : %s", prenom2);           /////////////////////////////
}

void pause()                                       /////////////////////////////
{                                                  //  Une petite pause pour  //
	for (unsigned long int i=0; i<1000000; i++)     //  que les pions ne       //
	{                                               //  tombes pas trop vite.  //
	}                                               //                         //
}                                                  /////////////////////////////

void main()
{

debut:

	clrscr();       // Efface l'écran

	int x = 4;             // l'abscisse pour '->' au premier menu
	char car;              // La touche pressé au premier menu
	char car_menu;         // La touche pressé au deuxieme menu
	int bas_max;           // Niveau le plus bas dans une colonne
	int pos_x = 0;         // Position pour le tableau (0, ...,8)
	int s = 21;            // L'ordonné pour '->' au deuxieme menu
	int match_nul = 0;     // 0 match non nul, 1 match nul : pour les stats

	printf("                       Puissance 4 par DEQUEKER MANUEL\n\n\n");       // Titre

	printf("Quel est le prénom du Joueur 1 : ");    /////////////////////////////
	gets (prenom1);                                 //  Demande des noms des   //
	printf("Quel est le prénom du Joueur 2 : ");    //        Joueurs          //
	gets (prenom2); 											/////////////////////////////

	clrscr();       // Efface l'écran

	presentation(prenom1, prenom2);       // Appel du la fonction présentation

	for(int i=0; i<11; i++)                         /////////////////////////////
	{                                               //                         //
		for(int j=0; j<13; j++)                      //  Initialisation à 0     //
		{                                            //                         //
			tableau[j][i] = 0;                        //            du tableau   //
		}                                            //                         //
	}																/////////////////////////////

do
{
	nbre_coup += 1;

	if (pion == 'X')
	{                                               /////////////////////////////
		pion = 'O';                                	//                         //
		gotoxy(45,8);                              	//  Changement des pions   //
		printf("->");                               	//                         //
		gotoxy(45,10);                              	//   Une fleche vers le    //
		printf("  ");                               	//                         //
	}                                              	//   Joueur qui doit jouer //
	else                                           	//                         //
	{                                              	//      Effacement de      //
		pion = 'X';                                 	//                         //
		gotoxy(45,10);                              	//    L'ancienne fléche    //
		printf("->");                                //                         //
		gotoxy(45,8);                                //                         //
		printf("  ");                                /////////////////////////////
	}

colonne_pleine:

	do
	{
		gotoxy(x,4);                                 // Positionnement initiale
		printf("%c", pion);                          // du pion du joueur

		car = getch();

		switch(car)                                  /////////////////////////////
		{                                            //                         //
			case 54:                                  //                         //
			pos_x += 1;                               //                         //
			x += 4;                                   //   Déplacement du pion   //
			if (x == 40)                              //                         //
			{                                         //                         //
				x = 4;                                 //                         //
				pos_x = 0;                             //                         //
				gotoxy(36,4);                          //                         //
				printf(" ");                           //      Du joueur sur      //
			}                                         //                         //
			gotoxy(x-4,4);                            //                         //
			printf(" ");    									//                         //
			break;                                    //        la grille        //
																	//                         //
			case 52:                                  //                         //
			pos_x -= 1;                               //                         //																//                         //
			x -= 4;                                   //                         //
			if (x == 0)                               //                         //
			{                                         //                         //
				x = 36;                                //                         //
				pos_x = 8;                             //                         //
				gotoxy(4,4);                           //                         //
				printf(" ");                           //                         //
			}                                         //                         //
			gotoxy(x+4,4);                            //                         //
			printf(" ");                              //                         //
			break;                                    //    (Horizontalement)    //
																	//                         //
			default:                                  //                         //
			printf("%c",0x07);                        //                         //
			break;                                    /////////////////////////////
		}
	} while (car != 13);         // Tant que ENTER n'est pas pressé

	bas_max=15;                                     /////////////////////////////
	for(int z=0; z<11; z++)                         //  On regarde s'il y a un //
	{                                               //  pion. Puis envoie les  //
		if (tableau[pos_x][z] != 0)                  //  coordonées du nouveau  //
		bas_max -= 1;                                //  pion.                  //
	}  															/////////////////////////////

	gotoxy(45,13);                                  // Effacement des messages
	printf("                                    "); // situé en (45,13)

	if (tableau[pos_x][-1] != 0)                    /////////////////////////////
	{                                               // Vérification de la      //
		gotoxy(45,13);                               // colonne (pleine ou pas) //
		printf("La colonne est pleine !!!!");        // Si pleine alors message //
		goto colonne_pleine;                         //                         //
	}                                               /////////////////////////////

	if (pion == 'O')                                /////////////////////////////
		tableau[pos_x][bas_max-7] = 1;               // Met 1 ou 2 ds le tableau//
	else                                            // En fonction du joueur   //
		tableau[pos_x][bas_max-7] = 2;               /////////////////////////////

	for (z=4; z<bas_max; z++)                                                         /////////////////////////////
	{                                                                                 //                         //
		pause();                                                                       //   Déplacement du pion   //
																	/////////////////////////////     //                         //  																// Nouvelle position du    //    //    Déplacement du pion  //
		gotoxy(x,z);                                 // Pion du joueur          //     //        du joueur        //
		printf("%c", pion);                          /////////////////////////////     //                         //
																												 //                         //
		gotoxy(x,z-1);                               // Effacement de l'ancienne       //     (Verticalement)     //
		printf(" ");                                 // position du pion du joueur     //                         //
	}                                                                                 /////////////////////////////

  int	gagnant = 0;
  int c = 1;
  int e, f;

  for(e=0; e<10; e++)                                                /////////////////////////////////////////////
  {                                                                  //                                         //
	c=1;                                                              //                                         //
	for(f=0; f<10; f++)                                               //                                         //
	{                                                                 //                                         //
		if(tableau[e][f] == tableau[e][f+1] && tableau[e][f] != 0)     //                                         //
		{                                                              //                                         //
			c = c + 1;                                                  //                                         //
			if(c == 4)                                                  //                                         //
			{                                                           //                                         //
				gagnant = tableau[e][f];                                 //        Tests pour voir s'il y a         //
				gotoxy(5,18);                                            //                                         //
				if(gagnant == 1)                                         //          un gagant en colonne           //
				{                                                        //                                         //
					 printf("%s a gagne en colonne", prenom1);            //                                         //
					 goto fin;                                            //                                         //
				}                                                        //                                         //
				else                                                     //                                         //
				{                                                        //                                         //
					 printf("%s a gagne en colonne", prenom2);   			//                                         //
					 goto fin;                                            //                                         //
				}                                                        //                                         //
			}                                                           //                                         //
		}                                                              //                                         //
		else                                                           //                                         //
		c=1;                                                           //                                         //
	}                                                                 //                                         //
  }                                                                  /////////////////////////////////////////////

  for(e=0; e<10; e++)                                                /////////////////////////////////////////////
  {                                                                  //                                         //
	c=1;                                                              //                                         //
	for(f=0; f<10; f++)                                               //                                         //
	{                                                                 //                                         //
		if(tableau[f+1][e] == tableau[f][e] && tableau[f][e] != 0)     //                                         //
		{                                                              //                                         //
			c = c + 1;                                                  //                                         //
			if(c == 4)                                                  //                                         //
			{                                                           //                                         //
				gagnant = tableau[f][e];                                 //       Tests pour voir s'il y a          //
				gotoxy(5,18);                                            //                                         //
				if(gagnant == 1)                                         //          un gagant en ligne             //
				{                                                        //                                         //
					 printf("%s a gagne en ligne", prenom1);              //                                         //
					 goto fin;                                            //                                         //
				}                                                        //                                         //
				else                                                     //                                         //
				{                                                        //                                         //
					 printf("%s a gagne en ligne", prenom2);              //                                         //
					 goto fin;                                            //                                         //
				}                                                        //                                         //
			}                                                           //                                         //
		}                                                              //                                         //
		else                                                           //                                         //
		c=1;                                                           //                                         //
	}                                                                 //                                         //
  }                                                                  /////////////////////////////////////////////

  for(f=0; f<10; f++)                                                /////////////////////////////////////////////
  {                                                                  //                                         //
		for(e=0; e<10; e++)                                            //                                         //
		{                                                              //                                         //
			if(tableau[e][f] == tableau[e+3][f+3] && tableau[e][f] == tableau[e+2][f+2] &&                         //
				tableau[e][f] == tableau[e+1][f+1] && tableau[e][f] != 0)                                           //
			{                                                           //                                         //
				gagnant = tableau[e][f];                                 //                                         //
				gotoxy(5,18);                                            //        Tests pour voir s'il y a         //
				if(gagnant == 1)                                         //                                         //
				{		                                                   //                                         //
					 printf("%s a gagne en diagonale (\\)", prenom1);     //                                         //
					goto fin;                                             //          un gagant en diagonale (\)     //
				}                                                        //                                         //
				else                                                     //                                         //
				{                                                        //                                         //
					printf("%s a gagne en diagonale (\\)", prenom2);      //                                         //
					goto fin;                                             //                                         //
				}                                                        //                                         //
																							//                                         //
			}                                                           //                                         //
		}                                                              //                                         //
  }                                                                  /////////////////////////////////////////////

  for(f=0; f<10; f++)                                                /////////////////////////////////////////////
  {                                                                  //                                         //
		for(e=0; e<10; e++)                                            //                                         //
		{                                                              //                                         //
			if(tableau[e][f] == tableau[e+3][f-3] && tableau[e][f] == tableau[e+2][f-2] &&                         //
				tableau[e][f] == tableau[e+1][f-1] && tableau[e][f] != 0)                                           //
			{                                                           //                                         //
				gagnant = tableau[e][f];                                 //                                         //
				gotoxy(5,18);                                            //        Tests pour voir s'il y a         //
				if(gagnant == 1)                                         //                                         //
				{		                                                   //                                         //
					printf("%s a gagne en diagonale (/)", prenom1);       //                                         //
					goto fin;                                             //          un gagant en diagonale (/)     //
				}                                                        //                                         //
				else                                                     //                                         //
				{                                                        //                                         //
					printf("%s a gagne en diagonale (/)", prenom2);       //                                         //
					goto fin;                                             //                                         //
				}                                                        //                                         //
																							//                                         //
			}                                                           //                                         //
		}                                                              //                                         //
  }                                                                  /////////////////////////////////////////////

} while (nbre_coup != 90);

	gotoxy(5,18);                                                     // Le tableau est plein don il y
	printf("Le match est nul !!!!");                                  // a match nul
	match_nul = 1;                                                    // affectation de 1 à macth_nul

fin:

	gotoxy(45,16);                                                       /////////////////////////////////////////////
	printf("############################");                              //                                         //
	gotoxy(45,17);                                                       //                                         //
	printf("#       STATISTIQUE        #");                              //                                         //
	gotoxy(45,18);                                                       //                                         //
	printf("############################");                              //                                         //
																								//                                         //
	if (match_nul == 0)                                                  //                                         //
	{                                                                    //                                         //
		gotoxy(45,20);                                                    //       Affichage du nombre de coup       //
		printf("    Le gagnant a gagné en   ");                           //                                         //
		gotoxy(45,21);                                                    //                                         //
		printf("          %d coups", nbre_coup);                          //        Si le match n'est pas nul        //
	}                                                                    //                                         //
	else                                                                 //                                         //
	{                                                                    //                  sinon                  //
		gotoxy(50,20);                                                    //                                         //
		printf("Non Disponible");                                         //        On affiche Non Disponible        //
	}                                                                    //                                         //
																								//                                         //
	gotoxy(0,25);                                                        //                                         //
	printf("Pour me contacter (renseignements, bugs, etc...) : ManDeq59@aol.com");////////////////////////////////////

	gotoxy(10,21);                                  /////////////////////////////
	printf("Recommencer");                          //  Affichage du menu      //
																	//     à la fin de la      //
	gotoxy(10,22);                                  //        partie           //
	printf("Quitter");                              /////////////////////////////

	do                                              /////////////////////////////
	{                                               //                         //
		gotoxy(5,s);                                 //                         //
		printf("->");                                //                         //
																	//                         //
		car_menu = getch();                          // Déplacement de la fléche//
																	//                         //
		switch(car_menu)                             //                         //
		{                                            //  Qui se trouve à gauche //
			case 50:                                  //                         //
			s += 1;                                   //                         //
			if (s == 23)                              //      des deux choix     //
			{                                         //                         //
				s = 21;                                //         possibles       //
				gotoxy(5,22);                          //                         //
				printf("  ");                          //                         //
			}                                         //                         //
			gotoxy(5,21);                             //  Effacement des         //
			printf("  ");                             //                         //
			break;                                    //            anciennes    //
																	//                         //
			case 56:                                  //  fléches lors des       //
			s -= 1;                                   //                         //
			if (s == 20)                              //            déplacements //
			{                                         //                         //
				s = 22;                                //                         //
				gotoxy(5,21);                          //                         //
				printf("  ");                          //                         //
			}                                         //                         //
			gotoxy(5,22);                             //                         //
			printf("  ");                             //                         //
			break;                                    //                         //
																	//                         //
			default:                                  //                         //
			printf("%c",0x07);                        //                         //
			break;                                    /////////////////////////////
		}
	} while (car_menu != 13);                       // Tant que la touche ENTER n'est pas pressé

	if (s == 21)                                    // Si la fléche est en position 'recommencer'
		goto debut;                                  //  alors on recommence (on va jusqu'a 'debut')
	else                                            //
	{                                               //  Sinon le programme se termine
	}                                               //
}

Conclusion :


C'est la premiere version donc si vous rencontrez des bugs merci de me le signaler merci.
Une seconde version est en cours encore un peu de patience.......

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.