creer un jeu en C

Version imprimable

18/05/2014, 08h30
Avatar91

creer un jeu en C

bonjour a tous
je dois créer un jeu "line of action"
http://fr.wikipedia.org/wiki/Lines_of_Action
c'est comme un jeu de dame sauf que ce ne sont pas les memes regles
j'aurai besoin d' aide:calim2: pour projet merci d'avance pour vos reponse
18/05/2014, 09h19
Kannagi

Et c'est quoi le souci ? :koi:
18/05/2014, 09h52
Avatar91

créer un jeu

Le souci c'est que je sais pas trop pas quoi commencer
J'ai voulu commencer pas tracer la grille comme celle d'un damier et je sais pas trop comment faire jouer contre l'intelligence artificielle et comment donner les différents deplacement sur la grille

Pour un jeu aussi simple tu peux coder l'approche "dirty" :mrgreen:
Sale parce que lorsque tu commences à avoir plus de 5 états, c'est très difficile à maintenir.
La technique alors consiste à séparer "les concepts" du jeux ;)

Voici l'algo:

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
State game_state <- { intro, home, options, end, // Écrans
                      gamer_1, gamer_2, game_pause, game_end, animation_new_game, // Pendant le jeu
                      animation_intro_home, animation_home_options, animation_options_home, animation_home_game, animation_game_home, animation_end }
 
// Pas forcément utile: c'est bien pour montrer l'idée de l'algo
// Cela sert surtout à savoir si le jeu peut recevoir des interactions
State logic_state <- { Wait, IA, Display, Program_End }
 
// Pas forcément utile: c'est bien pour montrer l'idée de l'algo
User_Interactions ui <- { none, click_play, click_options, click_exit, click_replay,
                          click_pause, click_menu, click_case_1, click_case_2, click_case_3, ... click_case_N, // Pendant le jeu
                          /* ... */ }
 
game_state  <- intro
last_game_state <- gamer_1
logic_state <- Wait
ui <- none
 
// Initialise le jeu
 
// Déclaration de toutes les données
// ...
 
