Jeu de dame

Soyez le premier à donner votre avis sur cette source.

Snippet vu 14 358 fois - Téléchargée 34 fois

Contenu du snippet

c'est un petit jeu de dame fait sous visual c++
sur mon pc ca fonctionne, ca devrai donc etre bon sur le votre

Source / Exemple :

/*	programme principal du jeu de dame */




#include <stdio.h>
#include "OutilsFenetre.h"
#include "OutilsMenu.h"
#include "string.h"

void main (void) 
{


	menu M ;
	int num , s;
	booleen fin = faux ;
	tpartie partie;
	partie=init_partie();










	InitialisationFenetre("accueil") ;
	M = init_menu_accueil() ;
	

	


	//boucle d'attente des choix de menu 
	do {
		
		AfficherMenu (M) ;
		DeplaceCurseur( 30 , 3);
		printf ("JEU de DAMES");
		num = ChoisirMenu(M) ;
			
		EffaceFenetre();

		switch (num) 
		{
			case 1 :
				DeplaceCurseur( 1 , 1 );
				printf("jeu au clavier ou a la souris ? (1 ou 2)\n");
				scanf ("%i", &s);
				EffaceFenetre();
				jeu( &partie, s);
				AttendreClic(); break ;
			case 2 :
				partie=charger();
				break ;
			case 3 :
				visionner(partie);
  				break ;
			case 4 :
				regles() ;
				AttendreClic(); break ;

			case 5 :
				fin = vrai ;
				break ;
		}
		
		EffaceFenetre();

	} while ( !fin ) ;

}
				
/**************************************************************************************************************/





/* fonction qui crée un pion blanc aux coordonnées de départ (0,0) */
tpion creat_pion_blanc (void)
{  
	tpion pion;

	pion.couleur='o';
	(pion.coordpion).colonne=0;
	(pion.coordpion).ligne=0;
	pion.niveau=0;

	return pion;
}




/* fonction qui crée un pion noir aux coordonnées de départ (0,0) */
tpion creat_pion_noir (void)
{  
	tpion pion;

	pion.couleur='x';
	(pion.coordpion).colonne=0;
	(pion.coordpion).ligne=0;
	pion.niveau=0;

	return pion;
}





/* procédure qui transforme un pion blanc en dame blanche */
void promotion_pion_dame_blanche (tpion *pion)
{  
	(*pion).couleur='O';
	(*pion).niveau=1;
}






/* procédure qui transforme un pion noir en dame noire */
void promotion_pion_dame_noire(tpion *pion)

{  
	(*pion).couleur='X';
	(*pion).niveau=1;
}



/* procédure qui modifie les coordonnée d'un pion */
void modif_coord_pion ( tpion * pion , tcoordonneejeu coord )
{
	((*pion).coordpion)=coord;
}


/* procedure qui retourne la couleur d'un pion */
void couleur_pion (tpion pion , chaine *couleur)
{
	
	strcpy ( *couleur , "blanc" );

	if ( pion.couleur == 'x' || pion.couleur == 'X' )
		{ 
			strcpy (*couleur , "noir" );
		}

}

/* procedure qui transforme une dame en pion */
void depromotion(tpion *pion)
{
	chaine couleur;
	int a;

	a=strcmp(couleur, "blanc");
	if (a==0)
	{
		(*pion).couleur='o';
	}
	else
	{
		(*pion).couleur='x';
	}
	(*pion).niveau=0;
}


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




/* fonction qui crée une nouvelle partie avec tous les pions */
tpartie init_partie (void)
{
	tpartie partie;
	pjeu pje;

	pje=NULL ;	
	
	cree_jeu_neuf ( &pje );

	partie.pj=pje;
	partie.pc=NULL;
	strcpy(partie.couleurjoueur, "blanc");

	return partie;
}



		

			

/*procedure qui permet de sauvegarder une partie */
void sauvegarder (tpartie partie)

{
	FILE *f;
	int nb , i, n, b;
	chaine nom_fichier;
	pjeu pjc;
	pcoup pcc;

	EffaceFenetre( );

	printf ("quel est le nom du fichier ?\n");
	scanf ("%s", nom_fichier);

	f=fopen(nom_fichier ,"w");		//creation du fichier
	
				// ecriture de la partie
	//ecriture de la chaine de pion

	n=nb_pion( partie.pj , "noir");
	b=nb_pion( partie.pj ,"blanc" );
	nb=b+ n;	//calcul du nombre de pion
	fprintf(f ,"%i \n",nb);
	pjc=partie.pj;
	for (i= 1 ; i<=nb ; i++)
	{
		fprintf(f ,"%c %i %i %i \n", pjc->pion.couleur , pjc->pion.coordpion.colonne , pjc->pion.coordpion.ligne , pjc->pion.niveau);
		pjc=pjc->suivant;
	}

	//ecriture de la chaine de coup
	nb=nb_coup( partie.pc )	;			//calcul du nombre de coup

	fprintf(f ,"%i\n",nb);
	pcc=partie.pc;
	for (i= 1 ; i<=nb ; i++)
	{
		
		fprintf(f, "%i %i %i %i %c %i %i %i \n" , pcc->coord_depart.colonne , pcc->coord_depart.ligne , pcc->coord_arrive.colonne , pcc->coord_arrive.ligne , pcc->pion_mange.couleur , pcc->pion_mange.coordpion.colonne , pcc->pion_mange.coordpion.ligne , pcc->pion_mange.niveau );

		pcc=pcc->suivant;
	}

	// ecriture de la couleur qui joue 
	fprintf (f ,"%s \n" , partie.couleurjoueur);

	fclose(f);
	EffaceFenetre( );
} 



