आरटीएस स्थानीय परिहार कैसे किया जाता है?

Question

वर्तमान में, मैं इकाइयों के स्थानीय परिहार के लिए भौतिकी प्रभाव बलों का अनुकरण कर रहा हूं, लेकिन यह विधि कभी-कभी इकाइयों को गठन से बाहर धकेलती है और जब यूनिट टकराती हैं तो बहुत अवांछनीय प्रभाव पड़ता है।

आरटीएस गेम जैसे स्टारक्राफ्ट 2 के लिए, स्थानीय परिहार कैसे किया जाता है? क्या भौतिकी सिम्युलेटेड या एक सर्वव्यापी नियंत्रक तय करता है कि सब कुछ कहाँ होना चाहिए? मुझे पता है कि यह सवाल थोड़ा व्यापक हो सकता है इसलिए मैं विशेष रूप से यह पूछ रहा हूं कि स्टारक्राफ्ट 2 के स्थानीय परिहार व्यवहार को कैसे प्राप्त किया जाए; हालांकि कुछ भी है कि काम बहुत सराहना की जाएगी।

मैं किसी भी कोड की तलाश नहीं कर रहा हूं - सिर्फ उपयोगी संसाधन या स्पष्टीकरण कि कैसे Starcraft 2 (या इसी तरह के खेल) स्थानीय परिहार को संभालता है।

वर्तमान में, मुझे टक्कर का पता लगाने (पैठ वेक्टर के साथ), टकराव की ताकतों, और वेग द्वारा आंदोलन को लागू किया गया है। टक्कर के लिए प्रत्येक इकाई को दूसरे के खिलाफ जांचा जाता है - यदि वे टकराते हैं, तो वस्तुओं को पैठ वेक्टर द्वारा तुरंत ऑफसेट किया जाता है फिर टकराव बल लागू किया जाता है। फिर एक और लूप ऑब्जेक्ट्स को अपने वेग द्वारा ले जाता है और वेगों पर ड्रैग को लागू करता है। ऑफसेट टकरा इकाइयों पर लागू अत्यधिक टकराव बलों की समस्या को कम करता है, लेकिन इकाइयां अभी भी कभी-कभी बाहर गोली मारती हैं।

समाधान मैं निम्नलिखित आवश्यकताओं को पूरा करने की जरूरत है (के रूप में Starcraft 2 में):

• ऑब्जेक्ट्स ओवरलैप नहीं होते; या कम से कम ओवरलैप को अंततः हल किया जाना चाहिए।
• ऑब्जेक्ट एक दूसरे को आवश्यकता से अधिक दूर नहीं धकेलते हैं इसलिए 2 इकाइयां खड़ी हो सकती हैं और एक गठन में एक दूसरे के बगल में आगे बढ़ सकती हैं।
• जब कोई वस्तु एक ही गंतव्य की ओर बढ़ती है तो कोई भी अजीब व्यवहार नहीं करना चाहिए।
• विभिन्न आकारों की इकाइयों, और यहां तक ​​कि अलग-अलग उत्तल आकृतियों का समर्थन कर सकते हैं।

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

Comments

"झुंड व्यवहार" (गूगल शब्द) एक बहुत ही व्यापक समस्या है,

— शाफ़्ट सनकी

यह क़रीबी वोट कतार में "बहुत व्यापक" था-मैं सहमत नहीं हूँ। संकीर्ण करने का प्रयास: आपने क्या प्रयास किया है? आप "अवांछनीय प्रभाव" से बचने के लिए क्या देख रहे हैं? क्या मैं यह कहने में सही हूं कि आप इकाइयों के गठन में बने रहना चाहते हैं?

— एको

आरटीएस गेम प्रायः प्रत्येक ग्राहक द्वारा प्रत्येक मशीन पर एक ही नियतात्मक सिमुलेशन चलाकर काम करते हैं। तो मूल रूप से, यदि आप इसे एक मशीन के लिए हल कर सकते हैं, तो आप मल्टीप्लेयर स्थितियों के लिए एक ही समाधान लागू कर सकते हैं, जो भी स्थानीय परिहार तकनीक आप के साथ जा रहे हैं।

— एलन वोल्फ

सवाल पर प्रतिक्रिया के लिए धन्यवाद। मैंने सवाल को थोड़ा कम कर दिया और विशेष रूप से समझाया कि मैं क्या हासिल करने की कोशिश कर रहा हूं।

— JPtheK9

यह एक महान संसाधन है: red3d.com/cwr/steer

— tbkn23

Answer 1

ऐसा लगता है कि आप जो खोज रहे हैं वह इष्टतम पारस्परिक टकराव परिहार एल्गोरिथ्म है। पूर्ववर्ती कागज भी लायक पढ़ने है। यद्यपि पेपर थोड़ा सा शामिल हो सकता है, एल्गोरिथ्म के पीछे का सिद्धांत काफी सीधा है:

मान लें कि आपके पास पहले से ही एजेंटों (इकाइयों) के साथ एक सिमुलेशन (गेम) है जिनके पास कुछ प्रकार की बाउंडिंग वॉल्यूम है। इस बाउंडिंग वॉल्यूम की संभावना है जो आप पहले से ही टक्कर का पता लगाने और प्रतिक्रिया करने के लिए उपयोग कर रहे हैं। प्रत्येक एजेंट के लिए, एक पसंदीदा वेग को परिभाषित करेंv_p जो एजेंट के लक्ष्य पर आधारित हो सकता है या नहीं।

अब, अनुकरण करने के लिए:

1. प्रत्येक एजेंट के लिए, यह मानते हुए कि यह स्थिर है, सभी वेगों की गणना करें, जो भविष्य में किसी भी अन्य चलती एजेंट के साथ किसी भी बिंदु पर टकराएगा। इसे "वेलोसिटी स्पेस" में आधे विमानों को समतल करने के एक सेट के रूप में दर्शाया जा सकता है (इसे एक वेग बाधा के रूप में भी जाना जाता है। )।
2. इस स्थान के निकटतम बिंदु का निर्धारण करें v_p, यह इकाई का नया वेग है।

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

ऊपर एल्गोरिथ्म के दो चरणों की गणना के लिए, आप वेग बाधा को निर्धारित करने के लिए मिन्कोवस्की रकम का उपयोग कर सकते हैं और फिर वेग बिंदु से बचने के लिए निकटतम बिंदु निर्धारित करने के लिए एक रेखीय प्रोग्रामिंग मॉडल (जैसे कि सिम्प्लेक्स एल्गोरिथम ) का उपयोग कर सकते हैं v_p। इसके अलावा, टक्कर परिहार करने के लिए कोड आपकी गड़बड़ी के लिए उपलब्ध है और इसे C # में एकता जैसे गेम इंजन में उपयोग करने के लिए पोर्ट किया गया है। इस तकनीक का कम से कम वारहैमर 40,000: स्पेस मरीन और शायद अन्य खेलों में उपयोग किया गया है ।

Comments

यह एक अद्भुत लेख था और मुझे लगता है कि मैं आपके स्पष्टीकरण से इसका आधा हिस्सा पढ़ूंगा। इस जानकारी के लिए धन्यवाद।

— JPtheK9

Answer 2

मुझे नहीं पता कि आपकी इकाइयाँ कैसे काम करती हैं लेकिन मुझे लगता है कि वे एक राज्य मशीन की तरह हैं:

संभव राज्य

• (X, y, z) पर चल रहा है
• अटैकिंग (दुश्मन_ड)
• Ressource एकत्रित करना (ressource_id)

अगर आप इस बात पर ध्यान देंगे कि स्टारक्राफ्ट इस समस्या को कैसे देखता है, तो आप पाएंगे कि:

1. यदि किसी दिशा में चलने के लिए स्थान है, तो चरचर उस दिशा में चलता है।
2. अगर जगह नहीं है तो रास्ते में इकाई जगह बनाने के लिए आगे बढ़ेगी
3. यदि जिस इकाई को स्थान बनाने के लिए स्थानांतरित करने की आवश्यकता है, उसके पास पहले से ही एक कमांड है, तो यह कमांड रखेगा, लेकिन अंत में जगह बनाने के लिए इसे थोड़ा संशोधित करें।

यहाँ परिदृश्य 1:

क्या मेरे पास वहां जाने के लिए जगह है? हाँ ? फिर जाइए

परिदृश्य 2:

क्या मेरे पास वहां जाने के लिए जगह है? नहीं ? अरे क्या तुम मेरे लिए कुछ जगह बना सकते हो, तुम मुझे रोक रहे हो मेरे पास पहले से ही फव्वारे को स्थानांतरित करने का आदेश है लेकिन मैं आपको रोकूंगा।

तो आपको क्या लागू करना होगा:

• इकाइयों को अपने परिवेश के बारे में पता होना चाहिए
• इकाइयों के पास एक दूसरे के साथ संवाद करने का एक तरीका होना चाहिए
• किसी अन्य इकाई को शामिल करने के दौरान आपको एक कमांड निष्पादित करने का एक तरीका लागू करना होगा

Comments

