আমি কীভাবে স্মৃতিতে একটি হেক্সটাইল / হেক্স গ্রিড উপস্থাপন করব?


118

আমি একটি hextile গ্রিড সঙ্গে একটি বোর্ড খেলা নির্মাণ করছি, মত বলুন Catan এর ঔপনিবেশিকরা :

Imgur.com দ্বারা হোস্ট করা হয়েছে

নোট করুন যে প্রতিটি ভার্টেক্স এবং প্রান্তের একটি বৈশিষ্ট্য থাকতে পারে (উপরে একটি রাস্তা এবং বন্দোবস্ত)।

আমি কীভাবে একটি ডেটা কাঠামো তৈরি করব যা এই বোর্ডকে উপস্থাপন করে? প্রতিটি টাইলের প্রতিবেশী, প্রান্ত এবং শীর্ষে প্রবেশের জন্য নিদর্শনগুলি কী কী?


আপনি একটি ইলবার্ট কার্ভটিও ব্যবহার করতে পারেন, তারা ফাইলিং বক্ররেখাগুলি ফাঁকা রাখছেন যে সমতলে সংলগ্নতা একটি লিনিয়ার এনকোডিংয়ে সংরক্ষণ করা হয়। স্থানিক সূচকগুলি পরীক্ষা করে দেখুন এবং এগুলি কীভাবে ব্যবহৃত হয়! v আকর্ষণীয়
pbordeaux

উত্তর:


155

অমিত প্যাটেল এই বিষয়ে একটি আশ্চর্যজনক পৃষ্ঠা পোস্ট করেছেন । এটি এতই বিস্তৃত এবং বিস্ময়কর যে এটির এই প্রশ্নের সুনির্দিষ্ট উত্তর হওয়া দরকার: হেক্সাগোনাল গ্রিড

cubez


27
ধন্যবাদ :) এই পৃষ্ঠাটি প্রান্ত এবং প্রান্তকে কভার করে না, তবে আমি এগুলি আমার গ্রিড নিবন্ধের অংশের মধ্যে সম্পর্ক বিভাগে www-cs-students.stanford.edu/~amitp/game-pogramming/gridsআচ্ছাদন করেছি (চিত্রগুলি হ'ল স্কোয়ার গ্রিডের জন্য তবে টেবিলটিতে অ্যাক্সিয়াল হেক্স গ্রিডের সূত্রগুলিও অন্তর্ভুক্ত রয়েছে)
amitp

18

এই জাতীয় গ্রিডটি একটি দ্বি-মাত্রিক অ্যারেতে প্রতিনিধিত্ব করা যেতে পারে:

যদি

   2
7     3
   1   
6     4
   5

হেক্স গ্রিডে এর প্রতিবেশীদের সাথে এক নম্বর, তারপরে আপনি এটি 2D অ্যারেতে এভাবে রাখতে পারেন:

2 3
7 1 4
  6 5

স্পষ্টতই প্রতিবেশী-নেস এই গ্রিডে কেবল অনুভূমিক বা উল্লম্ব সংলগ্ন না হয়ে একটি তির্যক ব্যবহার করেও নির্ধারিত হয়।

আপনি যদি চান তবে, একটি গ্রাফও ব্যবহার করতে পারেন।


কুল। প্রান্ত এবং শীর্ষেগুলির জন্য ডেটা সম্পর্কে কী?
একটি প্রদত্ত শিষ্টা

1
আমি সম্ভবত এগুলি আলাদা করে রাখতাম। আপনি প্রাথমিকভাবে টাইলস বা প্রান্ত / শীর্ষে তাকান কিনা তা নির্বিশেষে তথ্যগুলির অর্ধেক অংশ যন্ত্রণাদায়ক বা অনর্থক সংরক্ষণের জন্য।
জোয়

অমিত প্যাটেলের নিবন্ধটি "একটি অর্থপ্রদানকারী" উত্তর দেখুন।
aredridel

11

এই নিবন্ধটি কীভাবে একটি ইসোমেরিক / হেক্সাগোনাল গ্রিড গেম সেট আপ করতে পারে তার মধ্য দিয়ে যায়। আমি আপনাকে Forcing Isometric and Hexagonal Maps onto a Rectangular Gridবিভাগ এবং গতিবিধি বিভাগটি একবার দেখার পরামর্শ দিচ্ছি । যদিও আপনি এটি যা চেয়েছেন তা থেকে আলাদা যদিও আপনি যা চান তা কীভাবে তৈরি করতে আপনাকে সহায়তা করতে পারে।


2

আমি হেক্সেস নিয়ে অনেক কিছু করেছি। এই জাতীয় ক্ষেত্রে, আপনি হেক্সের সীমানার জন্য 6 টি পয়েন্টের প্রত্যেকটিকে ট্র্যাক করেন। এটি আপনাকে এটিকে সহজেই আঁকতে দেয়।

আপনার কাছে একক অ্যারে অবজেক্টস রয়েছে যা হেক্সেসকে উপস্থাপন করে। এই হেক্স অবজেক্টের প্রত্যেকটিতে 6 "পয়েন্টার" (বা অন্য অ্যারেতে সূচক) থাকে "পক্ষগুলির" এর অন্য অ্যারেতে নির্দেশ করে। "শীর্ষ" হিসাবে একই জিনিস। অবশ্যই উল্লম্বগুলি সংলগ্ন হেক্সেসের 3 পয়েন্টার থাকবে এবং পক্ষগুলির 2 টি থাকবে।

সুতরাং, একটি হেক্স্স এর মতো কিছু হতে পারে: এক্স, ওয়াই, পয়েন্ট ()), ভার্টেস ()), পাশ ())

