Recherche de cellules à portée sur une grille hexagonale

Tout d'abord - je sais que je suis super dense ici.

Avec cela à l'écart, j'essaie d'écrire une implémentation C # de cet algorithme:

var results = []
for each -N ≤ dx ≤ N:
  for each max(-N, -dx-N) ≤ dy ≤ min(N, -dx+N):
    var dz = -dx-dy
    results.append(cube_add(center, Cube(dx, dy, dz)))

J'ai tiré cela de cette formidable ressource.

Mon problème est que chaque implémentation de ce que j'ai essayé jusqu'à présent a eu des résultats fous. Par exemple, le code ci-dessous donne actuellement ceci:

et ça:

Mon code se trouve actuellement comme ceci:

for (int x = this.CellPositionX - distance; x <= this.CellPositionX + distance; x++)
    {
        for (int y = this.CellPositionY - Math.Max(-distance, -x - distance); y <= this.CellPositionY + Math.Min(distance, -x + distance); y++)
        {
            HexPosition rangePosition = new HexPosition(x, y);
            range.Add(rangePosition);
        }
    }

Quelqu'un peut-il repérer quelque chose de mal ici? Toutes les suggestions sont les bienvenues. Je me tape la tête sur celui-ci depuis un moment maintenant.

Merci!

Note mise à jour: j'utilise des coordonnées axiales dans la grille. Mise à jour # 2: comme indiqué ci-dessous, ma boucle for..each était incorrecte et je n'utilisais pas de deltas pour le travail. Merci pour l'aide!

J'ai actuellement un problème comme indiqué ci-dessous avec la mise en œuvre des réponses:

Je vais continuer à enquêter - si je le comprends, je posterai les résultats complets ici. Merci a tous!

Ainsi, après une inspection plus approfondie, votre problème n'a en fait rien à voir avec les conversions du système de coordonnées. Cela aurait pu être plus clair en ne nommant pas vos coordonnées axiales X et Y mais plutôt Q et R. Le problème que vous rencontrez est en fait de mauvaises conditions de boucle. L'exemple de code d'origine produit des delta q et r que vous essayez de convertir, dans vos boucles for, en coordonnées absolues et vous avez fait une erreur. L'algorithme devrait plutôt ressembler à ceci:

for (int dx = -distance; dx <= distance; dx++)
{
    for (int dy = Math.Max(-distance, -dx - distance); dy <= Math.Min(distance, -dx + distance); dy++)
    {
        HexPosition rangePosition = new HexPosition(
            this.CellPositionX + dx, this.CellPositionY + dy);
        range.Add(rangePosition);
    }
}

Comme l'a souligné Vector57 , le problème est que vous utilisez le mauvais système de coordonnées . L'algorithme décrit est destiné à être utilisé avec des coordonnées de cube , qui ont des composantes x, y et z :

Cela peut ne pas être évident d'après le pseudocode de l'algorithme, mais c'est parce que c'est une simplification de ceci :

var results = []
for each -N ≤ dx ≤ N:
    for each -N ≤ dy ≤ N:
        for each -N ≤ dz ≤ N:
            if dx + dy + dz = 0:
                results.append(cube_add(center, Cube(dx, dy, dz)))

... une boucle simple imbriquée sur x, y et z, ce que vous attendez d'un algorithme de plage.

Je ne sais pas quel système de coordonnées vous utilisez, mais je suppose que c'est l'un des systèmes de "coordonnées décalées", qui sont populaires car ils sont faciles à mettre en œuvre en plaçant les cellules de la grille dans un tableau 2D:

Cela ne signifie pas que vous ne pouvez pas utiliser ces algorithmes de cube; cela signifie simplement que vous devez convertir les coordonnées du cube en vos propres coordonnées . Par exemple, pour effectuer une conversion vers / depuis la disposition verticale "odd-q", utilisez-les:

# convert cube to odd-q offset
col = x
row = z + (x - (x&1)) / 2

# convert odd-q offset to cube
x = col
z = row - (col - (col&1)) / 2
y = -x-z