🤭 🔑 🧘🏾 हम एक खेल देव काढ़ा। भाग 1 🤽🏻 ✌🏾 👨🏾‍✈️

परिचय

कहानी ब्लॉकचेन-आधारित हैकाथॉन के साथ शुरू हुई। घटना की शुरुआत में, मैं एक ऐसे व्यक्ति से मिला, जो एक शौक के रूप में बोर्ड बिजनेस गेम बनाता है (मैं इस तरह के एक गेम के खेल में सबसे आगे था), हमने एक साथ मिलकर एक टीम ढूंढी, जिसके साथ उन्होंने सप्ताहांत में एक सरल रणनीतिक गेम "अंधा" किया। हैकाथॉन बीत गया, लेकिन उत्साह बना रहा। और हम खुशी, विश्व समुदाय और चुनावों के बारे में एक मल्टीप्लेयर कार्ड गेम के विचार के साथ आए।

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

खेल सारांश
बैकएंड क्या करना है, इस पर निर्णय कैसे किया गया। यह "लाइव" कहाँ होगा ताकि यह विकास के स्तर पर इसके लिए भुगतान न करे
विकास में पहला कदम - खिलाड़ी प्रमाणीकरण और मंगनी के संगठन
आगे की योजना

खेल किस बारे में है

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

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

राउंड 3, 6 और 9 के अंत में, कम से कम वोटों वाला खिलाड़ी खेल से हटा दिया जाता है। यदि कई खिलाड़ियों के पास समान न्यूनतम वोट होते हैं, तो इस परिणाम वाले सभी खिलाड़ियों को खेल से हटा दिया जाता है। इन खिलाड़ियों की आवाज मतदाता के सामान्य पूल में जाती है।

राउंड 12 के अंत में, विजेता सबसे अधिक मतों के साथ है।

बैकएंड के लिए एक उपकरण चुनना

खेल के वर्णन से इस प्रकार है:

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

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

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

PlayFab

सकारात्मक विशेषताएं:

विभिन्न खेलों के खातों को एक मास्टर खाते में जोड़ा जाता है
गेमिंग इकॉनमी को कोड की एक भी लाइन के बिना वर्णित किया गया है, जिसमें एक अलग वर्चुअल स्टोर के लिए मूल्य निर्धारण शामिल है
अनुकूल यूजर इंटरफेस
Microsoft अधिग्रहण के बाद उत्पाद प्राप्त करता है
Indie Studio सदस्यता द्वारा उत्पादन में स्वामित्व की लागत $ 99 (100k MAU तक) है, जब व्यावसायिक 1k MAU सदस्यता पर स्विच करना $ 8 (न्यूनतम खाता $ 300) का खर्च आएगा

नकारात्मक विशेषताएं:

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

GameSparks

सकारात्मक विशेषताएं:

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

नकारात्मक विशेषताएं:

भावना है कि अमेज़ॅन (सर्दियों 2018) द्वारा खरीद के बाद से उपकरण स्थिर हो गया है, कोई नवाचार नहीं हैं
फिर, अमेज़ॅन के अधिग्रहण के बाद, टैरिफ बदतर हो गए, पहले मुफ्त में उत्पादन में 10,000 एमएयू तक का उपयोग करना संभव था
स्वामित्व की उत्पादन लागत $ 300 (मानक सदस्यता) से शुरू होती है

सोच

सबसे पहले आपको गेम की अवधारणा को जांचना होगा। ऐसा करने के लिए, मैं मौद्रिक निवेश के बिना लाठी और स्कॉच टेप का एक प्रोटोटाइप बनाना चाहता हूं और खेल यांत्रिकी के खेल परीक्षण शुरू कर सकता हूं। इसलिए, पहली जगह में चुनते समय, मैं एक मुफ्त सदस्यता पर एक मैकेनिक को विकसित करने और परीक्षण करने का अवसर बढ़ाता हूं।
GameSparks इस कसौटी पर खरा उतरता है, लेकिन PlayFab नहीं करता है, क्योंकि आपको एक सर्वर की आवश्यकता होगी जो गेम क्लाइंट और एक इंडी स्टूडियो-स्तरीय सदस्यता ($ 99) की घटनाओं को संभाल लेगा।

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

विकास में पहला कदम

कनेक्शन और प्रमाणीकरण

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