last_time <- now
diff_time <- 0
time_animation <- 0
 
 
while(logic_state != Program_End) {
    logic_state <- Wait
 
//  Le jeux attend Xms
//  Si tu veux 25fps, X = 1/ 25
    sleep(Xms);
 
 
//  Mise à jour du temps
    diff_time <- now - last_time
    last_time <- now
 
 
//  Si le programme se termine on peut faire un continue pour quitter le jeu
    if (logic_state != Program_End) { logic_state <- IA }
    else { game_state <- end /* || animation_end*/ }
 
 
 
//  On recalcule le jeu avec les interactions des joueurs
//  Peut-être qu'il n'y a rien à faire: ui == none
//  Pour toutes les animations le mieux c'est d'utiliser le temps au lieu de faire des incréments fixes (variable diff_time)
//  <- IA Début
    switch(game_state) {
    case intro:
//      On calcule éventuellement les animations
//      On attend un peu avant de lancer l'animation d'introduction
        time_animation <-  time_animation + diff_time
 
        if time_animation > time_intro {
            time_animation <- 0
            state <- animation_intro_home
        }
        break
    case home:
//      On calcule éventuellement les animations
//      comme les boutons qui scintillent par exemple
 
        switch(ui) {
        case click_play: case click_replay: state <- animation_home_game break;
        case click_options: state <- animation_home_options break;
        case click_exit: state <- end break;
        case /* les autres interactions utilisateurs sur l'écran d'accueil */
        }
        break
    case options:
//      On calcule éventuellement les animations
//      comme les boutons qui scintillent par exemple
 
        switch(ui) {
        case click_menu: state <- animation_options_home break
        case /* les autres interactions utilisateurs dans les options */
        }
        break
    case end:
        time_animation <-  time_animation + diff_time
//      On calcule éventuellement les animations
//      On attend un peu avant de lancer l'animation de fin
 
        if time_animation > time_end {
            time_animation <- 0
            state <- animation_end
//          Si ce n'est pas encore fait, c'est peut-être le moment de détruire toutes les données
//          Ou alors faire cela après la boucle while s'il y a plusieurs endroits pour quitter la boucle
        }
        break
    case gamer_1: case gamer_2:
//      On calcule éventuellement les animations
 
        switch(ui) {
        case click_pause:
//          Ici il faudra éventuellement gérer les données afin qu'on puisse rejouer
            last_game_state <- state; state <- game_pause break
        case click_menu:
//          Ici il faudra gérer les données afin qu'on puisse rejouer si on revient dans le jeu
            state <- animation_game_home
            break
        case click_case_1: case click_case_2: case click_case_3: case ... case click_case_N:
//          C'est ici qu'il va y avoir l'IA du jeu
//          Ici il faut gérer les données puisque l'état peut passer à game_end
            break;
        case /* les autres interactions utilisateurs avec le jeu */
        }
        break
    case game_pause:
        switch(ui) {
        case click_pause:
//          Ici il faudra éventuellement gérer les données afin qu'on puisse rejouer
            state <- last_game_state
            break
        case /* les autres interactions utilisateurs pendant la pause */
        }
        break
    case game_end:
        switch(ui) {
        case case click_replay:
//          Ici il faut gérer les données pour une nouvelle partie
            state <- animation_new_game
            break
        case click_menu:
//          Ici il faut gérer les données puisque pour qu'on puisse après lancer une nouvelle partie
            state <- animation_game_home
            break
        case /* les autres interactions utilisateurs lors d'une fin de partie */
        }
        break;
    case animation_home_options:
    case animation_options_home:
    case animation_home_game:
    case animation_game_home:
        time_animation <-  time_animation + diff_time
 
        if time_animation < time_animation_2_screens {
//          On calcule l'animation
        } else {
            time_animation <- 0
            state <- home || last_game_state /* || animation_new_game */ || options
        }
        break
    case animation_new_game:
//      On calcule l'animation de début de partie
//      Et à la fin state <- gamer_1
//      Ici il faudra initialiser une nouvelle partie
        break
    case animation_intro_home:
//      On calcule l'animation d'introduction
//      Et à la fin state <- home
        break
    case animation_end:
//      On calcule l'animation de fin
        break
    }
//  -> IA Fin
 
 
//  Si le programme se termine on peut ne pas afficher le jeu
    if (logic_state != Program_End) { logic_state <- Display }
 
 
//  On affiche le jeu avec les nouvelles données de l'IA
//  <- Display Début
    switch(game_state) {
    case intro:
//      On affiche l'écran d'introduction
        break
    case home:
//      On affiche l'écran d'accueil
        break
    case options:
//      On affiche l'écran des options
        break
    case gamer_1: case gamer_2:
//      On affiche un écran du jeu: une grille de jeu
        break
    case game_pause:
//      On affiche un écran du style: la grille de jeu avec un message "Pause"
        break
    case game_end:
//      On affiche un écran du style: la grille de jeu avec un message "Fin de partie"
        break;
    case end:
//      On affiche un écran de fin
        break
    case animation_home_options:
    case animation_options_home:
    case animation_home_game:
    case animation_game_home:
    case animation_new_game:
    case animation_intro_home:
    case animation_end:
//      On affiche une des animations du jeu
        break
    }
//  -> Display Fin
 
 
//  Il me semble que c'est le bon endroit pour "des choses classiques": faire des sauvegardes, calcul du fps, ...
//  Et aussi; si soit l'IA soit l'affichage soit les 2 prennent du temps, on peut faire aussi des choses ici:
//  regarder s'il y a eu des interactions, redéfinir le temps d'attente, ...
}
 
//  Si ce n'est pas encore fait, c'est le moment de détruire toutes les données

J'ai un doute :?: il me semble qu'on arrête de dormir si un joueur joue.
Mais pendant l'IA et l'affichage, soit on bufferise soit on supprime les interactions joueurs

