Encontrar células dentro do alcance na grade hexagonal

Primeiro - eu sei que estou sendo superdensa aqui.

Com isso fora do caminho, estou tentando escrever uma implementação em C # deste 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)))

Eu tirei isso deste tremendo recurso.

Meu problema é que todas as implementações que tentei até agora tiveram resultados loucos. Por exemplo, o código mostrado abaixo atualmente resulta nisso:

e isto:

Meu código atualmente fica assim:

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

Alguém pode encontrar algo errado aqui? Todas as sugestões são bem-vindas. Eu tenho batido minha cabeça nisso há um tempo agora.

Obrigado!

Nota atualizada: estou usando coordenadas axiais na grade. Atualização # 2: como indicado abaixo, eu tive meu loop for..each errado e não estava usando deltas para o trabalho. Obrigado pela ajuda!

Atualmente, tenho um problema, como mostrado abaixo, com a implementação das respostas:

Vou continuar investigando - se eu descobrir, postarei os resultados completos aqui. Obrigado a todos!

Portanto, após uma inspeção mais aprofundada, seu problema não tem nada a ver com conversões do sistema de coordenadas. Isso poderia ter ficado mais claro se você não nomeasse as coordenadas axiais X e Y, mas sim com Q e R. O problema que você está enfrentando são as más condições de loop. O exemplo de código original produz delta qs e rs que você tenta converter, em seus loops for, em coordenadas absolutas e cometeu um erro. O algoritmo deve ter a seguinte aparência:

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 Vector57 observou, o problema é que você está usando o sistema de coordenadas errado . O algoritmo descrito deve ser usado com coordenadas de cubo , que possuem componentes x, ye z :

Isso pode não ser óbvio no pseudocódigo do algoritmo, mas é porque é uma simplificação disso :

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

... um loop aninhado simples sobre x, ye z, o que você esperaria de um algoritmo de intervalo.

Não sei qual sistema de coordenadas você está usando, mas acho que é um dos sistemas de "coordenadas de deslocamento", que são populares porque são fáceis de implementar, colocando as células da grade dentro de uma matriz 2D:

Isso não significa que você não pode usar esses algoritmos de cubo; significa apenas que você precisa converter as coordenadas do cubo para as suas . Por exemplo, para converter de / para o layout vertical "ímpar-q", use estes:

# 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