एकता में स्थिति टेम्पलेट को लागू करना

इन-गेम संस्थाओं की प्रोग्रामिंग की प्रक्रिया में, परिस्थितियां उत्पन्न होती हैं जब उन्हें अलग-अलग परिस्थितियों में अलग-अलग तरीकों से कार्य करना चाहिए, जो राज्यों के उपयोग का सुझाव देता है ।

लेकिन अगर आप जानवर बल का उपयोग करने का निर्णय लेते हैं, तो कोड जल्दी से कई नेस्टेड बयानों के साथ उलझ अराजकता में बदल जाएगा।

इस समस्या के एक सुंदर समाधान के लिए, आप स्टेट डिज़ाइन पैटर्न का उपयोग कर सकते हैं। हम इस ट्यूटोरियल को उसके लिए समर्पित करेंगे!

ट्यूटोरियल से आप:

• एकता में राज्य टेम्पलेट की मूल बातें जानें।
• आप सीखेंगे कि एक राज्य मशीन क्या है और इसका उपयोग कब करना है।
• अपने चरित्र की गति को नियंत्रित करने के लिए इन अवधारणाओं का उपयोग करना सीखें।

नोट : यह ट्यूटोरियल उन्नत उपयोगकर्ताओं के लिए है; यह माना जाता है कि आप पहले से ही जानते हैं कि एकता में कैसे काम करना है और C # का औसत स्तर है। इसके अलावा, यह ट्यूटोरियल यूनिटी 2019.2 और C # 7 का उपयोग करता है।

काम पर लगना

प्रोजेक्ट सामग्री डाउनलोड करें। ज़िप फ़ाइल खोलना और एकता में स्टार्टर प्रोजेक्ट खोलें।

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

ट्यूटोरियल पूरा करने के लिए, हम केवल दृश्यों और लिपियों के साथ काम करेंगे।

आरडब्ल्यू / दृश्यों पर जाएं और मेन खोलें। गेम मोड में, आपको मध्ययुगीन महल के अंदर हुड में एक चरित्र दिखाई देगा।


Play पर क्लिक करें और देखें कि कैमरा कैरेक्टर फ्रेम को कैसे फिट करता है। फिलहाल, हमारे छोटे खेल में कोई बातचीत नहीं है, हम ट्यूटोरियल में उन पर काम करेंगे।

चरित्र का अन्वेषण करें

पदानुक्रम में, वर्ण का चयन करें। इंस्पेक्टर बाहर की जाँच करें। आपको वर्ण नियंत्रण तर्क वाले समान नाम वाला एक घटक दिखाई देगा।


आरडब्ल्यू / लिपियों में स्थित ओपन कैरेक्टर्स ।

स्क्रिप्ट कई क्रियाएं करती है, लेकिन उनमें से ज्यादातर हमारे लिए महत्वपूर्ण नहीं हैं। अभी के लिए, आइए निम्न विधियों पर ध्यान दें।

• Move : यह चरित्र को गति देता है, गति और गति की speed रूप में प्रकार की speed प्राप्त करता है कोणीय गति के रूप में।
• ResetMoveParams : यह विधि चाल और चरित्र के कोणीय वेग को चेतन करने के लिए उपयोग किए जाने वाले मापदंडों को रीसेट करती है। इसका इस्तेमाल सिर्फ सफाई के लिए किया जाता है।
• SetAnimationBool : यह मान के लिए टाइप Bool के SetAnimationBool एनीमेशन पैरामीटर सेट करता है।
• CheckCollisionOverlap : यह एक प्रकार का Vector3 प्राप्त करता है और एक bool लौटाता है जो निर्धारित करता है कि से निर्दिष्ट त्रिज्या के भीतर कोई कोलाडर हैं या ।
• TriggerAnimation : इनपुट param एनीमेशन पैरामीटर TriggerAnimation करता है।
• ApplyImpulse : प्रकार ApplyImpulse के इनपुट पैरामीटर force बराबर कैरेक्टर के लिए ApplyImpulse पल्स ApplyImpulse ।

