Jeux de dames

Version imprimable

Jeux de dames

Salut ,
Je me dirige vers vous car j'ai comme projet un jeux de dames à rendre pour aprés les vacances .
Cependant je suis bloqués dés le début car je ne vois pas comment afficher Mon damier avec les pions (op pour les faire se déplacer par la suite ) .
Voilà mon code(faites pas attention certaine variable ne sont pas encore utilisé j'avais anticipé pour la suite) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <stdio.h>
#include <stdlib.h>
//#include <SDL2/SDL.h>
 
 
void affichages ()
{
    system("cls");
 
    int PN = 1; //Pion noir
    int PB = 2; //Pion blanc
    int DM = 3; //Dame noir
    int DB = 4; //Dame blanche
    int V = 0;  //Case vide
    int Afficheur;
    int compteur;
    char NomJoueur1,NomJoueur2;
    int Coordonne[10][10] = {{1,2,3,4,5,6,7,8,9,10},1,2,3,4,5,6,7,8,9,10};
    int x ,y;
    int continuer = 1;
 
 
    printf("Nom joueur 1 : ");
    scanf("%s",&NomJoueur1);
 
    printf("\nNom joueur 2 : ");
    scanf("%s",&NomJoueur2);
 
    system("cls");
 
 
 
    while(continuer == 1)
    {
 
 
        printf("   | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |");
        printf("\n   _________________________________________\n");
        for(Afficheur = 1; Afficheur <= 10 ; Afficheur++)
        {
            if(Afficheur==10)
            {
                printf("%d | . |   | . |   | . |   | . |   | . |   |\n",Afficheur);
 
            }
            else
                {
                    if(Afficheur%2 == 0)
                    {
                        printf("%d  | . |   | . |   | . |   | . |   | . |   |\n",Afficheur);
                        printf("   _________________________________________\n");
                    }
                    if(Afficheur%2 != 0)
                    {
                        printf("%d  |   | . |   | . |   | . |   | . |   | . |\n",Afficheur);
                        printf("   _________________________________________\n");
                    }
        }
 
 
    }
    printf("Continuer 0/1 : ");
    scanf("%d",&continuer);
 
    }
    return 0;
 
}

Merci de vos réponse .

Bonjour,

Si tu t'orientes en affichage pur texte, il faut définir une représentation des pions

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
enum ValeurCase {
    V = 0,  //Case vide
    PN = 1, //Pion noir
    PB = 2, //Pion blanc
    DM = 3, //Dame noire
    DB = 4, //Dame blanche
    NbTypeCases
};
const char Images[3][NbTypeCases] = 
{  "   ", " x ", " o ", "(X)", "(o)"
};
 
Ensuite la ligne 50 peut être remplacée par l'appel de 
void affiche_ligne( int table[10][] , int numLigne , int ligne_est_paire )
{
   int colonne;
   printf("%2d |" , num_ligne+1 );
   for ( colonne = 0 ; colonne < 10 ; ++colonne )
   {
      if ( (col % 2) == ligne_est_paire )
         printf(" . |");
      else
      {
          printf( Images[table[num_ligne][colonne]] );
          printf("|");
      }
   }
   printf("\n");
}

15/12/2015, 08h39
Matt_Houston
Cela m'a l'air pas trop mal parti, ta difficulté provient du fait que tu affiches ton damier ligne par ligne. Or il faut l'afficher case par case puisque son contenu évolue sans cesse (bon, en fait on peut le faire en affichant une ligne puis en repassant dessus mais il faut avoir recours à des manips pas forcément portables et un peu crades..). Tu as donc au moins besoin d'une boucle pour les ordonnées (axe y) et d'une autre imbriquée pour les abscisses (axe x), je te laisse chercher un peu à partir de là. ;)

Une petite remarque :
Code:

1 2 3 4 5 int PN = 1; //Pion noir int PB = 2; //Pion blanc int DM = 3; //Dame noir int DB = 4; //Dame blanche int V = 0; //Case vide
Sont-ce les valeurs des constantes que tu utilises dans ton tableau pour identifier le contenu des cases ? Un type enum serait plus approprié ici :
Code:

1 2 3 4 5 6 7 typedef enum { Vide = 0, PionNoir, PionBlanc, DameNoire, DameBlanche } ContenuCase;
Edit: grillé :mrgreen:

Merci pour vos deux réponse
J'ai une question à quoi sert le type enum et quand doit-on l'utiliser ??

Dalfab j'ai pas compris cette ligne

Code:

1
2
3
const char Images[3][NbTypeCases] = 
{  "   ", " x ", " o ", "(X)", "(o)"
}

Je sais que ça défini la représentation de chaque pion mais pourquoi tu as mis "Images[3][NbTypeCases]" ====> ça signifie quoi :calim2::calim2::weird:

EDIT : Je reviens vers vous car je n'arrive pas à faire revenir à la ligne mon damier quand il arrive à la 10 eme case :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
void affichages ()
{
    system("cls");
 
    enum ValeurCase {
        V = 0,  //Case vide
        PN = 1, //Pion noir
        PB = 2, //Pion blanc
        DM = 3, //Dame noire
        DB = 4, //Dame blanche
        NbTypeCases
    };
    const char Images[3][NbTypeCases] =
    {  "   ", " x ", " o ", "(X)", "(o)"
    };
    int colonne;
    int ligne;
    int nbligne;
    int nbcolonne;
    int continuer = 1;
while(continuer == 1)
    {
        for(colonne=1;colonne<=10;colonne++)
        {
            for(ligne=1;ligne<=10;ligne++)
            {
                if((colonne%2 == 0) && (ligne%2 !=0))
                {
                    printf(" . |");
                }
                else if((colonne%2 == 0) && (ligne%2 ==0))
                {
                    printf("   |");
                }
                else if((colonne%2 != 0)&& (ligne%2 !=0))
                {
                    printf("   |");
                }
                else if((colonne%2 != 0)&& (ligne%2 == 0))
                {
                    printf(" . |");
                }
 
            }
 
 
        }
 
 
    printf("\nContinuer 0/1 : ");
    scanf("%d",&continuer);
    }
    return 0;
 
    }

EDIT 2 :J'ai réussi manquait juste un printf("\n); à la ligne 44 .

Bon par contre maintenant je ne sais pas comment placer mes pions ...

Une énumération (enum en C) est simplement un entier qui peut prendre un nombre arbitraire mais fini de valeurs labellisées : auquelles on a donné un nom.
Tu peux voir cela comme une collection de constantes liées sémantiquement.

Un exemple courant est celui des cartes à jouer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <stdio.h>
 
 
/* les valeurs entières de cette énumération sont indéfinies, car elles ne font pas sens */
typedef enum {
    Spades,   // Pique
    Hearts,   // Coeur
    Diamonds, // Carreau
    Clubs     // Trèfle
} Suit; // Couleur
 
/* les valeurs entières de cette énumération sont précisément définies, car on veut pouvoir effectuer des comparaisons */
typedef enum {
    V2 = 2,                           // la valeur d'une entrée est incrémentée de 1 par rapport à la précédente
    V3, V4, V5, V6, V7, V8, V9, V10,  // V3 == 3, V4 == 4, etc...
    Jack,                             // Valet == 11
    Queen,                            // Dame  == 12
    King,                             // Roi   == 13
    Ace                               // As    == 14
} Value; // Valeur
 
struct card {
    Suit  suit;
    Value value;
};
 
 
const char *suit_to_str(Suit suit) {
    switch (suit) {
        case Spades:
            return "Spades";
        case Hearts:
            return "Hearts";
        case Diamonds:
            return "Diamonds";
        case Clubs:
            return "Clubs";
    }
 
    return NULL; // jamais atteint
}
 
void card_print(const struct card *c) {
    printf("the %d of %s!", c->value, suit_to_str(c->suit));
}
 
void card_compare(const struct card *c1, const struct card *c2) {
    const struct card *best = (c1->value < c2->value) ? c2 : ((c1->value > c2->value) ? c1 : NULL);
 
    if (best) {
        printf("winner: "); card_print(best);
    }
    else
        printf("it's a draw!"); // match nul !
}
 
int main(int argc, char *argv[]) {
    struct card c1 = { .suit = Hearts, .value = V7   }; // 7 de Coeur
    struct card c2 = { .suit = Spades, .value = Jack }; // valet de Pique
 
    card_print(&c1); printf("\n"); // affiche : "the 7 of Hearts!"
    card_print(&c2); printf("\n"); // affiche : "the 11 of Spades!"
 
    card_compare(&c1, &c2); printf("\n"); // affiche "winner: the 11 of Spades!"
 
    return 0;
}

Un type enum est implémenté par le compilateur sous la forme d'un entier d'un type assez large pour contenir toutes les valeurs définies par le programmeur. En pratique probablement un int, mais pas forcément.

À noter qu'il est - comme souvent en C - possible de faire n'importe quoi avec une variable de type enum et notamment lui affecter des valeurs qui ne sont pas listées dans sa définition !

15/12/2015, 13h49
Sve@r
Citation:

Envoyé par daftangel

J'ai une question à quoi sert le type enum et quand doit-on l'utiliser ??

Bonjour

Pour rajouter à la très bonne réponse de Matt_Houston, ça permet d'associer un nombre (pas forcément très lisible) à un label (plus clair pour l'humain qui doit relire le code). Pas obligatoire mais très pratique.
Citation:
Envoyé par daftangel

Dalfab j'ai pas compris cette ligne

Code:

1 2 3 const char Images[3][NbTypeCases] = { " ", " x ", " o ", "(X)", "(o)" }

Je sais que ça défini la représentation de chaque pion mais pourquoi tu as mis "Images[3][NbTypeCases]" ====> ça signifie quoi :calim2::calim2::weird:
Chaque élément "image[x]" possède 3 caractères. Et là, dalfab a plutôt chié dans la colle car en réalité, il en possède 4 (ne pas oublier le '\0' terminant toute chaine) !!!

Et si on veut faire plus simple, comme chaque élément est invariant, on peut alors les stocker dans la zone statique du code et ne mémoriser que les adresses de ces éléments. Et comme chaque adresse se stocke dans un pointeur, un simple tableau de pointeurs suffit.
Code:

1 2 3 const char const *Images[NbTypeCases] = { " ", " x ", " o ", "(X)", "(o)" }
Citation:

Envoyé par daftangel

Bon par contre maintenant je ne sais pas comment placer mes pions ...

Il faut que chaque case connaisse le pion qui se trouve sur elle. Ensuite, au moment où tu affiches la case[x], ben tu affiches aussi le pion qui est dessus...
15/12/2015, 14h16
Matt_Houston

Hep, hep hep ! J'y suis pour rien, moi ! :fessee: :mrgreen:
15/12/2015, 16h46
daftangel

