बड़े डेल्टा समय के लिए भौतिकी सिमुलेशन विधि?

Question

वास्तव में बड़े डेल्टा समय (घंटों से सप्ताह) के लिए कौन से भौतिकी सिमुलेशन तरीके सबसे उपयुक्त हैं?

इसके अलावा, क्या मुझे बड़े और छोटे डेल्टा समय के लिए अलग-अलग तरीकों के संयोजन में किसी भी समस्या का सामना करना पड़ेगा?

Comments

यह काफी हद तक आपके लक्षित क्षेत्र पर निर्भर करता है। आप के बारे में अधिक जानने के बिना कुछ भी कहना मुश्किल वहाँ असली लक्ष्य। बहुत चौड़ा।

— क्रॉमास्टर

यह प्रश्न संबंधित है।

— अंको

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

— mklingen

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

— v.oddou

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

— fread2281

Answer 1

आप इन बड़े समय स्पैन (जो शून्य त्वरण हो सकते हैं) के लिए निरंतर त्वरण का उपयोग कर रहे हैं। समय के संबंध में निरंतर त्वरण का व्युत्पन्न 0. है। इसका मतलब यह है कि यह समय के संबंध में नहीं बदलता है, इसलिए इससे कोई फर्क नहीं पड़ता कि आपका डेल्टा समय कितना बड़ा है।

समय के संबंध में यह थोड़ा एकीकरण आपके लिए आवश्यक समीकरण प्रदान करता है।

a = a
v = at + v0
s = .5at^2 + v0*t + s0

जहाँ: a = त्वरण, v = वेग, v0 = प्रारंभिक वेग, s = स्थिति, s0 = प्रारंभिक स्थिति, t = समय

इस रणनीति का उपयोग करके आप कई बार मिलीसेकंड से हफ्तों तक स्पैन का उपयोग कर सकते हैं यदि आप चाहते थे। इन्हें मिलाकर समीकरण के मापदंडों v0और s0मानकों का ध्यान रखा जाएगा ।

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

Comments

टक्करों के बारे में क्या?

— fread2281

मैंने टकराव से निपटने के लिए रणनीतियों को शामिल करने के लिए उत्तर अपडेट किया है।

— MichaelHouse

यह गलत है। यूलर इंटीग्रेशन को निरंतर एकीकरण के लिए विचलित करने के लिए जाना जाता है, जबकि वेरलेट (या आरके 2, आरके 4) नहीं करता है।

— v.oddou

@ v.oddou इन सिमुलेशन को खेल के लिए ध्यान में रखते हुए, मुझे नहीं लगता कि आपके द्वारा आवश्यक सटीकता आवश्यक है। वर्लेट के लिए टकरावों को जोड़ने की अतिरिक्त जटिलता और कठिनाई यूलर एकीकरण को एक बेहतर विकल्प बनाती है।

— MichaelHouse

Answer 2

गुरुत्वाकर्षण के साथ एक उदाहरण लेते हैं।

नीचे दिए गए फ़ंक्शन में, मान लें कि हमारे पास स्थिति और वेग के लिए वर्ग सदस्य चर हैं। हमें प्रत्येक dt सेकंड के गुरुत्वाकर्षण बल के कारण उन्हें अपडेट करने की आवश्यकता है।

void update( float dt )
{
   acceleration = G * m / r^2;
   velocity = velocity + acceleration * dt;
   position = position + velocity * dt;
}

जैसे-जैसे dtछोटा और छोटा होता जाता है, हमारा अनुकरण अधिक से अधिक सटीक होता dtजाता है (हालाँकि यदि बहुत छोटा हो जाता है तो हम बड़ी संख्या में छोटी संख्या जोड़ते समय सटीक त्रुटियों का सामना कर सकते हैं)।

मूल रूप से, आपको यह तय करना होगा कि dtआपका अनुकार कितना अच्छा परिणाम प्राप्त कर सकता है। और अगर dtवह अंदर आता है तो बहुत बड़ा है, तो बस सिमुलेशन को छोटे चरणों में तोड़ दें, जहां प्रत्येक चरण dtआपके द्वारा अनुमत अधिकतम है।

void update( float dt )
{
   acceleration = G * m / r^2;
   velocity = velocity + acceleration * dt;
   position = position + velocity * dt;
}

// this is the function we call. The above function is a helper to this function.
void updateLargeDt( float dt )
{
    const float timeStep = 0.1;
    while( dt > timeStep   )
    {
        update( timeStep  );
        dt -= timeStep ;
    }

    update( dt );  // update with whatever dt is left over from above
}

तो इस रणनीति के साथ, आप केवल timeStep जो भी निष्ठा की आवश्यकता है, उसे समायोजित कर सकते हैं (इसे एक दूसरा, मिनट, घंटा, या जो कुछ भी आवश्यक है भौतिकी का सटीक प्रतिनिधित्व प्राप्त करने के लिए आवश्यक है।

Answer 3

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

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

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

हालांकि, आरके 4 में टकराव को लागू करना बहुत चुनौतीपूर्ण हो सकता है ...