एक कार गेम में ट्रांसमिशन कार्यान्वयन

Question

मैं मैनुअल गियर परिवर्तन के साथ एक साधारण कार गेम बनाने की कोशिश कर रहा हूं। हालाँकि, मुझे गियर परिवर्तन को लागू करने में थोड़ी परेशानी हो रही है।

यहाँ "कार" के लिए मेरा वर्तमान कोड है:

int gear = 1; // Current gear, initially the 1st
int gearCount = 5; // Total no. of gears

int speed = 0; // Speed (km/h), initially 0
int[] maxSpeedsPerGear = new int[]
{
    40,  // First gear max. speed at max. RPM
    70,  // Second gear max. speed at max. RPM
    100, // and so on
    130,
    170
}

int rpm = 0; // Current engine RPM
int maxRPM = 8500; // Max. RPM

public void update(float dt)
{
    if(rpm < maxRPM)
    {
        rpm += 65 / gear; // The higher the gear, the slower the RPM increases
    }

    speed = (int) ((float)rpm / (float)maxRPM) * (float)maxSpeedsPerGear[gear - 1]);

    if(isKeyPressed(Keys.SPACE))
    {
        if(gear < gearCount)
        {
            gear++; // Change the gear
            rpm -= 3600; // Drop the RPM by a fixed amount
            if(rpm < 1500) rpm = 1500; // Just a silly "lower limit" for RPM
        }
    }
}

हालाँकि, यह कार्यान्वयन वास्तव में काम नहीं करता है। पहला गियर ठीक काम करता है, लेकिन निम्न गियर परिवर्तन गति ड्रॉप का कारण बनते हैं। कुछ डीबगिंग संदेशों को जोड़कर, RPM सीमा में बदलते समय मुझे ये गति मान मिलते हैं:

Speed at gear 1 before change: 40
Speed after changing from gear 1 to gear 2: 41

Speed at gear 2 before change: 70
Speed after changing from gear 2 to gear 3: 59

Speed at gear 3 before change: 100
Speed after changing from gear 3 to gear 4: 76

Speed at gear 4 before change: 130
Speed after changing from gear 4 to gear 5: 100

जैसा कि आप देख सकते हैं, प्रत्येक परिवर्तन के बाद की गति परिवर्तन से पहले धीमी होती है। गियर बदलने से पहले आप गति को कैसे ध्यान में रखेंगे ताकि गियर बदलते समय गति कम न हो?

Comments

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

— एरिक

Answer 1

नए गियर और कार की वर्तमान गति के आधार पर नए RPM की गणना करें।

speed = (int) ((float)rpm / (float)maxRPM) * (float)maxSpeedsPerGear[gear - 1]);

इसलिए: इसके बजाय:

rpm -= 3600; // Drop the RPM by a fixed amount

उपयोग:

rpm = max(maxRPM,(float)maxRPM * (float)speed / (float)maxSpeedsPerGear[gear - 1]);

गियर बदलने से पहले और बाद में गति समान होगी, और आप वहां से गति / विघटित कर सकते हैं।

संपादित करें: max(maxRPM, calc)आप इसे सीमित करना चाहते हैं के रूप में जोड़ा गया । एक कार की तरह, यह गति का एक बहुत अचानक नुकसान में परिणाम चाहिए

Answer 2

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

यह आपकी गलती है। आरपीएम ड्रॉपडाउन गियर्स के बीच तय नहीं है। आप प्रत्येक गियर के बीच आरपीएम ड्रॉप की सटीक संख्या को संग्रहीत करके एक दूसरी सरणी बनाकर इसे ठीक कर सकते हैं।

दूसरा तरीका आप इसे ठीक कर सकते हैं, शारीरिक रूप से आधारित गणनाओं का उपयोग करके। आप एक सिमुलेशन कर रहे हैं, इसलिए आप एक संख्यात्मक एकीकरण कर सकते हैं। समय, dtऔर यूलर एकीकरण, या वर्लेट एकीकरण का उपयोग करना । यह नामों और सभी के साथ जटिल लगता है लेकिन वास्तव में ऐसा नहीं है।

