👩🏾‍💼 ⛔️ 👩🏼‍🤝‍👨🏽 मुरब्बा फ्रेमवर्क (विराम मोड) 🐕 ✝️ 🤰🏼

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

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

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

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

चलो इंटरफेस के साथ शुरू करते हैं। IObject.update विधि में isPaused फ़्लैग जोड़ें, जो पॉज़ मोड सक्रिय होने पर सही पर सेट हो जाएगा:

IObject.h

class IObject { public: ... virtual void update(uint64 timestamp, bool isPaused) = 0; };

AbstractSpriteOwner एक समान ध्वज और विधि जोड़ देगा जिसे हम पॉज़ होने पर एनिमेटेड ऑब्जेक्ट्स के टाइमस्टैम्प को समायोजित करने के लिए कहेंगे:

AbstractSpriteOwner.h

 class AbstractSpriteOwner: public ISpriteOwner { public: ... virtual void update(uint64 timestamp, bool isPaused); virtual void correctPauseDelta(uint64 pauseDelta); };

CorrectPauseDelta पद्धति का कार्यान्वयन तुच्छ है। हम केवल नेस्टेड स्प्राइट्स को मिलीसेकंड में ठहराव की अवधि पास करते हैं:

AbstractSpriteOwner.cpp

 ... void AbstractSpriteOwner::correctPauseDelta(uint64 pauseDelta) { for (ZIter p = zOrder.begin(); p != zOrder.end(); ++p) { p->second->addPauseDelta(pauseDelta); } }

AnimatedSprite के कार्यान्वयन में, हम वर्तमान एनिमेशन के सभी टाइमस्टैम्प में प्राप्त विराम अवधि जोड़ते हैं। यदि कोई विराम मोड है, तो हम अपडेट विधि से जल्दी बाहर निकलते हैं:

AnimatedSprite.cpp

 ... void AnimatedSprite::addPauseDelta(uint64 pauseDelta) { for (CIter p = currentMessages.begin(); p != currentMessages.end(); ++p) { p->timestamp += pauseDelta; } } void AnimatedSprite::update(uint64 timestamp, bool isPaused) { if (isPaused && isPausable()) return; ... }

ThePausable Method को DefaultScreenObject में डिफ़ॉल्ट रूप से परिभाषित किया गया है और, यदि आवश्यक हो, तो इसके वंशज को ओवरराइड किया जाएगा, जिसका एनीमेशन अक्षम नहीं होना चाहिए:

AbstractScreenObject.h

 class AbstractScreenObject: public IScreenObject { public: ... virtual void addPauseDelta(uint64 pauseDelta) {} virtual bool isPausable() const {return true;} };

कम्पोज़िटसाइट में बदलाव करने के लिए, आपको यह याद रखना होगा कि एक ओर, यह स्प्राइट्स का एक कंटेनर है, जबकि दूसरी तरफ, यह स्वयं एनिमेट्रसाइट का उत्तराधिकारी है और एनीमेशन नियमों को संभाल सकता है:

CompositeSprite.cpp

 ... void CompositeSprite::addPauseDelta(uint64 pauseDelta) { AbstractSpriteOwner::correctPauseDelta(pauseDelta); AnimatedSprite::addPauseDelta(pauseDelta); } void CompositeSprite::update(uint64 timestamp, bool isPaused) { AnimatedSprite::update(timestamp, isPaused); AbstractSpriteOwner::update(timestamp, isPaused); }

एनीमेशन को रोकने और फिर से शुरू करने का मुख्य काम सीन क्लास द्वारा किया जाएगा।

Scene.h

 class Scene: public AbstractSpriteOwner { protected: ... bool IsPaused; uint64 pauseTimestamp; public: ... virtual void update(uint64 timestamp, bool isPaused); bool isPaused() const {return IsPaused;} void suspend(); void resume(); };

Scene.cpp

 ... void Scene::update(uint64 timestamp, bool) { if (IsPaused && (pauseTimestamp == 0)) { pauseTimestamp = pauseTimestamp; } if (!IsPaused && (pauseTimestamp != 0)) { uint64 pauseDelta = timestamp - pauseTimestamp; if (pauseDelta > 0) { correctPauseDelta(pauseDelta); } pauseTimestamp = 0; } ... AbstractSpriteOwner::update(timestamp, IsPaused); } bool Scene::sendMessage(int id, int x, int y) { if (AbstractSpriteOwner::sendMessage(id, x, y)) { return true; } if (IsPaused) return false; if (background != NULL) { return background->sendMessage(id, x, y); } return false; } void Scene::suspend() { desktop.suspend(); IsPaused = true; } void Scene::resume() { desktop.resume(); IsPaused = false; }

यह डेस्कटॉप क्लास में बैकग्राउंड म्यूज़िक पॉज़ कोड जोड़ने के लिए बना हुआ है:

Desktop.h

 class Desktop { private: ... bool isMusicStarted; public: Desktop(): touches(), names(), currentScene(NULL), isMusicStarted(false) {} ... void startMusic(const char* res); void stopMusic(); void suspend(); void resume(); };

Desktop.cpp

 ... void Desktop::startMusic(const char* res) { if (s3eAudioIsCodecSupported(S3E_AUDIO_CODEC_MP3) && s3eAudioIsCodecSupported(S3E_AUDIO_CODEC_PCM)) s3eAudioPlay(res, 0); isMusicStarted = true; } void Desktop::stopMusic() { isMusicStarted = false; s3eAudioStop(); } void Desktop::suspend() { if (isMusicStarted) { s3eAudioPause(); } } void Desktop::resume() { if (isMusicStarted) { s3eAudioResume(); } }

अब, Scene.suspend विधि सभी गेम स्प्राइट और बैकग्राउंड संगीत के एनीमेशन को रोक सकती है, और Scene.resume विधि उन्हें एक ही स्थान से फिर से शुरू कर सकती है।

मुरब्बा फ्रेमवर्क (विराम मोड)

More articles: