Jeu de dame
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
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();
}
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.