Citation:

Il faut que chaque case connaisse le pion qui se trouve sur elle. Ensuite, au moment où tu affiches la case[x], ben tu affiches aussi le pion qui est dessus...

Désolé mais je ne sais toujours pas comment les inclure dans mon code ...
15/12/2015, 17h25
stendhal666

J'ai l'impression que tu te concentres un peu trop sur l'affichage à l'écran de ton damier. Bien sûr c'est très important et ça permet de vérifier l'avancée de ton programme, mais ce n'est qu'une "couche" de ce programme.

Il existe plein de façons de représenter un damier avec ses pions, qui ont divers avantages. Pour faire quelque chose de simple, tu peux choisir un tableau de 10*10 char; chacune des cases du damier contient une valeur (0: vide, 1: pion blanc, etc.)

Le tableau en question est passé en argument à la fonction d'affichage et tu sais donc pour chaque coordonnée quel pion est dessus: board[2][2] == 1 signifie qu'il y a un pion blanc à la case 2,2 (ou 3,3 si tu commences à compter à partir de 1).

Le même tableau peut être utilisé pour vérifier qu'un coup est valide ou encore pour déterminer le meilleur coup, si ton programme doit contenir une intelligence artificielle.

Bon voilà ou j'en suis mais j'ai l'impression que c'est faux car je n'ai pas associé mes "images" au pions qui se trouvent dans le enum mais je sais du tout comment faire .

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
void affichages ()
{
    system("cls");
 
    enum ValeurCase {
        V = 0,  //Case vide
        PN = 1, //Pion noir
        PB = 2, //Pion blanc
        DM = 3, //Dame noire
        DB = 4, //Dame blanche
        NbTypeCases
    };
    const char const *Images[NbTypeCases] = {  "   ", " x ", " o ", "(X)", "(o)"};
    int colonne;
    int ligne;
    int nbligne;
    int nbcolonne;
    int continuer = 1;
 
 
 
    while(continuer == 1)
    {
        printf(" 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10\n");
        printf(" --------------------------------------\n");
        for(colonne=1;colonne<=10;colonne++)
        {
            for(ligne=1;ligne<=10;ligne++)
            {
                if((colonne)<=4)
                {
                    if((colonne%2 == 0) && (ligne%2 !=0))
                    {
                        printf(" . |");
                    }
                    else if((colonne%2 == 0) && (ligne%2 ==0))
                    {
                        printf ("%s",Images[1]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 !=0))
                    {
                        printf ("%s",Images[1]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 == 0))
                    {
                        printf(" . |");
                    }
 
 
                }
 
                if((colonne==5)||(colonne==6))
                {
                    if((colonne%2 == 0) && (ligne%2 !=0))
                    {
                        printf(" . |");
                    }
                    else if((colonne%2 == 0) && (ligne%2 ==0))
                    {
                        printf ("%s",Images[0]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 !=0))
                    {
                        printf ("%s",Images[0]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 == 0))
                    {
                        printf(" . |");
                    }
                }
 
                if((colonne >= 7)&& (colonne <= 10))
                {
                    if((colonne%2 == 0) && (ligne%2 !=0))
                    {
                        printf(" . |");
                    }
                    else if((colonne%2 == 0) && (ligne%2 ==0))
                    {
                        printf ("%s",Images[2]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 !=0))
                    {
                        printf ("%s",Images[2]);
                        printf("|");
                    }
                    else if((colonne%2 != 0)&& (ligne%2 == 0))
                    {
                        printf(" . |");
                    }
                }
 
 
 
            }printf("\n");
 
 
        }
 
 
    printf("\nContinuer 0/1 : ");
    scanf("%d",&continuer);
    }
    return 0;
 
    }

