👩🏾‍🏫 🛠️ 🙋🏾 एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 1 - एसडीएल ट्यूटोरियल मूल बातें 🧗🏻 🧖🏼 👇🏽

मैंने इस साइट के पाठों का अनुवाद हैबर में खोजा, लेकिन केवल एक ही उल्लेख था, और वह भी - टिप्पणियों में:

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

"हम सभी ने कहीं शुरुआत की"

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

प्रयुक्त उपकरण

पाठों में, कोड :: ब्लॉक (इसके बाद सीबी), जिसमें परियोजनाओं को संकलित करने के लिए GCC और MinGW शामिल हैं, का उपयोग IDE के रूप में किया जाएगा। आप अपनी पसंदीदा आईडीई और संकलक का उपयोग कर सकते हैं, लेकिन यह आपके पक्ष में आ सकता है यदि आपके पास पुस्तकालयों को जोड़ने में पर्याप्त अनुभव नहीं है। पहले आपको सीबी को यहां से डाउनलोड करने की आवश्यकता है, जिसमें बाइनरी असेंबली का चयन करना शामिल है जिसमें मिनॉग शामिल हैं, उदाहरण के लिए कोडब्लॉक -12.11मिंगw-setup.exe । समय बचाने के लिए एक स्थिर संस्करण का उपयोग करने की सिफारिश की जाती है।
जैसा कि आप पहले से ही समझ चुके हैं, मुख्य फोकस एसडीएल (सिंपल डायरेक्टमीडिया लेयर) के आसपास केंद्रित होगा - 2 डी ग्राफिक्स डिस्प्ले के लिए एक क्रॉस-प्लेटफॉर्म लाइब्रेरी। फिर बहुत सारे शब्द हैं जिनके बारे में पुस्तकालय अद्भुत है (अच्छी तरह से, यह पहले से ही ज्ञात है), ट्यूनिंग के बारे में बहुत सारे शब्द (जो किसी कारण से मुझे शुरू नहीं हुआ), लेखक के माफीनामे एसडीएल हेडर फ़ाइलों को नमूना निर्देशिका में अपने उदाहरणों में कॉपी करने के लिए और इसी तरह। जैसा कि वादा किया गया था, मैं विंडोज और उबंटू पर सीबी और एसडीएल बंडल को कॉन्फ़िगर करने के तरीके पर थोड़ा गैग लिखूंगा। मैं मिनिगॉव के साथ फ़ोल्डर में हेडर फ़ाइलों के सापेक्ष पथ का भी उपयोग करूँगा (ठीक है, यह मेरे लिए अधिक सुविधाजनक है)।

समायोजन

विंडोज

आधिकारिक साइट से सक्षम MinGW के साथ ताजा CB डाउनलोड करें, CB के साथ फ़ोल्डर में MinGW स्थापित करें;
नवीनतम SDL डेवलपमेंट लाइब्रेरी डाउनलोड करें ( डाउनलोड सेक्शन में, डेवलपमेंट लाइब्रेरी सेक्शन, Win32 सब-सेक्शन और SDL-devel-XXX-mingw32.tar.gz फ़ाइल का चयन करें जहाँ XXX वर्तमान वर्जन नंबर है);
एक अस्थायी फ़ोल्डर में संग्रह को अनपैक करें (अनपैक करने के बाद, एसडीएल-एक्सएक्सएक्स फ़ोल्डर दिखाई देगा);
इस फ़ोल्डर की सामग्री को पूरी तरह से उस फ़ोल्डर में स्थानांतरित किया जाना चाहिए जहां पहले मिनगॉव स्थापित किया गया था;
SDG.dll को MinGW फ़ोल्डर के बिन सबफ़ोल्डर से सिस्टम फ़ोल्डर्स C: \ Windows और C: \ Windows 's System32 ;
सीबी खोलें, एक नया खाली प्रोजेक्ट बनाएं;
स्पॉलर्स के नीचे इंगित की गई सामग्री के साथ CApp.h और CApp.cpp फाइलें जोड़ें;
मेनू में प्रोजेक्ट> बिल्ड विकल्प , संवाद में लिंकर सेटिंग्स टैब का चयन करें;
लिंक पुस्तकालयों में, जोड़ें क्लिक करें और mingw32 दर्ज करें; SDLmain; SDL ;
(आपको CApp.h बदलना होगा और SDL / SDL.h के बजाय SDL / SDL.h लिखना होगा यदि कंपाइलर शपथ लेता है कि कोई हेडर फाइल नहीं हैं)

