हेक्सागोन ग्रिड में टाइल्स की अंगूठी प्राप्त करें

Question

इस पोस्ट के लिए धन्यवाद: हेक्सागोनल टाइल्स और उनके आस-पास के पड़ोसियों को खोजने के लिए , मैं किसी दिए गए टाइल के लिए आसन्न टाइल एकत्र करने में सक्षम हूं। लेकिन मैं एक एल्गोरिथ्म पर बहुत ज्यादा फंस गया हूं जो मुझे केवल एक ऑफसेट द्वारा निर्दिष्ट टाइल्स की "रिंग" देता है। उस स्टैक ओवरफ्लो पोस्ट में दिए गए एल्गोरिथ्म में उस क्रम के बारे में बिल्कुल ध्यान नहीं दिया गया है जिसमें यह टाइल एकत्र करता है।

मुझे पता है कि हर ऑफसेट के साथ 6 टाइलें जोड़ी जाती हैं।

• ऑफसेट 1 आपको 6 टाइलें देता है (पहला निकटवर्ती टाइल)।
• ऑफसेट 2 आपको 12 देता है।
• ऑफसेट 3 आपको 18 आदि देता है।

प्रत्येक ऑफसेट के साथ 6 की निरंतर वृद्धि होती है। इसलिए मेरा मानना ​​है कि ऐसा नियम होना चाहिए जो इन ऑफसेटों के लिए अनुकूल हो। मैं वास्तव में यह पता नहीं लगा सकता। किसी को?

Answer 1

N की त्रिज्या के साथ एक षट्कोणीय वलय में 6 सीधी रेखाएँ होती हैं, जिनमें से प्रत्येक की लंबाई N के साथ है - नीचे मेरा अत्यंत क्रूड उदाहरण देखें: N = 2 के लिए:

तीर 2 हेक्स को कवर करते हैं।

मुझे लगता है कि आपके पास कुछ कार्य हैं जो आपको एक विशिष्ट दिशा में पड़ोसी टाइल देते हैं, जैसे उत्तर (), दक्षिण-पूर्व () आदि। इसलिए आपका एल्गोरिदम, छद्मकोड में, कुछ इस तरह होना चाहिए:

var point = startingPoint.north(N)
for i = 0..N-1:
    result.add(point)
    point = point.southeast(1);
for i = 0..N-1:
    result.add(point)
    point = point.south(1);
for i = 0..N-1:
    result.add(point)
    point = point.southwest(1);
for i = 0..N-1:
    result.add(point)
    point = point.northwest(1);
for i = 0..N-1:
    result.add(point)
    point = point.north(1);
for i = 0..N-1:
    result.add(point)
    point = point.northeast(1);

ध्यान दें कि यह किनारे के मामलों के लिए भी काम करना चाहिए N = 1, 6 टाइलें लौटा रहा है, और N = 0 एक खाली सेट लौटा रहा है।

मुझे पता है कि कोड सही नहीं है :) यहाँ कुछ अतिरेक है। मेरी परियोजनाओं में नियमित रूप से टाइल वाले नक्शे (हेक्सागोनल या अन्यथा) का उपयोग करते हुए, मेरे पास आमतौर पर एक एनम "दिशा" है, जो मुझे इसे और अधिक सुचारू रूप से करने की अनुमति देता है:

var point = startingPoint.inDir(N, Direction.North)
var dir = Direction.SouthEast.
for d = 0..Direction.count():
    for i = 0..N-1:
        result.add(point)
        point = point.inDir(1, dir);
    dir = nextDirection(dir);

Comments

इससे मुझे सही दिशा में आगे बढ़ना चाहिए। धन्यवाद!

— सिदार

ध्यान दें कि कोड नमूना पहले पांच खंडों के लिए डुप्लिकेट अंक जोड़ देगा। हालाँकि, यह एक अच्छा जवाब है।

— MichaelHouse

@ Byte56 हाँ मुझे लगा। लेकिन कम से कम मैं दिशा में बदलाव के बीच संबंध देखता हूं!

— सिदार

@ Byte56 सच में? हम्म। मैंने उस एक से बचने की कोशिश की ... 0..N-1 N = 2 के लिए 0..1 देता है, इसलिए यह i = 0 और i = 1 है, जो 2 मान है। हर बार 6 दिशाओं से 2 मान 12 टाइलें हैं, जैसा कि यह होना चाहिए ...?

— लियोसन

नहीं। आप सही हे। चूंकि प्रत्येक लूप पिछले लूप से एक बिंदु जोड़ रहा है मैं छोरों के लिए एक, मेरी गलती से बंद था। यह एक चतुर एल्गोरिथ्म है।

— MichaelHouse

Answer 2

मैंने इस लेख को हेक्सागोनल ग्रिड एल्गोरिदम के लिए एक बहुत अच्छा संदर्भ पाया है, और "दूरियां" पर इसका खंड दो टाइलों के बीच चरणों की संख्या निर्धारित करने के लिए एक विधि प्रदान करता है। यदि आप अपने अक्षीय निर्देशांक (xy) को घन निर्देशांक (xyz ) में परिवर्तित करते हैं , तो दूरी हमेशा दो टाइलों के बीच समन्वयित ऑफ़सेट के सबसे बड़े के बराबर होती है, या अधिकतम (| dx | |; | dy |; dz।)।

वांछित दूरी पर टाइल्स के लिए पूरे ग्रिड की एक विस्तृत खोज है $O(n^2)$ ग्रिड आयामों के साथ, लेकिन यह एक सरल कार्यान्वयन है जो छोटे ग्रिड के लिए अच्छा काम करता है।