हेक्सागोनल ग्रिड पर रेंज दिखा रहा है

Question

यहाँ स्थिति है।

मेरे पास हेक्सागोनल बोर्ड है, और उस पर एक इकाई, गति या चाल मान के साथ। 4. अलग-अलग इलाके में एक अलग लागत है। जब मैं इकाई पर क्लिक करता हूं, तो खेल को मुझे एक चाल रेंज दिखाना चाहिए।

मेरा समाधान ए * पाथफाइंडिंग के साथ 4 की सीमा में प्रत्येक हेक्स की जांच करना था, और यदि पथ की लागत 4 से कम थी, तो यह हेक्स सीमा में था। सामान्य रूप से गेम मुझे अच्छी तरह से उस इकाई की सीमा दिखाते हैं।

मेरा प्रश्न है: क्या हेक्स ग्रिड या स्क्वायर ग्रिड पर रेंज की खोज करने के लिए कोई अन्य समाधान है, क्योंकि यहां तक ​​कि अगर मुझे अपने समाधान में वास्तव में गर्व है, तो मुझे लगता है, यह अतिशयोक्ति है? :)

मुझसे यह सवाल क्या पूछा जाता है? मैंने देखा कि जब इकाई की गति 4 या 6 या 8 होती है, तो मेरे कंप्यूटर के लिए कंप्यूटिंग रेंज का समय वास्तव में अच्छा था, लेकिन जब गति 10 और अधिक थी, तो मैंने देखा कि मुझे गणना करने के लिए कुछ सेकंड इंतजार करने की आवश्यकता थी वास्तविक खेलों में। मैं ऐसा कुछ नहीं देखता हूं और मेरे ए * पाथफाइंडिंग को अच्छी तरह से अनुकूलित किया गया है, इसलिए यह सोचकर कि मेरा समाधान गलत है।

किसी भी उत्तर के लिए धन्यवाद।

Comments

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

— TheJollySin

Answer 1

आप सही कह रहे हैं कि A * थोड़ा ओवरकिल है, लेकिन ज्यादा नहीं। तुम जैसे हो वैसे देरी को नहीं देखना चाहिए। ए * वास्तव में सिर्फ एक संशोधित डायजिक्स्ट्रा का एल्गोरिथ्म है । चूँकि आप एक अंतिम स्थिति का उपयोग नहीं कर रहे हैं (जैसा कि आपकी अंतिम स्थिति "जहाँ तक आप जा सकते हैं"), A के साथ A का उपयोग करके इसे जोड़ा गया है। बस डायजिक्स्ट्रा या एक साधारण चौड़ाई वाली पहली खोज का उपयोग करना पर्याप्त होगा।

उदाहरण के लिए, Dikikstra सभी दिशाओं में समान रूप से फैल जाएगा:

(एक सरल चौड़ाई पहली खोज इस तरह दिखाई देगी)

प्रत्येक नोड पर जाने के लिए लागत का ट्रैक रखें। एक बार जब एक नोड अधिकतम यात्रा लागत पर होता है, तो इसके जुड़े नोड्स को आगे किसी भी प्रक्रिया में न डालें। (इसी तरह जहां नोड्स नीचे की दीवार में चलते हैं)।

यदि आप केवल 10 नोड्स पर प्रदर्शन समस्याओं में चल रहे हैं, तो आप देखना चाहेंगे कि आप नोड्स तक कैसे पहुंच रहे हैं। एक चौड़ाई वाली पहली खोज को ध्यान देने योग्य देरी (निश्चित रूप से कुछ सेकंड नहीं) के बिना सैकड़ों नोड्स को नेविगेट करने में सक्षम होना चाहिए। क्विक ट्रैवर्सल के लिए, ग्राफ प्रारूप में अपनी दुनिया के एक साधारण संस्करण को संग्रहीत करने पर विचार करें।

Comments

क्या आप BFS का उपयोग करते हुए और खाता बाधाओं / अलग-अलग भारों में दो नोड्स के बीच की दूरी पा सकते हैं?

— ल्यूक बी।

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

— MichaelHouse

धन्यवाद, अब मैं देख रहा हूं कि मेरी सोच गलत क्यों थी, इस के लिए कुंजी यह कथन था "चूंकि आप एक अंतिम स्थिति का उपयोग नहीं कर रहे हैं (जैसा कि आपकी अंतिम स्थिति" जहां तक ​​आप जा सकते हैं ")" "मेरे समाधान में। एक समाप्ति की स्थिति थी, यह इकाई थी। मैंने सिर्फ गलत दिशा से समस्या को हल किया। पहले मैंने सीमा का निर्धारण किया, और फिर वहाँ से मैं अपनी इकाई में वापस चला गया, इस तरह मैं शायद एक ही नोड के माध्यम से कई बार गया। जब मेरी गति में वृद्धि होती है, तो अभिकलन की संख्या भी बढ़ जाती है। जिस तरह से आप मुझे दिखाते हैं, मैं हमेशा एक बार नोड पर जाऊंगा। मेरे पास गलत दृष्टिकोण था, वास्तव में धन्यवाद, यह बहुत सरल है।

— user23673

Answer 2

अमित पटेल ने अपनी साइट पर रेंज प्राप्त करने के लिए एक उत्कृष्ट संसाधन प्रदान किया है । लेख में, वह एक सीमा के भीतर हेक्स टाइल्स एकत्र करने के लिए निम्नलिखित एल्गोरिदम का उपयोग करता है:

for each -N ≤ Δx ≤ N:
    for each max(-N, -Δx-N) ≤ Δy ≤ min(N, -Δx+N):
        Δz = -Δx-Δy
        results.append(H.add(Cube(Δx, Δy, Δz)))

यह हेक्स ग्रिड के साथ संरेखित सीमा बनाता है:

यह केंद्र हेक्स की एक निश्चित दूरी के भीतर सभी हेक्स को मिल जाएगा, यदि आप बाधाओं पर विचार करना चाहते हैं, तो मेरे अन्य उत्तर से पहले खोज की चौड़ाई का उपयोग करें।

Answer 3

यदि किसी को इसकी आवश्यकता है, तो यहां पटेल के एल्गोरिथ्म का C # कार्यान्वयन है:

IEnumerable<Hex> GetRange(Hex center, int range)
    {
        var inRange = new List<Hex>();
        for (int q = -range; q <= range; q++)
        {
            int r1 = Math.Max(-range, -q - range);
            int r2 = Math.Min(range, -q + range);
            for (int r = r1; r <= r2; r++)
            {
                inRange.Add(center.Add(new Hex(q, r, -q - r)));
            }
        }

        return inRange;
    }