यह देखते हुए कि मेरे पास एक मस्तिष्क टीडीडी है, मैंने क्लाइंट को खेल से जोड़ने के लिए एक परीक्षण बनाकर शुरू किया। चूंकि भविष्य में CloudCode को JS में लिखना होगा, इसलिए मैं mocha.js और chai.js. का उपयोग करके JS में एकीकरण परीक्षण करूंगा। पहला टेस्ट इस तरह निकला:

var expect = require("chai").expect; var GameClientModule = require("../src/gameClient"); describe("Integration test", function () { this.timeout(0); it("should connect client to server", async function () { var gameClient = new GameClientModule.GameClient(); expect(gameClient.connected()).is.false; await gameClient.connect(); expect(gameClient.connected()).is.true; }); })

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

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

 var GameSparks = require("../gamesparks-javascript-sdk-2018-04-18/gamesparks-functions"); var config = new require("./config.json"); exports.GameClient = function () { var gamesparks = new GameSparks(); this.connected = () => (gamesparks.connected === true); this.connect = function () { return new Promise(function (resolve, reject) { gamesparks.initPreview({ key: config.gameApiKey, secret: config.credentialSecret, credential: config.credential, onInit: () => resolve(), onMessage: onMessage, onError: (error) => reject(error), logger: console.log }); }); } function onMessage(message) { console.log("GAME onMessage: " + JSON.stringify(message)); } }

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

ऐसा लगता है कि काम पूरा हो गया है, लेकिन परीक्षण लाल है। यह GameSparks JS SDK नोड के साथ काम नहीं करता है। इसे करने के लिए, आप देखते हैं, इसमें ब्राउज़र संदर्भ का अभाव है। चलो उसे लगता है कि नोड खसखस पर क्रोम है। हम gameparks.js पर जाते हैं और बहुत शुरुआत में जोड़ते हैं:

 if (typeof module === 'object' && module.exports) { // node.js var navigator = { userAgent: "Chrome/73.0.3683.103", vendor: "Google Inc.", platform: "Mac" }; var window = {}; window.setInterval = setInterval; // <<<   KeepAlive  }

परीक्षण हरा हो गया, आगे बढ़ रहा है।

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

 it("should auth two anonymous players", async function () { var gameClient1 = new GameClientModule.GameClient(); expect(gameClient1.playerId).is.undefined; var gameClient2 = new GameClientModule.GameClient(); expect(gameClient2.playerId).is.undefined; await gameClient1.connect(); await gameClient1.authWithCustomId("111"); expect(gameClient1.playerId).is.equals("5b5f5614031f5bc44d59b6a9"); await gameClient2.connect(); await gameClient2.authWithCustomId("222"); expect(gameClient2.playerId).is.equals("5b5f6ddb031f5bc44d59b741"); });

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

GameClient जोड़ने में कार्यान्वयन के लिए:

 this.playerId = undefined; this.authWithCustomId = function (customId) { return new Promise(resolve => { var requestData = { "deviceId": customId , "deviceOS": "NodeJS" } sendRequest("DeviceAuthenticationRequest", requestData) .then(response => { if (response.userId) { this.playerId = response.userId; resolve(); } else { reject(new Error(response)); } }) .catch(error => { console.error(error); }); }); } function sendRequest(requestType, requestData) { return new Promise(function (resolve) { gamesparks.sendWithData(requestType, requestData, (response) => resolve(response)); }); }

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

दोनों परीक्षण हरे हैं, यह कनेक्शन और रिफ्लेक्टर के बंद होने को जोड़ने के लिए रहता है।
GameClient में, मैंने एक तरीका जोड़ा है जो सर्वर (डिस्कनेक्ट) और कनेक्टअंस से कनेक्शन को बंद कर देता है। कनेक्ट और ऑर्टविथकस्टमइडी के संयोजन का नाम। एक ओर, connectAsAnonymous एकल जिम्मेदारी के सिद्धांत का उल्लंघन करता है, लेकिन इसका उल्लंघन नहीं लगता है ... एक ही समय में यह प्रयोज्य जोड़ता है, क्योंकि परीक्षणों में अक्सर ग्राहकों को प्रमाणित करना आवश्यक होगा। आप इस बारे में क्या सोचते हैं?

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

अंतिम कोड रिपॉजिटरी में देखा जा सकता है, एक लिंक जिसे मैं लेख के अंत में दूंगा।

खेल खोज संगठन (मंगनी)

मैं मैचमेकिंग सुविधा शुरू करूंगा, जो मल्टीप्लेयर के लिए बहुत महत्वपूर्ण है। जब हम गेम में "गेम खोजें" बटन दबाते हैं तो यह सिस्टम काम करना शुरू कर देता है। वह या तो प्रतिद्वंद्वियों, या टीममेट्स, या दोनों (खेल के आधार पर) को चुनती है। एक नियम के रूप में, ऐसी प्रणालियों में, प्रत्येक खिलाड़ी के पास एक संख्यात्मक संकेतक MMR (मैच मेकिंग अनुपात) होता है - खिलाड़ी की व्यक्तिगत रेटिंग, जिसका उपयोग अन्य खिलाड़ियों को समान स्तर के कौशल के साथ करने के लिए किया जाता है।

इस कार्यक्षमता का परीक्षण करने के लिए, मैं निम्नलिखित परीक्षण के साथ आया:

 it("should find match", async function () { var gameClient1 = newGameClient(); var gameClient2 = newGameClient(); var gameClient3 = newGameClient(); await gameClient1.connectAsAnonymous(playerCustomIds.id1); await gameClient2.connectAsAnonymous(playerCustomIds.id2); await gameClient3.connectAsAnonymous(playerCustomIds.id3); await gameClient1.findStandardMatch(); expect(gameClient1.state) .is.equals(GameClientModule.GameClientStates.MATCHMAKING); await gameClient2.findStandardMatch(); expect(gameClient2.state) .is.equals(GameClientModule.GameClientStates.MATCHMAKING); await gameClient3.findStandardMatch(); expect(gameClient3.state) .is.equals(GameClientModule.GameClientStates.MATCHMAKING); await sleep(3000); expect(gameClient1.state) .is.equals(GameClientModule.GameClientStates.CHALLENGE); expect(gameClient1.challenge, "challenge").is.not.undefined; expect(gameClient1.challenge.challengeId).is.not.undefined; expect(gameClient2.state) .is.equals(GameClientModule.GameClientStates.CHALLENGE); expect(gameClient2.challenge.challengeId) .is.equals(gameClient1.challenge.challengeId); expect(gameClient3.state) .is.equals(GameClientModule.GameClientStates.CHALLENGE); expect(gameClient3.challenge.challengeId) .is.equals(gameClient1.challenge.challengeId); });

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

सबसे पहले, बैकएंड तैयार करें। GameSparks में खेल के लिए खोज को अनुकूलित करने के लिए एक तैयार-निर्मित उपकरण है, पथ पर उपलब्ध है "विन्यासकर्ता-> मिलान"। मैं एक नया बनाता हूं और सेटअप के साथ आगे बढ़ता हूं। मानक मापदंडों जैसे कि कोड, नाम और मैच का विवरण के अलावा, कस्टम गेम मोड के लिए आवश्यक खिलाड़ियों की न्यूनतम और अधिकतम संख्या इंगित की गई है। मैं बनाए गए मैच के कोड "StandardMatch" को असाइन करूंगा और 2 से 3 तक खिलाड़ियों की संख्या का संकेत दूंगा।

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

मान लीजिए कि 19 का MMR वाला खिलाड़ी खोज शुरू करता है। उपरोक्त उदाहरण में, पहले 10 सेकंड में 19 से 21 के MMR के साथ अन्य खिलाड़ियों का चयन होगा। यदि खिलाड़ियों का चयन नहीं किया गया, तो दूसरी खोज सीमा सक्रिय हो जाती है, जो अगले 20 सेकंड के लिए खोज सीमा को 16 से बढ़ा देती है ( 19-3) से 22 (19 + 3)। इसके बाद, तीसरी सीमा को शामिल किया गया है, जिसके भीतर 14 (19-25%) से 29 (19 + 50%) तक की सीमा में 30 सेकंड के लिए एक खोज की जाएगी, जबकि मैच को पूरा करने के लिए माना जाता है अगर खिलाड़ियों की न्यूनतम आवश्यक संख्या जमा हो गई है (न्यूनतम अंक को स्वीकार करें) । खिलाड़ी)।

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

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

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

 var matchRequest = new SparkRequests.MatchmakingRequest(); matchRequest.matchShortCode = "StandardMatch"; matchRequest.skill = 0; matchRequest.Execute();