नीचे आप इन तरीकों को देखेंगे। हमारे ट्यूटोरियल में, उनकी सामग्री और आंतरिक कार्य महत्वपूर्ण नहीं हैं।

राज्य मशीनें क्या हैं

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

राज्य की मशीनें

परिमित राज्य मशीन या FSM (परिमित राज्य मशीन) मशीनों के चार मुख्य परिवारों में से एक है । ऑटोमेटा सरल मशीनों के अमूर्त मॉडल हैं। उन्हें ऑटोमेटा के सिद्धांत के ढांचे में अध्ययन किया जाता है - कंप्यूटर विज्ञान की सैद्धांतिक शाखा।

संक्षेप में:

• FSM में परिमित मात्रा में स्थिति होती है । किसी भी समय , इनमें से केवल एक राज्य सक्रिय है ।
• प्रत्येक राज्य यह निर्धारित करता है कि आने वाली सूचनाओं के प्राप्त अनुक्रम के आधार पर वह किस राज्य में उत्पादन के रूप में जाएगा।
• आउटपुट स्टेट नया सक्रिय राज्य बन जाता है। दूसरे शब्दों में, राज्यों के बीच एक संक्रमण है ।

इसे बेहतर ढंग से समझने के लिए, एक प्लेटफ़ॉर्म गेम के चरित्र पर विचार करें जो जमीन पर है। चरित्र स्थायी स्थिति में है। यह उसकी सक्रिय स्थिति होगी जब तक कि खिलाड़ी बटन दबाता है ताकि चरित्र कूद जाए।

स्टैंडिंग स्टेट एक बटन प्रेस की पहचान एक महत्वपूर्ण इनपुट के रूप में करता है और आउटपुट के रूप में जंपिंग स्टेट में बदल जाता है।

मान लीजिए कि गति की ऐसी अवस्थाओं की एक निश्चित संख्या है और एक वर्ण एक समय में केवल एक राज्य में हो सकता है। यह एफएसएम का एक उदाहरण है।

पदानुक्रमित राज्य मशीनें

एफएसएम का उपयोग करने वाले एक प्लेटफ़ॉर्मर पर विचार करें, जिसमें कई राज्य एक सामान्य भौतिकी तर्क साझा करते हैं। उदाहरण के लिए, आप क्राउचिंग और स्थायी राज्यों में स्थानांतरित और कूद सकते हैं। इस स्थिति में, कई आवक चर दो अलग-अलग राज्यों के लिए समान व्यवहार और सूचना उत्पादन का नेतृत्व करते हैं।

ऐसी स्थिति में, सामान्य व्यवहार को किसी अन्य राज्य में सौंपना तर्कसंगत होगा। सौभाग्य से, यह पदानुक्रमित राज्य मशीनों का उपयोग करके प्राप्त किया जा सकता है।

एक पदानुक्रमित FSM में, उनके प्रतिस्थापन के लिए आने वाली कच्ची सूचनाओं को प्रत्यायोजित करने के विकल्प हैं। यह बदले में, आपको अपने तर्क को बनाए रखते हुए एफएसएम के आकार और जटिलता को कम करने की अनुमति देता है।

स्थिति टेम्पलेट

उनकी पुस्तक डिजाइन पैटर्न में: पुन: प्रयोज्य वस्तु-उन्मुख सॉफ्टवेयर के तत्व, एरिच गामा, रिचर्ड हेल्म, राल्फ जॉनसन और जॉन व्लिसिडिस ( द गैंग ऑफ़ फोर ) ने निम्नानुसार राज्य टेम्पलेट के कार्य को परिभाषित किया:

“जब आंतरिक स्थिति बदलती है तो उसे वस्तु को अपने व्यवहार को बदलने की अनुमति देनी चाहिए। इस मामले में, ऐसा लगेगा कि ऑब्जेक्ट ने अपनी कक्षा बदल दी है। ”

