メモリ内の六角形/六角形グリッドを表すにはどうすればよいですか？
カタンの開拓者 のような、六角形のグリッドでボードゲームを構築しているとしましょう
各頂点とEdgeには属性（上記の道路と集落）がある場合があることに注意してください。
このボードを表すデータ構造をどのように作成しますか？各タイルの隣接、エッジ、頂点にアクセスするためのパターンは何ですか？
Amit Patelがこのトピックに関するamazingページを投稿しました。それは非常に包括的で素晴らしいので、この質問に対する決定的な答えである必要があります： Hexagonal Grids
このようなグリッドは、2次元配列で表すことができます。
もし
2
7 3
1
6 4
5
は、16進グリッドに隣接する1番目であり、次のように2D配列に入れることができます。
2 3
7 1 4
6 5
明らかに、このグリッドの隣接性は、水平または垂直に隣接しているだけでなく、1つの対角線を使用して決定されます。
ただし、必要に応じてグラフも使用できます。
この記事 Isomeric/Hexagonalグリッドゲームのセットアップ方法を説明します。 Forcing Isometric and Hexagonal Maps onto a Rectangular GridセクションとMovementセクションをご覧になることをお勧めします。あなたが探しているものとは異なりますが、あなたが望むことをする方法を策定するのに役立つかもしれません。
私はヘクスをたくさん扱いました。このような場合、ヘクスの境界線の6ポイントのそれぞれを追跡します。これにより、非常に簡単に描画できます。
ヘックスを表すオブジェクトの単一の配列があります。これらの16進数オブジェクトのそれぞれには、「サイド」の別の配列を指す6つの「ポインター」（または別の配列へのインデックス）もあります。 「頂点」についても同じです。もちろん、頂点には隣接するヘクスへの3つのポインターがあり、側面には2があります。
そのため、ヘックスはX、Y、Point（6）、Vertices（6）、Sides（6）のようなものです。
次に、16進配列、頂点配列、およびサイド配列があります。
その後、ヘクスの頂点/側面、またはその他を見つけるのは非常に簡単です。
ポインタと言うと、頂点やサイド配列などの要素を指す整数になります。そしてもちろん、配列はリストなど何でも構いません。
クラスプロジェクトにSetaners of Catan AIを実装し、 this answer（これはバグがありました）のコードを修正して、頂点とエッジへの一定時間のランダムアクセスを持つボードを作成しました。それは楽しい問題でしたが、ボードには多くの時間がかかりましたので、ここで簡単な実装を探している人がいる場合はPythonコード：
class Board:
# Layout is just a double list of Tiles, some will be None
def __init__(self, layout=None):
self.numRows = len(layout)
self.numCols = len(layout[0])
self.hexagons = [[None for x in xrange(self.numCols)] for x in xrange(self.numRows)]
self.edges = [[None for x in xrange(self.numCols*2+2)] for x in xrange(self.numRows*2+2)]
self.vertices = [[None for x in xrange(self.numCols*2+2)] for x in xrange(self.numRows*2+2)]
for row in self.hexagons:
for hexagon in row:
if hexagon == None: continue
edgeLocations = self.getEdgeLocations(hexagon)
vertexLocations = self.getVertexLocations(hexagon)
for xLoc,yLoc in edgeLocations:
if self.edges[xLoc][yLoc] == None:
self.edges[xLoc][yLoc] = Edge(xLoc,yLoc)
for xLoc,yLoc in vertexLocations:
if self.vertices[xLoc][yLoc] == None:
self.vertices[xLoc][yLoc] = Vertex(xLoc,yLoc)
def getNeighborHexes(self, hex):
neighbors = []
x = hex.X
y = hex.Y
offset = 1
if x % 2 != 0:
offset = -1
if (y+1) < len(self.hexagons[x]):
hexOne = self.hexagons[x][y+1]
if hexOne != None: neighbors.append(hexOne)
if y > 0:
hexTwo = self.hexagons[x][y-1]
if hexTwo != None: neighbors.append(hexTwo)
if (x+1) < len(self.hexagons):
hexThree = self.hexagons[x+1][y]
if hexThree != None: neighbors.append(hexThree)
if x > 0:
hexFour = self.hexagons[x-1][y]
if hexFour != None: neighbors.append(hexFour)
if (y+offset) >= 0 and (y+offset) < len(self.hexagons[x]):
if (x+1) < len(self.hexagons):
hexFive = self.hexagons[x+1][y+offset]
if hexFive != None: neighbors.append(hexFive)
if x > 0:
hexSix = self.hexagons[x-1][y+offset]
if hexSix != None: neighbors.append(hexSix)
return neighbors
def getNeighborVertices(self, vertex):
neighbors = []
x = vertex.X
y = vertex.Y
offset = -1
if x % 2 == y % 2: offset = 1
# Logic from thinking that this is saying getEdgesOfVertex
# and then for each Edge getVertexEnds, taking out the three that are ==vertex
if (y+1) < len(self.vertices[0]):
vertexOne = self.vertices[x][y+1]
if vertexOne != None: neighbors.append(vertexOne)
if y > 0:
vertexTwo = self.vertices[x][y-1]
if vertexTwo != None: neighbors.append(vertexTwo)
if (x+offset) >= 0 and (x+offset) < len(self.vertices):
vertexThree = self.vertices[x+offset][y]
if vertexThree != None: neighbors.append(vertexThree)
return neighbors
# used to initially create vertices
def getVertexLocations(self, hex):
vertexLocations = []
x = hex.X
y = hex.Y
offset = x % 2
offset = 0-offset
vertexLocations.append((x, 2*y+offset))
vertexLocations.append((x, 2*y+1+offset))
vertexLocations.append((x, 2*y+2+offset))
vertexLocations.append((x+1, 2*y+offset))
vertexLocations.append((x+1, 2*y+1+offset))
vertexLocations.append((x+1, 2*y+2+offset))
return vertexLocations
# used to initially create edges
def getEdgeLocations(self, hex):
edgeLocations = []
x = hex.X
y = hex.Y
offset = x % 2
offset = 0-offset
edgeLocations.append((2*x,2*y+offset))
edgeLocations.append((2*x,2*y+1+offset))
edgeLocations.append((2*x+1,2*y+offset))
edgeLocations.append((2*x+1,2*y+2+offset))
edgeLocations.append((2*x+2,2*y+offset))
edgeLocations.append((2*x+2,2*y+1+offset))
return edgeLocations
def getVertices(self, hex):
hexVertices = []
x = hex.X
y = hex.Y
offset = x % 2
offset = 0-offset
hexVertices.append(self.vertices[x][2*y+offset]) # top vertex
hexVertices.append(self.vertices[x][2*y+1+offset]) # left top vertex
hexVertices.append(self.vertices[x][2*y+2+offset]) # left bottom vertex
hexVertices.append(self.vertices[x+1][2*y+offset]) # right top vertex
hexVertices.append(self.vertices[x+1][2*y+1+offset]) # right bottom vertex
hexVertices.append(self.vertices[x+1][2*y+2+offset]) # bottom vertex
return hexVertices
def getEdges(self, hex):
hexEdges = []
x = hex.X
y = hex.Y
offset = x % 2
offset = 0-offset
hexEdges.append(self.edges[2*x][2*y+offset])
hexEdges.append(self.edges[2*x][2*y+1+offset])
hexEdges.append(self.edges[2*x+1][2*y+offset])
hexEdges.append(self.edges[2*x+1][2*y+2+offset])
hexEdges.append(self.edges[2*x+2][2*y+offset])
hexEdges.append(self.edges[2*x+2][2*y+1+offset])
return hexEdges
# returns (start, end) Tuple
def getVertexEnds(self, Edge):
x = Edge.X
y = Edge.Y
vertexOne = self.vertices[(x-1)/2][y]
vertexTwo = self.vertices[(x+1)/2][y]
if x%2 == 0:
vertexOne = self.vertices[x/2][y]
vertexTwo = self.vertices[x/2][y+1]
return (vertexOne, vertexTwo)
def getEdgesOfVertex(self, vertex):
vertexEdges = []
x = vertex.X
y = vertex.Y
offset = -1
if x % 2 == y % 2: offset = 1
edgeOne = self.edges[x*2][y-1]
edgeTwo = self.edges[x*2][y]
edgeThree = self.edges[x*2+offset][y]
if edgeOne != None: vertexEdges.append(edgeOne)
if edgeTwo != None: vertexEdges.append(edgeTwo)
if edgeThree != None: vertexEdges.append(edgeThree)
return vertexEdges
def getHexes(self, vertex):
vertexHexes = []
x = vertex.X
y = vertex.Y
xOffset = x % 2
yOffset = y % 2
if x < len(self.hexagons) and y/2 < len(self.hexagons[x]):
hexOne = self.hexagons[x][y/2]
if hexOne != None: vertexHexes.append(hexOne)
weirdX = x
if (xOffset+yOffset) == 1: weirdX = x-1
weirdY = y/2
if yOffset == 1: weirdY += 1
else: weirdY -= 1
if weirdX >= 0 and weirdX < len(self.hexagons) and weirdY >= 0 and weirdY < len(self.hexagons):
hexTwo = self.hexagons[weirdX][weirdY]
if hexTwo != None: vertexHexes.append(hexTwo)
if x > 0 and x < len(self.hexagons) and y/2 < len(self.hexagons[x]):
hexThree = self.hexagons[x-1][y/2]
if hexThree != None: vertexHexes.append(hexThree)
return vertexHexes
私はここに座って、「楽しみのために自由時間でコーディングします」とヘックスで話します。そして、それはこのようになります...私はそれが言葉でどのように見えるかを教えます。
- 六角形：隣接する六角形が6つあります。隣接する各16進タイルの参照を提供できます。それが何で構成されているか（水、岩、ほこり）を知ることができます。それは他の人と自分自身を接続することができます。彼を取り巻く他の人を自動的に接続して、より大きなフィールドを作成したり、すべてのフィールドを隣人がアドレスできるようにすることもできます。
- 建物は、最大3つの道路と3つの六角タイルを参照します。彼らはあなたが彼らがどれであるかをあなたに伝えることができます。
- 道路は、隣接するタイルでアドレス指定されている2つのヘクスと他の道路を参照します。彼らはどのタイルで、どの道路や建物に接続しているかを知ることができます。
これは、私がどのように取り組むかというアイデアです。
2
7 3
1
6 4
5
マップの行を「フラット」にすることもできます。この例では、次のようになります。
2
7 1 3
6 5 4
1つの行に行を置くと便利な場合があります：P
次のようなものを提案します（Delphiスタイルの宣言を使用します）。
type
THexEdge = record
Hexes: array[1..2] of Integer; // Index of adjoining hexes.
// Other Edge stuff goes here.
end;
THexVertex = record
Hexes: array[1..3] of Integer; // Index of adjoining hexes.
// Other vertex stuff goes here.
end;
THex = record
Edges: array[1..6] of Integer; // Index of Edge.
Vertices: array[1..6] of Integer; // Index of vertex.
// Other hex stuff goes here.
end;
var
Edges: array of THexEdge;
Vertices: array of THexVertex;
HexMap: array of THex;
各ヘクスには6つのエッジと6つの頂点があります。各エッジは隣接する2つのヘクスを追跡し、各頂点は隣接する3つのヘックスを追跡します（マップのエッジのヘックスは特別な場合です）。
もちろん、別の方法でできることはたくさんあります。配列ではなくポインタを使用したり、レコードではなくオブジェクトを使用したり、他の回答者が示唆したようにヘックスを2次元配列に保存したりできます。
うまくいけば、それはあなたにそれにアプローチする1つの方法についていくつかのアイデアを与えるかもしれません。