Plateau de jeu hexagonal.

Bonjour,

Nous sommes un groupe d'étudiants souhaitant coder en C un plateau à cases hexagonales. Nous pensons le faire en utilisant un tableau en deux dimensions normal, dont nous agencerions plus tard en mode graphique les cases afin de pouvoir y insérer des boules ayant 6 voisines.
Nous programmons en utilisant des modules, et nous avons également rencontré un problème dans notre réflexion dans le codage et la conservation des coordonnées des boules sur le terrain. Il nous faudrait pouvoir conserver en mémoires la position de chacune des boules sur le terrain à la fois au niveau de la boule et au niveau du terrain.
Pour ce faire nous pensions donner la position réelle de la boule pour ce qui est de la conservation en mémoire de la position de la boule au niveau du module boule. Et au niveau du terrain la conservation en mémoire de la position de la boule en position "terrain" pas position réelle étant donné que nous partions sur une idée générale d'utiliser un tableau 2 dimensions "normal".

Voila, en espérant avoir été assez clairs, nous avons besoin d'aide pour le codage. Pour le terrain, n'étant pas un simple tableau 2D, les fonctions et procédure changent.. Bref, nous n'arrivons simplement pas à avancer.

Nous vous remercions par avance de vos suggestions, et de votre aide.

Bonjour,

Je n'ai pas tout à fait compris ce que vous cherchez à faire, mais pourquoi ne pas donner à votre boule une Position ?
Vous remplacez alors votre tableau 2D par un tableau 2D de Position (ou pourquoi pas un tableau 1D ?)

Position pourrait alors être :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

typedef struct { Boule * m_boule; //boule se situant sur la position union { struct{ char m_x; //coordonné char m_y; //abscisse } int m_id; //identifiant de la position } m_coordonne; }Position;

---

Bonjour,

je n'ai pas bien compris non plus, l'énoncé est un peu flou. Je ne peux que recommander de bien séparer la présentation de la gestion du jeu en lui-même en utilisant un pattern MVC par exemple.

Tout d'abord merci de vos réponse,

Je vais tenter de préciser un peu "le jeu".
Pour simplifier une peu.. Nous voulons donc faire un plateau de jeu hexagonal, de cette forme ci :

http://jeuxstrategie.free.fr/jeu_int...or/plateau.jpg

Ce plateau sera rempli de boules, le but étant de les faire toutes disparaître par paquet pour gagner le jeu.

Et donc, nous avons des difficultés d'abord, pour créer ce fameux plateau de jeu. Notre première idée étant de créer un tableau en 2D, mais décalant d'une demi case verticalement toutes les colonnes impaires de cette façon :

Citation:

---

Envoyé par 2Eurocents

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

+----+ +----+ +----+ | | | | | | | +----+ +----+ +-- | | | | | | +----+ +----+ +----+ | | | | | | | +----+ +----+ +-- | | | | | | +----+ +----+ +----+ | | | | | | | +----+ +----+ +-- | | | | | | +----+ +----+ +----+ | | | | | | | +----+ +----+ +-- | | | | | |

---

Cette façon de faire permet de trouver facilement les 6 case voisines de la case X,Y (en commençant par celle d'au dessus et en tournant dans le sens des aiguilles d'une montre) :

Cas des colonnes (X) impaires :
1) X, Y-1
2) X+1, Y
3) X+1, Y+1
4) X, Y+1
5) X-1, Y+1
6) X-1, Y

Cas des colonnes (X) paires :
1) X, Y-1
2) X+1, Y-1
3) X+1, Y
4) X, Y+1
5) X-1, Y
6) X-1, Y-1

---

Cependant, nous n'arrivons pas à le coder puisque ce n'est pas un simple tableau en 2D qui est ici pris en compte.


Notre second problème étant la gestion des boules, mais je trouve que l'idée de la position des boules est envisageable, alors merci Neckara. :)

En espérant avoir été plus claire. Merci de vos réponses !

Pour trouver les voisins facilement, il y a deux solutions :

- soit vous mettez dans chaque Position la liste des voisins.
avantage : c'est le plus rapide
inconvénient : initialisation plus longue et duplication des données.

- soit vous créez une fonction getVoisin
avantage : pas de duplication de donnée
inconvénient : plus lent

Pour getVoisin voici ce que je pourrais vous proposer :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Position * getVoisin(Position * p, Position ** tab, int nbLigne, int nbColonne, int numero) //pour pouvoir l'utiliser dans une boucle { switch(numero) { case 0: if(p.m_y + 1 < nbLigne) return tab[p.m_x][p.m_y + 1]; else return NULL; //idem avec -1 case 2 : if(p.m_x + 1 < nbColonne) return tab[p.m_x+1][p.m_y]; else return NULL; //idem avec -1 case 3 : if(p.m_x + 1 < nbColonne && p.m_y + 1 < nbLigne) // ou p.m_y - 1 selon votre tableau 2D return tab[p.m_x+1][p.m_y+1]; else return NULL; //idem avec p.m_x - 1 } }

---

Il suffit juste que votre tableau 2D ai 1/2 ligne à NULL en fin de tableau et en début de tableau.

Code:

---

1 2 3 4

| 2 |---| 5 | |----| 3 |---- | 1 |---| 4|

---

devient

Code:

---

1 2 3

2 3 5 1 NULL 4

---

ou

Code:

---

1 2 3

2 NULL 5 1 3 4

---

Bonsoir,

Après un rapide examen, il semblerait qu'il soit beaucoup plus intéressant de déplacer les lignes impaires d'une demi-case vers la droite, plutôt que les colonnes homologues vers le bas :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- Ligne 0 \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- Ligne 1 / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- Ligne 2 \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- Ligne 3 / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- Ligne 4 \ / \ / \ / \ / \ / \ / \ / \ / \ / \ /

---

Dès lors, il est effectivement possible d'assimiler ce maillage à une grille carrée ordinaire, même en avançant une ligne sur deux d'une demi-case :

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+

… et comme toutes les lignes contiennent de toutes façons le même nombre de case, et que les « décalages » ne se cumulent pas, alors tu peux l'assimiler à une grille normale, puisque tu peux toujours accéder à la même cellule en passant les mêmes coordonnées :

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+

… et de là, sur cette dernière grille, quelque soit la cellule examinée, tu peux poser deux postulats :

• Les cases gauche, droite, inférieure et supérieure sont toujours voisines ;
• Les case inférieures et supérieures gauches sont voisines dans le cas des lignes paires et les cases inférieures et supérieures droites le sont pour les lignes impaires ;

Ce qui donne :

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+

… ou :

+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+

Pour le reste, je pense que le problème vient justement du fait que vous n'avez pas clairement défini votre référentiel : « conserver les coordonnées de la boule au niveau de la boule » ne veut rien dire en soi. :-) En principe, on considère que les coordonnées sont celles de la cellule hexagonale qui contient ou non une boule.

Si, au contraire, les hexagones ne servent qu'à définir des parcelles officielles et qu'une boule (ou tout autre objet) peut se déplacer librement sur un terrain rectangulaire, fût-il partitionné en parcelles, et qu'une même boule peut occuper différentes positions à l'intérieur d'un hexagone, alors cela veut dire que votre référentiel restent les coordonnées cartésiennes sur le terrain. Il faut donc les utiliser par défaut et faire une fonction qui renvoie le numéro d'une cellule en fonction de ces coordonnées.