Mais en tout cas, les interactions tu les reçois: tu codes avec quelle librairie?

À tester si le jeu est réactif. De toute façon, c'est un jeu qui ne demande pas des interactions en continue :langue2:

Sinon, les interactions des joueurs et l'IA peuvent arrêter le jeu :mrgreen:

18/05/2014, 13h48
Avatar91

Merci foetus pour ta réponse
Quand tu dis IL tu parle de quoi??
Désolé je suis suis novice en programmation :oops:
Je travaille sur code bloks
je voulais séparer mon programme en plusieurs partie genre
Créer les différentes fonctions dont j'ai besoin et les utiliser après dans mon int main.
Fonction 1:construction de la grille
Fonction 2 :les joueurs et la possibilité de jouer contre l'ordinateur
Fonction 3:les déplacements possible pour un joueur qui s' affiche sur la grille
Fonction 4:le joueur a gagné ou non
Je crois que ça revient à ce que tu as dis je suis pas sur:calim2:
19/05/2014, 05h06
foetus

J'ai mis à jour mon petit code, pour montrer 2 écrans (accueil et options) en plus du jeu et les différentes animations (dont celle d'introduction et celle de fin) :mrgreen:

Citation:

Envoyé par Avatar91

Quand tu dis IL tu parle de quoi??

J'ai dit IL quand? :koi: :koi:

Citation:

Envoyé par Avatar91

Je travaille sur code bloks

Qt, OpenGL sont des libraires. code bloks est un IDE :langue2:

Citation:

Envoyé par Avatar91

Je crois que ça revient à ce que tu as dis je suis pas sur:calim2:

Faire un jeu c'est en définitive assez simple.
Mais tu vois que rien que pour gérer 2 écrans en plus du jeu cela devient assez conséquent (*) et qu'il faut une "rigueur" de programmation sinon tu n'arrives à rien.

Et au passage tu comprends pourquoi je parle d'algo sale: avec 2 écrans, le jeu et les animations cela en fait du code en "1 seul bloc" :mouarf: :mouarf:
Après on peut séparer les concepts en faisant des classes/ objets, des fonctions ou autres.

* -> Et en plus tu n'as pas le calcul de l'IA du jeu avec le déplacement des pièces... ni de la 2D très évoluée: pas de textures, un plateau fixe, pas/ pas trop d'animations pendant le jeu, pas de 3D...
19/05/2014, 08h44
Avatar91

créer un jeu

Bonjour
Tu n'a pas dit IL mais plutôt IA?
19/05/2014, 08h46
Avatar91

créer un jeu

Merci pour ta réponse
19/05/2014, 13h01
foetus

IA -> Intelligence Artificielle en anglais AI (comme le film :whistle:)
La logique du jeu, 2 lettres c'est plus rapide :mrgreen:
22/05/2014, 01h16
Avatar91

créer un jeu

Salut foetus désolé de répondre que maintenant j'étais en partiels
pourrait tu m'expliquer stp comment poster mon programme sur le forum car j'ai essayé de faire la fonction pour le damier
j'aimerais que tu le verifie stp:oops::oops::calim2:

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
#define PION_BLANC 1
#define DAME_BLANC 2
#define PION_NOIR -1
#define DAME_NOIR -2
#define CASE_VIDE  0
#define HUMAIN 0
#define CPU 1
 
typedef struct{
   int lig,col;
   } Case;
typedef struct{
  Case case_i,case_f;
  }deplacement
struct element {
Case C;
listeCases suivante;
};
typedef struct element +listeCases;
 
typedef struct {
 char *nom;
 int type;
 int couleur;
 }joueur;
 typedef struct{
    int plateau[10][10];
    int nb_noir;
    int nb_blanc;
    }damier;
 
