Encontrar celdas dentro del rango en una cuadrícula hexagonal

Primero: sé que estoy siendo súper denso aquí.

Con eso fuera del camino, estoy tratando de escribir una implementación en C # de este algoritmo:

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

He tomado esto de este tremendo recurso.

Mi problema es que cada implementación de esto que he probado hasta ahora ha tenido resultados locos. Por ejemplo, el código que se muestra a continuación actualmente da como resultado esto:

y esto:

Mi código actualmente se encuentra así:

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);
        }
    }

¿Alguien puede ver algo mal aquí? Todas las sugerencias son bienvenidas. He estado golpeándome la cabeza con esto hace un tiempo.

¡Gracias!

Nota actualizada: estoy usando coordenadas axiales en la cuadrícula. Actualización n. ° 2: como se señala a continuación, tenía mal mi ciclo ... cada uno y no estaba usando deltas para hacer ejercicio. ¡Gracias por la ayuda!

Actualmente tengo un problema como se muestra a continuación con la implementación de las respuestas:

Seguiré investigando; si lo descubro, publicaré los resultados completos aquí. ¡Gracias a todos!

Entonces, después de una inspección más profunda, su problema no tiene nada que ver con las conversiones del sistema de coordenadas. Esto podría haber quedado más claro al no nombrar sus coordenadas axiales X e Y, sino más bien Q y R. El problema que realmente tiene es malas condiciones de bucle. El ejemplo de código original produce delta q's y r's que intenta convertir, en sus bucles for, a coordenadas absolutas y cometió un error. El algoritmo debería verse como sigue:

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);
    }
}

Como señaló Vector57 , el problema es que está utilizando un sistema de coordenadas incorrecto . El algoritmo descrito está destinado a usarse con coordenadas de cubo , que tienen componentes x, y y z :

Esto puede no ser obvio por el pseudocódigo del algoritmo, pero eso es porque es una simplificación de esto :

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

... un bucle anidado simple sobre x, y y z, lo que esperarías de un algoritmo de rango.

No sé qué sistema de coordenadas está utilizando, pero supongo que es uno de los sistemas de "coordenadas de desplazamiento", que son populares porque son fáciles de implementar colocando las celdas de la cuadrícula dentro de una matriz 2D:

Esto no significa que no pueda usar estos algoritmos de cubo; solo significa que necesitas convertir las coordenadas del cubo a las tuyas . Por ejemplo, para convertir a / desde el diseño vertical "impar-q", use estos:

# 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