🤾🏽 💅🏼 🎷 एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 6

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

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

इस बीच, जैसा कि आप पहले से ही जानते हैं, बनाएँ, 2 फ़ाइलें CEntity.cpp और CEntity.h निम्नलिखित सामग्री के साथ:

CEntity.h

#include <vector> #include "CAnimation.h" #include "CSurface.h" class CEntity { public: static std::vector<CEntity*> EntityList; protected: CAnimation Anim_Control; SDL_Surface* Surf_Entity; public: float X; float Y; int Width; int Height; int AnimState; public: CEntity(); virtual ~CEntity(); public: virtual bool OnLoad(char* File, int Width, int Height, int MaxFrames); virtual void OnLoop(); virtual void OnRender(SDL_Surface* Surf_Display); virtual void OnCleanup(); };

अच्छी तरह से और तदनुसार:

CEntity.cpp

 #include "CEntity.h" std::vector<CEntity*> CEntity::EntityList; CEntity::CEntity() { Surf_Entity = NULL; X = Y = 0.0f; Width = Height = 0; AnimState = 0; } CEntity::~CEntity() { } bool CEntity::OnLoad(char* File, int Width, int Height, int MaxFrames) { if((Surf_Entity = CSurface::OnLoad(File)) == NULL) { return false; } CSurface::Transparent(Surf_Entity, 255, 0, 255); this->Width = Width; this->Height = Height; Anim_Control.MaxFrames = MaxFrames; return true; } void CEntity::OnLoop() { Anim_Control.OnAnimate(); } void CEntity::OnRender(SDL_Surface* Surf_Display) { if(Surf_Entity == NULL || Surf_Display == NULL) return; CSurface::OnDraw(Surf_Display, Surf_Entity, X, Y, AnimState * Width, Anim_Control.GetCurrentFrame() * Height, Width, Height); } void CEntity::OnCleanup() { if(Surf_Entity) { SDL_FreeSurface(Surf_Entity); } Surf_Entity = NULL; }

हमेशा की तरह, मेरे लिए आपको यह समझाने का समय आ गया है कि यहाँ क्या हो रहा है। मैंने पहले (मेरे और आपके) तरीकों द्वारा इस्तेमाल किए गए CApp 5 से एनकैप्सुलेट किया (इवेंट हैंडलिंग के अलावा - मैं अगले पाठ में बताऊंगा जैसा मैंने वादा किया था)। इस तरह के एक दृष्टिकोण से हम "अनाज को चफ से अलग कर सकेंगे" और "इकाईयों" को और अधिक पारदर्शी तरीके से संसाधित कर सकेंगे और मुख्यतः ( सीएपीपी ) वर्ग में ढेर में भर जाएंगे । इसके अलावा, हम आसानी से एंटिटीज के अलावा कुछ और प्रोसेस कर सकते हैं। क्या आपने स्टेटिक वेक्टर एंटिटी लिस्ट पर ध्यान दिया है? यह हमारे खेल संस्थाओं की एक सूची को संग्रहीत करने के लिए डिज़ाइन किया गया है और CEntity :: EntityList के माध्यम से सीधे सुलभ है, क्योंकि यह स्थिर है। महत्वपूर्ण: मैंने विशेष रूप से CEntity में EntityList की घोषणा की, क्योंकि यह दृष्टिकोण भविष्य में चक्रीय निर्भरता से बचाएगा । उदाहरण के लिए, कार्ड की एंटिटीज के साथ बातचीत, जब सीएमएपी वर्ग को CEntity के सदस्य के रूप में घोषित किया जाता है और CEntity को CMap के सदस्य के रूप में घोषित किया जाता है (यहां मुझे खुद समझ में नहीं आया कि लेखक का क्या मतलब है), संकलन चरण में एक त्रुटि का कारण बनेगा।