उबंटू

sudo apt-get install कोडब्लॉकों libsdl-ttf2.0-0 libsdl-ttf2.0-dev libsdl-image1.2 .2debian- सभी libgl1-mesa-dev libglu1-mesa-dev libglut3-dev xorg-dev libtool gforth
हाथ उठा के प्रेमियों के लिए
सीबी खोलें, एक नया खाली प्रोजेक्ट बनाएं;
स्पॉलर्स के नीचे इंगित की गई सामग्री के साथ CApp.h और CApp.cpp फाइलें जोड़ें;
मेनू में प्रोजेक्ट> बिल्ड विकल्प , संवाद में लिंकर सेटिंग्स टैब का चयन करें;
अन्य लिंकर विकल्पों में, -lSDLmain -lSDL दर्ज करें ;
(आपको CApp.h बदलना होगा और SDL / SDL.h के बजाय SDL / SDL.h लिखना होगा यदि कंपाइलर शपथ लेता है कि कोई हेडर फाइल नहीं हैं)

स्रोत कोड

CApp.h

#ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL/SDL.h> class CApp { public: CApp(); int OnExecute(); }; #endif

CApp.cpp

 #include "CApp.h" CApp::CApp() { } int CApp::OnExecute() { return 0; } int main(int argc, char* argv[]) { CApp theApp; return theApp.OnExecute(); }

खेल की अवधारणा

मैं खुद को प्रोग्रामिंग से थोड़ा सा खोदूंगा और ध्यान दें कि उत्पन्न CApp वर्ग हमारे कार्यक्रम के व्यवहार को परिभाषित करता है। खेल के विशाल बहुमत में मुख्य रूप से कार्यक्रम के मुख्य चक्र में 5 कार्य शामिल होते हैं, जो पूरे खेल की प्रक्रिया को पूरा करते हैं। उनमें से प्रत्येक का एक संक्षिप्त विवरण:

प्रारंभिक कार्य
यह सभी डेटा डाउनलोड को संसाधित करता है, यह बनावट, नक्शे, वर्ण या कोई अन्य (उदाहरण के लिए ऑडियो / वीडियो) हो सकता है।

इवेंट हैंडलर
यह माउस, कीबोर्ड, जॉयस्टिक, या अन्य उपकरणों या प्रोग्राम टाइमर से आने वाले सभी संदेशों को संसाधित करता है।

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

दृश्य प्रतिपादन
यह स्क्रीन पर पिछले फ़ंक्शन में गणना किए गए और तैयार किए गए दृश्यों को प्रदर्शित करने में लगा हुआ है, और इसके अनुसार डेटा (आउटपुट को छोड़कर) के साथ कोई भी हेरफेर करने की आवश्यकता नहीं है।

स्मृति की सफाई
यह रैम से सभी डाउनलोड किए गए संसाधनों (नक्शे, चित्र, मॉडल) को हटा देता है, और खेल के सही समापन को सुनिश्चित करता है।

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

GameLoop

 Initialize(); while(true) { Events(); Loop(); Render(); } Cleanup();

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

भागो, गधाचोट, भागो !!!

 if(Key == LEFT) X--; if(Key == RIGHT) X++; if(Key == UP) Y--; if(Key == DOWN) Y++;//... -   ... RenderImage(DonkeyHotImage, X, Y);