यह कोड StandardMatch में 0 के MMR के साथ एक खिलाड़ी को पंजीकृत करता है, इसलिए मानक खेल की खोज करने के लिए पंजीकृत कोई भी खिलाड़ी खेल सत्र बनाने के लिए उपयुक्त होगा। रेटिंग मैच के चयन में, इस प्रकार के मैच का MMR प्राप्त करने के लिए खिलाड़ी प्रोफाइल के निजी डेटा के लिए अपील की जा सकती है।

जब खेल सत्र शुरू करने के लिए पर्याप्त खिलाड़ी हैं, तो GameSparks सभी चयनित खिलाड़ियों को एक MatchFoundMessage संदेश भेजेगा। यहां आप स्वचालित रूप से एक खेल सत्र उत्पन्न कर सकते हैं और इसमें खिलाड़ियों को जोड़ सकते हैं। ऐसा करने के लिए, "उपयोगकर्ता संदेश-> MatchFoundMessage" में कोड जोड़ें:

 var matchData = Spark.getData(); if (Spark.getPlayer().getPlayerId() != matchData.participants[0].id) { Spark.exit(); } var challengeCode = ""; var accessType = "PRIVATE"; switch (matchData.matchShortCode) { case "StandardMatch": challengeCode = "StandardChallenge"; break; default: Spark.exit(); } var createChallengeRequest = new SparkRequests.CreateChallengeRequest(); createChallengeRequest.challengeShortCode = challengeCode; createChallengeRequest.accessType = accessType; var tomorrow = new Date(); tomorrow.setDate(tomorrow.getDate() + 1); createChallengeRequest.endTime = tomorrow.toISOString(); createChallengeRequest.usersToChallenge = []; var participants = matchData.participants; var numberOfPlayers = participants.length; for (var i = 1; i < numberOfPlayers; i++) { createChallengeRequest.usersToChallenge.push(participants[i].id) } createChallengeRequest.Send();

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

 var challangeData = Spark.getData(); var acceptChallengeRequest = new SparkRequests.AcceptChallengeRequest(); acceptChallengeRequest.challengeInstanceId = challangeData.challenge.challengeId; acceptChallengeRequest.message = "Joining"; acceptChallengeRequest.SendAs(Spark.getPlayer().getPlayerId());

अगला चरण, गेमस्पार्क्स ने चैलेंजस्टार्टमैसेज इवेंट को भेजा। इस ईवेंट के वैश्विक हैंडलर ("ग्लोबल मैसेज-> चैलेंजस्टार्टमैसेज") गेम सेशन को इनिशियलाइज़ करने के लिए एक आदर्श स्थान है, गेम लॉजिक को लागू करते समय मुझे इस बात का ध्यान रखना चाहिए।

ग्राहक आवेदन के लिए समय आ गया है। क्लाइंट मॉड्यूल में परिवर्तन:

 exports.GameClientStates = { IDLE: "Idle", MATCHMAKING: "Matchmaking", CHALLENGE: "Challenge" } exports.GameClient = function () { this.state = exports.GameClientStates.IDLE; this.challenge = undefined; function onMessage(message) { switch (message["@class"]) { case ".MatchNotFoundMessage": this.state = exports.GameClientStates.IDLE; break; case ".ChallengeStartedMessage": this.state = exports.GameClientStates.CHALLENGE; this.challenge = message.challenge; break; default: console.log("GAME onMessage: " + JSON.stringify(message)); } } onMessage = onMessage.bind(this); this.findStandardMatch = function () { var eventData = { eventKey: "FindStandardMatch" } return new Promise(resolve => { sendRequest("LogEventRequest", eventData) .then(response => { if (!response.error) { this.state = exports.GameClientStates.MATCHMAKING; resolve(); } else { console.error(response.error); reject(new Error(response)); } }) .catch(error => { console.error(error); reject(new Error(error)); }); }); } }

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

आगे क्या है?

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

मैं लेखों में बंधे भागों में गिटब पर स्रोतों को अपलोड करूंगा ।

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

हम एक खेल देव काढ़ा। भाग 1