एक हेक्सागोनल ग्रिड पर सबसे छोटा रास्ता खोजना

Question

मैं एक बारी आधारित खेल लिख रहा हूं जिसमें कुछ सिमुलेशन तत्व हैं। वर्तमान में जिस एक कार्य को मैं लटका रहा हूं वह पथ खोज के साथ है। मैं जो करना चाहता हूं वह अपने वर्तमान x, y और उसके लक्ष्य x, y का उपयोग करके अपने लक्ष्य के करीब एक AI साहसी एक टाइल को स्थानांतरित करना है।

अपने आप को यह पता लगाने की कोशिश में कि मैं 4 दिशाओं का उपयोग करके कोई समस्या नहीं निर्धारित कर सकता हूं

dx = currentX - targetY
dy = currentY - targetY

लेकिन मुझे यकीन नहीं है कि यह निर्धारित करने के लिए कि 6 दिशाओं में से कौन सा वास्तव में "सबसे अच्छा" या "सबसे छोटा" मार्ग है।

उदाहरण के लिए, जिस तरह से यह वर्तमान में सेटअप है, मैं पूर्व, पश्चिम, एनई, एनडब्ल्यू, एसई, एसडब्ल्यू का उपयोग करता हूं, लेकिन एनई टाइल को पाने के लिए मैं पूर्व की ओर बढ़ता हूं तो एनडब्ल्यू सिर्फ एनडब्ल्यू को स्थानांतरित करने के बजाय।

मुझे आशा है कि यह सब जुआ नहीं था। यहां तक ​​कि मुझे शुरू करने के लिए सिर्फ एक कड़ी या दो अच्छा होगा। मुझे जो जानकारी मिली है, उनमें से अधिकांश ग्रिड को आकर्षित करने और अजीब समन्वय प्रणाली की जरूरत को पूरा करने पर है।

Comments

A * आपको अपने ग्राफ के आकार की परवाह किए बिना सबसे छोटा रास्ता देता है (ग्रिड, हेक्स, फ्रीफॉर्म ..)

— Jari Komppa

Answer 1

कुछ जवाब!

हेक्स-आधारित ट्रैवर्सल के लिए सबसे अधिक बार मैंने जो समन्वय प्रणाली देखी है, वह वह है जहां खिलाड़ी हर सामान्य एनएसईडब्ल्यू दिशा में कदम रख सकता है, साथ ही साथ एनडब्ल्यू और एसई भी। तब आप बस प्रत्येक पंक्ति को आधा-वर्ग वर्गाकार ऑफसेट प्रदान करते हैं। एक उदाहरण के रूप में, स्थान (2,7) को (1,7), (3,7), (2,6), (2,8), और अजीब लोगों के समीप माना जाता है: (1,6) और (3,8)। इस बीच, अगर हम यह मान लें (2,7) स्क्रीन के केंद्र में प्रस्तुत किया गया है, (2,6) को ऊपर-और-दाएं गाया जाएगा, (2,8) को नीचे और नीचे गाया जाएगा -या-बाएँ, (1,7) और (3,7) इसे क्रमशः बाएँ और दाएँ पर ले जाएँगे, और (1,6) और (3,8) क्रमशः अपने आप को शीर्ष-बाएँ और नीचे-दाएँ स्थान देंगे।

मेरा क्या मतलब है:

यदि आप इसे इस तरह से कर रहे हैं, तो सबसे छोटा सीधा रास्ता खोजना मुश्किल नहीं है - अधिकतम एनडब्ल्यू / एसई दूरी की यात्रा करें जो आप अपने लक्ष्य को कार्डिनल अक्ष के साथ ओवरराइड किए बिना कर सकते हैं, फिर सीधे उस अक्ष पर लक्ष्य के साथ यात्रा करें।

लेकिन ज़ाहिर है कि खुशी से आप सीधे पहाड़ों या अन्य अगम्य इलाके के माध्यम से चलाएंगे। एक सवाल का जवाब देने के लिए जो आपने अभी तक नहीं पूछा है: ए * सर्च एल्गोरिथ्म पाथफाइंडिंग के लिए एक आम और यथोचित अच्छा तरीका है। यह न केवल अजीब गैर-ग्रिड लेआउट को संभाल लेगा, बल्कि खुशी से बाधाओं और यहां तक ​​कि बाधित / धीमी गति से निपटेगा।

Comments