/* procedure qui permet de jouer une partie */
void jeu (tpartie *partie , int s)
{
	int me , nbn , nbb , g , men , a , i , j ;


	tcoordonneejeu cj;
	COORD cs;
	booleen fin;

	me=0;
	g=0;
	men=0;
	a=0;
	fin=faux;
	nbb=12;
	nbn=12;

	


	affiche_tout((*partie));
	
	do
	{	
						//test de fin de partie
		nbn=nb_pion( (*partie).pj , "noir");
		nbb=nb_pion( (*partie).pj , "blanc");
		
					//affichage du nombre de pion 
		DeplaceCurseur (2,32);
		printf("nombre de pions blancs : %i / 12", nbb);
		DeplaceCurseur (2,33);
		printf("nombre de pions noirs  : %i / 12", nbn);



		if (nbn ==0 || nbb==0 )
		{
						//deplace curseur à place plus precisement
			DeplaceCurseur (1,3);
			printf ("Fin de partie");
			DeplaceCurseur (1,4);
					
			if (nbn==0 ) { printf("Le joueur blanc a gagne");}
			else {printf("Le joueur noir a gagne");}
		}
		DeplaceCurseur (1,2);
		printf("joueur %s", partie->couleurjoueur);

// gestion du déplacement (clavier ou souris)

		if (s==1)		//clavier
		{
			DeplaceCurseur (1,3);
			printf("Coordonnee du pion a deplace ? (colonne ligne)\n");
			DeplaceCurseur (1,4);
			scanf("%i %i" , &cj.colonne , &cj.ligne);
			cs=convert_coord_js( cj );
			g=appartient_grille_cj( cj );
		}
		else		//souris
		{
			cs=PositionClic();
			g=appartient_grille_cs( cs );
			DeplaceCurseur (1,3);
//			printf("Coordonnee du pion a deplace ? \n");
		}

		
	

		switch (g) 
		{
			case 1 :
				if (nbn !=0 && nbb!=0 ) 
				{
					mouvements (partie , cs, s);
				}
				break ;
			case 2 :
				TakeBack(&(*partie));
				affiche_tout(*partie);
				break ;
			case 3 :
				*partie=charger();
				affiche_tout(*partie);
  				break ;
			case 4 :
				sauvegarder(*partie);
				affiche_tout(*partie);
				break ;
		
			case 5 :
				fin = vrai ;
				break ;	
		}
			
		// effacement de la zone de dialogue
	for(i=1 ; i<=4 ; i++)
		{
			for(j=1 ; j<=30 ;  j++)
			{

				DeplaceCurseur (j,i);
				printf (" ");
			}
		}


	}while( fin != vrai );

}