इसे बेहतर ढंग से समझने के लिए, निम्नलिखित उदाहरण पर विचार करें:

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

इसलिए, इस तथ्य के कारण कि अलग-अलग समय पर वर्तमान राज्य चर अलग-अलग राज्यों को संदर्भित करता है, ऐसा लगेगा कि एक ही स्क्रिप्ट वर्ग अलग-अलग व्यवहार करता है। यह "स्थिति" टेम्पलेट का सार है।

हमारी परियोजना में, उपरोक्त वर्ण वर्ग अलग-अलग राज्यों के आधार पर अलग-अलग व्यवहार करेगा। लेकिन हम उसे खुद व्यवहार करने की जरूरत है!


सामान्य स्थिति में, प्रत्येक राज्य वर्ग के लिए तीन प्रमुख बिंदु होते हैं जो राज्य के व्यवहार को समग्र रूप से अनुमति देते हैं:

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

राज्य और राज्य मशीन को परिभाषित करना

आरडब्ल्यू / लिपियों पर जाएं और StateMachine.cs खोलें।

राज्य मशीन , जैसा कि आप अनुमान लगा सकते हैं, राज्य मशीन के लिए एक अमूर्तता प्रदान करती है। ध्यान दें कि CurrentState इस वर्ग के अंदर सही ढंग से स्थित है। यह वर्तमान सक्रिय राज्य मशीन राज्य के लिए एक लिंक संग्रहीत करेगा।

अब, राज्य की अवधारणा को परिभाषित करने के लिए, आइए RW / लिपियों पर जाएं और IDE में State.cs स्क्रिप्ट खोलें।

राज्य एक अमूर्त वर्ग है जिसे हम एक मॉडल के रूप में उपयोग करेंगे जिससे परियोजना राज्यों के सभी वर्ग व्युत्पन्न हैं। परियोजना सामग्री में कोड का हिस्सा पहले से ही तैयार है।

DisplayOnUI केवल ऑन-स्क्रीन UI में वर्तमान स्थिति का नाम प्रदर्शित करता है। आपको इसकी आंतरिक संरचना को जानने की जरूरत नहीं है, बस यह समझ लें कि यह एक इनपुट पैरामीटर के रूप में UIManager.Alignment प्रकार का एक UIManager.Alignment प्राप्त करता है, जो Left या Right हो सकता है। स्क्रीन के बाएं या दाएं तल में स्थिति के नाम का प्रदर्शन इस पर निर्भर करता है।

इसके अलावा, दो संरक्षित चर, character और stateMachine । character चर चरित्र वर्ग की एक आवृत्ति को संदर्भित करता है, और stateMachine राज्य के साथ जुड़े राज्य मशीन की एक आवृत्ति को संदर्भित करता है।

राज्य का उदाहरण बनाते समय, निर्माता character और stateMachine बांधता है।

एक दृश्य में Character के कई उदाहरणों में से प्रत्येक में राज्यों और राज्य मशीनों का अपना सेट हो सकता है।

अब State.cs में निम्न विधियाँ जोड़ें और फ़ाइल को सहेजें:

 public virtual void Enter() { DisplayOnUI(UIManager.Alignment.Left); } public virtual void HandleInput() { } public virtual void LogicUpdate() { } public virtual void PhysicsUpdate() { } public virtual void Exit() { } 

ये वर्चुअल तरीके ऊपर वर्णित प्रमुख स्थिति बिंदुओं को परिभाषित करते हैं। जब राज्य मशीन राज्यों के बीच एक संक्रमण करती है, तो हम पिछले स्थिति के लिए Exit और नया सक्रिय राज्य Enter ।

HandleInput , LogicUpdate और PhysicsUpdate एक साथ अपडेट लूप को परिभाषित करते हैं। HandleInput खिलाड़ी इनपुट को संभालता है। LogicUpdate बुनियादी तर्क की प्रक्रिया करता है, जबकि PhyiscsUpdate तर्क और भौतिकी की गणना करता है।