void affiche_ligne(int i,int damier[10][10]) {
     int j ;
printf(" %2d ",i+1);
 for(j=0;j<10 ;j++)
    { switch(damier[i][j]) {
         case PION_BLANC :
              printf("| O ") ;
              break ;
        case PION_NOIR :
            printf("| X ") ;
             break ;
        case DAME_NOIR :
             printf("| [X] ") ;
             break ;
        case DAME_BLANC :
             printf("| [O] ") ;
              break ;
        default :
            printf("| ") ;
            break ;
 
       }
}
 
printf("| %2d\n",i+1) ;
printf(" |--------------------------------------------------|\n") ; }/* Fonction qui affiche le damier en totalité
*/
void affiche_damier(int damier[10][10]) {
    int i ;
printf(" a     b     c    d     e    f    g    h     i     j \n") ;
printf(" |--------------------------------------------------|\n") ;
for(i=0;i<10 ;i++)
    affiche_ligne(i,damier) ;
printf(" a     b     c    d     e    f    g    h     i     j \n") ; }
 
void init_damier(damier* jeu) {
     jeu->nb_blanc = 20 ;
     jeu->nb_noir = 20 ;
     int i,j ;
//On initialise le tableau
 for(i=0;i<10 ;i++)
    for(j=0 ;j<10;j++)
       jeu->plateau[i][j] = 0 ;
//On remplie la partie haute du damier par des pions noirs
for(i=0;i<4 ;i++) {
//Si i est pair, la première case doit être noir (active)
if(i%2 == 0) j=1 ;
 else j=0 ;
 
for(j ;j<10 ;j+=2)
jeu->plateau[i][j] = PION_NOIR ;
}//On remplie la partie basse du damier par des pions blancs
for(i=6;i<10 ;i++) {
}}
//Si i est pair, la premier case doit être noir (active)
if(i%2 == 0) j=1 ;
 else j=0 ;
for(j ;j<10 ;j+=2)
    jeu->plateau[i][j] = PION_BLANC;
#define PION_BLANC 1
#define DAME_BLANC 2
#define PION_NOIR -1
#define DAME_NOIR -2
#define CASE_VIDE  0
#define HUMAIN 0
#define CPU 1
 
typedef struct{
   int lig,col;
   } Case;
typedef struct{
  Case case_i,case_f;
  }deplacement
struct element {
Case C;
listeCases suivante;
};
typedef struct element +listeCases;
 
typedef struct {
 char *nom;
 int type;
 int couleur;
 }joueur;
 typedef struct{
    int plateau[10][10];
    int nb_noir;
    int nb_blanc;
    }damier;
 
void affiche_ligne(int i,int damier[10][10]) {
     int j ;
printf(" %2d ",i+1);
 for(j=0;j<10 ;j++)
    { switch(damier[i][j]) {
         case PION_BLANC :
              printf("| O ") ;
              break ;
        case PION_NOIR :
            printf("| X ") ;
             break ;
        case DAME_NOIR :
             printf("| [X] ") ;
             break ;
        case DAME_BLANC :
             printf("| [O] ") ;
              break ;
        default :
            printf("| ") ;
            break ;
 
       }
}
 
printf("| %2d\n",i+1) ;
printf(" |--------------------------------------------------|\n") ; }/* Fonction qui affiche le damier en totalité
*/
void affiche_damier(int damier[10][10]) {
    int i ;
printf(" a     b     c    d     e    f    g    h     i     j \n") ;
printf(" |--------------------------------------------------|\n") ;
for(i=0;i<10 ;i++)
    affiche_ligne(i,damier) ;
printf(" a     b     c    d     e    f    g    h     i     j \n") ; }
 
void init_damier(damier* jeu) {
     jeu->nb_blanc = 20 ;
     jeu->nb_noir = 20 ;
     int i,j ;
//On initialise le tableau
 for(i=0;i<10 ;i++)
    for(j=0 ;j<10;j++)
       jeu->plateau[i][j] = 0 ;
//On remplie la partie haute du damier par des pions noirs
for(i=0;i<4 ;i++) {
//Si i est pair, la première case doit être noir (active)
if(i%2 == 0) j=1 ;
 else j=0 ;
 
for(j ;j<10 ;j+=2)
jeu->plateau[i][j] = PION_NOIR ;
}//On remplie la partie basse du damier par des pions blancs
for(i=6;i<10 ;i++) {
}}
//Si i est pair, la premier case doit être noir (active)
if(i%2 == 0) j=1 ;
 else j=0 ;