/* fonction qui teste si un deplacement est autoriser (renvoie vrai) */
/* on rentre les ccordonnées de départs et d'arrivée */
booleen test_deplacement (tpartie partie , tcoordonneejeu cjd , tcoordonneejeu cja )
{
	booleen test , test1, test2, test3, test4 ,test5;
	pjeu pjpa , pjpi , pjpd;
	chaine couleur , couleurbis;
	int a , i, j , b;
	tcoordonneejeu cji;

	a=-1;
	test=faux;
	test1=faux;
	test2=faux;
	test3=faux;
	test4=faux;
	test5=faux;


//	pour les pions courants 
	pjpd=adresse_pion(partie.pj, cjd);

	if (pjpd->pion.niveau==0 )
	{
		//teste de la longueur de déplacement 
		if ( abs(cja.colonne-cjd.colonne)<=2 )
		{
			test1=vrai;
		}
		else
		{
			test1=faux;
			DeplaceCurseur (1,3);
		}

		// test du sens de deplacement 
		couleur_pion(pjpd->pion , &couleur );
		a=strcmp(couleur , "blanc" );
		if (a==0)
		{
			if (cja.ligne-cjd.ligne > 0)
			{
				test2=vrai;
			}
			else
			{
				test2=faux;
				DeplaceCurseur (1,3);
			}
		}
		else
		{
			if (cja.ligne-cjd.ligne < 0)
			{
				test2=vrai;
			}
			else
			{
				test2=faux;
				DeplaceCurseur (1,3);
			}
		}
	}
	else 
	{
		test1=vrai;
		test2=vrai;
	}

// test d'occupation des cases 
			// test case arrivée 
	pjpa=adresse_pion(partie.pj , cja );
	if (pjpa==NULL)
	{
		test3=vrai;
	}
	else
	{
		test3=faux;
		DeplaceCurseur (1,3);
	}

			// test cases diverses
	if (abs(cja.colonne-cjd.colonne) >=2 )
	{
		a=0;			
	
		if (cja.ligne>cjd.ligne){i=1;}
		else {i=-1;}
	
		if(cja.colonne>cjd.colonne){j=1;}
		else {j=-1;}

		cji.ligne=cjd.ligne+i;					// on ne teste pas la case de départ
		cji.colonne=cjd.colonne+j;
	
		while( (cji.colonne != cja.colonne) && (cji.ligne != cja.ligne ) )
		{
			pjpi=adresse_pion(partie.pj , cji );			
	
			if (pjpi != NULL) 
			{
				a=a+1;
					// couleur du pion mange différente

				couleur_pion(pjpd->pion , &couleur );
				couleur_pion(pjpi->pion , &couleurbis );
				b=strcmp(couleur , couleurbis );
				if (b==0) {a=a+2;}
			}
			cji.colonne=cji.colonne+j;
			cji.ligne=cji.ligne+i;
		}
		if (a<=1) {test4=vrai;}
		else {test4=faux;}
	}
	else {test4=vrai;}

// test de deplacement sur les diagonnales

	if ( abs(cja.colonne-cjd.colonne) == abs(cja.ligne-cjd.ligne) )
	{
		test5=vrai;
	}
	else
	{
		test5=faux;
	}

		
			
// test final pour retour du booleen
	if (test1==vrai && test2==vrai && test3==vrai && test4==vrai && test5==vrai)
	{
		test =vrai;
	}
	else 
	{
		test = faux;
	}


	return test;

}




/*procedure qui gere les mouvements des pions d'une partie */
void mouvements (tpartie *partie , COORD css ,int s)
{

	int a , i ,j;
	tcoordonneejeu cja , cjd , cji;
	chaine couleur;
	booleen res;
	pjeu pjpd , pjpm , courant;
	tpion pmange;
	COORD cs;

	cjd=convert_coord_sj(css);						//convertion en coordonnee de jeu
	pjpd=adresse_pion(partie->pj, cjd );			//on cherche l'adresse du pion deplacé

	if ( pjpd != NULL )
	{

		couleur_pion(pjpd->pion , &couleur);			// préparation pour le test de couleur
	
		a=strcmp((*partie).couleurjoueur , couleur ) ;	//comparaison couleurs
	
		if (a==0)			// si couleur bonne 
		{
			// gestion du déplacement (clavier ou souris)

			if (s==1)		//clavier
			{
				DeplaceCurseur (1,3);
				printf("Coordonnee d'arrivee ? (colonne ligne)\n");
				DeplaceCurseur (1,4);
				scanf("%i %i" , &cja.colonne , &cja.ligne);	
			}
			else		//souris
			{	
				DeplaceCurseur (1,3);
				printf("Coordonnee d'arrivee ? \n");
				cs=PositionClic();
				cja=convert_coord_sj(cs);
			}

			res=test_deplacement(*partie , cjd , cja);

			if (res==vrai)
			{	
				
				
					// desaffichage du pion deplacé à son ancien emplacement 
				desaffich_pion( cjd );

					// modification des coordonnées du pion deplacé 
				pjpd->pion.coordpion=cja;
				couleur_pion(pjpd->pion , &couleur );
					// test pour savoir si creation d'une dame et si oui modification du pion
							//pion noir

				if (strcmp( "noir" , couleur ) == 0)
				{
					if (cja.ligne == 1 ) 
					{
						promotion_pion_dame_noire( &(pjpd->pion) ) ;
					}
				}

							//pion blanc
				if(strcmp( "blanc" , couleur ) == 0)
				{
					if ((cja.ligne == 8)   )
					{
						promotion_pion_dame_blanche( &(pjpd->pion) ) ;
					}
				}

					// affichage du pion deplacé à son nouvel emplacement 
				
				affich_pion( pjpd->pion );

					//initialisation pour action sur chaine de coup
				pmange=creat_pion_noir();
				pmange.niveau=-1;

				if ( abs(cjd.colonne-cja.colonne)>=2)
				{
	
					// repérage du pion mangé (eventuel)
					courant=partie->pj;
					cji=cjd;
					if (cja.ligne>cjd.ligne){i=1;}
					else {i=-1;}
					if(cja.colonne>cjd.colonne){j=1;}
					else {j=-1;}
						
					while(  (cji.colonne != cja.colonne) && (cji.ligne != cja.ligne) )
					{
						courant=adresse_pion( partie->pj , cji );
						if (courant!=NULL) { pjpm=courant;}
						cji.colonne=cji.colonne+j;
						cji.ligne=cji.ligne+i;
					}


					if (pjpm != NULL)
					{
						cji=pjpm->pion.coordpion;
						// modification de pmange
						pmange=pjpm->pion;

						//supression du pion mangé de la chaine jeu 
						supprimer_pion (&(*partie).pj , cji );
					
								// effacement graphique du pion mangé 
						desaffich_pion( cji );
					}
					
					
				}

					// on complete la chaine de coup 
				ajout_coup_tcoup ( &partie->pc ,  cjd ,  cja , pmange);

					// changement de joueur 
				a=strcmp(partie->couleurjoueur , "blanc" ) ;
				if (a==0)
				{
					strcpy(partie->couleurjoueur , "noir" );
				}
				else
				{
					strcpy (partie->couleurjoueur , "blanc" );
				}
			}
		}
		else
		{
			DeplaceCurseur (1,1);
			printf("case vide !!!!");
		}
	}

		
}