अब StateMachine.cs को फिर से खोलें, निम्न विधियाँ जोड़ें और फ़ाइल को सहेजें:

 public void Initialize(State startingState) { CurrentState = startingState; startingState.Enter(); } public void ChangeState(State newState) { CurrentState.Exit(); CurrentState = newState; newState.Enter(); } 

Initialize करने के लिए CurrentState सेट करके स्टेट मशीन को कॉन्फ़िगर Initialize करें और इसके लिए Enter कॉल Enter । यह पहली बार सक्रिय राज्य की स्थापना के लिए, राज्य मशीन को इनिशियलाइज़ करता है।

ChangeState राज्य संक्रमण को संभालता है । यह CurrentState साथ अपने संदर्भ को बदलने से पहले पुराने CurrentState लिए Exit कहता है। अंत में, यह Enter for newState कहता है।

इस प्रकार, हम राज्य और राज्य मशीन सेट करते हैं ।

मोशन स्टेट्स बनाना

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


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

एकता पर लौटें और आरडब्ल्यू / लिपियों / राज्यों में जाएं । वहां आपको कई सी # फाइलें मिलेंगी, जिनके नाम राज्य में समाप्त होंगे।

इनमें से प्रत्येक फाइलें एक वर्ग को परिभाषित करती हैं, जिनमें से प्रत्येक State से विरासत में मिली है। इसलिए, ये वर्ग उन राज्यों को परिभाषित करते हैं जो हम परियोजना में उपयोग करेंगे।

अब RW / Scripts फ़ोल्डर से Character.cs को खोलें।

#region Variables फ़ाइल के ऊपर स्क्रॉल करें और निम्न कोड जोड़ें:

 public StateMachine movementSM; public StandingState standing; public DuckingState ducking; public JumpingState jumping; 

यह movementSM एक राज्य मशीन को संदर्भित करता है जो Character उदाहरण के लिए गति तर्क को संसाधित करता है। हमने तीन राज्यों के लिंक भी जोड़े हैं जिन्हें हम प्रत्येक प्रकार के आंदोलन के लिए कार्यान्वित करते हैं।

एक ही फाइल में #region MonoBehaviour Callbacks जाएं। निम्नलिखित MonoBehaviour विधियों को जोड़ें और फिर सहेजें

 private void Start() { movementSM = new StateMachine(); standing = new StandingState(this, movementSM); ducking = new DuckingState(this, movementSM); jumping = new JumpingState(this, movementSM); movementSM.Initialize(standing); } private void Update() { movementSM.CurrentState.HandleInput(); movementSM.CurrentState.LogicUpdate(); } private void FixedUpdate() { movementSM.CurrentState.PhysicsUpdate(); } 

• Start कोड राज्य मशीन का एक उदाहरण बनाता है और इसे movementSM करने के लिए असाइन करता है, और विभिन्न गति राज्यों को भी त्वरित करता है। प्रत्येक मोशन स्टेट्स बनाते समय, हम this का उपयोग करते हुए Character इंस्टेंस के साथ-साथ movementSM इंस्टेंस का संदर्भ देते हैं। अंत में, हम प्रारंभिक अवस्था के लिए movementSM और Standing को प्रारंभिक अवस्था कहते हैं।
• Update विधि में, हम HandleInput और LogicUpdate को CurrentState मशीन के CurrentState के लिए कहते हैं। इसी तरह, FixedUpdate हम PhysicsUpdate को CurrentState मशीन के PhysicsUpdate लिए कहते हैं। संक्षेप में, यह एक सक्रिय राज्य को कार्य सौंपता है; यह "स्थिति" टेम्पलेट का अर्थ है।

अब हमें गति की प्रत्येक अवस्था के अंदर के व्यवहार को निर्धारित करने की आवश्यकता है। अपने आप को संभालो, बहुत सारे कोड होंगे!

स्थायी फर्म