मूल रूप से इसका मतलब होगा कि आप दिए गए rpms में इंजन टॉर्क के लिए लुकअप टेबल बनाते हैं। फिर आप गति के वर्ग के साथ बढ़ते हुए कुछ वायु प्रतिरोधों को ध्यान में रखेंगे। फिर अनुकार न्यूटन के दूसरे नियम को उलट कर अगली गति की गणना करेगा f=m a।
खोजने के लिए a=f/m, फिर यूलर एकीकरण speed=speed+a*dt:। m1200 (ठेठ कार वजन) के बारे में है। fइंजन टॉर्क से प्राप्त बल है, जिसे गियरबॉक्स में कम किया गया है, और फिर पहिया के त्रिज्या पर विचार करके लीवर फॉर्मूला का उपयोग करके बल में परिवर्तित किया गया है। (एक वेक्टर क्रॉस उत्पाद आमतौर पर, लेकिन त्रिज्या के साथ टोक़ के गुणन द्वारा सरल किया जा सकता है। क्योंकि नेटवटन / मीटर गुणा मीटर = न्यूटन।)

इस तरह, इंजन की आरपीएम की गणना रैखिक कार की गति के एक समारोह के रूप में की जाती है।

Comments

नहीं है exact number of RPM drop between each gear। @Baldrickk बताते हैं कि यह एक अनुपात है। और जबकि यह एक महान विचार है कि ट्रांसमिशन का आउटपुट स्पीड के बजाय टॉर्क हो सकता है, विंड रेसिस्टेंस और वर्ल इंटीग्रेशन की चर्चा सवाल के दायरे से थोड़ा बाहर है, नहीं?

— जस्टिन

हाँ। सवाल के जवाब पर एक जगह के लिए मैं बाल्ड्रिक के जवाब की सिफारिश करूंगा। मैंने इसे उकेरा।

— v.oddou

Answer 3

गियर का उपयोग एक कमी तंत्र के रूप में किया जाता है।

गियरबॉक्स में सिर्फ दो अनुपातों के साथ एक सरलीकृत संचरण का उपयोग करना , एक इनपुट गियर (इंजन) और एक आउटपुट गियर (गियरबॉक्स के अनुपात में से एक) में हमारे पास दो अलग-अलग कमी अनुपात हैं।

तो एक्स दांत के साथ एक इनपुट गियर और एक्स / 2 दांत के एक आउटपुट गियर के लिए, आउटपुट गियर की गति इनपुट गियर की गति (एक दो से एक अनुपात) से दोगुनी होती है

rpm2 = rpm1 * gearRatio

कहा पे:

gearRatio = teeth1 / teeth2

इसलिए प्रत्येक गियर को हार्डकोड स्पीड द्वारा सीमित करने के बजाय, हम इसे अनुपात द्वारा सीमित कर सकते हैं। फिर आप विशिष्ट (rpmEngine, गियर) जोड़ी के लिए गति की गणना कर सकते हैं, और, जब गियर बदला जाता है, तो ज्ञात गति और एक नई जोड़ी को देखते हुए इंजन की गति की गणना करें।

सरल बनाने के लिए, दो गियर से जुड़े एक इंजन का उपयोग करके:

rpmEngine = 5000

gearRatio[1] = 2 #low gear:  one rotation of the engine results in 2 rotations output
gearRatio[2] = 3 #high gear: one rotation of the engine results in 3 rotations output

vehicleSpeed = rpmEngine * gearRatio[selectedGear]

इसलिए:

selectedGear = 1
vehicleSpeed = rpmEngine * gearRatio[selectedGear] #5000 * 2 = 10000 

जब 2 गियर में शिफ्ट किया जाता है, तो 10000 गति है, इसलिए उसी सूत्र में प्लग करना, अब हमारे पास है:

vehicleSpeed = 10000 #computed above
selectedGear = 2

इस प्रकार हमारा नया आरपीएम:

rpmEngine = vehicleSpeed / gearRatio[selectedGear] #10000 / 3 = 3333.3

तब 10000 को एक अंतर से और कम किया जाएगा (जिसे केवल एक और गियर के रूप में सार किया जा सकता है, इसे ऊपर देखें, यदि आवश्यक हो, तो क्षमा करें, जूट दो लिंक पोस्ट कर सकते हैं) और फिर पहिया आकार से किलोमीटर या मील प्रति घंटे में जमीन की गति की गणना करने के लिए ।