तो, यह वेक्टर हमारे सभी खेल "एंटिटीज़" को उनके लिंक के रूप में संग्रहीत करेगा (भविष्य पर जोर देने के साथ, जब अन्य वर्गों को CEntity वर्ग से विरासत में मिलेगा)। इसलिए, उदाहरण के लिए, यदि हम एक मेगामैन गेम बनाने जा रहे हैं, तो हमारे पास सीएमईएजीएएमएमैन वर्ग होगा जो कि सीईएएनटी से विरासत में मिला होगा । और बहुरूपता की मदद से, हम एक EntityList में CMegaMan वर्ग की वस्तुओं को संग्रहीत कर सकते हैं। यही कारण है कि हमने उपरोक्त कार्यों को आभासी घोषित किया, और वर्ग के कुछ सदस्य संरक्षित हैं।

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

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

और अंत में, हमारे पास OnCleanup , मेरी पसंदीदा सफाई सब कुछ और सब कुछ है (Purgatory मेरे लिए रो रही है), एक स्मृति मुक्तिदाता, एक छोटा सा गृहणी।

जैसा कि मैंने शुरुआत में ही कहा था - हमने "एंटिटीज" के लिए केवल कक्षा का मूल ढांचा तैयार किया है, और, क्रोकिंग नहीं, मैं यह कहूंगा कि अब तक यह राक्षस बहुत कम कर सकता है (लेकिन अगले पाठों में सक्षम होगा)। लेकिन हम उसे अभी कमा सकते हैं! खोलने
CApp.h और "Entities" के एक जोड़े को जोड़ें:

CApp.h

 #include "CEntity.h" //...      private: CEntity Entity1; CEntity Entity2;

CApp_OnInit.cpp में कोड लिखकर उन्हें डाउनलोड करें। (यहां आपको अंतिम पाठ से एक तस्वीर की आवश्यकता होगी, या इसकी 2 प्रतियां होंगी):

CApp_OnInit.cpp

 if(Entity1.OnLoad("./entity1.bmp", 64, 64, 8) == false) { return false; } if(Entity2.OnLoad("./entity2.bmp", 64, 64, 8) == false) { return false; } Entity2.X = 100; CEntity::EntityList.push_back(&Entity1); CEntity::EntityList.push_back(&Entity2);

याद रखें कि मैंने कैसे कहा था कि हम मूल रूप से एक इकाई वर्ग में एक खेल के बुनियादी कार्यों को संक्षिप्त करते हैं? अब आपको उन्हें थोड़ा घुमाने की जरूरत है। CApp_OnLoop.cpp संपादित करें:

 for(int i = 0;i < CEntity::EntityList.size();i++) { if(!CEntity::EntityList[i]) continue; CEntity::EntityList[i]->OnLoop(); }

यानी हम "वेक्टर" के साथ अपने वेक्टर के माध्यम से चलाते हैं और प्रत्येक "एंटिटी" के लिए ओनलोप विधि को कॉल करते हैं (और एक छोटी सी जांच भी करते हैं ताकि अशक्त सूचक में न चला जाए)। यह CApp_OnRender.cpp में वैसा ही करता है :

 for(int i = 0;i < CEntity::EntityList.size();i++) { if(!CEntity::EntityList[i]) continue; CEntity::EntityList[i]->OnRender(Surf_Display); }

हैलो, प्रिय, अच्छी तरह से नमस्ते:

 for(int i = 0;i < CEntity::EntityList.size();i++) { if(!CEntity::EntityList[i]) continue; CEntity::EntityList[i]->OnCleanup(); } CEntity::EntityList.clear();

अंतिम स्पर्श ( CEntity :: EntityList.clear () ) हम "Entities" के वेक्टर को शून्य करते हैं ... संकलन करें, चलाएँ, आनंद लें!
ध्यान देने के लिए आप सभी का धन्यवाद।

स्रोत कोड लिंक:

सभी पाठों के लिंक:

एक खेल ढांचे का विकास। भाग 1 - एसडीएल की मूल बातें
एक खेल ढांचे का विकास। भाग 2 - निर्देशांक और मानचित्रण
एक खेल ढांचे का विकास। भाग 3 - घटनाएँ
एक खेल ढांचे का विकास। भाग 4 - टिक टीएसी को पैर की अंगुली
एक खेल ढांचे का विकास। भाग 5 - एनिमेशन
एक खेल ढांचे का विकास। भाग 6 - संस्थाएँ

एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 6 - एसडीएल संस्थाओं

More articles: