Individuazione di celle nel raggio d'azione sulla griglia esagonale

Prima di tutto, so di essere super denso qui.

A parte questo, sto cercando di scrivere un'implementazione C # di questo 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)))

L'ho preso da questa straordinaria risorsa.

Il mio problema è che ogni implementazione di questo che ho provato finora ha avuto risultati folli. Ad esempio, il codice mostrato di seguito attualmente risulta in questo:

e questo:

Il mio codice attualmente si trova così:

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

Qualcuno può individuare qualcosa di sbagliato qui? Tutti i suggerimenti sono benvenuti. Ci sto sbattendo la testa da un po 'ormai.

Grazie!

Nota aggiornata: sto usando le coordinate assiali nella griglia. Aggiornamento n. 2: come indicato di seguito, ho sbagliato il ciclo for..each e non ho utilizzato delta per l'allenamento. Grazie per l'aiuto!

Attualmente ho un problema come mostrato di seguito con l'implementazione dalle risposte:

Continuerò a indagare: se lo scoprirò, pubblicherò i risultati completi qui. Ringrazia tutti!

Quindi, dopo un'ulteriore ispezione, il problema in realtà non ha nulla a che fare con le conversioni del sistema di coordinate. Ciò avrebbe potuto essere più chiaro non nominando le coordinate assiali X e Y ma piuttosto Q e R. Il problema che si sta effettivamente verificando è in condizioni di loop errate. L'esempio di codice originale produce delta q e r che provi a convertire, nei tuoi per i loop, in coordinate assolute e hai fatto un errore. L'algoritmo dovrebbe invece apparire come segue:

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

Come notato da Vector57 , il problema è che stai usando un sistema di coordinate errato . L'algoritmo descritto deve essere utilizzato con le coordinate del cubo , che hanno componenti x, ye z :

Questo potrebbe non essere ovvio dallo pseudocodice dell'algoritmo, ma è perché è una semplificazione di questo :

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 semplice ciclo nidificato su x, ye z, cosa ti aspetteresti da un algoritmo di intervallo.

Non so quale sistema di coordinate stai usando, ma suppongo sia uno dei sistemi di "coordinate coordinate", che sono popolari perché sono facili da implementare posizionando le celle della griglia all'interno di un array 2D:

Questo non significa che non puoi usare questi algoritmi cubi; significa solo che devi convertire dalle coordinate del cubo alle tue . Ad esempio, per convertire in / dal layout verticale "dispari-q", utilizzare questi:

# 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