তারপরে আপনার একটি হেক্স অ্যারে, উল্লম্ব অ্যারে এবং পাশের অ্যারে রয়েছে।

তারপরে কোনও হেক্সের জন্য শীর্ষ বা দিকগুলি খুঁজে পাওয়া খুব সহজ or

আমি যখন পয়েন্টার বলি তখন এটি উল্টাস বা পাশের অ্যারে বা যে কোনও কিছুতে উপাদানটির দিকে ইশারা করা খুব সহজেই হতে পারে। এবং অবশ্যই অ্যারে তালিকা বা যা কিছু হতে পারে।


0
   2
7     3
   1   
6     4
   5

আপনি নিজের মানচিত্রের সারিগুলি 'সমতল' করার চেষ্টা করতে পারেন। উদাহরণস্বরূপ এটি হবে:

  2
7 1 3
6 5 4

এটি কখনও কখনও এক সারিতে সারি রাখার জন্য আরও দরকারী: পি


1
এটিতে কিছু অগোছালো প্রতিবেশী-চেকিং কোড থাকতে পারে, কারণ, উদাহরণস্বরূপ, 1 এবং 6 প্রতিবেশী তবে 3 এবং 5 নয়, তবুও তাদের একই আপেক্ষিক অবস্থান রয়েছে।
বার্নহার্ড বার্কার

0

আমি নিম্নলিখিতগুলির মতো কিছু প্রস্তাব করব (আমি ডেলফি-স্টাইলের ঘোষণাগুলি ব্যবহার করব):

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;

প্রতিটি হেক্সের ছয়টি প্রান্ত এবং ছয়টি শীর্ষে রয়েছে। প্রতিটি প্রান্তটি তার দুটি সংযুক্ত হেক্সসকে ট্র্যাক করে এবং প্রতিটি শীর্ষবিন্দুটি তার তিনটি সংযুক্ত হেক্সসকে ট্র্যাক করে রাখে (মানচিত্রের প্রান্তে হেক্সেস একটি বিশেষ কেস হবে)।

এমন অনেকগুলি বিষয় রয়েছে যা আপনি অবশ্যই আলাদাভাবে করতে পারেন। আপনি অ্যারেগুলির পরিবর্তে পয়েন্টার ব্যবহার করতে পারেন, আপনি রেকর্ডের চেয়ে অবজেক্ট ব্যবহার করতে পারবেন এবং অন্যান্য উত্তরদাতারা যেমন পরামর্শ দিয়েছিলেন তেমনভাবে আপনি আপনার হেক্সসকে একটি দ্বি-মাত্রিক অ্যারেতে সঞ্চয় করতে পারেন।

আশা করি, এটি আপনাকে কাছে যাওয়ার যদিও এক উপায় সম্পর্কে কিছু ধারণা দিতে পারে।


0

