हेक्सागोनल ग्रिड पर निकट पड़ोसियों को ढूंढना

Question

संपादित करें: कोड कोड में उदाहरण मानचित्र को लपेटें ताकि स्वरूपण सही हो।

ठीक है, मैं एक हेक्सागोनल ग्रिड पर एक बेहद सरल ए * एल्गोरिदम लिखने की कोशिश कर रहा हूं। मैं समझता हूं, और ए * भाग कर सकता हूं। वास्तव में, मेरा ए * स्क्वायर ग्रिड के लिए काम करता है। जो मैं अपने मस्तिष्क को चारों ओर लपेट नहीं सकता वह हेक्सागोन के साथ पड़ोसियों को ढूंढ रहा है। यहाँ heagonal ग्रिड

0101  0301 
    0201  0401 
0102  0302 
    0202  0402 

आदि के लिए लेआउट, आदि

तो, मैं के साथ एक षट्कोण वर्ग कि, यह देखते हुए यह हेक्स निर्देशांक है, पड़ोसियों की एक सूची उत्पन्न कर सकते हैं लिख रहा है मदद क्या जरूरत है। इसे पड़ोसियों को उत्पन्न करने में सक्षम होना चाहिए जो ग्रिड (0000 या 2101 की तरह 20x20 ग्रिड में 'गिर जाएंगे) क्योंकि इस तरह मेरे ए * ट्रैक कई तरफ रखे गए हैं। तो कुछ है कि इस कोड स्निपेट के साथ काम करेगा:

ग्रह = हेक्स ('0214') प्रिंट (planet.neighbors()) [ 'हेक्स 0213', 'हेक्स 0215', 'हेक्स 0115', 'हेक्स 0315 ',' हेक्स 0116 ',' हेक्स 0316 ']

Answer 1

यह इस बात पर निर्भर करता है कि आप अपने हेक्स टाइल्स के निर्देशांक को कैसे परिभाषित करते हैं।

चलो देखते हैं।

, , , , 
/\/\/\/\ 
| A1| A2| A3| A4| 
\/\/\/\/
    | B1| B2| B3| 
/\/\/\/\ 
| C1| C2| C3| C4| 
\/\/\/\/
    ' ' ' ' 

इस मामले में, पड़ोसी परिभाषा भी और विषम पंक्तियों के लिए अलग है।

एक सेल (एक्स, वाई) जहां वाई भी है, पड़ोसियों हैं: (एक्स, वाई -1), (एक्स + 1, वाई -1), (एक्स -1, वाई), (एक्स + 1, वाई), (एक्स, वाई + 1), (एक्स + 1, वाई + 1)

एक सेल (एक्स, वाई) जहां वाई अजीब है, पड़ोसियों हैं: (एक्स -1, वाई -1), (एक्स, वाई -1), (एक्स -1, वाई), (एक्स -1, वाई + 1), (एक्स, वाई + 1), (एक्स, वाई + 1)

Answer 2

ऊपर मेरी टिप्पणी के अनुसार, यहां कोड लागू किया गया है। सुझाव देने वाले किसी भी व्यक्ति को इसे साफ करने में मेरी सहायता करने के लिए, मैं प्रतिक्रिया का स्वागत करता हूं।

class Hexagon(): 
"""Implements a class of hexagon from a hex map which is vertically tiled. 
This hexagon is able to return a list of it's neighbors. It does not care 
if the neighbors are hexes which actually exist on the map or not, the map is 
responsible for determining that.""" 

def __init__(self,grid_number): 
    self.name = grid_number 
    self.x = int(grid_number[0:2]) 
    self.y = int(grid_number[2:4]) 

def neighbors(self): 
    ret_list = [] 
    if self.x % 2 == 0: 
     temp_list = [[self.x,self.y-1], 
       [self.x-1,self.y], [self.x+1,self.y], 
       [self.x-1,self.y+1],[self.x+1,self.y+1], 
        [self.x,self.y+1]] 
     for i in temp_list: 
      ret_list.append(format(i[0],'02d') + format(i[1],'02d')) 

    elif self.x % 2 == 1: 
     temp_list = [[self.x,self.y-1], 
       [self.x-1,self.y-1],[self.x+1,self.y-1], 
       [self.x-1,self.y],[self.x+1,self.y], 
        [self.x,self.y+1]] 
     for i in temp_list: 
      ret_list.append(format(i[0],'02d') + format(i[1],'02d')) 

    return ret_list 

def main(): 
    hex1 = Hexagon('0201') 
    hex2 = Hexagon('0302') 
    if hex1.neighbors() == ['0200','0101','0301','0102','0302','0202']: 
     print("Works for even columns.") 
    else: 
     print("Failed for even columns.") 
     print(hex1.neighbors()) 

    if hex2.neighbors() == ['0301','0201','0401','0202','0402','0303']: 
     print("Works for odd columns.") 
    else: 
     print("Failed for odd columns.") 
     print(hex2.neighbors()) 

if __name__ == '__main__': 
    main()