Discussion :

[ScaRed]

Bonjour à tous,

Je suis étudiant et dans le cadre d'un projet je dois réaliser un jeu en langage C. J'ai déjà essayé de chercher comment créer une table en deux dimensions et l'initialiser à vide. De même pour incrémenter la valeur des jetons etc... (voir pièce jointe). Mais je débute dans ce langage et je n'arrive pas du tout à avancer sur ce projet et faire le rapprochement avec les cours reçus.

Si quelqu'un pourrait m'aider ?

Bonne soirée à vous

Alex.

[Sve@r]

Bonjour

J'ai déjà essayé de chercher comment créer une table en deux dimensions

int tab[x][y].

et l'initialiser à vide.

Le vide n'existe pas en informatique. Ce que tu peux faire, c'est l'initialiser à "n" en établissant la convention que "n=vide".
Et si tu vas à la simplicité en disant "dans mon cas je choisis n=0" alors ça devient plus facile: int tab[x][y]={}.

De même pour incrémenter la valeur des jetons etc...

Oh, faut faire un effort d'association aussi. for (i=0; i < (L * C - 1) / 2; i++) et à chaque "i" les joueurs posent leur jeton.
Ton cours ne t'expliquera jamais comment faire un jeu. Il t'expliquera comment faire une boucle et ce sera à toi de dire "ok, si je dois jouer 15 fois ben j'ai besoin d'une boucle"...

[ScaRed]

[QUOTE=Sve@r;11892829]

Je sais bien que je dois faire des efforts mais j'ai vraiment du mal à comprendre ce qu'on me demande, je passe des heures et je n'avance pas.

[gerald3d]

Bonjour.

Lorsqu'on a une problématique la première à chose à faire est d'extraire les variables nécessaires ainsi que leurs bornes.

En partant de ce principe nous avons :

• Un tableau à deux dimensions L et C. L et C doivent être impairs. Nous appellerons ce tableau plateau[][] ;
• Les jetons sont bornés [1, (LxC-1)/2]. Nous pouvons donc utiliser la valeur 0 pour une case vide ;
• Les jetons sont joués dans l’ordre croissant. Il nous faut une variable qui contient le tour actuellement joué borné aussi [1, (LXC-1)/2]. Nous nommerons cette variable tour ;

En reprenant les explications précédentes initialisons ces variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
/* Les valeurs de L et C sont ici arbitraires */
int L=5, C=3;
int tableau [L][C] = {}; // initialise le tableau avec toutes les valeurs à 0.
int tour = 1;

Remarque : Pour les valeurs de L et C il faudra écrire un code qui demande aux joueurs leur taille. Il faudra bien entendu s'assurer que L et C sont impairs.

Ceci fait il faut maintenant créer une boucle comprisse entre [1 et (LxC-1)/2]. À chaque itération il faudra augmenter tour de 1. La boucle s'arrêtera lorsque tour sera supérieure à (LxC-1)/2.

En sortie de la boucle on scrutera la case vide. Pour rappel son contenu est égale à 0. Une fois trouvée on prendra les valeurs qui l'encadrent pour déterminer qui a gagné.

------------------------

Maintenant que la problématique est un peu plus détaillée comment déterminer dans ce tableau qui est rouge et qui est bleu ? Plusieurs solutions sont possibles :

• Utiliser une structure qui contient la valeur du jeton et sa couleur ;
• utiliser deux tableaux, un par couleur. Ça complique un peu l'affaire mais si tu ne connais pas les structures c'est la méthode à utiliser.

Au cas où voila la structure à utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct {
int num; // numéro du jeton
int couleur; // 0 pour bleu et 1 pour rouge par exemple.
}s_jeton;

Remarque : L'utilisation de 0 et 1 pour les couleurs n'est pas anodin ici. Ça va permettre d'utiliser la vérification par FALSE et TRUE lorsqu'on déterminera qui a gagné.

[droggo]

Bonjour,

Pour les valeurs de L et C il faudra écrire un code qui demande aux joueurs leur taille. Il faudra bien entendu s'assurer que L et C sont impairs

Pourquoi impair ?
(C'est peur-être précisé dans le fichier docx donné par le demandeur, mais j'ai pour principe de ne jamais ouvrir ce genre de document)

[gerald3d]

Bonjour,

Pourquoi impair ?
(C'est peur-être précisé dans le fichier docx donné par le demandeur, mais j'ai pour principe de ne jamais ouvrir ce genre de document)

Oui c'est précisé

[ScaRed]

Toujours aussi aimable.
T’es sur le serveur pour te prouver quelque chose ou pour rabaisser les gens ?
Sans internet ton métier n’existerait pas alors bon…

[Sve@r]

Toujours aussi aimable.

Ah non, tu te trompes de personnage, lui c'est ici

T’es sur le serveur pour te prouver quelque chose ou pour rabaisser les gens ?

Sur le forum, pas le serveur. Même sur ces termes assez basiques tu te rates...?

Sans internet ton métier n’existerait pas alors bon…

Effectivement tu ne connais vraiment mais alors vraiment rien à l'informatique, qui est née (et que j'ai commencée) bien avant la création du net !!!
Toutefois cela n'ayant absolument rien à voir avec le sujet de ce topic alors bon...

[gerald3d]

Bon essayons de reprendre les bases .

Il faut absolument que tu dessines un algorithme de ton jeu. Bien sûr je ne le ferai pas pour toi mais voici, en français ce que cela peut donner :