/*fonction qui permet de charger une partie déja enregistrer */
tpartie charger (void)

{
	FILE *f;
	int nb , i ;
	chaine nom_fichier , couleur;
	tcoordonneejeu cja , cjd;
	tpion pion;
	tpartie partie;

	partie.pc=NULL;
	partie.pj=NULL;

	EffaceFenetre( );

	DeplaceCurseur (1,1);
	printf ("quel est le nom du fichier ?\n");
	scanf ("%s", nom_fichier);

	f=fopen(nom_fichier ,"r");		//ouverture du fichier en lecture
	
				// lecture de la partie
	//lecture de la chaine de pion

	fscanf(f ,"%i \n",&nb);				// lecture du nombre de pion ds la chaine
	for (i= 1 ; i<=nb ; i++)
	{
		fscanf(f ,"%c %i %i %i \n", &pion.couleur , &pion.coordpion.colonne , &pion.coordpion.ligne , &pion.niveau);
		couleur_pion ( pion , &couleur);
	
		ajout_pion( &partie.pj , pion);
	
		
	}


	//lecture de la chaine de coup

	fscanf(f ,"%i \n",&nb);		// lecture du nombre de coup ds la chaine
	
	for (i= 1 ; i<=nb ; i++)
	{
		fscanf(f, "%i %i %i %i %c %i %i %i \n" , &cjd.colonne, &cjd.ligne , &cja.colonne , &cja.ligne , &pion.couleur , &pion.coordpion.colonne , &pion.coordpion.ligne , &pion.niveau );

		ajout_coup_tcoup( &partie.pc, cjd , cja , pion);
	}

	// ecriture de la couleur qui joue 
	fscanf (f ,"%s \n" , &partie.couleurjoueur);

	fclose(f);
	EffaceFenetre( );
	return partie;
} 





	

/*procedure qui annulle le dernier coup joué*/
void TakeBack(tpartie *partie)
{
	pcoup derc, courc;
	pjeu pj, pjm;
	chaine couleur;
	int a;
	// reperage du dernier coup jouer
	derc=(*partie).pc;
	courc=(*partie).pc;
	while (courc != NULL )
	{
		derc=courc;
		courc=courc->suivant;
	}
	
	// modification du pion deplace
			//modification des coordonnees
	pj=adresse_pion((*partie).pj, derc->coord_arrive);
	pj->pion.coordpion.colonne = derc->coord_depart.colonne;
	pj->pion.coordpion.ligne = derc->coord_depart.ligne;
			
			//modification si dame

	if (pj->pion.niveau==1)
	{
		if (derc->coord_arrive.ligne==1 || derc->coord_arrive.ligne==8)
		{
			depromotion(&(pj->pion));
		}
	}

	
	//	modification si unpion à été mangé 
	if (derc->pion_mange.niveau != -1)
	{
		couleur_pion(derc->pion_mange , &couleur);
		ajout_pion_tjeu (&((*partie).pj) , couleur , derc->pion_mange.coordpion);
		pjm=adresse_pion ((*partie).pj , derc->pion_mange.coordpion );
		pjm->pion.niveau=derc->pion_mange.niveau;
		pjm->pion.couleur=derc->pion_mange.couleur;
		affich_pion(pjm->pion);
	}

			
	// gestion de l'affichage
	desaffich_pion(derc->coord_arrive);
	affich_pion(pj->pion);

	// suppression du dernier coup 
	supprimer_pcoup (&((*partie).pc) );

	// modification du joueur 
	a=strcmp((*partie).couleurjoueur, "blanc");
	if (a==0)
	{
		strcpy((*partie).couleurjoueur , "noir");
	}
	else
	{
		strcpy((*partie).couleurjoueur , "blanc");
	}

}