for(j ;j<10 ;j+=2)
    jeu->plateau[i][j] = PION_BLANC;

Voici ma fonction pour le damier et les différentes structures.

22/05/2014, 03h15
foetus
C'est difficile de dire quelque chose :?
En effet cela va dépendre du code de la logique du jeu et de comment tu vas recevoir tes événements: ta classe Case peut être utile mais dans le code posté rien ne l'utilise

Si 2-3 petites choses, qui je pense que tu vas faire lors de l'avancement du jeu
- Ne pas poster le code en double et utiliser la balise code signalée par le croisillon # ;)
- Tes passages de paramètres int damier[10][10] ne fonctionne parce que tu codes dans 1 seul fichier. Si tu as plusieurs fichiers .c et .h, il faut passer un pointeur et 1 ou 2 tailles int* damier , int nb_lines, int nb_columns
- Justement peut-être faire une structure Plateau/ Board pour réduire les passages de paramètres
- Peut-être utiliser la méthode memset pour initialiser le plateau pour éviter une double boucle
- Au lieu de faire 3 boucles d'initialisation en faire qu'une seule

creer un jeu

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
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
 
 
int main(int argc, char *argv[])
{
  int plateau[9][9]; 
  int taille1, taille2; 
  int blanc, noir ;
  int ligne, colonne; 
 
  char case_blanche;
 
  case_blanche = 219; // Code ASCII d'une case blanche
 
  taille1 = 9;
  taille2 = 9;
 
  blanc = 1;
  noir = 0;
 
 
  for (ligne = 0 ; ligne<taille1-1 ; ligne++)
  {
       for (colonne = 0 ; colonne<taille2-1 ; colonne++)
       {
            plateau[ligne][colonne]=(ligne+colonne) %2;
       }
  }
 
 
  for (ligne = 0 ; ligne<taille1-1 ; ligne++)
  {
       for (colonne = 0 ; colonne<taille2-1 ; colonne++)
       {
            if (plateau[ligne][colonne]==0)
            {
            printf(" ");
 
            }
            else
            {
            printf("%c", case_blanche);   
            } 
       }
       printf("\n");
  }
 
  system("PAUSE"); 
  return 0;          
}

bonjour foetus ,je viens de finir juste mondamier je sais pas comment agrandir les cases et je saia pas comment ajouter les pions sur les 4 cotes

creer un jeu

j'ai besoin d'aide svp
j'ai reussi a faire ma grille ensuite a placer mes pions
la je dois créer une fonction qui compte le nombre de pions que j'ai en vertical en horizontal et en diagonal
j'ai reussi a faire les deux premiere mais j'arrive pas a faire celle en diagonale car il faut en faire deux la premiere et ensuite la seconde mais j'ai un peu de mal et pour les déplacements si possible mais un coup de main serait le bienvenu pour les deux diagonales svp :calim2:
je vous envoir ce que j'ai deja codé

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include "colour.h"
#define O 1
#define X 1
 
 void initialisation () ;
 char matricePion[8][8];
 int pionsHorizontaux(int lines);
 int pionsVerticaux(int colons);
 
 
