मैं एक टॉवर डिफेंस बना रहा हूं और मुझे इसके लिए एक अच्छी पाथिंग एल्गोरिदम की जरूरत है।
मैंने दीजकस्ट्रा के बारे में सोचा है, लेकिन मुझे एक की आवश्यकता है जो गतिशील हो सकता है; जब एक किनारे को हटा दिया जाता है या पूर्ण पुनर्गणना के बिना जोड़ा जाता है तो वह खुद को अपडेट करने में सक्षम होना चाहिए।
अगर यह मदद करता है तो मैं C # में कोडिंग कर रहा हूं।
जवाबों:
आप आम तौर पर ए * का उपयोग करना चाहते हैं, जब तक कि आपके लिए कुछ अलग महत्वपूर्ण न हो।
मुझे एक समान समस्या को हल करने की आवश्यकता थी: लगातार "लागत" और बाधाओं को बदलने के साथ एक बड़े भूलभुलैया जैसे ग्रिड पर पाथफाइंग करना।
बात यह है कि, टॉवर डिफेंस गेम में, उन संस्थाओं की संख्या, जिनके लिए पथ को हल करने की आवश्यकता होती है, आमतौर पर ग्राफ में नोड्स की संख्या से बहुत बड़ा होता है। इसे संभालने के लिए A * सबसे उपयुक्त एल्गोरिथ्म नहीं है, क्योंकि हर बार कुछ बदलने के बाद आपको इसे हल करना होगा। वैसे यह उचित है यदि आपको केवल एक ही रास्ता खोजने की आवश्यकता है, लेकिन मेरे मामले में मुझे उन संस्थाओं को संभालने में सक्षम होना चाहिए जो विभिन्न स्थानों में दिखाई दे सकते हैं और प्रत्येक का अपना रास्ता है।
फ्लोयड-Warshall एल्गोरिथ्म कहीं अधिक उपयुक्त है, हालांकि मेरे मामले के लिए मैं एक कस्टम एल्गोरिथ्म है कि जब भी एक नोड परिवर्तन, इसे फिर से गणना करता है अपने सभी पड़ोसियों से उस नोड के लिए लागत में लिखा था, और उसके बाद अगर पड़ोसियों बदल दिया गया है यह शुरू हो जाती है उन पर फिर से।
इसलिए खेल की शुरुआत में, मैं अपने सभी "गोल" नोड्स पर इस एल्गोरिथ्म को आग लगा देता हूं। फिर, जब भी कोई एकल नोड बदलता है (उदाहरण के लिए, संयुक्त राष्ट्र पास हो जाता है), मैं बस उस नोड पर आग लगाता हूं और परिवर्तन सभी नोड्स को प्रभावित करता है जो प्रभावित होता है, और फिर बंद हो जाता है। इसलिए वैश्विक पुनर्गणना की कोई आवश्यकता नहीं है, और एल्गोरिथ्म उन संस्थाओं की संख्या से पूरी तरह से स्वतंत्र है, जिन्हें पथ-निर्धारण की आवश्यकता होगी।
मेरा एल्गोरिथ्म मूल रूप से कुछ ऐसा था (छद्म कोड):
update_node method in Node class:
$old <- $my_score
find $neighbor node among all neighbors such that
$neighbor.score + distance_to($neighbor) is minimal
$my_score <- $neighbor.score + distance_to($neighbor)
$next_node <- $neighbor
if ($my_score != $old)
for each $neighbor
$neighbor.update_node()प्रारंभिक अंक के आधार पर कि नोड एक लक्ष्य है या किसी प्रकार का अवरोध है।
मेरे टीडी पर मैंने जिस रूट एल्गोरिथ्म का उपयोग किया था वह खेल में मेरे पास मौजूद संस्थाओं की संख्या के कारण सामान्य A * पथ से पीछे था। लक्ष्य से बुरे लोगों के लिए मार्ग के बजाय, मैंने लक्ष्य से बोर्ड के हर खाली वर्ग को पार किया।
इसमें बहुत लंबा समय नहीं लगता है, आप बस बोर्ड को तब तक चलाते रहते हैं जब तक आपको अपनी "लागत" नहीं मिल जाती है, और यह अवरुद्ध मार्गों के लिए अच्छी प्रतिक्रिया प्रदान करता है (यदि आप ऐसा कर रहे हैं)। फ्लॉयड के एल्गोरिथ्म का उपयोग ए * की तुलना में तेज़ और कैश फ्रेंडली है क्योंकि यह डेटा पर निर्भर लुकअप नहीं कर रहा है, यह सिर्फ धाराओं में डेटा पर लोड हो रहा है और काम कर रहा है।
अपने बोर्ड के साथ शुरू करें अनंत लागत पर सेट करें, फिर लक्ष्य वर्ग को शून्य लागत पर सेट करें, फिर बोर्ड चेकिंग पर यह देखने के लिए कि क्या कोई पड़ोसी सेल वर्तमान लागत से कम और यात्रा लागत से अधिक है। यात्रा की लागत वह है जहाँ आपने अपना अनुमान लगाया है (मेरे मामले में, तिरछे यात्रा करने की लागत अनंत थी, लेकिन एक टॉवर से यात्रा करने की लागत अधिक थी, इसलिए उन्हें टावरों के माध्यम से खाने की अनुमति दी गई थी, लेकिन तब तक नहीं जब तक कि उनके पास नहीं था पसंद)
एक बार जब आप अपनी लागत ग्रिड प्राप्त कर लेते हैं, तो आप कोशिकाओं पर लागत की सबसे बड़ी ढाल का परीक्षण करके "प्रवाह" ग्रिड का निर्माण कर सकते हैं। यह वास्तव में अच्छी तरह से बड़े पैमाने पर बुरे लोगों के लिए काम करता है क्योंकि उनमें से किसी को भी कभी भी रास्ता नहीं ढूंढना पड़ता है, वे बस वर्चुअल साइनपोस्ट का पालन करते हैं।
एक और लाभ यह है कि इस तरह से आपको केवल इस कार्य को हर बार चलाना पड़ता है जब आप अवरोधों को समायोजित करते हैं (या मेरे खेल में, जब एक रेंगना आपके टावरों में से एक के माध्यम से खाता है)। हर बार एक लता / भीड़ मैदान में प्रवेश नहीं करती है (जो हजारों भीड़ और प्रति सेकंड दसियों के साथ काफी सिरदर्द होता था)।
पाथफाइंडिंग तेज है, और कुछ पर एक सामान्य टॉवर रक्षा खेल का आकार है, जब भी आप कुछ परिवर्तन करते हैं, तो आपको पूर्ण ए * या डीजकस्ट्रा पास चलाने में कोई परेशानी नहीं होगी। हम एक पूर्ण ताज़ा के लिए मिलीसेकंड के तहत अच्छी तरह से बात कर रहे हैं। किसी भी तरह के अनुकूली पथ-प्रदर्शन भयावह रूप से जटिल हो जाता है। बस इसे सरल तरीके से करें, जब तक कि आप दुनिया का सबसे बड़ा टॉवर रक्षा ग्रिड नहीं बना रहे हैं।
A * पाथफाइंडिंग कैसे काम करता है? शुरू करने के लिए एक अच्छी जगह हो सकती है :-)
यह आपके समाधान के लिए ओवरकिल हो सकता है, लेकिन आगे की बजाय पीछे की तरफ रूटिंग करने के बारे में सोचें।
टीडी गेम में, दुश्मन आमतौर पर एक विशिष्ट लक्ष्य प्राप्त करने की कोशिश कर रहे हैं। उस लक्ष्य से पीछे की ओर पहले दुश्मन के लिए रूट करें, फिर उस रास्ते को कैश करें। बाद के दुश्मनों के लिए पथ निर्माण पर, शुरुआती रास्ते के रूप में पहले पथ का उपयोग करें, और इसी तरह। यदि आपके पास कई दुश्मन एंट्रेस पॉइंट्स हैं, या कई लक्ष्य हैं, तो शुरू करने के लिए पूर्व-कैश्ड रास्तों की एक सीमा है।
वेपाइंट पाथफाइंडिंग शायद एक td गेम के लिए सबसे अच्छा होगा, क्योंकि आम तौर पर स्तर के आधार पर ai एक सीधा रास्ता होता है। मूल रूप से आप अपने नोड्स या वेपॉइंट्स को सेट करते हैं, फिर वेपॉइन की ओर "एआई" बिंदु रखते हैं और उस पर चलते हैं, एक बार जब यह पर्याप्त हो जाता है तो यह अगले वेपॉइंट पर जाता है, इसका सामना करें और इसकी ओर बढ़ें।
चूँकि किसी ने पूछा था, आप हर बार खिलाड़ी के स्थान को हटाने या टावर को हटाने के लिए गतिशील रूप से बदलते परिवेश को संबोधित करते हैं, और आप उस समय को स्मृति में उस पथ को संग्रहीत करते हैं। पर्यावरण हर फ्रेम पर नहीं बदलता है।
ध्यान दें कि कुछ टीडी गेम्स में एक निर्धारित रास्ता होता है और आप उस पर टावरों को लगाने की अनुमति नहीं देते हैं, इसलिए वे आसान तरीके से पाथफाइंडिंग को हल करते हैं: एक पथ को हार्डकोड करके और आपको इसे ब्लॉक न करने दें :)
धोखा देने का एक सरल उपाय है।
यह सुनिश्चित करने के लिए मानचित्र को पहले से ही डिज़ाइन कर लें कि कोई मृत सिरा नहीं है। फिर प्रत्येक चौराहे में, एक ट्रिगर जोड़ें जो चरित्र को एक मार्ग चुनने के लिए बनाता है (उदाहरण: हमेशा बाएं मुड़ें, हमेशा दाएं मुड़ें, या यादृच्छिक)।