ए * खोज एल्गोरिदम के लिंक के लिए धन्यवाद। एकमात्र तरीका जो मैं कल्पना कर सकता हूं कि एनवीएस और एनवी / एसई एक झुका हुआ हेक्स है। जो मेरे सिर में अजीब लगता है। क्या आप मुझे उस के एक उदाहरण से जोड़ सकते हैं?

— तीमुथियुस

मैं कह रहा हूं कि आपकी प्रदान की गई छवि को आंतरिक संरचना से बहुत समानता नहीं है। मैं सुझाव दे रहा हूं कि आंतरिक रूप से आप एनएसईडब्ल्यू और एनडब्ल्यू / एसई का उपयोग करते हैं, लेकिन आप इसे उपयोगकर्ता को प्रदर्शित करते हैं जैसे कि यह एक ग्रिड था। मूल उत्तर :)

— ZorbaTHut

हेक्स ग्रिड के लिए दिलचस्प प्रतिनिधित्व। मैं आमतौर पर एक दांतेदार पैटर्न बनाता हूं, इसलिए आसन्न विषम और यहां तक ​​कि पंक्तियों के लिए अलग है। यह पथ खोज में एक अतिरिक्त न्यूनतम जटिलता का परिचय देता है, लेकिन एक द्विदिश सरणी का अधिक कुशलता से उपयोग करता है (पूरे नाटक क्षेत्र को दबाने से एक आयत है।

— पांडा पायजामा

@PandPajama: आयताकार नक्शे को कुशलता से संग्रहीत करने के लिए दांतेदार काम करता है; आप गैर-दांतेदार निर्देशांक इस चाल के

— amitp

@PandaPajama, एक और दिलचस्प ट्रिक है जिसका आप उपयोग कर सकते हैं - आप निर्देशांक के लिए गैर-दांतेदार प्रतिनिधित्व का उपयोग कर सकते हैं, फिर "दांतेदार" विधि का उपयोग करने वाली किसी चीज़ के पीछे अपने डेटा स्टोरेज के लिए बैकिंग को अमूर्त करें। मैंने पाया है कि गैर-दांतेदार की समन्वित प्रणाली से निपटने के लिए बहुत आसान है लेकिन निश्चित रूप से दूर होने के बाद, बैकएंड जो कुछ भी करना पसंद करता है वह चीजों को कुशल बनाना चाहता है :)

— ZorbaTHut

Answer 2

मैंने अभी यहां CodePlex.com पर हेक्स-ग्रिड उपयोग की एक लाइब्रेरी पोस्ट की है: https://hexgridutilities.codeplex.com/ लाइब्रेरी में पथ-खोज (A- * a la Eric Lippert का उपयोग करना) और स्वचालित रूपांतरण के बीच उपयोग शामिल हैं दांतेदार (उपयोगकर्ता कहा जाता है) कॉर्डिनेट और गैर-दांतेदार (कैन्यनिकल) निर्देशांक। पाथ-फाइंडिंग एल्गोरिथ्म प्रत्येक नोड के लिए स्टेप कॉस्ट को प्रवेश हेक्स और टे ट्रैवर्सेड हेक्स-साइड दोनों के साथ अलग-अलग करने की अनुमति देता है (हालांकि प्रदान किया गया उदाहरण सरल है)। इसके अलावा, छाया-कास्टिंग का उपयोग करके उन्नत फ़ील्ड-ऑफ-व्यू प्रदान किया जाता है, [संपादित करें: हटाए गए शब्द]।

यहां एक कोड नमूना है जो तीन हेक्स-ग्रिड समन्वय प्रणालियों के बीच आसानी से परिवर्तित होता है:

static readonly IntMatrix2D MatrixUserToCanon = new IntMatrix2D(2,1, 0,2, 0,0, 2);
IntVector2D VectorCanon {
  get { return !isCanonNull ? vectorCanon : VectorUser * MatrixUserToCanon / 2; }
  set { vectorCanon = value;  isUserNull = isCustomNull = true; }
} IntVector2D vectorCanon;
bool isCanonNull;

static readonly IntMatrix2D MatrixCanonToUser  = new IntMatrix2D(2,-1, 0,2, 0,1, 2);    
IntVector2D VectorUser {
  get { return !isUserNull  ? vectorUser 
             : !isCanonNull ? VectorCanon  * MatrixCanonToUser / 2
                            : VectorCustom * MatrixCustomToUser / 2; }
  set { vectorUser  = value;  isCustomNull = isCanonNull = true; }
} IntVector2D vectorUser;
bool isUserNull;