प्रोजेक्ट विंडो में RW / लिपियों / राज्यों में लौटें।

ग्राउंडेड खोलें। ध्यान दें और देखें कि इस वर्ग में एक कंस्ट्रक्टर है जो State कंस्ट्रक्टर से मेल खाता है। यह तर्कसंगत है क्योंकि यह वर्ग इससे विरासत में मिला है। आप अन्य सभी राज्य वर्गों में एक ही चीज़ देखेंगे।

निम्नलिखित कोड जोड़ें:

 public override void Enter() { base.Enter(); horizontalInput = verticalInput = 0.0f; } public override void Exit() { base.Exit(); character.ResetMoveParams(); } public override void HandleInput() { base.HandleInput(); verticalInput = Input.GetAxis("Vertical"); horizontalInput = Input.GetAxis("Horizontal"); } public override void PhysicsUpdate() { base.PhysicsUpdate(); character.Move(verticalInput * speed, horizontalInput * rotationSpeed); } 

यहाँ क्या होता है:

• हम मूल कक्षा में परिभाषित आभासी तरीकों में से एक को फिर से परिभाषित करते हैं। माता-पिता में मौजूद सभी कार्यक्षमता को संरक्षित करने के लिए, हम प्रत्येक अधिरोपित विधि से एक ही नाम के साथ base विधि कहते हैं। यह एक महत्वपूर्ण टेम्पलेट है जिसका हम उपयोग करना जारी रखेंगे।
• अगली पंक्ति, Enter उनके डिफ़ॉल्ट मानों के verticalInput horizontalInput और verticalInput सेट करता है।
• अंदर से Exit हम, जैसा कि ऊपर उल्लेख किया गया है, किसी अन्य राज्य में बदलते समय रीसेट करने लिए ResetMoveParams विधि को कॉल करें।
• HandleInput विधि में, horizontalInput इनपुट और वर्टिकल इनपुट वैरिएबल क्षैतिज और ऊर्ध्वाधर इनपुट अक्षों HandleInput मूल्यों को HandleInput हैं। इसके लिए धन्यवाद, खिलाड़ी कुंजियों डब्ल्यू , ए , एस और डी का उपयोग करके चरित्र को नियंत्रित कर सकता है ।
• PhysicsUpdate हम एक PhysicsUpdate कॉल करते हैं, जो verticalInput गति से गुणा किए जाने वाले horizontalInput PhysicsUpdate और verticalInput चर को पार करता है। चर speed गति की गति को संग्रहीत किया जाता है, और rotationSpeed , कोणीय वेग।

अब Standing.cs खोलें और इस तथ्य पर ध्यान दें कि यह Grounded से विरासत में मिला है। ऐसा इसलिए हुआ, क्योंकि जैसा कि हमने ऊपर कहा, स्टैंडिंग ग्राउंडेड का एक विकल्प है। इस रिश्ते को लागू करने के विभिन्न तरीके हैं, लेकिन इस ट्यूटोरियल में हम विरासत का उपयोग करते हैं।

निम्नलिखित override विधियों को जोड़ें और स्क्रिप्ट को सहेजें:

 public override void Enter() { base.Enter(); speed = character.MovementSpeed; rotationSpeed = character.RotationSpeed; crouch = false; jump = false; } public override void HandleInput() { base.HandleInput(); crouch = Input.GetButtonDown("Fire3"); jump = Input.GetButtonDown("Jump"); } public override void LogicUpdate() { base.LogicUpdate(); if (crouch) { stateMachine.ChangeState(character.ducking); } else if (jump) { stateMachine.ChangeState(character.jumping); } } 

• Enter हम Grounded से विरासत में प्राप्त चर को कॉन्फ़िगर करते हैं। speed और RotationSpeed चरित्र के MovementSpeed और RotationSpeed लागू करें। फिर वे क्रमशः आंदोलन की सामान्य गति और चरित्र के सार के लिए कोणीय गति से संबंधित हैं।
  
  इसके अलावा, crouch और jump इनपुट को संग्रहीत करने के लिए चर झूठे पर रीसेट हो जाते हैं।
