एंड्रॉइड गेम डेवलपमेंट: टकराव का पता लगाना

Question

मैं वर्तमान में एंड्रॉइड के लिए एक गेम विकसित कर रहा हूं, और मैं आपकी विशेषज्ञता को उस मुद्दे पर चाहूंगा जो मेरे पास है।

पृष्ठभूमि:

1. मेरे खेल फ्रेम दर स्वतंत्र गति है, जो खाता आवश्यक वेग गणना प्रदर्शन से पहले डेल्टा समय मूल्य में ले जाता है को शामिल किया गया।

2. यह गेम एक पारंपरिक 2 डी प्लेटफार्म है।

मुद्दा:

यहाँ मेरी मुद्दा (सरलीकृत) है। आइए दिखाएं कि मेरा चरित्र एक मंच के शीर्ष पर एक वर्ग खड़ा है ("गुरुत्वाकर्षण" चरित्र VelocityDown की निरंतर नीचे की गति के साथ)।

मैं टक्कर पता लगाने इस प्रकार है (Y अक्ष अंक नीचे की ओर कल्पना करते हुए) को परिभाषित किया है:

को देखते हुए characterFootY मेरी वर्ग चरित्र के आधार की y- निर्देशांक है, platformSurfaceY ऊपरी y है मेरे मंच के -coordinate, और platformBaseY मेरे मंच के निचले y- निर्देशांक है:

if (characterFootY + characterVelocityDown > platformSurfaceY && characterFootY + characterDy < platformBaseY) { 

        //Collision Is True 
        characterFootY = platformSurfaceY; 
        characterVelocityDown = 0; 

       } else{ 
        characterVelocityDown = deltaTime * 6; 

यह दृष्टिकोण पी काम करता है जब खेल नियमित गति से चल रहा है तो ठीक से ठीक है; लेकिन, अगर खेल को धीमा कर देती, deltaTime (जो पिछले फ्रेम और वर्तमान फ्रेम के बीच लगे समय है) बड़ा हो जाता है, और characterFootY + characterVelocityDown सीमाओं कि टक्कर का पता लगाने और चरित्र को परिभाषित बस गिर जाता है से अधिक सीधे माध्यम से (जैसे टेलीपोर्टिंग)।

इसे रोकने के लिए मैं इस मुद्दे से कैसे संपर्क करूँ?

आपकी मदद के लिए अग्रिम धन्यवाद और मैं आपसे सीखने की उम्मीद कर रहा हूं!

Answer 1

आपको अपने भौतिकी पाश को निरंतर डेल्टा समय के साथ चलाने और वर्तमान टिक के साथ जितनी बार आवश्यकता होती है उसे फिर से चलाने की आवश्यकता है।

const float PHYSICS_TICK = 1/60.f; // 60 FPS 
void Update(float dt) 
{ 
    m_dt += dt; 
    while(m_dt > PHYSICS_TICK) 
    { 
     UpdatePhysics(PHYSICS_TICK); 
     m_dt -= PHYSICS_TICK; 
    } 
} 

टिक छोड़ दिया (m_dt) miniumum टिक और अधिकतम टिक के लिए
कैप्स को संभालने के लिए इस्तेमाल किया विभिन्न टेकनीक रहे हैं भी बहुत जरूरी है।

Answer 2

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

तो मूल रूप से, जैसा कि सेव कहते हैं, अपने गेम लूप हैंडल मंदी करें। ऐसा करने का एकमात्र असली तरीका (मेरे स्वीकार्य रूप से सीमित अनुभव में) एक कैप लगाएगा कि कितना बड़ा डेल्टा हो सकता है। इसके परिणामस्वरूप आपकी घड़ी बिल्कुल समय पर नहीं चल रही है, लेकिन जब आप इसके बारे में सोचते हैं, तो इस तरह अधिकांश गेम मंदी को नियंत्रित करते हैं। आप स्टारक्राफ्ट को अपने पेंटियम 66 पर नहीं फेंकते हैं और इसे 5 एफपीएस पर चलाते हैं लेकिन पूर्ण गति, यह धीमा हो जाता है और स्लाइडशो के बावजूद इसे सामान्य के रूप में प्रोसेस करता है।

यदि आपने ऐसा किया है, तो आपके गेम में मंदी की अवधि के दौरान, यह स्पष्ट रूप से धीमा हो जाएगा ... लेकिन गणना अभी भी सभी जगह पर होनी चाहिए।

संपादित करें: बस एहसास हुआ कि आप SeveN हैं। बहुत बढ़िया।