আমরা একটি শ্রেণি প্রকল্পের জন্য ক্যাটান এআই এর সেটেলারদের বাস্তবায়ন করেছি, এবং শীর্ষস্থান এবং প্রান্তগুলিতে স্থির সময় র্যান্ডম অ্যাক্সেস সহ একটি বোর্ড তৈরি করতে এই উত্তর (যা বগি ছিল) থেকে সংশোধিত কোড । এটি একটি মজাদার সমস্যা ছিল, তবে বোর্ডটি অনেক সময় নিয়েছিল, তাই যদি কেউ এখনও একটি সাধারণ বাস্তবায়ন খুঁজছেন তবে আমাদের পাইথন কোডটি:

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

এই উত্তরটি ভয়াবহ। আপনি কিছু না বুঝিয়ে সবেমাত্র টন কোড পেস্ট করেছেন (কোডটি কে লিখেছেন তা বাদে)। এমনকি এখানে ঠিক থাকলেও কোডটি নিজেই ভয়াবহ। এখানে কোনও ডকাস্ট্রিংস নেই, প্রায় কোনও মন্তব্য নেই, এবং অন্তর্ভুক্ত কয়েকটি মন্তব্য অজ্ঞাতনীয় (এই ধারণাটি থেকে যুক্তিযুক্ত যে এটি getEdgesOfVertex বলছে এবং তারপরে প্রতিটি প্রান্ত getVertexEnd এর জন্য, তিনটি যা == ভারটিেক্স বের করে নেবে)।
কার্ল স্মিথ

0

আমি এখানে হেক্সস সহ "মজাদার জন্য কোডিংয়ে ফ্রি টাইমে" বসে আছি। এবং এটি এর মতো হয় ... আমি আপনাকে কথায় এটির মতো দেখতে বলব।

  1. ষড়ভুজ: এর ছয়টি প্রতিবেশী হেক্সাগন রয়েছে। এটি প্রতিটি প্রতিবেশী হেক্স টাইলের জন্য রেফারেন্স সরবরাহ করতে পারে। এটি আপনাকে বলতে পারে যে এটি কী (জল, শিলা, ধূলিকণা) নিয়ে গঠিত। এটি নিজেকে অন্যের সাথে সংযুক্ত করতে পারে এবং বিপরীতে। এমনকি আরও বড় ক্ষেত্র তৈরি করতে এবং বা আশেপাশের সমস্ত ক্ষেত্র তার প্রতিবেশীদের দ্বারা আদর করা যায় তা নিশ্চিত করার জন্য এটি তার চারপাশের অন্যান্যদেরও স্বয়ংক্রিয়ভাবে সংযুক্ত করতে পারে।
  2. তিনটি রাস্তা এবং তিনটি হেক্স টাইল পর্যন্ত একটি বিল্ডিংয়ের উল্লেখ রয়েছে। তারা আপনাকে বলতে পারে তারা কি।
  3. প্রতিবেশী টাইলস দ্বারা সজ্জিত যখন কোনও রাস্তা দুটি হেক্স এবং অন্যান্য রাস্তাগুলি উল্লেখ করে। তারা বলতে পারে কোন টাইলগুলি এবং কোন রাস্তা বা বিল্ডিংয়ের সাথে তারা সংযুক্ত রয়েছে।

এটি কীভাবে আমি এটিতে কাজ করব তা কেবল একটি ধারণা।


0

আপনি একটি 2 ডি অ্যারে তৈরি করতে পারেন এবং তারপরে বৈধ অবস্থানগুলি হিসাবে বিবেচনা করুন:

  • সমান সংখ্যাযুক্ত সারিগুলিতে (0,2,4, ...): বিজোড় সংখ্যাযুক্ত ঘর।
  • বিজোড় সংখ্যাযুক্ত সারিগুলিতে (1,3,5, ...): এমনকী সংখ্যাযুক্ত কক্ষগুলি।

প্রতিটি কক্ষের জন্য, এর প্রতিবেশীরা হবেন:

  • একই কলাম, 2 সারি উপরে
  • একই কলাম, 2 টি সারি নিচে
  • 1 টি বাম + 1 আপ
  • 1 বাম + 1 নীচে
  • 1 ডান + 1 আপ
  • 1 ডান + 1 নীচে

উদাহরণ: হেক্স গ্রিড

এক্স চিহ্নগুলি হেক্সেস। এক্স যে একে অপরের তির্যক প্রতিবেশী হয়। | উল্লম্ব প্রতিবেশীদের সংযুক্ত করে।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.