• HandleInput अंदर, crouch और jump वैरिएबल HandleInput और HandleInput लिए प्लेयर इनपुट स्टोर करते हैं। यदि मुख्य दृश्य में खिलाड़ी शिफ्ट कुंजी दबाता है , तो स्क्वैट को सही पर सेट किया गया है। इसी तरह, एक खिलाड़ी jump लिए स्पेस की का उपयोग कर सकता है।
• LogicUpdate हम टाइप bool के crouch और jump चर की जांच करते हैं। यदि crouch सत्य है, तो movementSM.CurrentState character.ducking बदल जाता character.ducking । यदि jump सही है, तो राज्य character.jumping बदलता है।

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


टेबल ऑब्जेक्ट्स के नीचे ले जाने का प्रयास करें। आप देखेंगे कि चरित्र के कोलाइडर की ऊंचाई के कारण यह संभव नहीं है। चरित्र को ऐसा करने के लिए, आपको स्क्वाटिंग व्यवहार को जोड़ना होगा।

हम टेबल के नीचे चढ़ते हैं

Ducking.cs स्क्रिप्ट खोलें। ध्यान दें कि Ducking के समान कारणों से Ducking को Grounded क्लास से विरासत में मिला है। निम्नलिखित override विधियों को जोड़ें और स्क्रिप्ट को सहेजें:

 public override void Enter() { base.Enter(); character.SetAnimationBool(character.crouchParam, true); speed = character.CrouchSpeed; rotationSpeed = character.CrouchRotationSpeed; character.ColliderSize = character.CrouchColliderHeight; belowCeiling = false; } public override void Exit() { base.Exit(); character.SetAnimationBool(character.crouchParam, false); character.ColliderSize = character.NormalColliderHeight; } public override void HandleInput() { base.HandleInput(); crouchHeld = Input.GetButton("Fire3"); } public override void LogicUpdate() { base.LogicUpdate(); if (!(crouchHeld || belowCeiling)) { stateMachine.ChangeState(character.standing); } } public override void PhysicsUpdate() { base.PhysicsUpdate(); belowCeiling = character.CheckCollisionOverlap(character.transform.position + Vector3.up * character.NormalColliderHeight); } 

• Enter अंदर Enter स्क्वाट एनीमेशन टॉगल का कारण बनने Enter पैरामीटर क्राउच पर सेट होता है, जो स्क्वाट एनीमेशन को सक्षम करता है। character.CrouchSpeed और character.CrouchRotationSpeed गुणों को speed और rotation मान निर्दिष्ट किए जाते हैं, जो एक स्क्वाट में चलते समय चरित्र की गति और कोणीय गति को वापस करते हैं।
  
  अगला character.CrouchColliderHeight CrouchColliderHeight चरित्र के कोलाइडर का आकार निर्धारित करता है, जो स्क्वीटिंग करते समय वांछित कोलाइडर की ऊँचाई देता है। अंत में, belowCeiling दिया गया गलत पर रीसेट हो जाता है।
• इनसिट से Exit स्क्वाट एनीमेशन पैरामीटर गलत पर सेट है। यह स्क्वाट एनीमेशन को निष्क्रिय करता है। फिर सामान्य कोलाइडर की ऊँचाई निर्धारित की जाती है, जिसे character.NormalColliderHeight द्वारा लौटा दिया जाता character.NormalColliderHeight । NormalColliderHeight।
• HandleInput अंदर HandleInput चर crouchHeld खिलाड़ी के इनपुट मूल्य को निर्धारित करता है। मुख्य दृश्य में, Shift को crouchHeld को सत्य crouchHeld है।
• PhysicsUpdate अंदर PhysicsUpdate चर के belowCeiling चर को belowCeiling प्रारूप में एक बिंदु पास करके एक मान दिया जाता है, जिसमें वर्ण गेम ऑब्जेक्ट के प्रमुख के साथ CheckCollisionOverlap विधि है। यदि इस बिंदु के पास एक टक्कर है, तो इसका मतलब है कि चरित्र किसी प्रकार की छत के नीचे है।
• आंतरिक रूप से, LogicUpdate चेक करता है कि क्या crouchHeld या उससे belowCeiling है। यदि उनमें से कोई भी सत्य नहीं है, तो movementSM.CurrentState ।