1. Demander la taille du jeu
2. Vérifier si la taille est conforme. Si non conforme retourner à la demande.
3. Initialiser le jeu avec la taille conforme.
4. Dans une boucle :
5. Demander la position du jeton bleu.
6. Vérifier si la position est vide. Si oui placer le jeton. Dans le cas contraire reposer la question.
7. Demander la position du jeton rouge.
8. Vérifier comme pour le jeton bleu si la position est vide. Si non, reposer la question.
9. Incrémenter le tour de jeu.
10. Si le tour est supérieur au nombre de tours maximal sortir de la boucle.
11. Trouver la case vide restante.
12. À partir de cette case calculer pour chaque couleur les totaux.
13. Afficher le gagnant.

Pour t'aiguiller un peu les points 3, 6, 8, 11 et 12 peuvent mais surtout doivent être écrit sous forme de fonction.

Après ce petit point d'éclaircissement j'aimerai te parler un peu des tableaux. Quelque soit la dimension du tableau que tu déclares ton ordinateur chéri le traduira en un simple tableau à une dimension. Le C autorise une écriture plus claire avec les fameux [][][][] mais pour ma part je ne te trouve pas ça très clair. Ce n'est que mon avis bien sûr. Comme en C tu passes ton temps à manipuler des pointeurs je préfère déclarer des tableaux à une dimension. Je crée deux fonctions qui me permettent d'accéder par la suite à mes données en fonction des coordonnées transmises. Ça peut paraître un peu lourd dingue sur le moment mais pour mon pauvre cerveau fatigué ça lui paraît plus clair .

Donc, en suivant ce principe voila ce que ça donne. Si je veux par exemple un tableau à deux dimensions, je déclare un simple tableau à une dimension. Par exemple 15 pour reprendre le sujet de l'exercice :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

in tab[15];

Pour calculer les coordonnées rien de plus simple. Soit (x,y) ces coordonnées. Il suffit d'ajouter à x le multiple de la ligne fois la longueur d'une ligne. Ce qui se traduit par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

coordonnées = x + y * longueur de la ligne

À partir de là je crée mes deux fonctions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 /* retourne dans "jeton" la valeur de la case aux coordonnées (position_L, position_C) dans "tab".
 * Renvoie true si les coordonnées sont dans le champ d'application et si jeton est différent de null..
 */
int get_piece_in_tab (int *plateau, int L, int C, int position_L, int position_C, int *jeton)
{
  if (position_L > 0 &&
      position_L < L &&
      position_C > 0 &&
      position_C < L) {
    if (jeton) {
      *jeton = plateau [position_L + position_C * L];
      return 1;
    }
    return 0;
  }
 
  return 0;
}
 
/* Place la valeur "tour" à la position (position_L, position_C) dans "tab".
 * Renvoie true si les coordonnées sont valides et si la case était vide 
 */
int set_piece_in_tab (int *plateau, int L, int C, int position_L, int position_C, int tour)
{
  if (position_L > 0 &&
      position_L < L &&
      position_C > 0 &&
      position_C < position_C)
      if (plateau [position_L + position_C * L]==0) {
	plateau [position_L + position_C * L]= tour;
	return 1;
 
  return 0;
}

Houla ! Je vois tes yeux s'écarquiller. Tu es en train de t'arracher les cheveux . Pas de panique. Un peu d'explication s'impose.

Tout d'abord, comme je n'ai pas créé de structure pour contenir le tableau et ses dimensions, je suis donc forcé de tout transmettre à chaque fonction (int *tab, int L et int C). Je te laisse le soin de faire autrement si tu désires un peu mieux structurer le code . Ensuite tu remarqueras que les fonctions renvoient un int. Mais il ne correspond en rien au résultat qu'on est en droit d'attendre. Le retour de ces fonctions est du type booléen (à toi d'utiliser bool si tu veux). Si les fonctions ont correctement fonctionné alors elles renvoient vraie (1). À l'inverse elles renvoient faux (0). Une évidence .

Remarque : la fonction set_piece_in_tab (); peut en l’état répondre aux points 6 et 8 précédents. Le joueur donne une position. Tu exécutes alors la dite fonction. Son retour te dit si la case était valide et dans ce cas le coup et en même temps joué .

Pour la fonction get_piece_in_tab (); je suis contraint d'ajouter un paramètre pour récupérer la valeur de la case. C'est le rôle de int *jeton. Je transmets un pointeur (l'adresse d'une variable int). Je peux donc changer la valeur de cette variable via son adresse. Bien entendu dans la fonction je vérifie que l'adresse transmise n'est pas nulle.

-------------------------------------------

Pour finir sur ce petit sujet l'allocation dans le tas ( malloc(); ) n'est pas forcément nécessaire sauf si tu autorises l'utilisateur à rentrer une taille de tableau gigantesque. Dans ce cas tu alloues et tu désalloues. C'est la seule chose à penser. Voila deux pseudo-codes pour voir comment faire avec et sans allocation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* Sans allocation. Attention à la taille du tableau. Grosso modo ne pas dépasser 1Mo sinon risque de dépassement de la pile et segfault à l'arrivée. */
int main (int argc, char **argv)
{
  int L=5, C = 3;
  int tab [L*C];
  ...
}
 
/* Avec allocation. Ici penser à désallouer lorsque l'utilisation de la mémoire allouée n'est plus nécessaire. */
int main (int argc, char **argv)
{
  int L=5, C = 3;
  int *tab = malloc (L*C*sizeof(int));
  /* Exécution du programme */
  if (tab) {
    ...
    /* Libération de la mémoire */
    free (tab);
  }
}

Dans les deux cas, lorsque tu transmets ton tableau aux différentes fonctions, tu transmets à chaque fois l'adresse. Donc aucune différence à l'utilisation .