इसलिए एक साधारण दृष्टिकोण की जांच करने के लिए है आप को ध्यान में तथ्य यह है कि एक निचले गियर में स्थानांतरण इंजन आरपीएम को जन्म देती है लेने के लिए होता maxRPM और अपनी अधिकतम rpm तक बदलाव के बाद आरपीएम की सीमा है, इस प्रकार वाहन की गति को कम करने।

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

यथार्थवादी सिमुलेशन के लिए, आपको कम से कम इंजन टॉर्क (v.oddou का उत्तर) और क्लच स्लिपेज को ध्यान में रखना होगा, जो कि संयुक्त रूप से इन प्रभावों को प्रभावित करेगा: - जब शिफ्टिंग होती है, तो यह मानते हुए कि शिफ्ट तेजी से पर्याप्त है कि इंजन रेक गिरता नहीं है गति को तब उठाया जाएगा जब इंजन आरपीएम को कम किया जाता है जब तक कि उन्हें बाहर संतुलित नहीं किया जाता है - जब नीचे शिफ्ट किया जाता है, तब तक वाहन की गति कम हो जाएगी जब तक कि इंजन को नए आरपीएम तक नहीं उठाया जाएगा लेकिन यह संभवतः "सरल" कार्यान्वयन से परे है।

Answer 4

ध्यान रखें कि एक लगे हुए मैनुअल ट्रांसमिशन एक टू-वे डिवाइस है। इंजन वाहन को गति दे सकता है, जैसे वाहन (अधिक विशेष रूप से इसकी गति) इंजन को गति दे सकता है।

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

जब तक कि सिंक्रोमेश विकसित नहीं किया गया था। यह एक ऐसा तंत्र है जो इनपुट और आउटपुट स्पीड सिंक में होने तक ट्रांसमिशन को उलझाने से रोकता है।

इसलिए, मेरा सुझाव है कि आप सिंक्रोमेश का अनुकरण करें और इंजन आरपीएम और कार की गति को उनके वर्तमान स्तरों पर मिलान न करें।

Answer 5

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

ओवरराइविंग (आपकी 8500 RPM की सीमा को घटाते हुए) एक ऐसी चीज है जिसे आप अलग से लागू करेंगे, लेकिन यह कारों में एक बुरी चीज है और आप इसे अपने खेल में एक बुरी चीज होने दे सकते हैं।

Comments

मौजूदा जवाब बिल्कुल वही है जो मैंने देखा है कि ज्यादातर गेम, यहां तक ​​कि सरल आर्केड गेम भी हैं, क्योंकि यह वास्तव में उतना जटिल नहीं है। स्क्रीन पर RPM सिर्फ एक संख्या हो सकती है, लेकिन यह दृष्टिकोण आपको दोनों संख्या देता है (जो कि आप दृश्य संकेतकों को किसी भी तरह से ट्वीक कर सकते हैं), और उन नंबरों से मिलान करने का व्यवहार

— सेलाली एडोबोर

Answer 6

जैसा कि दूसरों ने उल्लेख किया है, वाहन की गति का वास्तविक मूल्य होना चाहिए और आरपीएम उसी से प्राप्त होना चाहिए। अपशिफ्टिंग से इंजन की घूर्णी गति कम हो सकती है क्योंकि आरपीएम प्रति किमी / घंटा का अनुपात "तुरंत" बदल जाएगा लेकिन वाहन नहीं चलेगा।

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

Answer 7

का उपयोग करते हुए @ v.oddou पर बिल्डिंग

max(maxRPM, calc)

गियर को शिफ्ट करने के लिए RPMS को तुरंत अधिकतम करने का कारण होगा, गियर से गियर में किसी भी चिकनी संक्रमण के लिए अनुमति नहीं। समीकरण के रूप में गति चर का उपयोग करके RPM के लिए हल करना उचित तरीका होगा।

speed = (int) ((float)rpm / (float)maxRPM) * (float)maxSpeedsPerGear[gear - 1]);

आरपीएम के लिए हल करें

rpm = (maxRPM * speed) / maxSpeedsPerGear[gear - 1] ;

चूंकि गियर पहले की तुलना में 1 अधिक है, आरपीएम कम होगा।