int main()
{
  int plateau[8][8];
 
  int taille1, taille2;
 
  int blanc, noir ;
 
  int y, x ;
 
  char case_blanche;
 
  //case_blanche = '219'; // Code ASCII d'une case blanche
 
  taille1 = 8;
  taille2 = 8;
 
  blanc = 1;
  noir = 0;
 
 
 
 
  for (y = 0 ; y < taille1 ; y++)
  {
       for (x = 0 ; x < taille2 ; x++)
       {
            plateau[x][y]=( x + y ) %2;
       }
  }
 
 
  for (y = 0 ; y < taille1 ; y++)
  {
       for (x = 0 ; x  <taille2 ; x++)
       {
            if (plateau[y][x] == 0)
            {
				backColour(CYAN);
 
				printf("   ");
 
            }
            else
            {
				backColour(MAGENTA);
 
				printf("   ");
 
				//printf("%c", case_blanche);
            }
       }
	   printf("\n");
  }
 
 initialisation() ;
 pionsVerticaux(0);
 //matricePion[8][8];
 
 backColour(BLACK);
 
 foreColour(WHITE);
 
  system("PAUSE");
 
  return 0;
}
 
 
 
void initialisation () {
 
	int x;
	int y;
 
	for (y=0; y < 8; y ++ ) {
		for ( x = 0; x<8; x ++) {
			posXY ( x*3+1 , y);
 
			if((y == 0 || y == 7) && x>0 && x<7){
 
				printf ("X");
				matricePion[x][y]= 'X';
			}else if((x == 0 || x == 7) && y>0 && y<7){
				printf ("O");
				matricePion[x][y] = 'O';
			}else{
				matricePion[x][y] = 0;
			}
			printf ("\n");
			foreColour (BLACK);
 
		}
 
	}
	foreColour (WHITE);
 
}
 
 
 
 
int pionsVerticaux(int colons){
 
	int result = 0;
	int x;
 
	for ( x = 0; x<8 ; x ++){
 
		if ( matricePion[x][colons] != 0) {
		//if (matricePion[colons][x] == "X" || matricePion[colons][x] == "O")
 
			result ++;
 
		}
 
	}
 
	printf ("nombre de pions verticaux = %d", result);
	return result;
 
}
 
int pionsHorizontaux(int lines){
 
	int result = 0;
	int y;
 
	for (y=0; y < 8; y ++) {
 
		if (matricePion[lines][y] != 0) {
 
			result ++;
 
		}
	}
	return result;
}

j'ai besoin d'aide svp:calim2::calim2::calim2::calim2:

06/06/2014, 05h17
foetus
Pour les déplacements diagonaux ce n'est pas compliqué (de moins il me semble) :weird: :weird:
1. Déplacement horizontal: X [+ ou -] 1
2. Déplacement vertical: X [+ ou -] 1
3. Déplacement diagonal vers le bas-droite: X+1 Y+1
4. Déplacement diagonal vers le haut-droite: X+1 Y-1
5. Déplacement diagonal vers le bas-gauche: X-1 Y+1
6. Déplacement diagonal vers le haut-gauche: X-1 Y-1

creer un jeu

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
int diagonaleGauche(int y ,int x){
    int i = 0, result = 0, nbrePions = 0;
 
    if(y>x){
        result = x;
    }else{
        result = y;
    }
 
    for(i = 0; i <= TAILLE_PLATEAU-result; i++){
        if( (matricePion[y-result+i][x-result+i] == 'X') || (matricePion[y-result+i][x-result+i] == 'O') ){
            nbrePions++;
        }
    }
 
    printf("Le nombre de pions dans la diagonale gauche de la case situe en (%d,%d) : %d\n", y, x, nbrePions);
 
    return nbrePions;
}
 
int diagonaleDroite(int y ,int x){
    int i = 0, result = 0, nbrePions = 0;
 
    if(y>x){
        result = x;
    }else{
        result = y;
    }
 
    for(i = 0; i <= TAILLE_PLATEAU-result; i++){
        if( (matricePion[y-result+i][x+result-i] == 'X') || (matricePion[y-result+i][x+result-i] == 'O') ){
            nbrePions++;
        }
    }
 
    printf("Le nombre de pions dans la diagonale droite de la case situe en (%d,%d) : %d\n", y, x, nbrePions);
 
    return nbrePions;
}

j'ai essayé de le faire comme ceci mais j'ai un petit problème pour la diagonale de droite elle ne fonctionne pas
merci fœtus pour ta reponse