Finden von Zellen in Reichweite auf einem hexagonalen Gitter

Zuerst einmal - ich weiß, dass ich hier sehr dicht bin.

Damit versuche ich, eine C # -Implementierung dieses Algorithmus zu schreiben:

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

Ich habe dies aus dieser enormen Ressource genommen.

Mein Problem ist, dass jede Implementierung, die ich bisher ausprobiert habe, verrückte Ergebnisse erzielt hat. Der unten gezeigte Code führt derzeit beispielsweise dazu:

und das:

Mein Code sieht derzeit so aus:

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

Kann hier jemand etwas Falsches erkennen? Alle Vorschläge sind willkommen. Ich habe jetzt schon eine Weile meinen Kopf darauf geschlagen.

Vielen Dank!

Aktualisierter Hinweis: Ich verwende Axialkoordinaten im Raster. Update Nr. 2: Wie unten erwähnt, hatte ich meine for..each-Schleife falsch und verwendete keine Deltas für das Training. Danke für die Hilfe!

Ich habe derzeit ein Problem wie unten gezeigt mit der Implementierung aus den Antworten:

Ich werde weiter nachforschen - wenn ich es herausfinde, werde ich die vollständigen Ergebnisse hier veröffentlichen. Vielen Dank an alle!

Bei näherer Betrachtung hat Ihr Problem also nichts mit Koordinatensystemkonvertierungen zu tun. Dies hätte deutlicher gemacht werden können, indem Sie nicht Ihre Axialkoordinaten X und Y, sondern Q und R benannt haben. Das Problem, das Sie tatsächlich haben, sind schlechte Schleifenbedingungen. Das ursprüngliche Codebeispiel erzeugt Delta-Qs und -Rs, die Sie in Ihren for-Schleifen in absolute Koordinaten konvertieren möchten, und Sie haben einen Fehler gemacht. Der Algorithmus sollte stattdessen wie folgt aussehen:

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

Wie Vector57 feststellte, besteht das Problem darin, dass Sie das falsche Koordinatensystem verwenden . Der beschriebene Algorithmus soll mit Würfelkoordinaten verwendet werden , die x-, y- und z-Komponenten haben :

Dies kann nicht aus dem Algorithmus des Pseudo - Code offensichtlich sein, aber das ist , weil es sich um eine Vereinfachung der ist dies :

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

... eine einfache verschachtelte Schleife über x, y und z, was Sie von einem Bereichsalgorithmus erwarten würden.

Ich weiß nicht, welches Koordinatensystem Sie verwenden, aber ich vermute, es ist eines der "Versatzkoordinatensysteme", die beliebt sind, weil sie einfach zu implementieren sind, indem die Gitterzellen in einem 2D-Array platziert werden:

Dies bedeutet nicht, dass Sie diese Cube-Algorithmen nicht verwenden können. es bedeutet nur, dass Sie müssen von den Würfelkoordinaten in Ihre eigenen konvertieren . Verwenden Sie beispielsweise Folgendes, um in das vertikale Layout "odd-q" zu konvertieren:

# 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