यह निम्नानुसार काम करता है: एक चक्र में, यह जाँच की गई थी कि क्या LEFT, RIGHT, आदि कुंजियों को दबाया गया था, और अगर वहाँ था, तो हम X या Y समन्वय के लिए जिम्मेदार चर को घटाते या बढ़ाते हैं। इसलिए, यदि हमारा खेल 30 तख्ते की आवृत्ति पर चलता है। दूसरा, और हम LEFT कुंजी दबाते हैं, हमारा DonkeyHot बाईं ओर 30 पिक्सेल प्रति सेकंड की गति से आगे बढ़ेगा (FPS यहाँ अच्छी तरह से लिखा गया है )। यदि आप अभी भी गेम चक्र के उपकरण को नहीं समझते हैं, तो चिंता न करें - आप जल्द ही समझ जाएंगे।

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

CApp_OnInit.cpp

 #include "CApp.h" bool CApp::OnInit() { return true; }

CApp_OnEvent.cpp

 #include "CApp.h" void CApp::OnEvent(SDL_Event* Event) { }

CApp_OnLoop.cpp

 #include "CApp.h" void CApp::OnLoop() { }

CApp_OnRender.cpp

 #include "CApp.h" void CApp::OnRender() { }

CApp_OnCleanup.cpp

 #include "CApp.h" void CApp::OnCleanup() { }

CApp.h और CApp.cpp खोलें, और उन्हें इस तरह बनाएँ:

CApp.h

 #ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL.h> class CApp { private: bool Running; public: CApp(); int OnExecute(); public: bool OnInit(); void OnEvent(SDL_Event* Event); void OnLoop(); void OnRender(); void OnCleanup(); }; #endif

CApp.cpp

 #include "CApp.h" CApp::CApp() { Running = true; } int CApp::OnExecute() { if(OnInit() == false) { return -1; } SDL_Event Event; while(Running) { while(SDL_PollEvent(&Event)) { OnEvent(&Event); } OnLoop(); OnRender(); } OnCleanup(); return 0; } int main(int argc, char* argv[]) { CApp theApp; return theApp.OnExecute(); }

आप कुछ नए चर और तरीके देखते हैं, लेकिन देखते हैं कि पहले क्या होता है। सबसे पहले, हम अपने खेल को शुरू करने की कोशिश करते हैं, यदि आरंभीकरण नहीं हुआ, तो -1 (त्रुटि कोड) लौटाएं, जिससे खेल पूरा हो सके। यदि सब कुछ ठीक है, तो हम खेल चक्र में जाते हैं। गेम लूप के भाग के रूप में, हम संदेशों की जांच करने के लिए SDL_PollEvent का उपयोग करते हैं, और उन्हें एक बार Onventvent विधि से पास करते हैं। फिर, हम डेटा को हेरफेर करने के लिए OnLoop पर जाते हैं, और फिर स्क्रीन पर अपना गेम ड्रा करते हैं। हम इस चक्र को तब तक दोहराते हैं जब तक कि कोई संदेश न हो, जो इंगित करता है कि उपयोगकर्ता गेम को क्विट करता है, इस तरह के संदेश को प्राप्त करने के बाद (उदाहरण के लिए, उपयोगकर्ता ने क्रॉस या ईएससी कुंजी दबाया) हम अपने खेल के कब्जे वाले संसाधनों को खाली करने के लिए ऑनक्लीनअप पर जाते हैं। सब कुछ सरल है।
अब, SDL_Event और SDL_PollEvent पर एक नज़र डालते हैं । पहली एक संरचना है जिसमें संदेशों के बारे में जानकारी होती है। दूसरा एक फ़ंक्शन है जो संदेश कतार से संदेशों का चयन करेगा। एक कतार में कितने भी संदेश हो सकते हैं, इस कारण से हम उन सभी के माध्यम से पुनरावृति करने के लिए एक लूप का उपयोग करते हैं। इसलिए, उदाहरण के लिए, मान लें कि उपयोगकर्ता क्लिक करता है और माउस को हिलाता है जबकि ऑनरेंडर फ़ंक्शन चल रहा है । एसडीएल इसका पता लगाएगा और दो घटनाओं को कतार में रखेगा , एक प्रति कुंजी और एक माउस चाल। हम इस संदेश को SDL_PollEvent का उपयोग करके कतार से चुन सकते हैं, और फिर इसे OnEvent विधि में पास कर सकते हैं , जिसके अनुसार इसे संसाधित करने की आवश्यकता है। जब संदेशों में कोई ईवेंट नहीं होते हैं, तो SDL_PollEvent गलत हो जाएगा, इस प्रकार संदेश कतार प्रसंस्करण लूप से बाहर निकल जाएगा।
आगे हम चलते हुए चर को देखते हैं। यह मुख्य खेल चक्र से बाहर निकलने को नियंत्रित करता है। जब यह पैरामीटर गलत हो जाता है , तो हम प्रोग्राम को समाप्त कर देंगे, और कंट्रोल को प्रोग्राम एग्जिट फंक्शन में ट्रांसफर कर देंगे। इसलिए, उदाहरण के लिए, यदि उपयोगकर्ता ESC कुंजी दबाता है, तो हम इस चर को गलत पर सेट कर सकते हैं, जिससे खेल से बाहर निकलने का संकेत मिलता है।
इस स्तर पर, आप परियोजना को संकलित करने का प्रयास कर सकते हैं, लेकिन चूंकि हमारे पास कोई संदेश प्रसंस्करण नहीं है, इसलिए आपको कार्यक्रम को पूरा करने के लिए उपलब्ध साधनों का उपयोग करना होगा।
अब जब सब कुछ सेट हो गया है, तो हमारे गेम के लिए एक विंडो बनाकर शुरू करें, जिसे प्रदर्शित किया जाएगा। CApp.h खोलें और SDL_Surface प्रकार का एक चर जोड़ें। सब कुछ इस तरह दिखना चाहिए:

CApp.h

 #ifndef _CAPP_H_ #define _CAPP_H_ #include <SDL.h> class CApp { private: bool Running; SDL_Surface* Surf_Display; public: CApp(); int OnExecute(); public: bool OnInit(); void OnEvent(SDL_Event* Event); void OnLoop(); void OnRender(); void OnCleanup(); }; #endif

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

अब, पहले से ही इस सतह को बनाने के लिए CApp_OnInit.cpp खोलें:

CApp_OnInit.cpp

 #include "CApp.h" bool CApp::OnInit() { if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { return false; } if((Surf_Display = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) { return false; } return true; }

सबसे पहले हमने एसडीएल को इनिशियलाइज़ किया था, ताकि अब हम इसके फंक्शन्स को एक्सेस कर सकें। SDL_INIT_EVERYTHING पैरामीटर का अर्थ है कि लाइब्रेरी के सभी सबसिस्टमों का आरम्भिकरण (अन्य पैरामीटर हैं, उदाहरण के लिए, SDL_INIT_AUDIO , SDL_INIT_VIDEO , लेकिन अब हम उन पर ध्यान केंद्रित नहीं करेंगे)। अगला फ़ंक्शन, SDL_SetVideoMode , हमारी विंडो और बेस सतह बनाता है। यह 4 पैरामीटर लेता है: खिड़की की चौड़ाई, खिड़की की ऊंचाई, उपयोग की जाने वाली बिट्स की संख्या (16 या 32 की सिफारिश की जाती है), और "" | "ऑपरेटर" के माध्यम से सूचीबद्ध झंडे प्रदर्शित करें। अन्य झंडे हैं, लेकिन अभी तक हमारे पास इनमें से काफी हैं। पहला ध्वज SDL को हार्डवेयर त्वरण का उपयोग करने के लिए कहता है, और दूसरा इसे डबल बफ़रिंग का उपयोग करने के लिए कहता है (जो महत्वपूर्ण है यदि आप अंत में फ़्लिकरिंग स्क्रीन प्राप्त नहीं करना चाहते हैं)। एक और झंडा जो अब आपकी रुचि हो सकता है, वह SDL_FULLSCREEN है ; यह विंडो को पूर्ण स्क्रीन मोड में स्विच करता है।