EDIT : J'ai fait ça :

Code:

1
2
3
4
5
    Images[0] = V;
    Images[1] = PN;
    Images[2] = PB;
    Images[3] = DM;
    Images[4] = DB;

Es-ce que c'est bon ?

Hello,

Sans m'occuper des pièces blanches ou noires (je t'en laisse le soin), le modulo est ton copain:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
int main(void) {
	int i,j;
 
	for(i=0;i<4;i++) {
		putchar('|');				// not needed, example
		for(j=0;j<10;j++)
			if((i+j)%2)
				putchar(' ');
			else
				putchar('x');
		puts("|");				// not needed, example (but puts("") or putchar('\n') is needed)
	}
	return(0);
}

A+

Edgar;

Citation:
Envoyé par daftangel
J'ai fait ça :
Code:

1 2 3 4 5 Images[0] = V; Images[1] = PN; Images[2] = PB; Images[3] = DM; Images[4] = DB;
Es-ce que c'est bon ?
Non, le tableau Image[] contient ce qu'il faut afficher,
Pour représenter des pions, il faut qu'il existe quelque part une table qui indique là où ils sont,
l'affichage consiste alors à lire dans cette table pour afficher chaque case.

Par exemple, on peut initialiser une table de 10*10 cases qui contiendra toutes tes pions et leur position
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 enum ValeurCase board[10][10] = { { PB, V, PB, V, PB, V, PB, V, PB, V }, { V, PB, V, PB, V, PB, V, PB, V, PB }, { PB, V, PB, V, PB, V, PB, V, PB, V }, { V, PB, V, PB, V, PB, V, PB, V, PB }, { V, V, V, V, V, V, V, V, V, V }, { V, V, V, V, V, V, V, V, V, V }, { PN, V, PN, V, PN, V, PN, V, PN, V }, { V, PN, V, PN, V, PN, V, PN, V, PN }, { PN, V, PN, V, PN, V, PN, V, PN, V }, { V, PN, V, PN, V, PN, V, PN, V, PN }, };
Cette table non constante, évoluera quand les pions bougerons.

Pour afficher, il faut effectuer la traduction : à la position (colonne,ligne) qui y a-t-il? et l'afficher.
Dans une boucle, au moment où on est à la bonne position, il suffit de faire :
Code:

1 2 3 enum ValeurCase contenuCase = board[colonne][ligne]; const char *aAfficher = Image[contenuCase]; printf( aAfficher );
J'avais ceci en une seule ligne dans mon exemple précédent.

Attention, les indices des tableau commencent à 0 (donc 0 à 9 ici).
Pour être plus exact, la ligne :
const char const *Images[NbTypeCases] = { " ", " x ", " o ", "(X)", "(o)"};
pourrait être refusée par ton compilateur, elle devrait être plutôt :
static const char *const Images[NbTypeCases] = { " ", " x ", " o ", "(X)", "(o)"};

Tous le monde te donne une bonne solution, mais attention chacun gère les choses différemment, il est important d'y puiser les informations utiles.

Je vois que tu es toujours bloqué,

pour avancer il te faut bien comprendre la signification de chacun des symboles du langage (fonction, variables, types, ...)

La fonction d'affichage plus simple que ce que tu as écris, elle doit inclure le code suivant (rien de lus rien de moins)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 void affichages() { int colonne; int ligne; printf(" | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10|\n"); printf("---+---+---+---+---+---+---+---+---+---+---|\n"); for ( colonne=1;colonne<=10;colonne++ ) { printf( "%-2d |" , colonne ); for ( ligne=1;ligne<=10;ligne++ ) { if ( (ligne+colonne) % 2 != 0 ) printf( " . |"); else { printf( Images[tab[colonne-1][ligne-1]] ); printf( "|" ); } } printf("\n"); } printf("---+---+---+---+---+---+---+---+---+---+---|\n"); }
Les données qui perdurent au delà d'une fonction doivent être en dehors ce celle-ci.
Par exemple, le tableau tab[][] peut être défini en global, il sera modifié par une fonction void demander_deplacement( int indice_joueur);

Le code principal doit être dans une boucle :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for(;;) { // afficher les possibilités (noms des joueurs, nouvelle partie, ...) .... // demander à l'utilisateur .... // si choix est : jouer affichage(); demander_deplacement(); affichage(); // ....etc }
La fonction demander_deplacement() est la plus intéressante, elle doit effacer de tab[][] le pion qui bouge, effacer aussi les pion pris, mettre dans tab[][] le pion à sa nouvelle position tout en vérifiant que les mouvement sont possibles!

Citation:

Envoyé par dalfab

Code:

1
2
3
4
5
6
7
8
9
10
11
12
for(;;) {
    // afficher les possibilités (noms des joueurs, nouvelle partie, ...)
     ....
    // demander à l'utilisateur
     ....
    // si choix est : jouer
    affichage();
    demander_deplacement();
    affichage();
    //
    ....etc
}

Je ne pourrais pas la mettre dans une boucle while avec un Tant que PartieGagner == 0 continuer .

18/12/2015, 00h51
dalfab

Citation:

Envoyé par daftangel

Je ne pourrais pas la mettre dans une boucle while avec un Tant que PartieGagner == 0 continuer .

tout à fait

Re , ça fait longtemps que j'ai pas posté mais je suis bloqué au niveau des règles de déplacement .

Voilà où j'en suis :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        if((tab[choixdpltX-1][choixdpltY-1] == V)&&((tab[choixdpltX-1][choixdpltY-1] != tab[choixpionX][choixpionY])||(tab[choixdpltX-1][choixdpltY-1] != tab[choixpionX][choixpionY-2])))
        {
            printf("Erreur coup impossible\n");
            system("pause");
        }
 
        else if((tab[choixdpltX-1][choixdpltY-1] == V)&&((tab[choixdpltX-1][choixdpltY-1] == tab[choixpionX-1][choixpionY-1])||(tab[choixdpltX-1][choixdpltY-1] == tab[choixpionX][choixpionY-2])))
        {
            tab[choixpionX-1][choixpionY-1] = V;
            tab[choixdpltX-1][choixdpltY-1] = PB ;
            system("pause");
 
        }

Mais tout ceci ne fonctionne pas et je galère dessus :roll:
Une piste ?

C'est ici qu'il ne faut pas hésiter à faire un dessin.

Dans tous cas : la case [pionX][pionY] doit être de la couleur, et la case [dpltX][dpltY] doit être vide.

Pour un déplacement valide on doit avoir : pionX +/- 1 == dpltX et pionY+1 == dpltY (ou - 1 suivant si pion blanc ou noir).
Pour une prise valide ou doit avoir : pionX +/- 2 == dpltX et pionY +/- 2 == dpltY
et la case intermédiaire c-a-d tab[(pionX+dpltX)/2][(pionY+dpltY)/2] doit contenir un pion de couleur adverse.

pour le test de prise
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int priseOk = 0; if ( tab[pionX][pionY] == couleurCourante && tab[dpltX][dpltY] == V ) { int sx = dpltX - pionX; int sy = dpltY - pionY; if ( abs(sx)==2 && abs(sy)==2 ) if ( tab[pionX+sx/2][pionY+sy/2] == couleurAdverse ) priseOk=1; } if ( priseOk ) { /* effectuer la prise */ }
Il restera aussi à gérer les prises multiples, et les déplacements et prises des dames...

Bonjour,

Pour gérer les dames. Un pion se transforme en dame sur la dernière ligne (dépend de la couleur); Les dames ont des possibilités de déplacement et de prises différents; dans les tests de prise un pion ou une dame sont équivalents.

On peut créer les fonctions utilitaires :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// si BOOL n'existe pas, il est bien pratique
#define BOOL unsigned char
#define TRUE (1==1)
#define FALSE (0!=0)
 
// est-ce une dame de la couleur
inline BOOL estDame( enum ValeurCase coul  , int x , int y )
{
    if ( coul == PN ) return board[x][y] == DM;
    if ( coul == PB ) return board[x][y] == DB;
    return FALSE;
}
 
// est-ce le bon pion ?
inline enum ValeurCase couleur( int x , int y )
{
    switch ( board[x][y] )
    {
        case PN:
        case DM:
            return PN;
        case PB:
        case DB:
            return PB;
        default:
        case V:
            return V;
        }
    }
}
 
