एकता का उपयोग करके एक और प्लेटफ़ॉर्मर कैसे विकसित किया जाए। एक और ट्यूटोरियल

नमस्कार, हेब्र!

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

लेख में बहुत सारे पाठ (नियमित और स्रोत दोनों) और कई चित्र हैं।

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

गहराई से सोचने के बाद, मैंने खुद से सवाल पूछा: मैं वास्तव में विभिन्न प्रकार के कंप्यूटिंग उपकरणों के साथ क्या करना पसंद करता हूं? मेरे लिए मेरे सवाल ने मुझे बचपन में दूर तक फेंक दिया, अर्थात् पीएस 1, पीएस 2, पीसी के लिए रेलरोज टाइकून 3 के लिए बिताए सुखद घंटों में ... ठीक है, आप समझते हैं। वीडियो गेम!

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

कुछ महीनों के बाद, मैंने पहले ही अधिक जटिल प्लेटफ़ॉर्मर को रिलीज़ कर दिया। तब एक विराम था (आखिरकार, काम पर काम किया जाना चाहिए, आखिरकार)।

लगभग दो हफ्ते पहले, मैंने 2 डी गेम ( https://habr.com/en/post/456152/ ) के लिए स्तर डिज़ाइन पैटर्न नामक एक हब पर लेख का अनुवाद देखा और खुद से सोचा - क्यों नहीं? लेख में एक सरल और स्पष्ट तालिका है कि खेल में क्या होना चाहिए ताकि यह दिलचस्प हो। मैंने कृपया OneNote में तालिका को खुद को कॉपी किया और टैग के मामलों (जिसे पूरा किया जा सकता है) के साथ प्रत्येक पैटर्न को चिह्नित किया।

मैं परिणाम के रूप में क्या प्राप्त करना चाहता हूं? आपकी आलोचना। जैसा कि मैं खुद से कहना चाहता हूं - यदि आप सीखना चाहते हैं कि कैसे तैरना है, तो अपने सिर के साथ गोता लगाएँ। अगर आपको लगता है कि मैंने कुछ अच्छा किया है - तो इस बारे में मुझे कमेंट में लिखें। अगर आपको लगता है कि मैंने कुछ बुरा किया है - इसके बारे में दोगुना लिखें।

मैं एक और platformer प्रोग्रामिंग के लिए अपने लंबे कार्यक्रम शुरू कर देंगे।

अवतार

एक खेल के भीतर खिलाड़ियों द्वारा नियंत्रित इकाई। उदाहरण के लिए, सुपर मारियो ब्रदर्स (निंटेंडो, 1985) में मारियो और लुइगी।

कई उपकथाएं हैं जिन्हें नायक जीवन देने के लिए लागू करने की आवश्यकता है। अर्थात्:

•   ( ) •      •      •       •        

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

Apply पर क्लिक करें , फिर SpriteEditor ।

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

इसके अलावा, एकता स्प्राइट के भीतर वस्तुओं की सीमाओं को स्वचालित रूप से उजागर करने की क्षमता प्रदान करती है। स्प्राइट एडिटर विंडो में, ऐसा करने के लिए, आपको स्लाइस बटन पर क्लिक करना होगा। ड्रॉप-डाउन मेनू में आपके पास टाइप => स्वचालित, धुरी => केंद्र होना चाहिए। आपको बस स्लाइस बटन पर क्लिक करना है। उसके बाद, स्प्राइट के अंदर सभी वस्तुओं को स्वचालित रूप से चुना जाएगा।

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

एक खाली गेम ऑब्जेक्ट, जिसे डिफ़ॉल्ट रूप से स्टेज पर बनाया गया है, केवल एक घटक है - ट्रांसफ़ॉर्म । यह घटक मंच पर वस्तु की स्थिति, झुकाव के कोण और इसके पैमाने को निर्धारित करता है।

आप शब्द परिवर्तन को दो अलग-अलग अर्थों में पूरा कर सकते हैं:

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

   transform.position = new Vector2 (transform.position.x + dirX, transform.position.y + dirY);. 

  
  
  यह लाइन मंच पर लुकास के आंदोलन के लिए जिम्मेदार होगी।

अपना स्वयं का घटक बनाने के लिए, वस्तु निरीक्षक के टैब में घटक जोड़ें बटन पर क्लिक करें। अगला, मानक घटकों के बीच एक खोज बॉक्स दिखाई देता है। यह भविष्य की स्क्रिप्ट (या पहले से लागू घटक) का नाम लिखना शुरू करने के लिए पर्याप्त है, अगर कोई उपयुक्त नाम नहीं हैं, तो एकता आपको एक नया घटक बनाने की पेशकश करेगी। मैंने इस घटक को HeroScript.cs कहा है।

पहले, हम उन क्षेत्रों का वर्णन करते हैं जो लुकास के दृश्य और भौतिक घटक के बारे में जानकारी संग्रहीत करेंगे:

 private Animator animator; //      . private Rigidbody2D rb2d; //rb     

अगला, क्षेत्र जो चरित्र के आंदोलन का जवाब देगा:

 /*  ,     */ Vector3 localScale; bool facingRight = true; [SerializeField] private float dirX, dirY; //    [Range(1f, 20f)] [SerializeField] private float moveSpeed; //    private SpriteRenderer sprite; //   SpriteRenderer /*   ,     */ 

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

 /* *      . *         *    . */ public enum CharState { idle, //   0 Run, //   1 Walk, //   2 Die //   3 } 

हम एक ऐसी संपत्ति लागू करते हैं जो एक नया एनीमेशन राज्य प्राप्त और सेट करेगी:

 public CharState State { get {//    CharState    animator       int return (CharState)animator.GetInteger("State"); } set { //    animator     int    State       ,      int. animator.SetInteger("State", (int)value); } } 

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

ऐसा करने के लिए, आपको पहले से बनाए गए मल्टी स्प्राइट को एक खाली गेम ऑब्जेक्ट के साथ जोड़ना होगा। आपको बस यूनिटी एक्सप्लोरर में फ़्रेमों का चयन करना है और उन्हें एक खाली गेम ऑब्जेक्ट पर खींचना है, जिसमें हमने पहले स्क्रिप्ट को ठीक किया है।

प्रत्येक बाद के एनीमेशन के साथ ऐसा करें। इसके अलावा, एनिमेशन में एक्सप्लोरर में आपको ब्लॉक आरेख और प्ले बटन के साथ एक वस्तु का रूप मिलेगा। इस पर डबल क्लिक करने से एनिमेटर टैब खुल जाएगा। अंदर, आपको एनिमेशन के साथ कई ब्लॉक दिखाई देंगे और शुरुआत में, केवल एंट्री के राज्य और एनीमेशन का पहला सेट जो जुड़े थे। AnyState और अन्य एनिमेशन नियमित ग्रे वर्ग के रूप में प्रदर्शित किए जाएंगे। सब कुछ बांधने के लिए, आपको AnyState की स्थिति पर क्लिक करने और एकमात्र मेक ट्रांजेक्शन ड्रॉप-डाउन मेनू का चयन करने और इसे ग्रे ब्लॉक में बाँधने की आवश्यकता है। यह ऑपरेशन प्रत्येक स्थिति के लिए किया जाना चाहिए। अंत में, आपको कुछ ऐसा मिलना चाहिए जो आप नीचे दिए गए स्क्रीनशॉट में देखते हैं।

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

अगला चरण लुकास को मंच के चारों ओर घूमना सिखाने के लिए है। यह पूरी तरह से प्रोग्रामिंग है। दृश्य के चारों ओर चरित्र को स्थानांतरित करने के लिए, आपको बटन की आवश्यकता होगी, जिस पर क्लिक करने पर लुकास आगे और पीछे जाएगा। ऐसा करने के लिए, एसेट्स स्टोर टैब में, हमें स्टैंडआर्ट एसेट्स को आयात करने की आवश्यकता है, लेकिन यह सब नहीं, केवल कुछ अतिरिक्त, अर्थात्:

• CrossPlatformInput
• संपादक
• पर्यावरण

एसेट आयात करने के बाद, एकता मुख्य विंडो को संशोधित किया जाना चाहिए और एक अतिरिक्त टैब मोबाइल इनपुट दिखाई देगा। हम इसे सक्रिय करते हैं।

चलो मंच पर नए यूआई तत्व बनाते हैं - नियंत्रण बटन। प्रत्येक दिशा में 4 बटन बनाएं। ऊपर, नीचे, आगे और पीछे। छवि घटक में, हम एक छवि को बटन को असाइन करते हैं जो छवि के अनुरूप होगा, जिसका अर्थ है स्थानांतरित करने की क्षमता। यह नीचे स्क्रीनशॉट की तरह कुछ दिखना चाहिए:

प्रत्येक बटन के लिए, एक AxisTouchButton घटक जोड़ें। इस लिपि के केवल 4 क्षेत्र हैं। धुरीनाम क्षेत्र का अर्थ है कि कौन सा नाम कब बुलाया जाए। एक्सलव्यू फ़ील्ड उस दिशा के लिए जिम्मेदार है जिसमें लुकास आगे बढ़ेगा। लक्सस अपनी गति को कितनी तेजी से विकसित करेगा, इसके लिए रिस्पांसपीड फील्ड जिम्मेदार है। बटन को केंद्र में कितनी तेजी से लौटाता है इसके लिए returnToatalogSpeed फ़ील्ड जिम्मेदार है। फॉरवर्ड बटन के लिए, इसे वैसे ही छोड़ दें। बैक बटन के लिए, अक्ष के मान को -1 में बदलें ताकि लुकास वापस आ जाए। ऊपर और नीचे के बटन के लिए, अक्ष को बदलें कार्यक्षेत्र । अप बटन एक्सिलव्यू के लिए, मान -1 को डाउन -1 के लिए सेट करें।

इसके बाद HeroScript.cs को संशोधित करें । उपयोग करने के निर्देश में नाम स्थान जोड़ें

 using UnityStandardAssets.CrossPlatformInput; //    . 

        : /*  ,     */ Vector3 localScale; //   bool facingRight = true; [SerializeField] private float dirX, dirY; //    [Range(1f, 20f)] [SerializeField] private float moveSpeed; //    private SpriteRenderer sprite; //   SpriteRenderer /*   ,     */ 

मानक प्रारंभ विधि में, निम्न कोड जोड़ें:

  void Start() { localScale = transform.localScale; animator = GetComponent<Animator>(); //     . sprite = GetComponent<SpriteRenderer>(); //  SpriteRenderer rb = GetComponent<Rigidbody2D>(); State = CharState.idle; } 

हम एक ऐसा तरीका बनाते हैं जो नायक को स्थानांतरित करने के लिए जिम्मेदार होगा:

 public void MoveHero() { dirX = CrossPlatformInputManager.GetAxis ("Horizontal") * moveSpeed * Time.deltaTime; dirY = CrossPlatformInputManager.GetAxis ("Vertical") * moveSpeed * Time.deltaTime; transform.position = new Vector2 (transform.position.x + dirX, transform.position.y + dirY); } 

जैसा कि आप देख सकते हैं, सब कुछ सरल है। DirX और DirY फ़ील्ड एक्सिस ( क्षैतिज और ऊर्ध्वाधर ) की दिशा के बारे में जानकारी को गति से गुणा करती है (जिसे संपादक में निर्दिष्ट करने की आवश्यकता होगी) और अंतिम फ्रेम से यात्रा के समय से गुणा किया जाता है।
transform.position हमारे गेम ऑब्जेक्ट के ट्रांसफॉर्म घटक में नई स्थिति लिखता है।

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

 void CheckWhereToFace () { if (dirX > 0) { facingRight = true; State = CharState.Walk; } if (dirX < 0) { facingRight = false; State = CharState.Walk; } if (dirX == 0) { State = CharState.idle; } if (dirY < 0) { State = CharState.Walk; } if (dirY > 0) { State = CharState.Walk; } if (((facingRight) && (localScale.x < 0)) || ((!facingRight) && (localScale.x > 0))) localScale.x *= -1; transform.localScale = localScale; 

कोड का यह हिस्सा भी मुश्किल नहीं है। विधि का वर्णन है कि यदि dirX > 0 (यदि हम दाईं ओर जाते हैं), तो हम स्प्राइट को इस दिशा में घुमाते हैं और वॉक एनीमेशन शुरू करते हैं। यदि 0 से कम है, तो लुकास 180 डिग्री घुमाएं और एनीमेशन शुरू करें। यदि dirX शून्य है, तो लुकास खड़ा है और आपको प्रतीक्षा एनीमेशन शुरू करने की आवश्यकता है।

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

हम CheckWhereToFace () फ़ंक्शन को अपडेट () फ़ंक्शन में रखते हैं, इसके फ्रेम-बाय-फ्रेम मॉनिटरिंग के लिए।

बहुत बढ़िया। 5 के पहले 2 अंक पूरे हो गए हैं। चलो लुकास की जरूरतों पर आगे बढ़ते हैं। बताते चलें कि लुकास को जिंदा रहने के लिए 3 तरह की जरूरतें पूरी करनी होंगी। यह जीवन स्तर, भूख का स्तर और प्यास का स्तर है। आपको प्रत्येक आइटम के संकेतक के साथ एक सरल और समझने योग्य पैनल बनाने की आवश्यकता है। ऐसा पैनल बनाने के लिए, राइट-क्लिक करें और UI => पैनल चुनें ।

नीचे दिखाए अनुसार इसे लगभग चिह्नित करें

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

नए स्थिर चर को परिभाषित करें:

 /*  ,     */ [SerializeField] public static float Health = 100, Eat = 100, Water = 100, _Eat = 0.05f, _Water = 0.1f; //        .    _  . /*   ,     */ /*  ,      */ [SerializeField] Image iHealt, iEat, iWater; //      /*   ,      */ 

इस स्थिति में, मैं स्थैतिक क्षेत्रों का उपयोग करता हूं। ऐसा इसलिए किया जाता है ताकि ये क्षेत्र पूरी कक्षा के लिए अद्वितीय हों। इसके अलावा, यह हमें सीधे वर्ग नाम से इन क्षेत्रों तक पहुंचने की अनुमति देगा। हम कुछ सरल कार्य लिखते हैं:

 private float fEat(float x) { Eat = Eat - x * Time.deltaTime; iEat.fillAmount = Eat / 100f; // ,        return Eat; } private float fWater(float x) { Water = Water - x * Time.deltaTime; iWater.fillAmount = Water / 100; return Water; } 

फिर, हम एक विधि लिखते हैं जो खाने और पीने की इच्छा के बारे में जानकारी एकत्र करती है:

 private void Needs() { if (fEat(_Eat) < 0) { Debug.Log(Eat); } else if (fEat(0) == 0) { StartCoroutine(ifDie()); } if (fWater(_Water) < 0) { Debug.Log(Water); } else if (fWater(0) == 0) { StartCoroutine(ifDie()); } 

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

 if (fEat(_Eat) < 0) 

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

 StartCoroutine(ifDie()); 

जो मौत एनीमेशन शुरू करता है और स्तर को पुनरारंभ करता है:

 IEnumerator ifDie() { State = CharState.Die; yield return new WaitForSeconds(2); SceneManager.LoadScene("WoodDay", LoadSceneMode.Single); } 

हार्ड टाइल

एक गेम ऑब्जेक्ट जो खिलाड़ी को इसके माध्यम से पारित करने की अनुमति नहीं देता है। उदाहरण: सुपर मारियो ब्रोस (निनटेंडो, 1985) में लिंग।

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

अब, एक रोमांचक स्तर अंकन प्रक्रिया। सुविधा के लिए, आप इस क्यूब को भूमि से प्रीफ़ैब में निर्यात कर सकते हैं। प्रीफ़ैब एक गेम ऑब्जेक्ट का एक कंटेनर है, जिसके संशोधन पर आप स्वचालित रूप से इस प्रीफ़ैब से बनाई गई सभी गेम ऑब्जेक्ट में परिवर्तन लागू कर सकते हैं। इसके बाद, इस प्रीफ़ैब को CTRL + D (पदानुक्रम टैब में चुनने के बाद) के साथ क्लोन करें और इसे मंच पर रखें।

प्रदर्शन

वर्तमान में खिलाड़ी को दिखाई देने वाले खेल के स्तर / दुनिया का हिस्सा।

एक कैमरा सेट करें जो खिलाड़ी को दृश्य का हिस्सा प्रदर्शित करने के बारे में अनुसरण करेगा। अगला, लागू करने के लिए एक बहुत ही सरल स्क्रिप्ट होगी:

 public GameObject objectToFollow; public float speed = 2.0f; void Update () { CamFoll(); } private void CamFoll() { float interpolation = speed * Time.deltaTime; Vector3 position = this.transform.position; position.y = Mathf.Lerp(this.transform.position.y, objectToFollow.transform.position.y, interpolation); position.x = Mathf.Lerp(this.transform.position.x, objectToFollow.transform.position.x, interpolation); this.transform.position = position; } 

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

प्रक्षेप क्षेत्र में अंतिम फ्रेम दर्ज होने के बाद से गति की जानकारी। इसके बाद, Lerp पद्धति का उपयोग किया जाएगा, जो X और U कुल्हाड़ियों के साथ चलने पर लुकास के पीछे कैमरे की सुगम गति सुनिश्चित करेगा। दुर्भाग्य से, मैं लाइन के संचालन की व्याख्या नहीं कर सकता।

 position.y = Mathf.Lerp(this.transform.position.y, objectToFollow.transform.position.y, interpolation); 

गणित की दृष्टि से। इसलिए, मैं सरलता से कहूंगा - यह विधि किसी भी कार्रवाई के निष्पादन समय को बढ़ाएगी। हमारे मामले में, यह ऑब्जेक्ट के पीछे कैमरे की गति है।

ख़तरा

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

एक खाली गेमऑबजेक्ट बनाएं और स्प्राइट रेंडरर और पॉलीगॉन कोल्लर 2 डी घटकों को इससे कनेक्ट करें। स्प्राइट रेंडरर घटक में, हम कांटेदार बटन या किसी अन्य वस्तु के स्प्राइट को इच्छानुसार जोड़ते हैं। इसके अलावा, टैग = कांटे को स्पाइक पर असाइन करें।

इसके बाद, लुकास गेमऑबजेक्ट पर, हम एक स्क्रिप्ट बनाते हैं जो उस के लिए ज़िम्मेदार होगी, अगर लुकास अन्य कोलर्स से टकराता है। मेरे मामले में, मैंने इसे ColliderReaction.cs कहा

 private Rigidbody2D rb2d; void Start() { rb2d = GetComponent<Rigidbody2D>(); } public void OnTriggerEnter2D(Collider2D collision) { switch (collision.gameObject.tag) { case "Thorn": { rb2d.AddForce(transform.up * 4, ForceMode2D.Impulse); HeroScript.Health = HeroScript.Health - 5; } break; } } 

स्क्रिप्ट का सार 2x2 जितना सरल है। जब एक कांटा टैग गेम ऑब्जेक्ट से टकराता है , तो स्विच स्टेटमेंट उन उम्मीदवारों के साथ तुलना करता है जिन्हें हमने निर्दिष्ट किया था। हमारे मामले में, अभी के लिए, यह कांटा है । पहले, लुकास फेंकता है, और फिर हम एक स्थिर चर में बदल जाते हैं और लुकास से 5 जीवन इकाइयां लेते हैं। आगे देखते हुए, मैं कह सकता हूं कि दुश्मनों के साथ संघर्ष के लिए एक ही चीज का वर्णन करना समझ में आता है:

 case "Enemy": { rb2d.AddForce(transform.up * 2, ForceMode2D.Impulse); HeroScript.Health = HeroScript.Health - 10; } break; 

इसके बाद, मैंने एक पत्थर से दो पक्षियों को मारने का प्रस्ताव रखा।

एकत्रित वस्तु और नियम।

एक खेल वस्तु जिसे खिलाड़ी उठा सकते हैं।

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

हम एक स्क्रिप्ट को उस पेड़ से जोड़ते हैं जो जिम्मेदार होगा कि यदि आप इसे काटना शुरू करते हैं तो आप कितने लॉग से दस्तक दे सकते हैं। चूंकि स्प्राइट्स के सेट में केवल हमले का एनीमेशन प्रस्तावित किया गया था, हम पेड़ (उत्पादन लागत) में कटौती करते समय इसका उपयोग करेंगे।
पेड़ पर जो लिपि है:

 [SerializeField] private Transform inst; //     [SerializeField] private GameObject FireWoodPref; //   [SerializeField] private int fireWood; //        

जब स्तर शुरू होता है, तो हम फ़ायरवूड में एक यादृच्छिक मान लिखते हैं :

 void Awake() { fireWood = Random.Range(4,10); } 

एक पैरामीटर के साथ एक विधि का वर्णन करता है जो एक झटके में कितने लॉग गिर जाएगा इसके लिए जिम्मेदार होगा:

 public int fireWoodCounter(int x) { for (int i = 0; i < fireWood; i++) { fireWood = fireWood - x; InstantiateFireWood(); } return fireWood; } 

एक विधि जो मंच पर लॉग क्लोन बनाएगी।
निजी शून्य झटपटफ़ायरवूड ():

  { Instantiate(FireWoodPref, inst.position, inst.rotation); } 

आइए एक लॉग बनाएं और एक स्क्रिप्ट को निम्न कोड से कनेक्ट करें:

 public void OnTriggerEnter2D(Collider2D collision) { switch (collision.gameObject.tag) { case "Player": { if (InventoryOnHero.woodCount > 10) { Debug.Log("   !"); } else { InventoryOnHero.woodCount = InventoryOnHero.woodCount + 1; Destroy(this.gameObject); } } break; } } 

अगला, हम एक वर्ग भी बनाएंगे जो इन्वेंट्री के लिए जिम्मेदार होगा।

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

पुल बनाने के लिए, हमें पुल के बाएं और दाएं आधे हिस्से के साथ 2 प्रीफैब चाहिए। BoxCollider2D . , , - , .

:

 [SerializeField] private Transform inst1, inst2; //        [SerializeField] private GameObject bridgePref1, bridgePref2; //   [SerializeField] private int BridgeCount; //   ,   .    

:

 public void BuildBridge() { if (InventoryOnHero.woodCount == 0) { Debug.LogWarning (" !"); } if (InventoryOnHero.woodCount > 0) { BridgeCount = BridgeCount - 1; InventoryOnHero.woodCount = InventoryOnHero.woodCount - 1; } switch (BridgeCount) { case 5: Inst1(); break; case 0: Inst2(); break; default: Debug.LogWarning("-      "); break; } } 

, , . , 10 , 12 8.

, , , , . , 1 , 1 . , 5, , . 0, . , .

.

, ColliderReaction.cs :

 void OnTriggerStay2D(Collider2D collision) { switch (collision.gameObject.tag) { case "Ladder": { rb2d.gravityScale = 0; } break; } } void OnTriggerExit2D(Collider2D collision) { switch (collision.gameObject.tag) { case "Ladder": { rb2d.gravityScale = 1; } break; } } 

OnTriggerStay2D , . , 0. , . OnTriggerExit2D , .

, .

19 , . , , , , , .

GO, SpriteRenderer , BoxCollider2D , Rigidbody2D . , — , . , ru.stackoverflow.com.

Trees .

, . , -, , Raycast 2 (4 ). , , , ( ). ( ), . , . , , . , . , , ( , ).

, . , - .

:

 [SerializeField] private GameObject area; private bool m1 = true, m2; // m  move private void fGreenMonster() { float dist = Vector3.Distance(greenMonster.transform.position, area.transform.position); Debug.Log(dist); if (m1) { if (dist < 3f) { transform.position += new Vector3(speed,0,0) * Time.deltaTime; SR.flipX = true; } else { m1 = false; m2 = true; } } if (m2) { if(dist >= 1f) { transform.position += new Vector3(-speed,0,0) * Time.deltaTime; SR.flipX = false; } else { m2 = false; m1 = true; } } } 

Update() , . , 3 , . 3, , .

, .

 private void fSunFlower() { canBullet = canBullet - minus * Time.deltaTime; if (canBullet <= 0 && SR.flipX == false) { GameObject newArrow = Instantiate(sunFlowerBullet) as GameObject; newArrow.transform.position = transform.position; Rigidbody2D rb = newArrow.GetComponent<Rigidbody2D>(); rb.velocity = sunFlowerTrans.transform.forward * -sunFlowerBulletSpeed; canBullet = 2; } if (canBullet <= 0 && SR.flipX == true) { GameObject newArrow = Instantiate(sunFlowerBullet) as GameObject; newArrow.transform.position = transform.position; Rigidbody2D rb = newArrow.GetComponent<Rigidbody2D>(); rb.velocity = sunFlowerTrans.transform.forward * sunFlowerBulletSpeed; canBullet = 2; } 

 canBullet = canBullet - minus * Time.deltaTime; 

, .

 if (canBullet <= 0 && SR.flipX == false) { GameObject newArrow = Instantiate(sunFlowerBullet) } 

, , , , :

 public int Damage(int x) { Health = Health - x; return Health; } 

, , :

 public void ifDie() { if (Damage(0) <= 0) { Destroy(this.gameObject); } } 

0, .

, :

 if (bGreenMonster) { fGreenMonster(); } if (bSunFlower) { fSunFlower(); } 

, .

.

, ?

, .

:

:

 [SerializeField] private Transform Hero; //         [SerializeField] private float distWhatHeroSee; //   [SerializeField] private LayerMask Tree, BridgeBuild, LadderBuild ,drinkingWater, lEnemy; //   

, :

 private void AttackBtn() { if (CrossPlatformInputManager.GetButtonDown("Attack")) { GameObject.Find("Hero").GetComponent<HeroScript>().State = CharState.AttackA; Collider2D[] Trees = Physics2D.OverlapCircleAll(Hero.position, distWhatHeroSee, Tree); for (int i = 0; i < Trees.Length; i++) { Trees[i].GetComponent<TreeControl>().fireWoodCounter(1); Debug.Log("Trees Collider"); HeroScript.Water = HeroScript.Water - 0.7f; } // BB  BridgeBuild Collider2D[] BB = Physics2D.OverlapCircleAll(Hero.position, distWhatHeroSee, BridgeBuild); for (int i = 0; i < BB.Length; i++) { BB[i].GetComponent<BridgeBuilding>().BuildBridge(); HeroScript.Water = HeroScript.Water - 0.17f; } 

 GameObject.Find("Hero").GetComponent<HeroScript>().State = CharState.AttackA; 

, .
, :

 Collider2D[] Trees = Physics2D.OverlapCircleAll(Hero.position, distWhatHeroSee, Tree); for (int i = 0; i < Trees.Length; i++) { Trees[i].GetComponent<TreeControl>().fireWoodCounter(1); Debug.Log("Trees Collider"); HeroScript.Water = HeroScript.Water - 0.7f; } 

Trees , . , , , . .
, . Simple as that!

, - :

, — .
, . , , , .

2 , .

!

.

https://opengameart.org/ , :

• Unity ru.stackoverflow.com
• Google Play
• Google Play
• sourceforge.net.
  worldofonehero@gmail.com.