मेरा चरित्र कहां रुकेगा?


12

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

  • दुश्मन वर्तमान में X = 540.0 पर है।
  • दुश्मन प्रति फ्रेम 10 पिक्सल पर सही चल रहा है।
  • जब दुश्मन रुकना चाहता है, तो इसकी गति 1 पिक्सेल प्रति फ्रेम तक गिर जाएगी जब तक कि यह शून्य तक न पहुंच जाए।

क्या कोई सरल सूत्र है जो मुझे उस स्थिति में पहुंचा देगा जहां दुश्मन पूरी तरह से बंद होने पर समाप्त हो जाए? मैंने अपनी आवश्यकताओं के लिए काम करने वाले ऑफसेटों को पूर्वव्यापी और हार्डकोडिंग समाप्त कर दिया, लेकिन अलग-अलग गति वाले दुश्मनों के लिए अलग से गणना करनी होगी।

जवाबों:


7

मैं आम तौर पर जॉन के जवाब से सहमत हूं। मैं थोड़ा संशोधित सूत्र पेश करने जा रहा हूं (जो उनके मूल्य पर अतिरिक्त V / 2 जोड़ता है):

D = V / A * (V + A) / 2 

साथ V = 10और A = 1, कि हो जाता है डी = 55। यह ठीक उसी का परिणाम है

10 + 9 + 8 + 7 + .... + 3 + 2 + 1

जो दुश्मन के फ्रेम-बाय-फ्रेम मोशन है।

यहां बताया गया है कि आप उस चरण को कैसे प्राप्त करते हैं।

  1. V : करंट वेलोसिटी = 10 पिक्सल्स / फ्रेम, : करंट एक्सेलेरेशन = 1 पिक्सल्स / फ्रेम ^ 2
  2. टी : एक स्टॉप = वी / ए = 10 फ़्रेम पर आने का समय।
  3. दूरी 10 फ्रेम = फ्रेम 1 + फ्रेम 2 + फ्रेम 3 + ... = वी + (वीए) + (वी -2 * 1 ए) के साथ यात्रा की ...
  4. यह T * V - A / 2 * T * (T-1) के बराबर है, जो उपरोक्त समीकरण को सरल बनाता है।

+1 मैं आपके समाधान में कोई तर्क दोष नहीं देख सकता, और मुझे वास्तव में याद नहीं है कि मैं अपने समाधान में कैसे आया। इसलिए मेरी अभिव्यक्ति गलत होनी चाहिए और छोटे अंतर और विस्तृत परीक्षण की कमी के कारण शायद मैंने नोटिस नहीं किया? क्या मेरी अभिव्यक्ति सही हो जाएगी अगर मैंने बस वेग का आधा जोड़ दिया?
जॉन मैकडॉनल्ड्स

मैंने पावर कैल्क का उपयोग करके अपने स्वयं के प्रश्न का उत्तर दिया। मेरी अभिव्यक्ति + (v / 2) लेना किसी भी दिए गए v और a के लिए हमेशा आपकी अभिव्यक्ति के बराबर प्रतीत होता है।
जॉन मैकडॉनल्ड्स

@ जॉन और आप दोनों की बदौलत, इसने मुझे बहुत दिनों में वापस बचाने का प्रयास किया! मैं इस उत्तर को स्वीकार कर रहा हूं, क्योंकि यह सरल और अधिक कुशल है, लेकिन जॉन के उत्तर की बहुत सराहना की जाती है। चीयर्स गायस!
किवोसुकलताजा

6

मेरे खेल पर काम करते समय मेरे पास एक ही मुद्दा था, और मुझे गणित सही (ब्लाह) पाने के लिए हमेशा के लिए ले गया। तो यहाँ यह है:

minDistanceToStop = 0.5 * acceleration * Math.Pow(velocityLinear() / acceleration, 2.0);

नियमित गणित में फिर से लिखा:

(Acceleration / 2) * (linearVelocity / Acceleration)^2

जहां आपके मामले में त्वरण 1 है, और रैखिक वेग 10 है:

(1 / 2) * (10 / 1)^2
= 50 units to stop

संपादित करें

जिमी का परिणाम और स्पष्टीकरण दोनों सही हैं। मेरे सूत्र की आवश्यकता है कि आप वेग का आधा भाग भी जोड़ दें।

minDistanceToStop = (0.5 * acceleration * Math.Pow(velocityLinear() / acceleration, 2.0)) + (velocityLinear() / 2);

या

((Acceleration / 2) * (linearVelocity / Acceleration)^2) + (linearVelocity / 2)
((1 / 2) * (10 / 1)^2) + (10 / 2)
= 55

2
सिर्फ रिकॉर्ड के लिए, Math.Pow () यहाँ एक भयानक, भयानक विचार है। यह हो सकता है विशेष-केस '2.0' प्रतिपादक अगर यह स्मार्ट पर्याप्त है, लेकिन किसी भी तरह से आप इसे काट, '0.5 * linearVelocity * linearVelocity / त्वरण' के रूप में है कि अभिव्यक्ति को फिर से लिखने एक बड़ी जीत होना चाहिए।
स्टीवन स्टैडनिक

4

बदलते वेगों के बारे में गणना पथरी का संपूर्ण बिंदु है। मैंने ऐसा कुछ समय में नहीं किया है, इसलिए मुझे अपने सिर के ऊपर से याद नहीं है, लेकिन मुझे लगता है कि आपकी स्थिति केवल -1 (यानी मंदी) का अभिन्न अंग रही है।


0

क्या यह निरंतर त्वरण गति नहीं है?

X = Xi + V*t + (1/2) * a * (t^2)

कहां:
X: अंतिम स्थिति
शी: प्रारंभिक स्थिति
V: वेग
t: समय
: त्वरण

यहां एकमात्र मुश्किल हिस्सा यह है कि "टी" कैसे निर्धारित किया जाए, चूंकि हम -1 के त्वरण के साथ धीमा हो जाते हैं, फिर हम टी = वी / ए की गणना कर सकते हैं, फिर टी 10 है।

इसलिए,
शी: 540
वी: 10
टी: 10
ए: -1

सब कुछ पर रखो:

X = 540 + 10*10 + (1/2) * (-1) * (10 ^ 2) 
X = 540 + 100 + (-50) 
X = 540 + 50 
X = 590

त्वरण का एकीकरण लेने से सूत्र आता है: यहां देखें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.