एक 2 डी टाइल आधारित आरटीएस में एक पुल के नीचे से गुजरने वाली नाव

Question

मैं एक 2D टाइल आधारित RTS लिख रहा हूँ। और मैं इसमें 'छद्म 3 डी' फीचर जोड़ना चाहता हूं - नदियों पर पुल।

मैंने अभी तक किसी भी कोडिंग को शुरू नहीं किया है, बस यह सोचने की कोशिश कर रहा है कि यह टकराव का पता लगाने वाले मॉडल को कैसे फिट करता है। पुल के नीचे से गुजरने वाली एक नाव और पुल के ऊपर से आगे बढ़ने वाली एक इकाई अंततः मानचित्र पर उसी सेल पर कब्जा कर लेगी। उन्हें टकराने से कैसे रोकें?

क्या ऐसी समस्या को हल करने के लिए एक सामान्य दृष्टिकोण है? या मुझे ऐसा करने के लिए एक 3D दुनिया को लागू करने की आवश्यकता है?

Comments

अच्छी तरह से अगर आप एक टाइल आधारित प्रणाली कर रहे हैं, तो आप प्रत्येक बार के लिए "isOccupied" विधि की तरह कुछ जोड़ सकते हैं। बस नीचे और ऊपर पुल की जांच है।

— बेंजामिन खतरे जॉनसन

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

— GameAlchemist

Answer 1

आपको मूल रूप से एक तीसरा आयाम बनाना होगा, हालांकि सबसे सरल मामले में यह केवल दो मूल्यों से मिलकर बन सकता है: "जमीन पर / पुल पर" और "पानी / नीचे पुल पर"।

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

ASC के मामले में, स्तर निम्न हैं:

• अंतरिक्ष
• उच्च ऊंचाई (बमबारी)
• मध्यम ऊंचाई (इंटरसेप्टर)
• जमीन पर हमला
• जमीन (अधिकांश जमीनी इकाइयाँ और होवरक्राफ्ट, यहाँ तक कि पानी के ऊपर)
• पानी
• आंशिक रूप से जलमग्न (पनडुब्बी)
• जलमग्न ("छिपी" पनडुब्बियां)

Answer 2

आप प्रत्येक टाइल में एक साधारण विशेषता जोड़ सकते हैं जो इसके स्तर को निर्दिष्ट करता है।

उदाहरण के लिए:

tileA.layer = 0 // Will be at the bottom
tileB.layer = 1 // Will be above level 0, on top of it. 

// Add tiles to layered list
List<List<Tile>> tiles = new List<List<Tile>>();
tiles[0].add(tileA);
tiles[1].add(tileB);

// Draw 'em in the right order!
void Draw(List<List<Tile>> tiles) {
    foreach( var listOfTiles in tiles ) {
        foreach( var tile in listOfTiles ) {
            tile.draw();
        }
}

अब आप अपनी टाइलों को उनकी परत के मूल्यों के आधार पर क्रमबद्ध कर सकते हैं और उन्हें नीचे खींच सकते हैं -> शीर्ष! इससे ऐसा लगेगा कि आप अपने खेल में एक निश्चित गहराई रखते हैं। अधिकांश टाइल इंजन इसका समर्थन करते हैं। एक और बढ़िया चीज़ जिसे आप जोड़ सकते हैं वह है आपके बनावट की पारदर्शिता ताकि आप नीचे की परत से देख सकें।

यह उदाहरण के लिए पानी के साथ किया जा सकता है - lvl 1 पर पानी की कल्पना करें और फिर lvl 0. पर समुद्र तल। अगर पानी की बनावट कुछ पारदर्शी है, तो आप ऊपर से समुद्र तल देख पाएंगे।

Comments

@aleguna कोई चिंता नहीं! यह सिर्फ मदद करने के लिए मजेदार है। :)

— जोलोमन