प्रोजेक्ट बनाएं और Play पर क्लिक करें। अब आप दृश्य के चारों ओर घूम सकते हैं। यदि आप Shift दबाते हैं, तो वर्ण नीचे बैठ जाएगा और आप स्क्वाट में जा सकते हैं।

आप मंच के नीचे भी चढ़ सकते हैं। यदि आप प्लेटफ़ॉर्म के नीचे शिफ्ट रिलीज़ करते हैं, तो चरित्र तब तक एक वर्ग में रहेगा, जब तक वह अपना आश्रय नहीं छोड़ देता।

चढ़ता है!

जंपिंग खोलें। आपको Jump नामक एक विधि दिखाई देगी। यह कैसे काम करता है इसके बारे में चिंता न करें; यह समझने के लिए पर्याप्त है कि इसका उपयोग किया जाता है ताकि चरित्र भौतिकी और एनीमेशन को ध्यान में रखकर कूद सके।

अब सामान्य override विधियों को जोड़ें और स्क्रिप्ट को बचाएं

 public override void Enter() { base.Enter(); SoundManager.Instance.PlaySound(SoundManager.Instance.jumpSounds); grounded = false; Jump(); } public override void LogicUpdate() { base.LogicUpdate(); if (grounded) { character.TriggerAnimation(landParam); SoundManager.Instance.PlaySound(SoundManager.Instance.landing); stateMachine.ChangeState(character.standing); } } public override void PhysicsUpdate() { base.PhysicsUpdate(); grounded = character.CheckCollisionOverlap(character.transform.position); } 

• Enter अंदर Enter सिंगलटन SoundManager की आवाज बजाता है। फिर grounded को उसके डिफ़ॉल्ट मान पर रीसेट कर दिया जाता है। आखिर में Jump को कहा जाता है।
• PhysicsUpdate अंदर PhysicsUpdate चरित्र के पैरों के आगे PhysicsUpdate बिंदु PhysicsUpdate को भेजा जाता है, जिसका अर्थ है कि जब चरित्र जमीन पर है, तो grounded को सही पर सेट किया जाएगा।
• LogicUpdate , यदि grounded सही है, तो हम TriggerAnimation एनीमेशन को सक्षम करने के लिए ट्रिगर एनिमेशन कहते हैं, टचडाउन साउंड बजाया जाता है, और movementSM.CurrentState में character.standing बदलाव होता character.standing ।

इसलिए, इस पर हमने "राज्य" टेम्पलेट का उपयोग करके FSM विस्थापन का पूर्ण कार्यान्वयन पूरा कर लिया है । प्रोजेक्ट बनाएं और उसे चलाएं। कैरेक्टर जंप करने के लिए स्पेस दबाएं।

आगे कहाँ जाना है?

परियोजना सामग्री में एक मसौदा परियोजना और एक तैयार परियोजना है।

इसकी उपयोगिता के बावजूद, राज्य मशीनों की सीमाएं हैं। समवर्ती राज्य मशीनें और पुशडाउन ऑटोमैटन मशीनें इनमें से कुछ सीमाओं को संभाल सकती हैं। आप उनके बारे में रॉबर्ट निस्ट्रोम गेम प्रोग्रामिंग पैटर्न की पुस्तक में पढ़ सकते हैं।

इसके अलावा, गेम में अधिक जटिल गेम बनाने के लिए उपयोग किए जाने वाले व्यवहार पेड़ों की जांच करके विषय को गहराई से खोजा जा सकता है।