एकता 3 डी टैंक ट्यूटोरियल: हवाई जहाज़ के पहिये (सबक 2. ट्रैक हवाई जहाज़ के पहिये)

पाठ 1 <<

प्रविष्टि

मैं घर पर टैंक को इकट्ठा करने पर सबक जारी रखता हूं। पिछले पाठ में, आपने एकता पर वाहन चलाने की मूल बातें सीखीं, इस पाठ में हम वही करेंगे जो आप इस डेमो में देख सकते हैं।

अर्थात्: मैं एक 3D संपादक में ट्रैक की गई चेसिस को बेहतर तरीके से मॉडल करने के बारे में बात करूंगा ताकि यह पर्याप्त रूप से आगे बढ़ सके और इलाके के धक्कों का जवाब दे सके, मैं आपको एक तैयार मॉडल भी दूंगा जिसे आप डेमो में देख सकते हैं, फिर आप सीखेंगे कि इस पूरी चीज को कैसे लाया जाए और कैसे लाया जाए? व्हील कोलाइडर्स के साथ गति में सेट।

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

1. ट्रैक मॉडलिंग तकनीक

यह अजीब नहीं है, लेकिन इन तरीकों को कैटरपिलर आंदोलन के तरीकों के साथ अटूट रूप से जोड़ा जाता है, लेकिन स्वाभाविक रूप से, सब कुछ इस बात पर भी निर्भर करता है कि जिस इंजन पर हम अपने आंदोलन को लागू करना चाहते हैं, वह हमें क्या पेशकश कर सकता है। यूनिटी 3 डी के मामले में, मुझे दो परिदृश्य दिखाई देते हैं:

1. हम कई अलग-अलग वस्तुओं से एक कमला अनुकरण करते हैं, उदाहरण के लिए इस मामले में:
   (अधिकतम 3ds)
   
   
   हम प्रत्येक ट्रैक को उसके बाद की स्थिति प्राप्त करके गति में सेट करते हैं और धीरे-धीरे वर्तमान ट्रैक की स्थिति को अगले की स्थिति में बदल देते हैं, Collider class Raycast () विधि का उपयोग करते हुए इलाके की अनियमितताओं के आधार पर ट्रैक विरूपण की गणना करते हैं, यह एक निश्चित दिशा में एक निश्चित लंबाई की एक बीम को प्रक्षेपित करता है, और वापस लौटता है सच है अगर यह किसी भी कोलाइडर के साथ प्रतिच्छेदन करता है।
   इस विधि के लाभ: कैटरपिलर का उच्च विवरण, कैटरपिलर का उच्च यथार्थवादी आंदोलन।
   नुकसान: कार्यान्वयन की जटिलता, कंप्यूटिंग पॉवर पर भार चूंकि पटरियों की संख्या पर निर्भर करता है आपको प्रत्येक के लिए रेकास्ट () की गणना करनी होगी, अगर बहुत सारे हैं, तो प्रदर्शन में गिरावट अपरिहार्य है।
   ईमानदारी से, मैंने इस पद्धति को लागू करने की कोशिश नहीं की, क्योंकि Gamedev मंचों चढ़ते दूसरे पाया।
   
2. हम एक निरंतर टेप के साथ एक कमला मॉडल करते हैं:
   (अधिकतम 3ds)
   
   
   फिर हम एक या एक से अधिक पटरियों की दोहराई गई बनावट को लागू करते हैं।
   
   वास्तव में देखो, यहां सब कुछ सरल है, एक कैटरपिलर की पटरियों के संचलन का भ्रम इसकी बनावट के निर्देशांक को बदलकर बनावट को स्थानांतरित करके बनाया जा सकता है। और इलाके की अनियमितताओं के अनुसार विरूपण टेप के उन स्थानों में हड्डियों को बांधकर किया जा सकता है जहां ट्रैक रोलर्स स्थित हैं, क्योंकि पहले सबक से हम पहले से ही जानते हैं कि व्हीकलहोल्डर के पहिये से जुड़ी गेटगोहाइट () विधि के आधार पर पहियों की स्थिति की गणना कैसे करें, फिर गणना करें हड्डियों की स्थिति जिसके लिए टेप संलग्न है, मुश्किल नहीं है। या आप उसी Raycast का उपयोग कर सकते हैं (कोई भी, जैसा कि आप कृपया, मैं WheelCollider निलंबन के लिए बाध्य होने से काफी खुश हूं)।
   इस पद्धति के लाभ: कार्यान्वयन में आसानी, गणना पर एक छोटा भार।
   नुकसान: पहली विधि की तुलना में ट्रैक डिटेल इतनी अधिक नहीं है (हालांकि यह सवाल सापेक्ष है, इस बात पर गौर करें कि टैंक, क्राइसिस, बैटलफील्ड: बैड कंपनी में ऐसा ही कैसे किया गया था, लेकिन हां हर जगह एक रिबन है जो बनावट के साथ है जो पारदर्शिता का समर्थन करता है, और यह काफी यथार्थवादी लग रहा है)।
   

तो, हम दूसरी विधि चुनते हैं, और हम हड्डियों को कैटरपिलर से जोड़ते हैं ताकि इसे निम्न प्रकार से विकृत किया जा सके:
(अधिकतम 3ds)




जैसा कि आप स्क्रीनशॉट में देख सकते हैं, पहिए भी कैटरपिलर के समान हड्डियों से जुड़े होते हैं। चलिए प्रयोग करते हैं, किसी तरह का आदिम बनाते हैं, इसे एक हड्डी से जोड़ते हैं, या कई, फिर इसे एकता को निर्यात करते हैं (आप यहां विभिन्न 3 डी मॉडलिंग पैकेज से निर्यात के बारे में पढ़ सकते हैं, मैं व्यक्तिगत रूप से FBX प्रारूप में सब कुछ निर्यात करने की सलाह देता हूं, और फिर परिणामस्वरूप फ़ाइल को फ़ोल्डर में कॉपी कर सकता हूं आपकी परियोजना के एसेट्स, उसके बाद आप इस फाइल का नाम अपने प्रोजेक्ट के प्रोजेक्ट टैब में देख सकते हैं, और इसे आगे के हेरफेर के लिए इसे केवल दृश्य पर खींचें)। उसके बाद, स्वयं मॉडल का चयन करें और इसे स्थानांतरित करने, घुमाने, खिंचाव करने का प्रयास करें। यह पता चला है? यह सही है, यह काम नहीं करता है! तथ्य यह है कि एकता में, हड्डी (हड्डियों) से जुड़ी कोई भी स्किनड मेष अपने परिवर्तनों के लिए एक दास बन जाती है, उसी ऑपरेशन को हड्डी के साथ करने का प्रयास करें जिससे यह जुड़ा हुआ है और आप सफल होंगे।

तदनुसार, हमें पहियों को हड्डी से बांधने की आवश्यकता नहीं है क्योंकि उन्हें घूमना होगा। हम उन्हें खोल देते हैं, अब इसे इस तरह देखना चाहिए:
(अधिकतम 3ds)


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

2. एक मॉडल आयात करें और एक स्क्रिप्ट तैयार करें

इसलिए, जैसा कि मैंने ऊपर लिखा है, मॉडल और बनावट को अपनी परियोजना के एसेट्स फ़ोल्डर में कॉपी करें, या आप उन्हें सीधे प्रोजेक्ट एक्सप्लोरर में अपने एक्सप्लोरर से खींच सकते हैं, मुख्य बात यह है कि मॉडल और बनावट एक ही फ़ोल्डर में हैं ताकि बनावट स्वचालित रूप से ओवरलैप हो जाए किसी कारण से, आप पटरियों पर बनावट नहीं देखते हैं (इससे पहले कि आप प्राकृतिक रूप से मंच पर मॉडल को खींचने की आवश्यकता देखें), या आप इसे किसी अन्य फ़ोल्डर में फेंकना चाहते हैं, यह कोई फर्क नहीं पड़ता, बस पटरियों में से एक का चयन करें (उन्हें Track_line_left और Track_line_right कहा जाता है। ), फिर इंस्पेक्टर ऑन टेक्सचर सेटिंग पर जाएं, सेलेक्ट बटन दबाएं और ट्रैक टेक्सचर चुनें।

पटरियों की संख्या बढ़ाने के लिए, छवि के अनुसार, 2 के बराबर y पर टाइलिंग सेट करें।

अब एक नई C # स्क्रिप्ट बनाएं (Assets -> Create -> C Sharp Script), इसे टैंकट्रैककंट्रोलर नाम दें, इसे खोलें और उन चरों की घोषणा करें जिन्हें हमें भविष्य में काम करने की आवश्यकता है:

using UnityEngine; using System.Collections; using System.Collections.Generic; //1 public class TankTrackController : MonoBehaviour { public GameObject wheelCollider; //2 public float wheelRadius = 0.15f; //3 public float suspensionOffset = 0.05f; //4 public float trackTextureSpeed = 2.5f; //5 public GameObject leftTrack; //6 public Transform[] leftTrackUpperWheels; //7 public Transform[] leftTrackWheels; //8 public Transform[] leftTrackBones; //9 public GameObject rightTrack; //6 public Transform[] rightTrackUpperWheels; //7 public Transform[] rightTrackWheels; //8 public Transform[] rightTrackBones; //9 public class WheelData { //10 public Transform wheelTransform; //11 public Transform boneTransform; //12 public WheelCollider col; //13 public Vector3 wheelStartPos; //14 public Vector3 boneStartPos; //15 public float rotation = 0.0f; //16 public Quaternion startWheelAngle; //17 } protected WheelData[] leftTrackWheelData; //18 protected WheelData[] rightTrackWheelData; //18 protected float leftTrackTextureOffset = 0.0f; //19 protected float rightTrackTextureOffset = 0.0f; //19 } 

1. हम गतिशील सूचियों का उपयोग करने के लिए आवश्यक नाम स्थान को हल करते हैं, वे बाद में काम में आएंगे।
2. हम एक चर घोषित करते हैं जिसमें हमारे व्हील कोलाइडर के प्रीफैब को संग्रहीत किया जाएगा (पिछले पाठ के आइटम 2 को याद रखें)।
3. हमारे पहियों की त्रिज्या।
4. जब यह सतह को स्पर्श नहीं करता है, तो प्रारंभिक स्थिति के सापेक्ष पहिया की ऑफसेट।
5. कैटरपिलर की गति (वास्तव में, बनावट के विस्थापन की गति)
6. बाएँ और दाएँ ट्रैक।
7. बाएं और दाएं ऊपरी पहिए जिसमें व्हील कोलाइडर को नहीं जोड़ा जाएगा।
8. पहिए जिसमें व्हील कोलाइडर जोड़े जाएंगे (जैसा कि आप यहां देख सकते हैं, पिछले पाठ के विपरीत, मैंने व्हील कोलाइडर्स के लिए सरणियों की घोषणा नहीं की थी, वे पहिया स्थिति का उपयोग करके स्क्रिप्ट से सीधे हमारे पहियों में जुड़ जाएंगे, इसलिए फ़िल्टर करने से पहले पहियों को स्थानांतरित न करें प्ले बटन पर, उन्हें एक दूसरे के सापेक्ष संरेखित किया जाना चाहिए)।
9. बाएं और दाएं कैटरपिलर से जुड़ी हड्डियां।
10. हम एक वर्ग की घोषणा करते हैं जिसमें हम प्रत्येक पहिया (अपरहेल को छोड़कर) के बारे में आवश्यक जानकारी संग्रहीत करेंगे, अर्थात्:
11. पहियों को बदलना;
12. कैटरपिलर से जुड़ी ट्रांसफॉर्मर हड्डी;
13. व्हीलचेयर पहियों;
14. पहिया की प्रारंभिक स्थिति;
15. हड्डी की प्रारंभिक स्थिति;
16. व्हील रोटेशन कोण;
17. पहिए के घूमने का प्रारंभिक कोण।
18. हम बाएं और दाएं पहियों पर डेटा को संग्रहीत करने की सरणियों की घोषणा करते हैं, जैसा कि आप देखते हैं कि संरक्षित एक्सेस संशोधक का उपयोग किया जाता है, ताकि हम इस डेटा को कक्षा के बाहर नहीं बदल सकें।
19. और अंत में, हम उन चरों की घोषणा करते हैं जो बनावट की वर्तमान ऑफसेट को ट्रैक पर समन्वयित करेंगे।

तो मुख्य चर घोषित किए जाते हैं, यह उन्हें हमारे मॉडल के साथ जोड़ना, स्क्रिप्ट को सहेजना, संपादक के पास जाना, हमारी स्क्रिप्ट को टैंक ऑब्जेक्ट पर खींचें (जब तक कि आपने इसका नाम नहीं बदला)।

टैंक ऑब्जेक्ट पर ही जाएं, जैसा कि आप देखते हैं, स्क्रिप्ट के अलावा सिर्फ संलग्न है, वहां एक एनीमेशन ऑब्जेक्ट है, आप इसे सुरक्षित रूप से कुछ भी नहीं निकाल सकते हैं।


इसके बाद, WheelCollider के साथ ऑब्जेक्ट का प्रीफ़ैब बनाएं (हम पिछले पाठ के आइटम 2 को याद करते हैं), मैंने इसे टैंक_कोलाइडर कहा है, इसमें निम्नलिखित पैरामीटर होंगे।


हम वस्तुओं को हमारी स्क्रिप्ट में खींचना शुरू करते हैं, पहली चीज जो आप कर सकते हैं वह हमारी स्क्रिप्ट के अंदर व्हील कोलाइडर फ़ील्ड में नए बनाए गए प्रीफ़ैब को खींचें। इसके बाद, बाएं ट्रैक और राइट ट्रैक फ़ील्ड पर पटरियों को खींचें (उन्हें Track_line_left और Track_line_right कहा जाता है)। फिर ऊपरी पहिए (अपर_व्हील [संख्या] _left, अपर_व्हील [संख्या] _right), लेफ्ट ट्रैक ऊपरी पहियों और दाएं ट्रैक ऊपरी पहियों सरणियों में। खैर, मुझे लगता है कि आप पहियों और हड्डियों के बाकी हिस्सों का पता लगा सकते हैं (पहियों को rowheel_ [संख्या] _right और rowheel_ [संख्या] _left कहा जाता है), और हड्डियों का सस्पेंशन_बोन [संख्या] _left और निलंबन_bone [संख्या] _right) है, मुख्य बात यह है कि सभी पहियों और हड्डियों को एक ही स्थान पर स्थानांतरित किया जाता है। इसे करना आसान बनाने के लिए, मैंने उन्हें विशेष रूप से गिना, और चेन_बोन [संख्या] _left और Chain_bone [संख्या] _right कहा जाता है कि हड्डियों को स्पर्श न करें, ठीक है, कैटरपिलर का स्थैतिक हिस्सा उनसे जुड़ा हुआ है।

यहां बताया गया है कि यह सब आखिर में कैसा होना चाहिए:


अगला, टैंक ऑब्जेक्ट का चयन करें और निम्न मापदंडों के साथ इसमें Rigidbody जोड़ें:


फिर पतले बच्चे के ऑब्जेक्ट (टैंक बॉडी) को ढूंढें, इसमें एक मेष कोलाइडर जोड़ें (घटक -> भौतिकी -> मेष कोलाइडर), और उत्तल बॉक्स की जांच करें (इस चेकबॉक्स का अर्थ है कि यह मेष कोलाइडर टैंक बॉडी में समाहित सभी त्रिकोणों के टकराव की गणना नहीं करेगा, लेकिन अपनी खुद की जाली बनाएं जिसमें अधिकतम 255 त्रिकोण होंगे)।

3. व्हील कोलाइडर और व्हील पैरामीटर सेट करें

तो अब हमारे चर घोषित किए गए हैं और आरंभिक हैं, आगे बढ़ते हैं, और पहिएदारटा में पहिया मापदंडों को बचाते हुए शुरू करते हैं [] leftTrackWheelData और WheelData [] rightTrackWheelData सरणियों। हम इसे अवेक () फ़ंक्शन के अंदर करेंगे और सहायक फ़ंक्शन व्हीलडेटा सेटअपव्हील्स () घोषित करेंगे, जो कि आप देख सकते हैं, इसके साथ सभी ऑपरेशन करने से पहले, टाइप व्हीलडेटा का मान वापस करना चाहिए। यह सब इस तरह दिखता है:

 void Awake() { leftTrackWheelData = new WheelData[leftTrackWheels.Length]; //1 rightTrackWheelData = new WheelData[rightTrackWheels.Length]; //1 for(int i=0;i<leftTrackWheels.Length;i++){ leftTrackWheelData[i] = SetupWheels(leftTrackWheels[i],leftTrackBones[i]); //2 } for(int i=0;i<rightTrackWheels.Length;i++){ rightTrackWheelData[i] = SetupWheels(rightTrackWheels[i],rightTrackBones[i]); //2 } Vector3 offset = transform.position; //3 offset.z +=0.01f; //3 transform.position = offset; //3 } WheelData SetupWheels(Transform wheel, Transform bone){ //2 WheelData result = new WheelData(); GameObject go = new GameObject("Collider_"+wheel.name); //4 go.transform.parent = transform; //5 go.transform.position = wheel.position; //6 go.transform.localRotation = Quaternion.Euler(0,wheel.localRotation.y,0); //7 WheelCollider col = (WheelCollider) go.AddComponent(typeof(WheelCollider));//8 WheelCollider colPref = wheelCollider.GetComponent<WheelCollider>();//9 col.mass = colPref.mass;//10 col.center = colPref.center;//10 col.radius = colPref.radius;//10 col.suspensionDistance = colPref.suspensionDistance;//10 col.suspensionSpring = colPref.suspensionSpring;//10 col.forwardFriction = colPref.forwardFriction;//10 col.sidewaysFriction = colPref.sidewaysFriction;//10 result.wheelTransform = wheel; //11 result.boneTransform = bone; //11 result.col = col; //11 result.wheelStartPos = wheel.transform.localPosition; //11 result.boneStartPos = bone.transform.localPosition; //11 result.startWheelAngle = wheel.transform.localRotation; //11 return result; //12 } 

1. हम एरे के आयाम की घोषणा करते हैं जिसमें हमारे पहियों के बारे में जानकारी होगी।
2. हम इन सरणियों को भरते हैं, इसके लिए, जैसा कि मैंने ऊपर लिखा था, पहले तर्क के साथ SetupWheels () फ़ंक्शन बनाया जिसमें हम ट्रांसफ़ॉर्म पहियों को पारित करते हैं, और दूसरा ट्रांसफॉर्म हड्डियों के साथ।
3. अजीब बात है, लेकिन जब मैंने प्ले मोड में प्रवेश किया, तो कोलाडर लगातार भूमिगत हो गए, सौभाग्य से, यह केवल टैंक ऑब्जेक्ट को थोड़ा आगे बढ़ाकर इलाज किया जाता है, जो कि ये ऑपरेशन करते हैं।
4. एक नया खाली GameObject बनाएँ जिसका नाम Collider_ उपसर्ग के साथ पहिया के नाम से युक्त होगा।
5. हम नई बनाई गई वस्तु को उस वस्तु का एक बच्चा बनाते हैं जिससे स्क्रिप्ट जुड़ी हुई है (हमारे मामले में, टैंक ऑब्जेक्ट का एक बच्चा)।
6. हम नव निर्मित वस्तु को उस स्थान पर स्थानांतरित करते हैं जहां हमारे पास पहिया है।
7. हम वाई अक्ष के चारों ओर स्थानीय रूप से उसी कोण से घुमाते हैं जिस पर वर्तमान पहिया घुमाया जाता है।
8. व्हील कोलाइडर घटक को हमारे खाली GO पर जोड़ें।
9. हम अपने प्रीफ़ैब से व्हील कोलाइडर सेटिंग्स प्राप्त करते हैं।
10. हम प्रीफ़ैब से प्राप्त सेटिंग्स को नए बनाए गए व्हील कोलाइडर के रूप में असाइन करते हैं (जैसा कि आप देखते हैं, हमें प्रत्येक सेटिंग को अलग से असाइन करना था, इस मामले में हम इस डिज़ाइन को केवल col = colPref संकलित नहीं कर सकते हैं, लेकिन डिफ़ॉल्ट रूप से कोलाइडर रहते हैं)।
11. हम अपनी जरूरत की बाकी जानकारी देते हैं।
12. हम परिणाम वापस करते हैं।

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

4. "रिवाइव" पहियों और ट्रैक

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

 void FixedUpdate(){ UpdateWheels(); //1 } public void UpdateWheels(){ //1 float delta = Time.fixedDeltaTime; //2 float trackRpm = CalculateSmoothRpm(leftTrackWheelData); //3 foreach (WheelData w in leftTrackWheelData){ //4 w.wheelTransform.localPosition = CalculateWheelPosition(w.wheelTransform,w.col,w.wheelStartPos); //5 w.boneTransform.localPosition = CalculateWheelPosition(w.boneTransform,w.col,w.boneStartPos); //6 w.rotation = Mathf.Repeat(w.rotation + delta * trackRpm * 360.0f / 60.0f, 360.0f); //7 w.wheelTransform.localRotation = Quaternion.Euler(w.rotation, w.startWheelAngle.y, w.startWheelAngle.z); //8 } leftTrackTextureOffset = Mathf.Repeat(leftTrackTextureOffset + delta*trackRpm*trackTextureSpeed/60.0f,1.0f); //9 leftTrack.renderer.material.SetTextureOffset("_MainTex",new Vector2(0,-leftTrackTextureOffset)); //10 trackRpm = CalculateSmoothRpm(rightTrackWheelData); //3 foreach (WheelData w in rightTrackWheelData){ //4 w.wheelTransform.localPosition = CalculateWheelPosition(w.wheelTransform,w.col,w.wheelStartPos); //5 w.boneTransform.localPosition = CalculateWheelPosition(w.boneTransform,w.col,w.boneStartPos); //6 w.rotation = Mathf.Repeat(w.rotation + delta * trackRpm * 360.0f / 60.0f, 360.0f); //7 w.wheelTransform.localRotation = Quaternion.Euler(w.rotation, w.startWheelAngle.y, w.startWheelAngle.z); //8 } rightTrackTextureOffset = Mathf.Repeat(rightTrackTextureOffset + delta*trackRpm*trackTextureSpeed/60.0f,1.0f); ///9 rightTrack.renderer.material.SetTextureOffset("_MainTex",new Vector2(0,-rightTrackTextureOffset)); //10 for(int i=0;i<leftTrackUpperWheels.Length;i++){ //11 leftTrackUpperWheels[i].localRotation = Quaternion.Euler(leftTrackWheelData[0].rotation, leftTrackWheelData[0].startWheelAngle.y, leftTrackWheelData[0].startWheelAngle.z); //11 } for(int i=0;i<rightTrackUpperWheels.Length;i++){ //11 rightTrackUpperWheels[i].localRotation = Quaternion.Euler(rightTrackWheelData[0].rotation, rightTrackWheelData[0].startWheelAngle.y, rightTrackWheelData[0].startWheelAngle.z); //11 } } private float CalculateSmoothRpm(WheelData[] w){ //12 float rpm = 0.0f; List<int> grWheelsInd = new List<int>(); //13 for(int i = 0;i<w.Length;i++){ //14 if(w[i].col.isGrounded){ //14 grWheelsInd.Add(i); //14 } } if(grWheelsInd.Count == 0){ //15 foreach(WheelData wd in w){ //15 rpm +=wd.col.rpm; //15 } rpm /= w.Length; //15 }else{ //16 for(int i = 0;i<grWheelsInd.Count;i++){ //16 rpm +=w[grWheelsInd[i]].col.rpm; //16 } rpm /= grWheelsInd.Count; //16 } return rpm; //17 } private Vector3 CalculateWheelPosition(Transform w,WheelCollider col,Vector3 startPos){ //18 WheelHit hit; Vector3 lp = w.localPosition; if (col.GetGroundHit(out hit)) { lp.y -= Vector3.Dot(w.position - hit.point, transform.up) - wheelRadius; }else { lp.y = startPos.y - suspensionOffset; } return lp; } 

1. हम फिक्स्डअपडेट () फ़ंक्शन के अंदर हमारे फ़ंक्शन अपडेटव्हील () को कॉल करेंगे, जो पहियों के रोटेशन की स्थिति और कोण की गणना करेगा।
2. सबक 1 देखें।
3. फ़ंक्शन CalculateSmoothRpm () पहियों की औसत गति की गणना करेगा (मैं आपको बाद में अधिक बताऊंगा) ताकि वे एक ही गति से घूमें, हम पूरे वामट्रैकव्हेलडैट [] सरणी को पास करते हैं, और फिर राइटट्रैकव्हेलडाटा [] सरणी।
4. बाएं और दाएं पहियों पर डेटा वाले सरणियों के सभी तत्वों के लिए, हम निम्नलिखित ऑपरेशन करते हैं:
5. हम वाई अक्ष के साथ पहिया की स्थानीय स्थिति की गणना करते हैं, जो हमें फ़ंक्शन कैलक्लेटवेलपोसिशन () (नीचे विवरण) के साथ मदद करेगा, जिसमें हम पहिया के ट्रांसफॉर्मर, उसके व्हीक्लॉइडर, और इसकी प्रारंभिक स्थानीय स्थिति को पास करते हैं;
6. एक ही संचालन, केवल इस बार हड्डी की स्थानीय स्थिति की गणना करने के लिए जिसमें कैटरपिलर का यह हिस्सा जुड़ा हुआ है;
7. हम पहिया के रोटेशन के कोण की गणना करते हैं (सबक 1 देखें), लेकिन इस बार हम कॉइडर की आरपीएम का उपयोग नहीं करते हैं, लेकिन औसत रोटेशन की गति जो पहले गणना की गई थी;
8. चक्र के रोटेशन के स्थानीय कोण पर गणना किए गए रोटेशन कोण को लागू करें (सबक 1 देखें)।
9. हम कैटरपिलर की बनावट की भरपाई करते हैं। दुर्भाग्य से, मुझे एक सार्वभौमिक सूत्र नहीं मिला जो हमें पहिया को घुमाने और उसी गति से कैटरपिलर को स्थानांतरित करने की अनुमति देगा, इसलिए मुझे एक अतिरिक्त चर trackTextureSpeed ​​(ऊपर देखें) को पेश करना होगा, जिसे बाद में मैन्युअल रूप से समायोजित करना होगा कि पहिया और कैटरपिलर समान गति से चले गए।
10. Y समन्वित (नया वेक्टर 2 (0 -leftTrackTextureOffset)) के कैटरपिलर ऑफ़सेट को लागू करें, GO leftTrack और दाएँ हाथ की बैरक द्वारा उपयोग की जाने वाली सामग्री की मुख्य बनावट ("_MainTex")।
11. हम उन ऊपरी पहियों के रोटेशन की गणना करते हैं, जिनसे WheelColliders संलग्न नहीं हैं, हम किसी अन्य पहिया से रोटेशन के कोण को उधार ले सकते हैं, सभी एक ही, अब वे सभी एक ही गति से चलते हैं।
12. खैर, आखिरकार हमें कैलकुलेटस्मूथआरपीएम () फ़ंक्शन मिला, जो कि व्हीलडैट प्रकार की एक सरणी को अपने पहले तर्क के रूप में लेता है, जो मूल नाम w को सहन करता है।
13. हम एक नई गतिशील सूची बनाते हैं, जिसमें सरणी डब्ल्यू के उन तत्वों के सूचक शामिल होंगे जिनके अंदर व्हीक्लॉइडर कोलो वर्तमान में सतह (टेर्रान) को छू रहा है।
14. हम सरणी के माध्यम से जाते हैं और उन तत्वों के सूचकांकों को ढूंढते हैं जिनमें कोलेडर सतह को छूते हैं।
15. यदि सूची में तत्वों की संख्या शून्य है, अर्थात, यदि कोई भी कोलाडर जमीन को नहीं छूता है, तो सरणी डब्ल्यू के अंदर सभी आरपीएम कोलाइडर को जोड़ दें, फिर परिणामी मान को सरणी डब्ल्यू में तत्वों की संख्या से विभाजित करें, इस प्रकार औसत मान प्राप्त करें।
16. यदि हमारे पास सूची के एक या अधिक तत्व हैं, अर्थात, यदि एक या एक से अधिक कोलाइडर जमीन को छूते हैं, तो केवल इन कोलाइडर की गति को जोड़ें और सूची में तत्वों की संख्या से विभाजित करें।
17. हम परिणामी मान लौटाते हैं। (आपके पास एक प्रश्न होना चाहिए: जमीन को छूने वाले कोलाइडर की गणना के लिए ये सभी ऑपरेशन क्यों, और आप सभी पहियों के रोटेशन की औसत गति को लगातार क्यों नहीं पा सकते हैं? जवाब होमवर्क है: (और बेहतर प्रयोग) सोचें कि फिर इसमें पहिए कैसे घूमेंगे? स्थिति:
    
18. फ़ंक्शन कैलकुलेटवेलपॉज़िशन () जो पहले तर्क के रूप में व्हील (या बोन) के ट्रांसफ़ॉर्म को लेता है, व्हीलचेयर के दूसरे को, और व्हील (या हड्डी) की शुरुआती स्थानीय स्थिति को तीसरा। जैसा कि मैंने ऊपर कहा, यह फ़ंक्शन पहिया (या हड्डी) की स्थानीय स्थिति की गणना करता है, और बिल्कुल कुछ नया नहीं करता है, क्योंकि हमने पहले पाठ में इस एल्गोरिथ्म की जांच की थी।

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

5. सवारी करना सीखना

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

तो एक टैंक कैसे जगह में बदल सकता है, या बिना किसी स्टीयरिंग व्हील के बिल्कुल भी मुड़ सकता है? सब कुछ अपमानजनक रूप से सरल है, जैसा कि आप ऊपर दिए गए वीडियो से देख सकते हैं, एक कैटरपिलर आगे बढ़ता है, दूसरा पीछे की ओर बढ़ता है, इसलिए टैंक अपनी धुरी के चारों ओर घूमता है। लगभग उसी तरह से टैंक आंदोलन के दौरान बदल जाता है, सिवाय इसके कि हम जिस ओर मुड़ना चाहते हैं उस पर स्थित कैटरपिलर विपरीत दिशा में नहीं बढ़ता है, लेकिन थोड़ा धीमा हो जाता है।

मैंने सरलतम के साथ शुरू करने और हमारे टैंक को मौके पर चालू करने के लिए सिखाना शुरू करने का प्रस्ताव दिया। यहां सब कुछ स्पष्ट लग रहा था। और हम यह कर सकते हैं:

 public float rotateOnStandTorque = 1500.0f; //1 public float rotateOnStandBrakeTorque = 500.0f; //2 public float maxBrakeTorque = 1000.0f; //3 void FixedUpdate(){ float accelerate = 0; float steer = 0; accelerate = Input.GetAxis("Vertical"); //4 steer = Input.GetAxis("Horizontal"); //4 UpdateWheels(accelerate,steer); //5 } public void UpdateWheels(float accel,float steer){ //5 float delta = Time.fixedDeltaTime; float trackRpm = CalculateSmoothRpm(leftTrackWheelData); foreach (WheelData w in leftTrackWheelData){ w.wheelTransform.localPosition = CalculateWheelPosition(w.wheelTransform,w.col,w.wheelStartPos); w.boneTransform.localPosition = CalculateWheelPosition(w.boneTransform,w.col,w.boneStartPos); w.rotation = Mathf.Repeat(w.rotation + delta * trackRpm * 360.0f / 60.0f, 360.0f); w.wheelTransform.localRotation = Quaternion.Euler(w.rotation, w.startWheelAngle.y, w.startWheelAngle.z); CalculateMotorForce(w.col,accel,steer); //6 } leftTrackTextureOffset = Mathf.Repeat(leftTrackTextureOffset + delta*trackRpm*trackTextureSpeed/60.0f,1.0f); leftTrack.renderer.material.SetTextureOffset("_MainTex",new Vector2(0,-leftTrackTextureOffset)); trackRpm = CalculateSmoothRpm(rightTrackWheelData); foreach (WheelData w in rightTrackWheelData){ w.wheelTransform.localPosition = CalculateWheelPosition(w.wheelTransform,w.col,w.wheelStartPos); w.boneTransform.localPosition = CalculateWheelPosition(w.boneTransform,w.col,w.boneStartPos); w.rotation = Mathf.Repeat(w.rotation + delta * trackRpm * 360.0f / 60.0f, 360.0f); w.wheelTransform.localRotation = Quaternion.Euler(w.rotation, w.startWheelAngle.y, w.startWheelAngle.z); CalculateMotorForce(w.col,accel,-steer); //6 } rightTrackTextureOffset = Mathf.Repeat(rightTrackTextureOffset + delta*trackRpm*trackTextureSpeed/60.0f,1.0f); rightTrack.renderer.material.SetTextureOffset("_MainTex",new Vector2(0,-rightTrackTextureOffset)); for(int i=0;i<leftTrackUpperWheels.Length;i++){ leftTrackUpperWheels[i].localRotation = Quaternion.Euler(leftTrackWheelData[0].rotation, leftTrackWheelData[0].startWheelAngle.y, leftTrackWheelData[0].startWheelAngle.z); } for(int i=0;i<rightTrackUpperWheels.Length;i++){ rightTrackUpperWheels[i].localRotation = Quaternion.Euler(rightTrackWheelData[0].rotation, rightTrackWheelData[0].startWheelAngle.y, rightTrackWheelData[0].startWheelAngle.z); } } public void CalculateMotorForce(WheelCollider col, float accel, float steer){ //6 if(accel == 0 && steer == 0){ //7 col.brakeTorque = maxBrakeTorque; //7 }else if(accel == 0.0f){ //8 col.brakeTorque = rotateOnStandBrakeTorque; //9 col.motorTorque = steer*rotateOnStandTorque; //10 } } 

1. टॉर्क जिस जगह पर होता है हम टॉर्क को पहुंचाएंगे।
2. जब हम टैंक में होते हैं, तो ब्रेकिंग मोमेंट हम कोलाइडर में भेज देते हैं।
3. अधिकतम ब्रेकिंग टॉर्क।
4. सबक 1 देखें।
5. हम UpdateWheels () फ़ंक्शन को संशोधित करते हैं ताकि यह वर्चुअल कुल्हाड़ियों से मान ले सके।
6. हम CollateMotorForce () फ़ंक्शन का उपयोग करें और टकराने वाले क्षणों में टॉर्क और ब्रेकिंग क्षण को नियंत्रित करने के लिए करेंगे, हम इस फ़ंक्शन को कोलाइडर और वर्चुअल कुल्हाड़ियों को पास करेंगे (बाएंट्रैकवेल्डाटा के लिए हम क्षैतिज अक्ष से एक सकारात्मक मान पास करते हैं, और राइटट्रैकवेल्डा के लिए नकारात्मक है, जो हमें अलग-अलग दिशाओं में पटरियों को स्थानांतरित करने की अनुमति देता है) )।
7. यदि कोई आंदोलन कुंजी दबाया नहीं जाता है, तो अधिकतम ब्रेकिंग टोक़ को कोलाइडर में स्थानांतरित करें (ताकि यह असमान स्थानों को रोल न करें)।
8. यदि फ़ॉर्वर्ड बटन दबाया नहीं जाता है, लेकिन फुटपाथ बटन दबाया जाता है, तो:
9. हम कॉलर को ब्रेकिंग पल स्थानांतरित करते हैं।
10. हम क्षैतिज अक्ष से प्राप्त मूल्य से गुणा किए गए टोक़ को प्रसारित करते हैं (यह टोक़ टैंक को स्थानांतरित करने के लिए रोटेनास्टैंडब्रैक टोक़ के ब्रेकिंग टोक से अधिक होना चाहिए)।

तो, Play पर क्लिक करें, और फिर बग़ल की कुंजी (A या D) पर क्लिक करें। और हम क्या देखते हैं, केवल हमारे टैंक के दयनीय प्रयासों को मौके पर घूमने के लिए, ऐसा लगता है कि इसमें शक्ति की कमी है। आप निश्चित रूप से वेरिएबल रोटऑनस्टैंडटॉर्क के मूल्य को बढ़ा सकते हैं लेकिन परिणाम काफी मजेदार होगा।

दरअसल, यह टॉर्क की बात नहीं है, यह टैंक को चालू करने के लिए पर्याप्त से अधिक है। चलिए वापस जड़ों की ओर जाते हैं, जो कि हमारे प्रीफैब टैंक_कोलाइडर के लिए है, जिसकी सेटिंग हमें टैंक के सभी व्हीलचेयर के लिए विरासत में मिली है। साइडवेज़ घर्षण क्षेत्र पर ध्यान दें, पिछले पाठ में मैंने इस सेटिंग का उल्लेख किया था, मैंने कहा कि यह पहिया का "पार्श्व" घर्षण बल है, और यह उपयोगी है अगर हम बहाव को लागू करना चाहते हैं। अब यह बहुत घर्षण बल जो पक्षों से हमारे कॉलेडर्स पर कार्य करता है, अविश्वसनीय रूप से बड़ा है, पहिया टोक़ इसे पार करने में सक्षम नहीं है, इसलिए हमारा टैंक चालू नहीं होता है। अब साइडवेज़ फ्रिक्शन के अंदर स्टिफनेस फैक्टर वैरिएबल पर ध्यान दें, हमें इसकी आवश्यकता है, वास्तव में यह वह संख्या है जिसके द्वारा पार्श्व घर्षण बल को गुणा किया जाता है, इसे शून्य पर रखें, प्ले दबाएं।


चमत्कारिक रूप से, हमारा टैंक पागल हो गया और अब वह शीर्ष गति से घूम सकता है, और यहां तक ​​कि बग़ल में ड्राइव कर सकता है, यह सही है, अब कोई पार्श्व घर्षण नहीं है। अब Play मोड से बाहर निकलें, मान को 0.06 पर सेट करें और Play को फिर से दबाएँ। खैर, आखिरकार, अब हमारा टैंक अपनी धुरी पर घूम रहा है और काफी पर्याप्त है। प्ले मोड से बाहर निकलें और 1. पर साइडवॉल घर्षण मूल्य को वापस सेट करें। बेशक, यह सब प्रीफ़ैब से सीधे मूल्य को बदलने के लिए अच्छा है, लेकिन स्क्रिप्ट से ऐसा करना बेहतर है, क्योंकि जब साइड फ्रिक्शन नियंत्रणीय नहीं है, तो एक मौका है कि हमारा टैंक एक वास्तविक बहाव में प्रवेश करेगा। उसी समय, हम टैंक को आगे बढ़ने और ड्राइविंग करते समय मोड़ने के लिए सिखाएंगे। हम फ़ंक्शन को संशोधित करते हैं CalculateMotorForce () और कुछ और वैश्विक चर घोषित करते हैं:

 public float forwardTorque = 500.0f; //1 public float rotateOnMoveBrakeTorque = 400.0f; //2 public float minBrakeTorque = 0.0f; //3 public float minOnStayStiffness = 0.06f; //4 public float minOnMoveStiffness = 0.05f; //5 public float rotateOnMoveMultiply = 2.0f; //6 public void CalculateMotorForce(WheelCollider col, float accel, float steer){ WheelFrictionCurve fc = col.sidewaysFriction; //7 if(accel == 0 && steer == 0){ col.brakeTorque = maxBrakeTorque; }else if(accel == 0.0f){ col.brakeTorque = rotateOnStandBrakeTorque; col.motorTorque = steer*rotateOnStandTorque; fc.stiffness = 1.0f + minOnStayStiffness - Mathf.Abs(steer); }else{ //8 col.brakeTorque = minBrakeTorque; //9 col.motorTorque = accel*forwardTorque; //10 if(steer < 0){ //11 col.brakeTorque = rotateOnMoveBrakeTorque; //12 col.motorTorque = steer*forwardTorque*rotateOnMoveMultiply;//13 fc.stiffness = 1.0f + minOnMoveStiffness - Mathf.Abs(steer); //14 } if(steer > 0){ //15 col.motorTorque = steer*forwardTorque*rotateOnMoveMultiply;//16 fc.stiffness = 1.0f + minOnMoveStiffness - Mathf.Abs(steer); //17 } } if(fc.stiffness > 1.0f)fc.stiffness = 1.0f; //18 col.sidewaysFriction = fc; //19 if(col.rpm > 0 && accel < 0){ //20 col.brakeTorque = maxBrakeTorque; //21 }else if(col.rpm < 0 && accel > 0){ //22 col.brakeTorque = maxBrakeTorque; //23 } } 

1. (, ).
2. .
3. .
4. .
5. .
6. .
7. fc WheelFrictionCurve, Sideways Friction Wheel Collider'.
8. , :
9. ;
10. ;
11. ( , , ) :
12. ( , );
13. ( , );
14. fc.
15. ( , , ) :
16. , .
17. fc.
18. , , .
19. sidewaysFriction fs ( col.sidewaysFriction.stiffnes = (float), ).
20. , :
21. .
22. यदि पहिए वापस घूमते हैं और हम आगे की को दबाते हैं:
23. कोई टिप्पणी नहीं।

ठीक है, यह सब, आपका टैंक अलर्ट पर है, हालांकि यह अभी भी दुश्मनों को गोली नहीं मार सकता है, यह उन्हें कुचल सकता है।

अंत में, मैं कहूंगा कि यह टैंक की गति के लिए एक सार्वभौमिक एल्गोरिथ्म से दूर है, यह अभी भी काम करता है और इस पर काम करता है, उदाहरण के लिए, अधिकतम गति सीमा निर्धारित करना आवश्यक है ताकि हमारा टैंक 300 किमी तक गति न कर सके। प्रति घंटे। मुझे लगता है कि यदि आप ऊपर लिखी गई हर चीज को समझते हैं, तो आप इसे आसानी से संशोधित कर सकते हैं। आपके ध्यान के लिए धन्यवाद, निम्न पाठ जल्द ही आ रहे हैं।