लिंडरडैम पहेली में उपलब्धि प्रणाली

इतना समय पहले नहीं, गेम के लिए एक उपलब्धि प्रणाली को डिजाइन करने के बारे में Habré पर सवाल उठाया गया था। टिप्पणियों में विभिन्न विकल्पों की तूफानी और उपयोगी चर्चा हुई। फिर हमने पहले से ही अपने खेल का परीक्षण किया, जो रिलीज के लिए तैयार था और मैं बहस में भाग नहीं ले सका। लेकिन जब उन्होंने इस विषय को देखा, तो उन्होंने तुरंत सोचा: “हमारे पास इस तरह की कार्य प्रणाली है। उसके बारे में बात क्यों नहीं करते? ” सोचा और टूडू-लिस्ट में लिख दिया। आज यह बताने का समय है कि यह हमारे लिंडरडैम पहेली गेम प्रोजेक्ट में कैसे काम करता है।



उपलब्धि एक ऐसा आयताकार पदक है, जिसे उपयोगकर्ता को कुछ कार्रवाई करने के लिए दिया जाता है। लिंडरडैम पहेली में लगभग सौ ऐसे पदक हैं। यहाँ एक उदाहरण दिया गया है कि यह यूआई में कैसा दिखता है:



कुछ विचार:

• प्रत्येक उपलब्धि या तो कार्यों के अनुक्रम से जुड़ी होती है (कुछ चित्रों को इकट्ठा करें, कुछ समय बिताएं, आदि) या एक घटना (5 सेकंड से अधिक तेजी से एक तस्वीर इकट्ठा करें, फेसबुक पर जाती है, आदि)।
• कुछ उपलब्धियों में एक व्याख्यात्मक पाठ है जो इस उपलब्धि की दिशा में वर्तमान प्रगति को दर्शाता है।
• गुप्त उपलब्धियां हैं जो आपको मिलने तक दिखाई नहीं देती हैं।
• ऐसी उपलब्धियां हैं जो खेल के मुफ्त संस्करण में उपलब्ध नहीं हैं। :)
• उपलब्धियों को संरक्षित करने की आवश्यकता है ताकि उपयोगकर्ता अपनी उपलब्धियों को न खोए।

हम कोड करना शुरू करते हैं। शुरू करने के लिए, हम एक मोटी दुश्मनी शुरू करते हैं, जिसमें हम वह सब कुछ सूचीबद्ध करते हैं जो हमारे पास है,

enum LAchievement { LA_SUPPORTER = 0, LA_REVIEWER, LA_MONTHLING, LA_CASUAL, LA_ENTHUSIAST, LA_FANATIC, LA_PUZZLENEWBIE3X3, // ... // -  ,    }; 

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

दो प्रकार की घोषणा करें:

 typedef bool (*HasAchievementProc)(void); // ,    typedef LString (*GetNoteProc)(void); //  -, , " 99 " 

यह निर्धारित करने के लिए कि कोई गुप्त उपलब्धि है या नहीं, हम इस प्रकार को परिभाषित करते हैं:

 enum AchievementVisibility { L_VIS, L_HID, }; 

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

एक उपलब्धि का वर्णन अंततः इस तरह से देखने लगा:

 struct sAchievement { int FID; //  LAchievement bool FPaidVersion; //     ? const char* FName; //  ,    const char* FDescription; // ,     HasAchievementProc FProc; AchievementVisibility FHidden; const char* FProgressNote; //    ,  "%s solved" GetNoteProc FNoteProc; bool FShowNoteAfterAwarding; //         //   ,     . //       . // generated at runtime iGUIView* FViewPlate; iGUIView* FViewNote; clCVar* FAwarded; }; 

इसके बाद शुरू होता है उपलब्धियों का आविष्कार करने का रचनात्मक काम और साकची तत्वों की एक विशाल तालिका को भरने का काम। यह हमारी पूरी उपलब्धि प्रणाली का दिल है। यहाँ इससे कुछ पंक्तियाँ हैं:

 static sAchievement Achievements[] = { { LA_SUPPORTER, false, "Supporter", "Purchased Linderdaum Puzzle HD", &Check_Supporter, L_VIS, NULL }, { LA_REVIEWER, false, "Reviewer", "Added a review on Google Play", &Check_Reviewer, L_VIS, NULL }, { LA_MONTHLING, false, "Month's campaign", "Used the game for one month", &Check_Monthling, L_VIS, "%s days", &Get_DaysSinceFirstUse, true }, { LA_CASUAL, false, "Casual", "Spent half an hour in game", &Check_Casual, L_VIS, "%s minutes", &Get_MinutesInGame, false }, { LA_ENTHUSIAST, false, "Enthusiast", "Spent 2 hours in game", &Check_Enthusiast, L_VIS, "%s minutes", &Get_MinutesInGame, false }, { LA_FANATIC, true, "Fanatic", "Spent 10 hours in game", &Check_Fanatic, L_VIS, "%s hours", &Get_HoursInGame, false }, // ... // -  ,    } 

Check_ * फ़ंक्शन "कार्यों का अनुक्रम" प्रकार की उपलब्धियों को प्राप्त करने के लिए शर्तों की जांच करते हैं। इस तरह के एक समारोह की विशिष्ट सामग्री:

 bool Check_Monthling() { LDate FirstRun = LDate( FirstRunDate.GetString() ); LDate Today; int Days = Today-FirstRun; return Days >= 30; } 

यह ध्यान देने योग्य है कि "एकल घटना" प्रकार की घटनाओं के लिए, ऐसे कार्यों की आवश्यकता नहीं है और उनके लिए तालिका में NULL है। पुरस्कार के लिए कतार में ऐसी उपलब्धियां लाना सीधे खेल कोड में किया जाता है:

 if ( Time < 5.0 ) g_Achievements->Award( LA_BLINKOFANEYE ); 

आपने शायद यह भी देखा कि FProgressNote और FNoteProc हैं । आप सिर्फ एक FNoteProc क्यों नहीं कर सके और तुरंत एक वाक्यांश वापस कर सकते हैं? सब कुछ सरल है। वर्तमान भाषा में वाक्यांश को स्थानीय बनाने के लिए। टेम्पलेट स्थानीयकृत है, और फिर उसमें एक स्ट्रिंग-संख्या दी गई है, जिसे FNoteProc से लौटाया गया है ।

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

 class clAchievementsManager: public iObject { public: //    // // clAchievementsManager // /// trigger the award for a one-time achievement virtual void Award( LAchievement Achievement ); virtual void AwardName( const LString& AchievementName ); virtual bool IsAwarded( LAchievement Achievement ) const; /// called automatically every 6 seconds or so to check new achievements virtual void ProcessAchievements(); virtual void RecheckAchievements(); //     -     public: std::deque<LAchievement> FPendingAwards; iGUIView* FAchievementsText; mlNode* FNode_Awarded; }; 

ProcessAchievements () हर 6 सेकंड में एक बार कहा जाता है और हाथी पदक वितरित करता है। यह इस तरह की कॉल द्वारा प्राप्त किया जाता है:

 Env->SendAsyncCapsule( BindCapsule( &clAchievementsManager::ProcessAchievements, this ), 6.0 ); 

अंदर, इस कोड की तरह कुछ (थोड़ा तले हुए):

 void clAchievementsManager::ProcessAchievements() { // save gamestate // ... RecheckAchievements(); // check achievements once in a while Env->SendAsyncCapsule( BindCapsule( &clAchievementsManager::ProcessAchievements, this ), 6.0 ); // nothing new to award if ( FPendingAwards.empty() ) return; LAchievement A = FPendingAwards.front(); FPendingAwards.pop_front(); // this achievement had been awarded long time ago if ( Achievements[ A ].FAwarded->GetBool() ) return; Achievements[ A ].FAwarded->SetBool( true ); // don't lose achievements in case of crash g_Game->SaveAchievements( g_SaveAchievementsFileName ); // show nice message here Env->Renderer->GetCanvas()->AnnounceObject( Construct<clAchievementAnnouncer>( Env, A, FNode_Awarded ), 0.0, 5.0 ); clPuzzl_AchievementsContainer* C = Env->GUI->FindView<clPuzzl_AchievementsContainer>("AchievementsContainer"); // update UI if ( C ) C->RecreateSubViews(); } 

कुछ भी जटिल नहीं है। केवल स्थितियों की जाँच करना और "इवेंट" प्रकार की उपलब्धियों को उस कतार से टाइप करना जिसमें पुरस्कार () विधि इसे डालती है। ClAchievementAnnouncer क्लास इस तरह से पूरे UI के ऊपर एक सुंदर प्लेट खींचती है:



कृपया ध्यान दें कि खेल को हर 6 सेकंड में सहेजा जाता है - हम नहीं चाहते कि उपयोगकर्ता अपनी प्रगति खो दे।

RecheckAchievements () विधि UI को सभी उपलब्धियों की तालिका के साथ अपडेट करती है, जो पहले स्क्रीनशॉट में थी। UI सीधे clPuzzl_AchievementsContainer वर्ग द्वारा प्रबंधित किया जाता है, जो आपके UI सिस्टम के आधार पर बहुत विशिष्ट होगा। हमारे साथ, वह केवल प्यालों को प्यालों से भरता है (फिर से, पहले स्क्रीनशॉट देखें)।

शवपरीक्षा

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

मैं जो करना चाहता था, लेकिन उसके पास समय नहीं था:

• ट्विटर उपयोगकर्ता पर एक संदेश प्रदर्शित करके उपलब्धियों की वर्जिनिटी बढ़ाएँ। उदाहरण के लिए, ओसमोस के रूप में, फोरस्क्वेयर करता है।
• उपलब्धियों को स्थानीय रूप से नहीं, बल्कि उपयोगकर्ता के खाते में क्लाउड में सहेजें। यह Google ऐप इंजन या कुछ इसी तरह की सेवाओं की कोशिश करने के लायक है। वहाँ आप खेल की स्थिति को बचा सकते हैं। यह विशेष रूप से महत्वपूर्ण है जब बड़ी पहेली को इकट्ठा करते हैं, जब आप एक तस्वीर पर कुछ घंटे बिता सकते हैं।

PS खेल Linderdaum इंजन पर बनाया गया है।