👩🏾‍✈️ 🚥 💅 स्पलैश! - विंडोज फोन 7. भाग II के लिए गेम डेवलपमेंट 👊 🥝 🧑🏾‍🤝‍🧑🏽

हमारे लेख के पिछले भाग ( भाग I ) में, हमने विंडोज फोन 7 के लिए गेम बनाने के बुनियादी मुद्दों, उपकरणों और प्रौद्योगिकियों की पसंद की जांच की। अब हम फोन के साथ प्रोग्रामिंग और बातचीत के मुद्दों पर विस्तार से जांच करेंगे।

खेल तर्क

हम एक अलग GameController वर्ग में सभी खेल तर्क बाहर ले जाएगा। अब खेल वर्ग में अपडेट फ़ंक्शन निम्नानुसार है:

protected override void Update(GameTime gameTime) { // Allows the game to exit if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) this.Exit(); GameController.Update(gameTime); base.Update(gameTime); }

कृपया ध्यान दें कि हम GameController.Update के लिए गेमटाइम क्लास ऑब्जेक्ट पास कर रहे हैं। इसमें ElapsedGameTime संपत्ति है, जो यह बताती है कि पिछली कॉल से लेकर अपडेट फ़ंक्शन तक कितना समय बीत चुका है। एक नियम के रूप में, यह समय निर्धारित है और फोन 33 मिलीसेकंड के बराबर है, लेकिन यह इस पर भरोसा नहीं करना, बल्कि सभी गणनाओं में संचरित मूल्य का उपयोग करना बेहतर है।

जहाँ भी हमें खेल की दुनिया में वस्तुओं की आवाजाही की गणना करने की आवश्यकता होगी, हम ElapsedGameTime का उपयोग करेंगे। उदाहरण के लिए, अगर हमें सफेद गेंद की नई स्थिति (फोन के झुकाव के प्रभाव के तहत) की गणना करने की आवश्यकता है, तो कोड कुछ इस तरह दिखाई देगा:

 position += (float)(acceleration * gameTime.ElapsedGameTime.TotalSeconds);

गेंदों और धब्बों की त्रिज्या (उनकी उपस्थिति के समय) की गणना निम्नानुसार की जाएगी:

 radius += (float)(GrowSpeed * gameTime.ElapsedGameTime.TotalSeconds);

स्वाभाविक रूप से, हम इन सभी गणनाओं को अलग-अलग कक्षाओं में करेंगे - उनमें से प्रत्येक का अपना समान फ़ंक्शन अपडेट (गेमटाइम) होगा। और GameController.Update केवल उन्हें कॉल करेगा।

ड्राइंग ग्राफिक्स

हम ड्राइंग को गेमकंट्रोलर वर्ग में भी स्थानांतरित करेंगे। खेल वर्ग में ड्रा समारोह अब इस तरह दिखता है:

 protected override void Draw(GameTime gameTime) { GraphicsDevice.Clear(Color.Black); spriteBatch.Begin(); GameController.Draw(spriteBatch); spriteBatch.End(); base.Draw(gameTime); }

कृपया ध्यान दें कि हम GameController.Draw के लिए स्प्राइटबच क्लास का केवल ऑब्जेक्ट पास करते हैं - यह विशेष रूप से ड्राइंग के लिए अभिप्रेत है। हमें यहां गेमटाइम की आवश्यकता नहीं है, क्योंकि अपडेट फ़ंक्शन में सभी आवश्यक गणना पहले से ही की गई है।

इसके बाद, GameController.Draw खेल की दुनिया के तर्क को लागू करने वाली कक्षाओं पर समान ड्रा (स्प्राइटबैच) कार्यों को बुलाएगा।

ड्राइंग अपने आप में बहुत सरल लगती है:

 spriteBatch.Draw(texture, position, color);

यही है, हम स्क्रीन पर केवल समाप्त बनावट प्रदर्शित कर सकते हैं - XNA में 2D प्राइमेटिव्स (रेखाएँ, आयताकार, दीर्घवृत्त, आदि) की ड्राइंग प्रदान नहीं की गई है।

बनावट सामग्री से इसे डाउनलोड करके प्राप्त किया जा सकता है:

 Texture2D texture = Content.Load<Texture2D>(assetName);

बनावट पहले से ही भरी हुई है, सभी पदों की गणना की जाती है। लेकिन रंग के साथ आप कुछ दिलचस्प कर सकते हैं। अगर हमें बनावट के मूल रंग की आवश्यकता है, तो हमें Color.White को पास करना होगा।

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

दो रंगों को मिलाने के लिए Color.Lerp फ़ंक्शन का उपयोग करें। और एक अल्फा चैनल जोड़ने के लिए - आपको Color.FromNonPremultiplied फ़ंक्शन का उपयोग करना चाहिए।

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

पाठ प्रदर्शित करें

स्क्रीन पर पाठ प्रदर्शित करना ग्राफिक्स प्रदर्शित करने के समान सरल है:

 spriteBatch.DrawString(spriteFont, text, position, color);

SpriteFont वर्ग की एक वस्तु को सामग्री से लोड करके प्राप्त किया जा सकता है:

 SpriteFont spriteFont = Content.Load<SpriteFont>(assetName);

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

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

SpriteBatch.DrawString फ़ंक्शन के लिए अन्य विकल्प हैं जो आपको पाठ को घुमाते हैं और स्केल करते हैं। लेकिन आपको याद रखना चाहिए कि इस तरह के किसी भी हेरफेर से पाठ की विकृति होती है। ऐसा इसलिए है क्योंकि XNA मूल वेक्टर फ़ॉन्ट के साथ काम नहीं करता है, लेकिन इसके बिटमैप प्रतिनिधित्व के साथ, जो परियोजना के संकलन के समय बनाया गया है और सामग्री में जोड़ा गया है।

टच स्क्रीन

यह निर्धारित करने के लिए कि उपयोगकर्ता ने स्क्रीन पर कहां क्लिक किया है, आपको Microsoft.Xna.Framework.Input.Touch.TouchPanel वर्ग से डेटा प्राप्त करने की आवश्यकता है:

 foreach (var item in TouchPanel.GetState()) { if (item.State == TouchLocationState.Pressed || item.State == TouchLocationState.Moved) { // Get item.Position } }

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

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

खेल की शुरुआत में, हम संकेत देते हैं कि हमें ऐसे इशारों (टैप) के लिए समर्थन की आवश्यकता है:

 TouchPanel.EnabledGestures = GestureType.Tap;

तब हम गेम लूप के प्रत्येक पुनरावृत्ति में इशारे पा सकते हैं:

 while (TouchPanel.IsGestureAvailable) { GestureSample gesture = TouchPanel.ReadGesture(); if (gesture.GestureType == GestureType.Tap) { // Get guesture.Position } }

accelerometer

फोन के झुकाव के बारे में जानकारी प्राप्त करने के लिए, हम Microsoft.Devices.Sensors.Accelerometer वर्ग का उपयोग करेंगे। दुर्भाग्य से, एक्सेलेरोमीटर से सीधे डेटा प्राप्त करना असंभव है (जैसा कि हमने टचपैनल के साथ किया था) - यह केवल इवेंट मॉडल का समर्थन करता है। इसलिए, आपको एक सहायक वर्ग बनाना होगा जो ऑब्जेक्ट बनाता है और इसके ईवेंट की सदस्यता लेता है:

 accelerometer = new Microsoft.Devices.Sensors.Accelerometer(); accelerometer.ReadingChanged += AccelerometerChanged; accelerometer.Start();

ईवेंट हैंडलर में, हम त्वरण के मूल्य को याद रखेंगे और भविष्य के उपयोग के लिए इसे बचाएंगे:

 private void AccelerometerChanged(object sender, AccelerometerReadingEventArgs e) { vector = new Vector3((float)eX, (float)eY, (float)eZ); }

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

 public Vector2 Acceleration { get { return new Vector2(vector.X, -vector.Y); } }

यह वह तेजी है जो हम अपनी सफेद गेंद को देंगे।

एक्सेलेरोमीटर के अक्षों का अधिक दृश्य प्रतिनिधित्व यहां प्राप्त किया जा सकता है ।

आवाज बजाओ

XNA में साउंड बजाना क्लास साउंडफेक्ट के ऑब्जेक्ट के प्ले फंक्शन का उपयोग करके किया जाता है। इस वर्ग की एक वस्तु सामग्री से डाउनलोड की जा सकती है:

 SoundEffect sound = Content.Load<SoundEffect>(assetName);

वास्तव में, यह सब - हमें ध्वनियों के साथ और कुछ करने की आवश्यकता नहीं है।

खिड़कियां

अंत में, खेल किया जाता है: सफेद गेंद को एक्सीलरोमीटर द्वारा नियंत्रित किया जाता है, बाकी इसके बाद पीछा करते हैं और जब आप अपनी उंगली से उन पर क्लिक करते हैं, तो बिंदुओं में बदल जाते हैं, अंक गिने जाते हैं, आवाज़ें होती हैं। लगता है सब कुछ तैयार है? वहाँ यह था!

अब आपको खिड़कियां बनाने की आवश्यकता है: प्रारंभ विंडो (मुख्य मेनू), ठहराव संवाद और गेम पूरा करने वाली खिड़की (स्कोर डिस्प्ले और रिकॉर्ड के साथ)।

विंडोज फोन के लिए XNA में कोई विंडो नहीं है, इसलिए आपको उन्हें स्वयं करना होगा। यह उतना मुश्किल नहीं है जितना पहली नज़र में लग सकता है।

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

उसके बाद, आप पहले से ही आसानी से खिड़कियों के अंदर तत्वों को रख सकते हैं।

राज्य संरक्षण

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

राज्य (और एक ही समय सेटिंग्स पर) को संग्रहीत करने के लिए, हम System.IO.IsolatedStorage.IsolatedStorageSettings.ApplicationSettings वर्ग का उपयोग करते हैं। यह वर्ग IDEDIA <string, object> interface को लागू करता है, इसलिए इसके साथ काम करना बहुत सरल है। खेल की दुनिया में सभी वस्तुओं की वर्तमान स्थिति को जोड़ें (सौभाग्य से, हमारे पास उनमें से कुछ हैं) इस शब्दकोश में और IsolatedStorageSettings.ApplicationSettings.Save () फ़ंक्शन को कॉल करें।

हम आवेदन से बाहर निकलने के समय को बचाएंगे, इसके लिए, हम गेम क्लास में ऑनएक्सिटिंग फ़ंक्शन को ब्लॉक करेंगे:

 protected override void OnExiting(object sender, EventArgs args) { GameController.SaveState(); base.OnExiting(sender, args); }

राज्य की बहाली इसी तरह से की जाती है - एप्लिकेशन लोड करते समय, हम IsolatedStorageSettings.ApplicationSettings से डेटा प्राप्त करते हैं और खेल की दुनिया के सभी ऑब्जेक्ट्स को पुनर्स्थापित करते हैं।

एप्लिकेशन को सक्रिय और निष्क्रिय करें

हमारा एप्लिकेशन हमेशा एक सक्रिय स्थिति में नहीं होगा - कभी-कभी इसे निष्क्रिय किया जा सकता है (एक इनकमिंग कॉल द्वारा, उदाहरण के लिए), और फिर फिर से सक्रिय किया गया।

इन घटनाओं को ट्रैक करने के लिए, हम गेम क्लास में OnActivated और OnDeactivated फ़ंक्शन को ब्लॉक करेंगे।

जब एप्लिकेशन को निष्क्रिय कर दिया जाता है, तो हम गेम को रोकें मोड में डाल देंगे - ताकि जब वह गेम में वापस आए, तो उपयोगकर्ता को गेम जारी रखने के प्रस्ताव के साथ एक संवाद मिलेगा।

इसके अलावा, निष्क्रिय अवस्था में फोन के कंप्यूटिंग संसाधनों को बर्बाद न करने के लिए, खेल वर्ग में अपडेट फ़ंक्शन की शुरुआत के लिए निम्न कोड जोड़ें:

 if (!IsActive) { SuppressDraw(); return; }

स्पलैश स्क्रीन

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

विंडोज फोन के लिए सिल्वरलाइट एप्लिकेशन में, प्रोजेक्ट में SplashScreenImage.jpg फ़ाइल जोड़ें - और यह स्वतः ही स्टार्टअप पर दिखाई देगा। हालाँकि, यह XNA प्रोजेक्ट्स के लिए काम नहीं करता है।

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

अब एप्लिकेशन का लॉन्च बहुत अच्छा लग रहा है।

फोन पर खेल का स्थान

हमारे खेल के लिए खेल अनुभाग में फोन पर प्रदर्शित होने के लिए (आप फोन की स्टार्ट स्क्रीन पर XBOX LIVE कहते हैं बटन पर क्लिक करके वहां पहुंच सकते हैं), आपको प्रोजेक्ट में WMAppManifest.xml फ़ाइल को संपादित करना होगा। इस फाइल में, लाइन Genre = "Apps.Normal" के बजाय, आपको Genre = "Apps.Games" लिखना होगा।

उसी समय, हम एक ही फ़ाइल में (शीर्षक और विवरण विशेषताओं में) गेम का नाम और विवरण दर्शाते हैं। और अनावश्यक आवश्यकताओं (खंड) को हटा दें। इस खंड में हम एक्सेलेरोमीटर का समर्थन करने के लिए केवल /> छोड़ते हैं। खेल के इस संस्करण में बाकी सभी को हमें अभी तक ज़रूरत नहीं है।

प्रोजेक्ट में दो चित्र होने चाहिए: GameThumbnail.png और Background.png।

खेल अनुभाग में गेम को दिखाने के लिए पहली तस्वीर की आवश्यकता है, और दूसरा - फोन की शुरुआत स्क्रीन पर। दोनों चित्र समान आकार के होने चाहिए: 173x173 पिक्सेल।

परीक्षण मोड

चूंकि हमारे खेल का भुगतान किया जाएगा, इसलिए हमें परीक्षण मोड के लिए समर्थन जोड़ना होगा। परीक्षण सत्यापन पहले से ही प्लेटफ़ॉर्म में बनाया गया है और Microsoft.Phone.Marketplace.icenseInformation वर्ग का उपयोग करके किया जाता है:

 var license = new Microsoft.Phone.Marketplace.LicenseInformation(); return license.IsTrial();

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

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

जब आप खरीदें बटन पर क्लिक करते हैं, तो हम विंडोज फोन मार्केटप्लेस में अपना एप्लिकेशन प्रदर्शित करेंगे:

 var market = new Microsoft.Phone.Tasks.MarketplaceDetailTask(); market.Show();

खरीदारी के बाद, उपयोगकर्ता एप्लिकेशन पर वापस लौटने और गेम जारी रखने में सक्षम होगा।

बैक बटन

अंत में, सब कुछ तैयार है और हम एप्लिकेशन को विंडोज फोन मार्केटप्लेस पर भेज रहे हैं। प्रकाशन से पहले, इसे Microsoft पर अच्छी तरह से परखा जाता है और कुछ दिनों बाद एक फैसला जारी किया जाता है: यह पारित नहीं हुआ है। मामला क्या है?

समस्या यह है कि हम अद्यतन समारोह में छोड़ दिया कोड में निकला:

 protected override void Update(GameTime gameTime) { // Allows the game to exit if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) this.Exit(); ... }

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

लेकिन बैक बटन हमेशा हमें एप्लिकेशन से बाहर निकलने के लिए प्रेरित करता है। हम इस कोड को हटाते हैं, बैक बटन की सही प्रोसेसिंग करते हैं, और फिर से इसे सत्यापन के लिए जमा करते हैं। बार-बार की समीक्षा में बहुत कम समय लगता है।

परिणाम

और फिर अंत में स्वीकार कर लिया! अब यह गेम विंडोज फोन मार्केटप्लेस में है।

कुल मिलाकर, लगभग दो सप्ताह विकास पर खर्च किए गए (और एक और दो सप्ताह खेल को स्टोर में रखने पर खर्च किए गए)। परिणाम एक बहुत अच्छा और रोमांचक खेल है:

बेस्ट WP7 गेम्स वेबसाइट के संपादकों ने इस गेम की समीक्षा की: www.bestwp7games.com/splash-fun-accelerometer-game-for-wp7-review.html

और उपस्थिति के एक हफ्ते बाद, गेम ने विंडोज फोन मार्केटप्लेस में शीर्ष 100 भुगतान किए गए गेम को मारा।

आप यहां गेम डाउनलोड कर सकते हैं।

इस खेल को विकसित करने के अनुभव से क्या निष्कर्ष निकाला जा सकता है? विंडोज फोन 7 के लिए गेम बनाना वास्तव में आसान है!

स्पलैश! - विंडोज फोन 7. भाग II के लिए गेम डेवलपमेंट