static IntMatrix2D MatrixCustomToUser = new IntMatrix2D(2,0, 0,-2, 0,(2*Height)-1, 2);
static IntMatrix2D MatrixUserToCustom = new IntMatrix2D(2,0, 0,-2, 0,(2*Height)-1, 2);
IntVector2D VectorCustom {
  get { return !isCustomNull ? vectorCustom : VectorUser * MatrixUserToCustom / 2; }
  set { vectorCustom  = value;  isCanonNull = isUserNull = true; }
} IntVector2D vectorCustom;
bool isCustomNull;

IntMatrix2D और IntVector2D हैं [संपादित करें: सजातीय] affine2D ग्राफिक्स वेक्टर और मैट्रिक्स का पूर्णांक कार्यान्वयन। वेक्टर अनुप्रयोगों पर 2 से अंतिम विभाजन वैक्टर को फिर से सामान्य करने के लिए है; यह IntMatrix2D कार्यान्वयन में दफन किया जा सकता है, लेकिन फिर IntMatrix2D कंस्ट्रक्टर्स के लिए 7 वें तर्क का कारण कम स्पष्ट है। गैर-मौजूदा योगों के संयुक्त कैशिंग और आलसी-मूल्यांकन पर ध्यान दें।

ये मैटर केस के लिए हैं:

• हेक्स अनाज ऊर्ध्वाधर;
• Canonical और उपयोगकर्ता निर्देशांक के लिए ऊपरी-बाएँ में उत्पत्ति, कस्टम निर्देशांक के लिए निचले-बाएँ;
• वाई-अक्ष लंबवत रूप से नीचे;
• आयताकार X- अक्ष क्षैतिज रूप से पार; तथा
• उत्तर-पूर्व (यानी ऊपर और दाईं ओर, 120 डिग्री CCW Y- अक्ष से) के लिए कैन्यिकल एक्स-एक्सिस।

ऊपर उल्लिखित कोड लाइब्रेरी हेक्स-पिकिंग के लिए एक समान रूप से सुरुचिपूर्ण तंत्र प्रदान करता है (यानी माउस क्लिक से चयनित हेक्स की पहचान)।

Canonical निर्देशांक में, 6 कार्डिनल दिशा-वेक्टर हैं (1,0), (0,1), (1,1) और सभी हेक्सागोन्स के लिए उनके आक्रमण, दांतेदार कॉर्डिनेट्स की अस्मिता के बिना।

Comments

वाह! नेट वर्किंग कोड की लाइब्रेरी पोस्ट करने के लिए नेट एक डाउन-वोट, उदाहरण और प्रलेखन के साथ, जो ओपी द्वारा प्रस्तुत प्रश्न / समस्या का उत्तर देता है।

— पीटर जार्जेंस

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

— स्टीवन स्टडनिक

अच्छे अंक; धन्यवाद। मैंने अंश के साथ पोस्ट का विस्तार किया है जो कई हेक्स ग्रिड निर्देशांक को कुशलतापूर्वक बनाए रखने के प्रश्न को संबोधित करता है। पोस्ट कोड लाइब्रेरी फ़्रीवेयर है

— पीटर गेकरेंस

ऊप्स! विभाजन-दर-2 केवल धनात्मक पूर्णांक के लिए काम करता है। (फिर से धन्यवाद, K & R।) इसे IntVector2D में Normalize () विधि के लिए एक कॉल द्वारा प्रतिस्थापित किया जाना चाहिए:

— Pieter Geerkens

public IntVector2D Normalize() { if (Z==1) return this; else { var x = (X >= 0) ? X : X - Z; var y = (Y >= 0) ? Y : Y - Z; return new IntVector2D(x/Z, y/Z); } }

— पीटर जॉर्जन्स

Answer 3

यह एक हल की गई समस्या है, जिसमें बहुत से साहित्य का समर्थन किया गया है। रेड ब्लॉब गेम्स पर मुझे पता है कि सबसे अच्छा संसाधन: https://www.redblobgames.com/grids/hexagons/ है ।

संक्षेप में, सबसे संभावित कारण यह है कि आपने गलत समन्वय प्रणाली के साथ शुरुआत की थी। एक घन समन्वय प्रणाली का उपयोग करके ए * एल्गोरिदम को लागू करना काफी सरल है। उपरोक्त लिंक पर लाइव डेमो देखें।

यदि आप वास्तव में किसी अन्य प्रणाली का उपयोग करना चाहते हैं, तो जरूरत पड़ने पर और उससे परिवर्तित करें।