जानकारी और दृश्य के लिए धन्यवाद। अभी मैं यह पता लगाने के लिए टकराव का पता लगा रहा हूं कि क्या कोई इकाई दूसरी जगह जा सकती है या कोई अन्य इकाई उस पर कब्जा कर रही है या नहीं। मुख्य बात मैं यह पता लगाने की कोशिश कर रहा हूं कि किसी इकाई का एक एल्गोरिथ्म है जो दूसरी इकाई को बताए कि किस दूरी को स्थानांतरित करना है या किस वेग से समायोजित करना है। दूसरे शब्दों में, कैसे अवरुद्ध इकाई पारित करने की कोशिश कर रही इकाई को समायोजित करेगी।

— JPtheK9

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

— एंटोनी

"जब तक यह रास्ते से हटता है" का क्या मतलब है? इकाई पहले स्थान पर कैसे चलती है?

— JPtheK9

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

— JPtheK9

Answer 3

इसे करने का एक तरीका यह है कि इकाइयां ऑटो-फॉर्म फॉर्मेशन हों, और उन्हें गठन के केंद्र के सापेक्ष स्थिति में रहने का प्रयास करना चाहिए । फिर, प्रत्येक इकाई को व्यक्तिगत रूप से स्थानांतरित करने के बजाय, गठन के केंद्र को चारों ओर घुमाएं।

इकाइयों को उनके उपयुक्त पदों पर बनाए रखने के लिए एक बॉक्स बनाने और सरल स्प्रिंग्स का उपयोग करने का यह एक मूल तरीका है:

// Defines a phalanx (box) formation
class Formation
    // Center of the box in the world
    Position center;
    // Width in # of units
    int width;
    // Height in # of units
    int height;
    // Space between units
    float scale;
    // How much force units will apply to stay near
    // their assigned spot.
    float springforce;

    // Return a position of a unit at the given row and column
    // Todo: add a rotation to this formation so it can rotate when moving.
    Position GetUnitPhalanxPosition(int row, int column)
        return new Position(center.X + column * scale - width * scale /2, 
                            center.Y + row * scale    - height* scale / 2);

// Represents a simple point object with a velocity and position;
// it belongs to a formation.
class Unit
    Position pos;
    Velocity vel;
    Formation formation;
    // What's our assigned spot in the formation?
    int row;
    int column;

    void Update(float dt)
        // Get the desired target position in the formation
        Position target = formation.GetUnitPhalanxPosition(row, column);
        // Apply a spring force toward the position (todo: you might want to damp this)
        vel += (target - position) * dt * formation.springforce;
        // Move along the velocity vector.
        pos += vel * dt;

Comments

धन्यवाद! यह वास्तव में दिलचस्प और रचनात्मक समाधान है। मैंने भीड़ के व्यवहार / संरचनाओं के लिए कुछ इसी तरह लागू किया है, लेकिन मुझे अभी भी इकाइयों के अतिव्यापी होने की समस्या है। यदि 2 सूत्र एक दूसरे में चलते हैं तो क्या होना चाहिए?

— JPtheK9

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

— मर्जों को एक साथ मिलाते हैं

मेटा-फॉर्मेशन वास्तव में जटिल और छोटी लग रहा है: सी। आपके द्वारा जोड़ा गया चित्र ठीक वही हो सकता है, जिसकी मुझे आवश्यकता है। मैं स्टीयरिंग बलों पर कुछ और शोध करने जा रहा हूं। क्या आपके पास छवि के लेख का लिंक है?

— JPtheK9

मुझे आपकी एक समान समस्या है, यह जानना दिलचस्प होगा कि आपने इसे कैसे हल किया। इस लेख को समाप्त करने के बाद विचार का एक शॉट दिमाग में आया: हो सकता है कि सूक्ष्म टकराव से बचने के लिए

— रिपेल

Answer 4

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

Comments

धन्यवाद! अनुसंधान मेरे लिए स्पष्टीकरण के रूप में सहायक है। मैं इस कागज में डुबकी लगाऊंगा।

— JPtheK9

मेरे पास पहले से स्थापित एक प्रभाव नक्शा है लेकिन यह मेरे स्वाद के लिए बहुत जटिल लगता है। मुख्य बात विभिन्न इकाइयों के लिए उन्हें स्थानांतरित करने के लिए संभावित क्षेत्र उत्पन्न कर रही है, और संभावित क्षेत्र से डेटा को स्थानांतरित करने के लिए वेग में परिवर्तित करना भी है। असल में, मुझे नहीं लगता कि यह विभिन्न आकारों की इकाइयों के लिए काम करेगा। यह बहुत अच्छा पढ़ा है, हालांकि बहुत सारे दिलचस्प विचार हैं।

— JPtheK9