/*procedure qui permet de visionner tous les coups jouéss lors d'une partie */
void visionner (tpartie partie)
{

	tpartie p;
	pcoup pcc;
	pjeu pjpd, pjpm ;
	chaine couleur;
	tcoordonneejeu cjd , cja ;
	int nbc , n ;

	n=1;
	p=init_partie();
	p.pc=partie.pc;
	pcc=p.pc;
	nbc=nb_coup(p.pc);
	affiche_tout( p );
	
	DeplaceCurseur (1,3);
	printf ("cliquer\n");
	
	AttendreClic();
	

	while (pcc != NULL)
	{
		cjd=pcc->coord_depart;
		cja=pcc->coord_arrive;
		DeplaceCurseur (1,4);
		printf ("coup %i / %i", n, nbc);
		


				pjpd=adresse_pion(p.pj, cjd );				//on cherche l'adresse du pion deplacé


					// desaffichage du pion deplacé à son ancien emplacement 
				desaffich_pion( cjd );


					// modification des coordonnées du pion deplacé 
				pjpd->pion.coordpion.colonne=cja.colonne;
				pjpd->pion.coordpion.ligne=cja.ligne;
					
					// test pour savoir si creation d'une dame et si oui modification du pion
				couleur_pion(pjpd->pion , &couleur );			
						//pion noir

				if (strcmp( "noir" , couleur ) == 0)
				{
					if (cja.ligne == 1 ) 
					{
						promotion_pion_dame_noire( &(pjpd->pion) ) ;
					}
				}

							//pion blanc
				if(strcmp( "blanc" , couleur ) == 0)
				{
					if ((cja.ligne == 8)   )
					{
						promotion_pion_dame_blanche( &(pjpd->pion) ) ;
					}
				}

					// affichage du pion deplacé à son nouvel emplacement 
				
				affich_pion( pjpd->pion );


				if ( pcc->pion_mange.niveau != -1)
				{
	
					// repérage du pion mangé (eventuel)
				
					pjpm=adresse_pion( p.pj , pcc->pion_mange.coordpion );


					if (pjpm != NULL)
					{
					
					

						//supression du pion mangé de la chaine jeu 
						supprimer_pion (&(p.pj) , pjpm->pion.coordpion );
					
								// effacement graphique du pion mangé 
						desaffich_pion( pjpm->pion.coordpion );
					}
					
				}
		AttendreClic();
		pcc=pcc->suivant;
		n++;
	}
}

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






/* procédure qui ajoute un pion à une chaine de tjeu de couleur et aux coordonnées imposées */
/* il est ajouter à la fin */ 
/* couleur: blanc ou noir ; coordonnées (1,1)->(8,8) */
void ajout_pion_tjeu ( pjeu *jeu , chaine couleur , tcoordonneejeu coord )

{
	pjeu nouveau ;
	tpion p;
	int a;

										// creation du pion 
	a=strcmp("blanc",couleur);							/* compare la couleur; retourne 0 si couleur=blanc */
	if (a==0)	
		{ p = creat_pion_blanc (); }
	else 
		{ p = creat_pion_noir (); }

	p.coordpion=coord;
	
	
	// cree un maillon de la chaine en tete 
	nouveau=(pjeu) malloc (sizeof(tpion));

	nouveau->pion=p;
	nouveau->suivant=*jeu;
	*jeu=nouveau;

}



/* procedure qui crée un jeu de départ avec tous les pions */
void cree_jeu_neuf ( pjeu *jeu )

{
	tcoordonneejeu coord;
	int i , j ;

// lignes 1 , 3	
	for (j=1 ; j<=3 ; j=j+2 )
		{
			coord.ligne=j;
			for ( i=2  ; i<=8 ; i=i+2 )
				{
					coord.colonne=i;
					ajout_pion_tjeu ( jeu , "blanc" ,  coord );
				}
		}

// lignes 6 , 8
	for (j=6 ; j<=8 ; j=j+2 )
		{
			coord.ligne=j;
			for ( i=1  ; i<=7 ; i=i+2 )
				{
					coord.colonne=i;
					ajout_pion_tjeu ( jeu , "noir" ,  coord );
				}
		}
	
// ligne 2
	coord.ligne=2;
	for ( i=1  ; i<=7 ; i=i+2 )
		{
			coord.colonne=i;
			ajout_pion_tjeu ( jeu , "blanc" ,  coord );
		}

// ligne 7
	coord.ligne=7;
	for ( i=2  ; i<=8 ; i=i+2 )
		{
			coord.colonne=i;
			ajout_pion_tjeu ( jeu , "noir" ,  coord );
		}

}


/* Fonction qui retourne le nombre de pion dans un jeu */
int nb_pion( pjeu pj , chaine cl)
{
	chaine couleur;
	int nb , a;	
	pjeu courant;

	courant=pj;
	nb=0;




	while(courant != NULL)
		{ 
			couleur_pion(courant->pion , &couleur);
			a=strcmp(cl,couleur);
		
			if (a==0) {	nb=nb+1;}

			courant=courant->suivant;

		}
	return nb;
}



/* procedure qui supprime un pion de la chaine de jeu d'apres ses coordonnées */
void supprimer_pion (pjeu *jeu , tcoordonneejeu coord )
{
	pjeu courant , precedent;

	courant=*jeu;
	precedent=*jeu;

			//recherche du pion à supprimer 
	if (( courant->pion.coordpion.colonne == coord.colonne ) && ( courant->pion.coordpion.ligne == coord.ligne ) )
	{
		*jeu=courant->suivant;
	}
	else
	{
		while (	( courant->pion.coordpion.colonne != coord.colonne ) || ( courant->pion.coordpion.ligne != coord.ligne ) )
		{
			precedent=courant;
			courant=courant->suivant;
		}


								//lie les 2 maillons de la chaine 
		precedent->suivant=courant->suivant;
	}
	
	
}



/* fonction qui renvoie l'addresse d'un pion d'apres ces coordonnées*/
/* renvoie NULL si pion non trouvé */
pjeu adresse_pion (pjeu pj , tcoordonneejeu cj)
{
	pjeu pjc , res;
	int c, l;
	
	pjc=pj;
	c=cj.colonne;
	l=cj.ligne;
	res=NULL;


	while ( pjc != NULL )
	{
		if( c==pjc->pion.coordpion.colonne && l==pjc->pion.coordpion.ligne )
		{
			res=pjc;
			
		}
	
		pjc=pjc->suivant;
	}

	return res;
}


/* procedure qui ajoute un pion à un jeu*/
void ajout_pion(pjeu *jeu , tpion p)
{
	pjeu nouveau ;


		
	// cree un maillon de la chaine en tete 
	nouveau=(pjeu) malloc (sizeof(tpion));
	nouveau->pion= p;
	nouveau->suivant= *jeu;
	*jeu=nouveau;
}



/* valeur absolue */
int abs(int a)
{
	int res;
	
	res=a;

	if (a<0)
	{
		res=-a;
	}
	return res;
}


void ecrire_booleen (booleen B) {
	printf("%s",B?"vrai":"faux");
}



/* procédure qui ajoute un coup à une chaine de tcoup de coordonnées de départ et d'arrivée imposées */ 
void ajout_coup_tcoup_en_tete ( pcoup *coup , tcoordonneejeu cd , tcoordonneejeu ca , tpion pion)
{	pcoup nouveau ;


	nouveau=(pcoup) malloc (sizeof(tcoup));
		/* creation du coup */
	nouveau->coord_depart=cd;
	nouveau->coord_arrive=ca;
	nouveau->suivant=*coup;
	nouveau->pion_mange=pion;
	*coup = nouveau ;
}



/* procédure qui ajoute un coup à une chaine de tcoup de coordonnées de départ et d'arrivée imposées */ 
void ajout_coup_tcoup ( pcoup *coup , tcoordonneejeu cd , tcoordonneejeu ca , tpion pion)

{
	if (*coup==NULL) 
		ajout_coup_tcoup_en_tete ( &*coup , cd , ca , pion) ;
	else 
		ajout_coup_tcoup ( &((*coup)->suivant) , cd , ca , pion) ;
}





/* procedure qui supprime le dernier coup de la chaine de tcoup */
void supprimer_pcoup (pcoup *coup )
{
	pcoup dernier , precedent;

	dernier=*coup;
	

	// recherche du dernier maillon de la chaine 
	while (dernier != NULL)
		{
			precedent=dernier;		
			dernier=dernier->suivant;
		}

	precedent->suivant=NULL;
	
}

/* Fonction qui retourne le nombre de coup dans un jeu */
int nb_coup( pcoup pc )
{
	
	int nb ;	
	pcoup courant;

	courant=pc;
	nb=0;




	while(courant != NULL)
	{ 
		nb=nb+1;
		courant=courant->suivant;

	}
	return nb;
}

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

/* procedure qui affiche une grille de jeu vierge */
void affiche_grille (void)
{
	
	short j ,a;
	int i ;
	i=1;

		DeplaceCurseur ( 12 ,6);	
		printf("| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |\n");
	for ( j=1 ; j<=16; j=j+2 )
		{
			a=j+6;
			DeplaceCurseur ( 9 ,a);	
			printf("------------------------------------\n");
			a=j+7;
			DeplaceCurseur ( 10 ,a);	
			printf("%i |   |   |   |   |   |   |   |   |\n", i);
			i++;
		}
	DeplaceCurseur ( 9 ,23);
	printf("------------------------------------\n");
}




/* procédure qui affiche un pion à ces coordonnées */
void affich_pion(tpion pion)
{

	COORD cs;
	
	cs=convert_coord_js ( pion.coordpion);
	

	DeplaceCurseur ( cs.X , cs.Y ) ;

	printf("%c" ,pion.couleur);

}



/*fonction qui convertis les coordonnées jeu en coordonnées système */
COORD convert_coord_js ( tcoordonneejeu cd)
{
	COORD cs;

	cs.X = (cd.colonne*3)+(cd.colonne-2)+12;
	cs.Y= (cd.ligne *2)-1+7;
	return cs; 

}

/*fonction qui convertis les coordonnées système en coordonnées jeu */
tcoordonneejeu convert_coord_sj ( COORD cs)
{
	tcoordonneejeu cj;
	cj.colonne=(cs.X+2-12)/4;
	cj.ligne=(cs.Y+1-7)/2;

	return cj;
}

/* procedure qui efface un pion d'apres ses coordonnées */
void desaffich_pion(tcoordonneejeu cj)
{

	COORD cs;
	
	cs=convert_coord_js ( cj);
	

	DeplaceCurseur ( cs.X , cs.Y ) ;

	printf(" ");

}








/* FONCTION QUI affiche LE MENU DE JEU */
void init_menu_jeu(void)
{
	DeplaceCurseur ( 55 , 6 );
	printf("o-----------x");
	DeplaceCurseur ( 55 , 7 );
	printf("|           |");
	DeplaceCurseur ( 55 , 8 );
	printf("| Take-Back |");
	DeplaceCurseur ( 55 , 9 );
	printf("|    0 1    |");
	DeplaceCurseur ( 55 , 10 );
	printf("x-----------o");


	DeplaceCurseur ( 55 , 11 );
	printf("o-----------x");
	DeplaceCurseur ( 55 , 12 );
	printf("|           |");
	DeplaceCurseur ( 55 , 13 );
	printf("|    Load   |");
	DeplaceCurseur ( 55 , 14);
	printf("|    0 2    |");
	DeplaceCurseur ( 55 , 15 );
	printf("x-----------o");

	DeplaceCurseur ( 55 , 16 );
	printf("o-----------x");
	DeplaceCurseur ( 55 , 17 );
	printf("|           |");
	DeplaceCurseur ( 55 , 18 );
	printf("|    Save   |");
	DeplaceCurseur ( 55 , 19);
	printf("|    0 3    |");
	DeplaceCurseur ( 55 , 20 );
	printf("x-----------o");

	DeplaceCurseur ( 55 , 21 );
	printf("o-----------x");
	DeplaceCurseur ( 55 , 22 );
	printf("|           |");
	DeplaceCurseur ( 55 , 23 );
	printf("|    EXIT   |");
	DeplaceCurseur ( 55 , 24);
	printf("|    0 4    |");
	DeplaceCurseur ( 55 , 25 );
	printf("x-----------o");

}

/* FONCTION QUI RENVOIE LE MENU DE accueil */
menu init_menu_accueil(void)
{
	menu M;
	
	M=CreationMenu();
	AjouterBouton( &M , FabriquerBouton ("Play",28,10,17,6));
	AjouterBouton( &M , FabriquerBouton ("Load",28,15,17,6));
	AjouterBouton( &M , FabriquerBouton ("dynamic game",28,20,17,6));
	AjouterBouton( &M , FabriquerBouton ("How to play ?",28,25,17,6));
	AjouterBouton( &M , FabriquerBouton ("EXIT",28,30,17,6));
	return M;
}




/* fonction qui renvoie si la coordonnée système appartient à la grille ou aux boutons */
/* grille:1 take-back:2 Load:3 Save:4 Exit:5*/
int appartient_grille_cs( COORD cs )
{
	int res;
	res=0;
		// test d'appartennance à la grille de jeu
	if (cs.X >=12 && cs.X <=44 )
	{
		if (cs.Y>=7 && cs.Y <=23 )
		{
			res=1;
		}
	}

		// test d'appartenance à Take-back

	if (cs.X >=55 && cs.X <=68 )
	{
		if (cs.Y>=6 && cs.Y <=10 )
		{
			res=2;
		}
	}
	
		// test d'appartenance à Load

	if (cs.X >=55 && cs.X <=68 )
	{
		if (cs.Y>=11 && cs.Y <=15 )
		{
			res=3;
		}
	}
	
		// test d'appartenance à Save

	if (cs.X >=55 && cs.X <=68 )
	{
		if (cs.Y>=16 && cs.Y <=20 )
		{
			res=4;
		}
	}

	
		// test d'appartenance à Exit

	if (cs.X >=55 && cs.X <=68 )
	{
		if (cs.Y>=21 && cs.Y <=25 )
		{
			res=5;
		}
	}

	return res;
}


/* fonction qui renvoie si la coordonnée jeu appartient à la grille ou aux boutons */
/* grille:1 take-back:2 Load:3 Save:4 Exit:5*/
int appartient_grille_cj( tcoordonneejeu cj )
{
	int res;
	res=1;

	if(cj.colonne==0)
	{
		// test d'appartenance à Take-back

		if (cj.ligne==1)
		{
			res=2;
		}
	
		// test d'appartenance à Load

		if (cj.ligne==2)
		{
			res=3;
		}
	
		// test d'appartenance à Save

		if (cj.ligne==3)
		{
			res=4;
		}

	
		// test d'appartenance à Exit

		if (cj.ligne==4)
		{
			res=5;
		}
	}
	
	return res;
}

/* affiche la grille, les pions, et les "boutons" */
void affiche_tout( tpartie partie )
{
	pjeu pjc;

//affichage de l'"interface graphisque"
	EffaceFenetre();
	affiche_grille ();
	init_menu_jeu();

						
//affichage de tous les pions
	pjc=partie.pj ;
	while (pjc != NULL )
	{
		affich_pion(pjc->pion);
		pjc=pjc->suivant;
	}
}




/* fonction qui affiche les règles du jeu */
void regles(void)
{
	EffaceFenetre();

DeplaceCurseur( 30 , 1);
printf("Les regles du jeu \n");
printf("\n");  
printf("\n");
printf("1) Le but du jeu\n"); 
printf("\n");

printf("La partie est gagnee si on prend toutes les pieces de l'adversaire\n");
printf("ou si on bloque toutes les pieces de l'adversaire\n");
printf("l'adversaire abandonne.\n");
printf("\n"); 
printf("La partie est nulle (ou remise) si:\n");
printf("aucun des deux joueurs ne peut prendre toutes les pieces adverses.\n"); 
printf("\n");
printf("\n");
printf("2) Disposition initiale \n");
printf("\n");

printf("Le jeu se deroule sur un damier de 8 cases.\n");
printf("Chaque joueurs possedent 12 pions places sur les 3 premieres rangees.\n");
printf("Les joueurs jouent chacun a leur tour. Les blancs commencent toujours.\n");
printf("\n");
printf("\n");

printf("3) Le mouvement des pions\n");
printf("\n");

printf("Les pions se deplacent d'une case vers l'avant en diagonale.\n"); 
printf("Les pions qui arrive sur la derniere rangee et s'y arrete sont promus dames.\n");
printf("\n");
printf("\n");
printf("4) Le mouvement de la dame\n");
printf("\n");

printf("La dame se deplace sur une meme diagonale d'une case, en avant et en arriere.\n");
printf("Son mouvement est seulement limite par les autres pieces sur le damier.\n");
printf("\n");
printf("\n");
printf("5) La prise par le pion \n");
printf("\n");

printf("Pour prendre avec un pion, il faut: \n");
printf("On se place a cote d'un pion adverse \n");
printf("il faut sauter par dessus le pion adverse et se rendre sur la case vide situee derriere celui-ci.\n");
printf("\n");
printf("\n");
printf("6) La prise par la dame \n");
printf("\n");
printf("La dame peut prendre en avant, en arriere mais un seul pion a la fois.\n");
 


	AttendreClic();
}

A voir également

Ajouter un commentaire

Commentaires

Messages postés
5
Date d'inscription
jeudi 24 juin 2004
Statut
Membre
Dernière intervention
18 novembre 2004

salut
je suis debutant en c++ et plus encore à visual c++..ce jeu de dame ne fonctionne pas chez moi ou alors c'est pas moi qui ne siat pas manipuler..il y a bien des erreurs..si quelqu'un peut bien m'expliquer comment je peux le faire fonctionner je lui en serai gré.de plus si quelqu'un connait comment on utilise les consoles dans vsc++ qu'il me le fasse savoir car je ne sais pas quel console sert à quoi..excuser moi pour mon français...je parles plutot l'italien
Messages postés
1
Date d'inscription
lundi 8 septembre 2003
Statut
Membre
Dernière intervention
21 décembre 2003

sans les fichiers .h cela ne risque pas de marcher comme chez nous!
Messages postés
1
Date d'inscription
dimanche 30 novembre 2003
Statut
Membre
Dernière intervention
30 novembre 2003

S'il vout plait, je ne trouve pas "OutilsFenetre.h" et "OutilsMenu.h".
Aidez moi. Urgent
Messages postés
157
Date d'inscription
jeudi 17 octobre 2002
Statut
Membre
Dernière intervention
11 septembre 2004

met un zi avec un *.exe sa sera plus facile
Messages postés
4
Date d'inscription
mardi 28 janvier 2003
Statut
Membre
Dernière intervention
14 septembre 2005

pour les fichiers d'en-têtes
#include "OutilsFenetre.h"
#include "OutilsMenu.h"


ou on les trouve svp
et merci d'avance
Afficher les 9 commentaires

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.