// couleur opposee de la courante
inline enum ValeurCase couleurOpposee( enum ValeurCase coul )
{
    switch ( coul )
    {
        case PN:
        case DM:
            return PB;
        case PB:
        case DB:
            return PN;
        default:
            return V;
        }
    }
}
 
// deplacement dame, possible si aucun pion sur la diagonale
// prise dame, si un seul pion de couleur oppose sur la diagonale (et indique ses coord)
BOOL deplacementDamePossible( enum ValeurCase coul , int debX , int debY , int destX , int destY , int* priseX , int*PriseY )
{
    int nbPrises = 0;
    int x;
    int y;
    int dx;
    int dy;
    enum ValeurCase opp = couleurOpposee( coul );
 
    if ( !estDame(coul,debX,debY) )
        return FALSE; // pas une dame de la couleur au depart
    if ( couleur(destX,destY) != V )
        return FALSE; // pas vide a l'arrivee
    int deltaX = destX - debX;
    int deltaY = destY - debY;
    if ( abs(deltaX) != abs(deltaY) )
        return FALSE; // pas sur une diagonale
    // verifier les cases intermediaires
    dx = (deltaX > 0) ? +1 : -1;
    dy = (deltaY > 0) ? +1 : -1;
    *priseX = -1; *priseY = -1; // si -1 alors il s'agit d'un deplacement, modifie apres si prise
    for ( y = posY+dy , x = posX+dx ; y!=destY ; y+=dy , x+=dx )
        if ( couleur(x,y) == opp )
        {
            nbPrises++;
            if ( nbPrise > 1 )
                return FALSE; // plusieurs pions dans la trajectoire
            *priseX = x;
            *priseY = y;
        }
        else if ( couleur(x,y) != V )
            return FALSE; // couleur interdite dans la trajectoire
 
    return TRUE; // tous les tests ont passe
}

La fonction couleur() est à utiliser dans le code pour les tests de contrôles de couleur au lieu de tests board[x][y]==coul pour tenir compte de la présence de dames.

Il reste à appeler les bonnes fonctions au bon moment, pour distinguer les prises pions des prises dame, effectuer les deplacements en modifiant la table board[][], ...