Discussion :

[Oberown]

Dans les jeux de type wargame souvent les cases sont de forme hexagonale (6 côtés).
Quand on créé un plateau style damier, ou échiquier les cases sont des carrés, et on utilise un tableau deux dimensions.

Comment fait-on pour faire un plateau héxagonal en code ?

Sachant qu'il existe six directions devant, derriere, devant droite, devant gauche, arriere droit, arriere gauche.

Quand on fait un damier, c'est tres simple de se déplacer.
Comment bien modéliser et faire des déplacement dans une carte à hexagone ?

Exemple :

[alveric]

Pour numéroter les cases, c'est pas dur: (Ah làlà... Un papier, un crayon, et c'est fait en 30 secondes... Par contre, en ASCII Art, je promets rien :p )

Code :

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

1
2
3
4
5
6
7
8
9
10
  __      __
 /  \    /  \
/ x0 \__/ x2 \__/
\ y0 /  \ y0 /  \
 \__/ x1 \__/ x3
 /  \ y0 /  \ y0
/ x0 \__/ x2 \__/
\ y1 /  \ y1 /  \
 \__/ x1 \__/ x3
 /  \ y1 /  \ y1

Du coup:
1) c'est magique, deux coordonnées x ety permettent de se repérer sur un plan. Donc une matrice et roujez jeunesse...
2) Si tu étudies les déplacements dans les 6 directions, tu trouveras vite qu'il suffit d'incrémenter/décrémenter x et/ou y à chaque fois... Genre bas-droit: x+1,y+1.

Par exemple (idée en l'air et en direct live, je ne garantis rien), tu modélise ton terrain par une matrice, dont l'élément M[x][y] sera une structure (ou un objet, suivant le langage...) qui contient le type de terrain, les unités présentes, et autres joyeusetés (genre un booléen pour dire si la case fait partie de la carte, histoire de faire des frontières un peu plus torturées qu'un rectangle).

Par contre, pour l'affichage, je n'ai pas d'idée dans mon chapeau magique pour l'instant...

[tlse]

Moi j'aurais tendance à me le représenter comme ça dans un tableau à deux dimensions:




Du coups tu peux le voir comme des carrés, il faut juste ajouter 2 déplacements en diagonale

[Oberown]

2) Si tu étudies les déplacements dans les 6 directions, tu trouveras vite qu'il suffit d'incrémenter/décrémenter x et/ou y à chaque fois... Genre bas-droit: x+1,y+1.

Et non ca ne marche pas tout le temps

Regarde si tu fais un bas droite entre (2, 0) et (3,0) ca fait du x+1, y+0
Mais ca marche bien avec (1,0) et (2,1) et là ca fait bien du x+1,y+1

Il y a un piège entre les x pair et impaires car il ne commencent pas au même endroit. Donc il faut faire un mod.
Si on veut descendre (gauche, tout droite, droite) à partir d'un X pair, il faut pas incrémenter y. Mais si on est sur un X impaire il faut l'incrémenter.
Etc...

[Dr DLP]

C'est facile à faire mais très difficile à intégrer -du moins pour moi-.
Pour faciliter les choses, il faut:

• Un référentiel fixe, le centre du graphique, défini par ses coordonnées x,y (0,0 est en bas à gauche, inutile de se compliquer la vie avec des entiers négatifs)
• Des référentiels changeants, le centre de tes figures

Donc étape 1, calculer ça (il suffit de définir un espacement entre chaque figure, et de remplir ligne par ligne: je l'ai fait en PHP: les lignes impaires d'abord, puis les lignes paires espacées de 1/2 taille de la figure).

Ensuite dessiner la figure à partir de son centre: il suffit de repérer sa position dans le quadrant dessiné à partir du centre de la figure pour la tracer

[alveric]

2) Si tu étudies les déplacements dans les 6 directions, tu trouveras vite qu'il suffit d'incrémenter/décrémenter x et/ou y à chaque fois... Genre bas-droit: x+1,y+1.

Et non ca ne marche pas tout le temps

Comme qui dirait, chuis allé trop vite dans mes conclusions
Mais bon l'algo complet de déplacement n'est pas trop complexe...

[Mac LAK]

J'aurais plutôt tendance à utiliser un système angulaire pour ça, en découpant le cercle trigo en 6 zones correspondant à un hexagone régulier. Bien entendu, ça demande à avoir un damier à peu près circulaire, et ayant comme origine une case donnée.

De cette manière, et éventuellement en utilisant la partie entière des coordonnées trigonométriques, on obtient un couple d'entiers "angulaires". Ces entiers sont bien entendu dans Z.
Après tout, qui a dit que, d'un point de vue mathématique, les damiers hexagonaux devaient avoir les cases qui se touchent ? :-)

Pour le déplacement d'une case, rien de plus simple : c'est une translation d'origine la case source, de longueur "1" (l'unité étant la distance suivant ce référentiel entre deux cases contigües), et de direction au choix parmi les 6 prises comme base de construction.

Pour finir, il faut rendre ces coordonnée positives, et non-ambigües : ce n'est pas franchement difficile à faire, une fonction affine suffit la plupart du temps pour faire ça.

Et comme tout ce qui se résume à une liste de deux entiers positifs peut être stockée sous forme d'un tableau à deux dimensions.... :-)

[Guigui_]

Si tu utilises Delphi, y'a un composant ici (THexGrid) (que je n'ai jamais utilisé mais ca m'intéresse de faire des plateaux hexagonales)
http://www.silicmdr.com/Freeware.htm
et lire le fichier HexGrid.pas pour comprendre comment ca marche.

[2Eurocents]

La solution qui me parait la plus simple (je l'ai utilisé il y a une douzaine d'année, du temps d'un 486 SX 25, donc je cherchais quelque chose de rapide), c'est un tableau à 2 dimensions, X et Y (une matrice, quoi).

D'un point de vue de la représentation (visuelle), il suffit de considérer les colonnes paires, à leur place, et les colonnes impaires décalées d'une demi-ligne (allez, je me lance dans l'ascii-art, moi aussi :

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
 
+----+    +----+    +----+
|    |    |    |    |    |
|    +----+    +----+    +--
|    |    |    |    |    |
+----+    +----+    +----+
|    |    |    |    |    |
|    +----+    +----+    +--
|    |    |    |    |    |
+----+    +----+    +----+
|    |    |    |    |    |
|    +----+    +----+    +--
|    |    |    |    |    |
+----+    +----+    +----+
|    |    |    |    |    |
|    +----+    +----+    +--
|    |    |    |    |    |

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

La différence entre lignes paires et impaires est très très très facile à coder (en C notamment) (mais je ne vais quand même pas tout livrer d'un coup !


Le gros avantage de cette méthode, c'est dans le calcul des distances :
En prenant la formule classique de distance entière :
Arrondi_sup ( racine ( (dx * dx) + (dy * dy) ) )
on obtient exactement le nombre de case à traverser (points de mouvement ), par le chemin le plus court pour aller d'une case
à l'autre ...

Moi, je m'en était servi pour des calculs de potentiels et de diffusion dans un milieu scientifique, mais ça marche aussi très bien en milieu plus ludique