कैसे एक बुनियादी एकता मंच खेल बनाने के लिए

कैसे
)।



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

तो अगर आप सोच रहे हैं कि एकता WebGL गेम कैसे बनाया जाए, तो पढ़ें!



आवश्यकताओं को

  • एकता
  • HTML5 / जावास्क्रिप्ट ज्ञान
  • (वैकल्पिक) जैसे एक अच्छा पाठ संपादक Notepad ++

यूनिटी को शुरू करने, डाउनलोड करने और स्थापित करने के लिए, और सुनिश्चित करें कि आप WebGL समर्थन घटक स्थापित करें।





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

आपके पास भी है खेल टैब (संपादक के अंदर खेल का परीक्षण करने के लिए), और दाईं ओर है निरीक्षक पैनल। यह वह जगह है जहां तत्वों को संपादित किया जा सकता है, उदाहरण के लिए, रोशनी, अभिनेता, आदि।

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



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

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

अब हम वास्तव में कुछ सरल बनाने जा रहे हैं - एक 'प्लेटफ़ॉर्मर' प्रकार का खेल, जहाँ हमारा चरित्र प्लेटफ़ॉर्म के चारों ओर बस चलता है। गिरने का अर्थ है मृत्यु। हम 3 डी / पहले व्यक्ति के दृश्य में ऐसा कर रहे हैं, इसलिए एक चरित्र वास्तव में मॉडल नहीं है - वास्तव में, हम सिर्फ अपने चरित्र के लिए एक सरल 'क्षेत्र' वस्तु का उपयोग करने जा रहे हैं, क्योंकि यह बनाने के लिए सबसे सरल है।

तो में अनुक्रम पैनल, 'बनाएँ' पर क्लिक करें और इन गुणों को संपादित करें:

  • स्थिति {X: 0, Y: 2.5, Z: 0}
  • स्केल {एक्स: ०.३, वाई: ०.३, जेड: ०.३}

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

तो में निरीक्षक पैनल, गोले के लिए एक घटक जोड़ें और चुनें कठोर शरीर - इसके अलावा, हम नहीं चाहते हैं कि गोला घुमाएँ , इसलिए कॉन्स्टैन्ट्स पर जाएं> सभी कुल्हाड़ियों को चुनें रोटेशन क्षेत्र।

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

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

में एक नया सबफ़ोल्डर बनाएँ संपत्ति निर्देशिका और इसे 'सामग्री' जैसा कुछ नाम दें, और फिर एक नई भौतिकी सामग्री बनाएं। इसे 'Bouncy_blob' या जो भी आप चाहते हैं।

अब में निरीक्षण पैनल, इन मूल्यों को उछालभरी सामग्री में जोड़ें:

  • गतिशील घर्षण: 10
  • स्टेटिक फिक्शन: 10
  • परिषद: 1
  • घर्षण संयोजन: अधिकतम
  • बाउंस कंबाइन: अधिकतम

हमें अपने गोले के नीचे प्लेटफ़ॉर्म में एक भौतिक सामग्री भी जोड़ना चाहिए - यह ऐसा होगा कि हमारा क्षेत्र हर उछाल पर ऊँचाई के साथ उछल जाएगा। तो एक और सामग्री बनाएं और इसे 'Platform_bouncing' की तरह नाम दें, और इसे निम्न मान दें:

  • गतिशील घर्षण: 0.9
  • स्टेटिक फिक्शन: 0.9
  • परिषद: 1
  • घर्षण संयोजन: औसत
  • बाउंस कंबाइन: गुणा

अब जब आप 'प्ले' बटन दबाते हैं, तो आप देखेंगे कि हमारा चरित्र प्रत्येक उछाल पर अधिक उछलता है।

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

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

किसी भी स्थिति में, आपको कैमरे को इस तरह संपादित करना होगा:

  • स्थिति {X: 0, Y: 1, Z: 0}
  • रोटेशन {X: 90, Y: 0, Z: 0}
  • स्केल {एक्स: २.५, वाई: २.५, जेड: २.५}
  • स्पष्ट झंडे: ठोस रंग
  • पृष्ठभूमि: # 000
  • फील्ड ऑफ़ व्यू: 80.3

अब हमें ऊंचाई पर कूदने के लिए 'परिप्रेक्ष्य' की भावना देने के लिए, हम एक स्पॉटलाइट जोड़ देंगे। इसलिए स्पॉटलाइट वैल्यू को ट्वीक करें:

  • रोटेशन {X: 90, Y: 0, Z: 0}

अब हम गेम के नियंत्रणों को प्रोग्राम करना चाहते हैं, ताकि हम अपने माउस का उपयोग चरित्र के मूवमेंट को नियंत्रित करने के लिए कर सकें। हमें इसके लिए एक स्क्रिप्ट की जरूरत है।

कैसे फ़ायरफ़ॉक्स पर adchoices से छुटकारा पाने के लिए

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

जब आप स्क्रिप्ट को एकता के डिफ़ॉल्ट स्क्रिप्ट संपादक में खोलते हैं, तो उसे इस तरह दिखना चाहिए:

इसलिए हम चाहते हैं कि 'GameObject' वैरिएबल हमारे कैरेक्टर को संदर्भित करे - इसके लिए, आप केवल एकता कैमरा दृश्य पर वापस जा सकते हैं, और इनपुट क्षेत्र पर हमारे क्षेत्र को ड्रैग / ड्रॉप कर सकते हैं।

अब हम असाइन करना चाहते हैं आधा स्क्रीन की चौड़ाई और प्रारंभ समारोह के लिए ऊंचाई। तो स्क्रिप्ट को इस तरह से संपादित करें:

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

थोड़ा समझाने के लिए, चर एक्स और जेड नियंत्रक अक्ष के लिए हैं - हम चाहते हैं कि जब हम गेम में नियंत्रक इनपुट भेजें तो हम अपने चरित्र की स्थिति में हेरफेर करें। हमें Input.mousePosition चर का संदर्भ देने की आवश्यकता है, जो हमें एक 2D वेक्टर देता है। इस 2D वेक्टर को हमारे समन्वय ट्रैकिंग में जोड़ा जाना चाहिए, इसलिए हम एक फ़ंक्शन को कॉल करेंगे setHeroPosition तर्क के रूप में मूल्यों के साथ।

इसलिए एक नई स्क्रिप्ट बनाएं, इसे कॉल करें HeroController और इसे हमारे क्षेत्र / वर्ण में संलग्न करें। इस तरह दिखने के लिए स्क्रिप्ट को संपादित करें:

अब जब आप 'प्ले' बटन दबाते हैं, तो आपको अपने माउस का उपयोग करके मंच के चारों ओर चरित्र को नेविगेट करने में सक्षम होना चाहिए, और यहां तक ​​कि मंच से गिर जाना चाहिए! हमारा अंतिम लक्ष्य एक मंच के खेल के समान बनाना है छोटा जीवन , इसलिए हम अगले गाइड में इस खेल को थोड़ा और बढ़ा देंगे।

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

प्रक्रियात्मक प्लेटफ़ॉर्म बनाना

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

इसके लिए, हमें एक प्लेटफ़ॉर्म टेम्प्लेट चाहिए - जिसे 'प्रीफ़ैब' के रूप में जाना जाता है। Prefab के लिए कम है पूर्वनिर्मित, और इसका सीधा सा अर्थ है 'पूर्व-निर्मित' - आमतौर पर एक गेम ऑब्जेक्ट की एक प्रति जिसे आप बार-बार पुन: उपयोग कर सकते हैं। वास्तव में, प्रीफैब हो सकते हैं पदानुक्रम खेल की वस्तुओं, जिसका अर्थ है कि आप खेल वस्तुओं के एक पूरे दृश्य को 'प्रीफैब' कर सकते हैं।

विंडोज़ 10 स्वागत स्क्रीन पर अटक गया

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

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

इसका कारण हम इसे कैमरे से जोड़ते हैं, क्योंकि कैमरा कभी नष्ट नहीं होता है, और यह स्थिर रहता है - इसलिए स्क्रिप्ट कभी नष्ट नहीं होती है और इसे संलग्न रहने से स्थिर रहती है।

यहाँ क्या स्क्रिप्ट में शामिल किया जाना चाहिए:

इस कोड को थोड़ा समझाने के लिए, हमारे लिए यह आवश्यक है कि हम प्रीफैब पैनल और क्षेत्र (हमारे चरित्र) दोनों का संदर्भ बनाएं, इसलिए आपको उन्हें अपने संपादक में उनके विशिष्ट स्लॉट में खींचने और छोड़ने की आवश्यकता है।

इस कोड में तीन निजी चर भी होते हैं - जो लाइनें शुरू होती हैं निजी संस्करण। ये निम्नलिखित तरीकों से प्रीफ़ैब पैनल को तुरंत (संदर्भ) भेज देंगे:

  • निजी संस्करण सीमा: फ्लोट y- अक्ष पर एक सीमा रखता है, इसलिए जब हमारा चरित्र कूदता है उच्चतर इस सीमा की तुलना में, एक नया पैनल बनाया जाएगा।
  • निजी var रोटेशन: Quaternion; बस हमारे प्रीफ़ैब्स को तुरंत जोड़ने के लिए एक आवश्यक रोटेशन जोड़ता है - हालांकि, हम जोड़ रहे हैं रोटेशन = Quaternion.identify; चूंकि यह इंजन को गेम ऑब्जेक्ट को घुमाने के लिए निर्देश नहीं देता है। ऑब्जेक्ट (हमारे प्रीफ़ैब पैनल) सचमुच दुनिया के साथ 'पूरी तरह से गठबंधन' होंगे।
  • अंतिम निजी चर lastPlatformPosition 3 डी वेक्टर के रूप में अंतिम प्लेटफ़ॉर्म की स्थिति को याद रखना और सहेजना होगा (मूल रूप से, आपके पीछे प्लेटफ़ॉर्म गायब नहीं होते हैं, इसलिए आप खेल की दुनिया के माध्यम से पीछे जा सकते हैं, यदि आप चाहते हैं)।

इस स्क्रिप्ट के अगले बिट में, हम एक चेक जोड़ने जा रहे हैं हर फ्रेम हमारा क्षेत्र (वर्ण) सीमा से ऊपर है या नहीं (जो नए प्लेटफॉर्म बनाता है) - यदि हमारा चरित्र सीमा से ऊपर है, तो हम करेंगे सीमा की सीमा बढ़ाएँ पिछले से अधिक एक नया पैनल / प्लेटफ़ॉर्म बनाने के लिए।

हमारा अगला चरण कोड जोड़ना है जो अगले पैनल की स्थिति निर्धारित करता है:

हम एक का उपयोग कर रहे हैं जबकि ऐसा इस कोड में लूप यह सुनिश्चित करने के लिए कि वेक्टर का एक्स और जेड मान (खेल की दुनिया में इसकी स्थिति) पिछले प्लेटफार्मों के समान नहीं है - इसलिए हमारे प्रक्रियात्मक रूप से उत्पन्न प्लेटफॉर्म हमेशा ऊंचाई में बढ़ेंगे।

बेशक, हम नहीं चाहते कि ये मूल्य हों सख्ती से रखा - थोड़ी सी यादृच्छिकता एक अच्छी बात है, अन्यथा हम सिर्फ एक परिपूर्ण सीढ़ी बना रहे हैं। इसलिए हम इसका उपयोग कर रहे हैं Random.Range फ़ंक्शन मान -1 और 2 के बीच, एक्स और जेड के लिए यादृच्छिक मानों को कॉल करने के लिए। यदि आप मूर्ख बनाना चाहते हैं तो आप इन नंबरों के साथ थोड़ा खेल सकते हैं।

गेम मेनू बनाना

अब तक, हमने एक 'गेम' बनाया है जहां आप बढ़ती ऊंचाई के साथ कूद सकते हैं और दिशा को नियंत्रित करने के लिए माउस को घुमा सकते हैं। समस्या यह है कि यदि आप प्लेटफ़ॉर्म से गिरते हैं, तो आप बस अंतहीन रूप से गिर जाएंगे - हमें शुरू करने के लिए 'मौत' / खेल मेनू में स्क्रिप्ट करने की आवश्यकता है।

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

हमारा पहला चरण यह जांचना होगा कि क्या क्षेत्र एक विशिष्ट सीमा से नीचे गिर गया है। में जाओ GameManager स्क्रिप्ट हमने पहले बनाई थी और देखो अगर का बयान अपडेट करें समारोह।

हम एक का उपयोग करने जा रहे हैं और अगर यहाँ यह जाँचने के लिए कि क्या हमारे क्षेत्र की स्थिति Y-स्थिति की -2.0 इकाइयों से कम है - यदि यह हमारा निजी कार्य है खेल खत्म होगा ... ठीक है, स्क्रिप्ट की वह बिट आत्म-व्याख्यात्मक है।

स्क्रिप्ट का वह अंतिम बिट 'गेम ओवर' स्थिति को संभालने के लिए उपयोग करने के लिए और हमारे गेम मेनू को लोड करने का कार्य है।

यह यूनिटी को परेशान करता है आवेदन वर्ग - हम कॉल करने में सक्षम हैं LoadLevel एक नया दृश्य लाने के लिए कार्य, जो इस मामले में, बस हमारा गेम मेनू है - याद रखें कि मूल रूप से एकता में सब कुछ 'स्तर' है। मुख्य मेनू (गेम शुरू करें - विकल्प - क्रेडिट - आदि) मूल रूप से क्लिक करने योग्य पाठ के बिट्स के साथ केवल स्तर / दृश्य हैं। Skyrim की लोडिंग स्क्रीन की तरह, एह? वे लोडिंग बार के साथ एक खाली दुनिया के स्थान पर सिर्फ 3 डी मॉडल हैं।

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

हमारा मेनू दृश्य अभी भी खुला होना चाहिए, इसलिए बस 'वर्तमान जोड़ें' बटन पर क्लिक करें और दृश्य को अपने में जोड़ें सेटिंग्स बनाएँ - लेवल सीन के साथ फिर से ऐसा करें।

जब हम खेल में मर जाते हैं, तो हमारे द्वारा बनाई गई स्क्रिप्ट हमें खेल के स्तर से मेनू दृश्य में परिवर्तित कर सकती है।

खिलाड़ियों के लिए एक 'प्रारंभ' बटन जोड़ें

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

तो खेल मेनू दृश्य पर स्विच करें, और इस बिट को कैमरे में जोड़ें ( इंस्पेक्टर पैनल में, पीटी से याद रखें। इस ट्यूटोरियल के 1?)।

  • स्पष्ट झंडे: ठोस रंग
  • पृष्ठभूमि: # 000
  • चौड़ाई: 200
  • ऊँचाई: 60

यह हमारे गेम मेनू के लिए हमें एक ठोस ब्लैक बैकग्राउंड देगा - यह इसमें किया गया है RGB मान , हेक्स नहीं - इतना नीला 001 होगा, हरा 010 है, लाल 100 है, आदि मैं आपको इसके बारे में समझा सकता हूं, लेकिन अगर आप एक विशिष्ट रंग चाहते हैं तो आपको Google 'RGB पिकर' करने की आवश्यकता है।

आगे बढ़ते हुए, हमें खेल शुरू करने के लिए अपना बटन जोड़ना होगा। इसके माध्यम से किया जाता है यूआई तत्व - मूल रूप से, हम UI तत्वों को उसी तरह जोड़ सकते हैं जैसे हम 3D तत्वों को जोड़ते हैं, के माध्यम से अनुक्रम पैनल। तो आगे बढ़ो और एक बनाएँ यूआई बटन , और आपको कुछ नए तत्व दिखाई देंगे अनुक्रम पैनल:

  • EventSystem
  • कैनवास
  • बटन
  • टेक्स्ट

इसे तोड़ने के लिए - ए कैनवास सभी UI तत्वों के लिए हमारा कंटेनर है, और हम इसे उत्तरदायी बना सकते हैं ( उत्तरदायी द्वारा मेरा मतलब है 'स्क्रीन आकार को स्केलिंग', उत्तरदायी नहीं जैसे यह आपके द्वारा पूछे गए सवालों के जवाब देगा। यह AI लिपियों में सबसे अच्छा बचा है)। किसी भी स्थिति में, हम बटन की स्थिति को इसमें बदलने जा रहे हैं:

  • Rect Transform {Pos X: 0, Pos Y: 0, Pos Z: 0}
  • Rect Transform {चौड़ाई: 200, ऊँचाई: 60}

इसे थोड़ा और सुरुचिपूर्ण बनाने के लिए, आप बटन की 'स्रोत छवि' को हटा सकते हैं, और इसके लिए एक रंग सेट कर सकते हैं। और बटन के पाठ को बदलने के लिए, बस संपादित करें टेक्स्ट 'START GAME' जैसी किसी चीज़ के लिए तत्व, और इसे 16 के आसपास फ़ॉन्ट-आकार दें।

बटन बनाने के लिए क्लिक करने योग्य , हम UIController स्क्रिप्ट में एक फ़ंक्शन जोड़ेंगे बटन तत्व। बस इस कोड को नीचे जोड़ें:

आउटलुक 2010 सर्च काम नहीं कर रहा है

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

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

कैसे निर्यात / एक WebGL ब्राउज़र गेम के रूप में प्रकाशित करें

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

  • अपने गेम को किसी प्रकार के फ़ाइल होस्ट (ड्रॉपबॉक्स, Google ड्राइव, आदि) पर अपलोड करें, फिर लिंक साझा करें। यह छोटे के लिए उपयोगी है क़ौम आप दोस्तों, या संभावित ग्राहकों को दिखाना चाहते हैं ( खेल पोर्टल वेबसाइटें जो या तो आपके खेल को खरीदेंगी या आपके साथ एक विज्ञापन-साझा राजस्व स्थापित करेंगी)।
  • अपना गेम एक एफ़टीपी सर्वर पर अपलोड करें जिसे आप अपना मानते हैं, और इसे एक में एम्बेड करते हैं