अब जब इनिशियलाइज़ेशन पूरा हो गया है, तो सफाई का ध्यान रखने का समय आ गया है। CApp_OnCleanup.cpp खोलें और निम्नलिखित जोड़ें:

CApp_OnCleanup.cpp

 #include "CApp.h" void CApp::OnCleanup() { SDL_Quit(); }

इसलिए हम एसडीएल के साथ काम खत्म करते हैं। आपको ध्यान देना चाहिए कि इस फ़ंक्शन में खेल द्वारा उपयोग की जाने वाली सभी सतहों और संसाधनों को मुक्त कर दिया जाता है।
यह भी अनुशंसा की जाती है कि आप अप्रिय क्षणों से बचने के लिए, क्लास कंस्ट्रक्टर में NULL को Surf_Display सेट करें। CApp.cpp खोलें और निम्नलिखित जोड़ें:

CApp.cpp

 CApp::CApp() { Surf_Display = NULL; Running = true; }

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

CApp_OnEvent.cpp

 #include "CApp.h" void CApp::OnEvent(SDL_Event* Event) { if(Event->type == SDL_QUIT) { Running = false; } }

SDL_Event संरचना प्रकारों में टूट गई है। ये प्रकार कीस्ट्रोक्स से लेकर माउस आंदोलनों तक भिन्न हो सकते हैं, और इस उदाहरण में, घटना के प्रकार की जाँच की जाती है। CApp_OnEvent.cpp में हम समापन के बारे में एक संदेश की उम्मीद करते हैं (विशेष रूप से, जब उपयोगकर्ता हमारी विंडो के शीर्षक बार में क्रॉस पर क्लिक करता है) और यदि ऐसा होता है, तो रनिंग चर को झूठा सेट किया जाता है , खेल अपने मुख्य लूप को समाप्त करता है, गेंद समाप्त होती है, मोमबत्तियां बाहर जाती हैं। निम्नलिखित पाठों में, हम संदेश प्रसंस्करण को अधिक विस्तार से देखेंगे।
वह सब है! अब आपके पास गेम बनाने के लिए एक अच्छा ढांचा है। यहां तक कि यह हमारी परियोजना के आधार पर सीबी के लिए एक टेम्पलेट बनाने के लिए अच्छा होगा। लेकिन मैं इस बारे में बात नहीं करने जा रहा हूं कि यह कैसे किया जा सकता है, Google को थोड़ी सी हिचकिचाहट न करें (मदद में फ़ाइल: फ़ाइल-> प्रोजेक्ट को टेम्पलेट के रूप में सहेजें ...)।
यदि आपने इस पाठ में सामग्री को अच्छी तरह से सीखा है, तो सतहों के बारे में अधिक जानने के लिए अगले को जारी रखें।

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

UPD 0।

स्रोत कोड से लिंक (* निक्स के लिए भी उपयुक्त)

कार्यक्रम का परिणाम।

UPD 1।

यह अनुशंसा की जाती है कि आप CApp.cpp में SDL_PollEvent के बजाय SDL_WaitEvent का उपयोग करें। यह आपको आने वाले संदेशों का तुरंत जवाब देने और खेल चक्र के प्रत्येक पुनरावृत्ति को संदेश कतार में न रखने की अनुमति देगा।

UPD 2।

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

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

एसडीएल गेम फ्रेमवर्क श्रृंखला का अनुवाद। भाग 1 - एसडीएल ट्यूटोरियल मूल बातें

"हम सभी ने कहीं शुरुआत की"

प्रयुक्त उपकरण

समायोजन

स्रोत कोड

खेल की अवधारणा

More articles: