DevOps C++ और "रसोई युद्ध", या कैसे मैंने भोजन करते समय गेम लिखना शुरू किया

"मैं जानता हूं कि मैं कुछ नहीं जानता" सुकरात

किसके लिए: उन आईटी लोगों के लिए जो सभी डेवलपर्स पर थूकते हैं और उनके गेम खेलना चाहते हैं!

किस बारे मेँ: यदि आपको इसकी आवश्यकता है तो C/C++ में गेम लिखना कैसे प्रारंभ करें!

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

हैलो मेरा नाम है एंड्री ग्रैनकिन, मैं लक्सॉफ्ट में एक डेवऑप्स हूं। एप्लिकेशन डेवलपमेंट मेरी कार्य विशेषता नहीं है, लेकिन मैं हर सप्ताह कोडिंग करने का प्रयास करता हूं। क्योंकि मुझे खेल पसंद हैं!

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

साथ ही, अन्य लोगों के गेम खेलते समय, हम लगातार उन स्थानों, कथानक, पात्रों, गेम मैकेनिक्स द्वारा सीमित होते हैं जो अन्य लोगों के साथ आए थे। तो मुझे एहसास हुआ कि...

...यह अपनी खुद की दुनिया बनाने का समय है, केवल मेरे अधीन। वे संसार जहाँ मैं पिता, और पुत्र, और पवित्र आत्मा हूँ!

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

इस लेख में मैं आपको यह बताने की कोशिश करूंगा कि मैंने C/C++ में छोटे गेम लिखना कैसे शुरू किया, विकास प्रक्रिया क्या है और व्यस्त माहौल में मुझे शौक के लिए समय कहां मिलता है। यह व्यक्तिपरक है और व्यक्तिगत शुरुआत की प्रक्रिया का वर्णन करता है। अज्ञानता और विश्वास के बारे में सामग्री, इस समय दुनिया की मेरी व्यक्तिगत तस्वीर के बारे में। दूसरे शब्दों में, "प्रशासन आपके व्यक्तिगत दिमाग के लिए ज़िम्मेदार नहीं है!"।

अभ्यास

"अभ्यास के बिना ज्ञान बेकार है, ज्ञान के बिना अभ्यास खतरनाक है।" कन्फ्यूशियस

मेरी नोटबुक मेरी जिंदगी है!

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

मेरी (पहले से भरी हुई) नोटबुक। यह इस तरह दिखता है. इसमें रोजमर्रा के कार्य, विचार, रेखाचित्र, आरेख, समाधान, काली बहीखाता पद्धति, कोड इत्यादि शामिल हैं।

इस स्तर पर, मैं तीन परियोजनाओं को पूरा करने में कामयाब रहा (यह "अंतिमता" की मेरी समझ में है, क्योंकि किसी भी उत्पाद को अपेक्षाकृत अंतहीन रूप से विकसित किया जा सकता है)।

• प्रोजेक्ट 0: यह यूनिटी गेम इंजन का उपयोग करके C# में लिखा गया एक आर्किटेक्ट डेमो 3D दृश्य है। MacOS और Windows प्लेटफ़ॉर्म के लिए.
• गेम 1: विंडोज़ के लिए कंसोल गेम सिंपल स्नेक (जिसे सभी लोग "स्नेक" के नाम से जानते हैं)। सी में लिखा है
• गेम 2: कंसोल गेम क्रेज़ी टैंक (सभी को "टैंक" के रूप में जाना जाता है), पहले से ही C++ (कक्षाओं का उपयोग करके) और विंडोज़ के अंतर्गत भी लिखा गया है।

प्रोजेक्ट 0 आर्किटेक्ट डेमो

• मंच: विंडोज़ (विंडोज़ 7, 10), मैक ओएस (ओएस एक्स एल कैपिटन वी. 10.11.6)
• भाषा: C#
• खेल यंत्र: एकता
• प्रेरणा: डैरिन लिल
• भंडार: GitHub

3डी सीन आर्किटेक्ट डेमो

पहला प्रोजेक्ट C/C++ में नहीं, बल्कि यूनिटी गेम इंजन का उपयोग करके C# में लागू किया गया था। यह इंजन हार्डवेयर पर उतनी मांग वाला नहीं था अवास्तविक इंजन, और मुझे स्थापित करना और उपयोग करना भी आसान लगा। मैंने अन्य इंजनों पर विचार नहीं किया।

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

मैंने यूट्यूब पर 3डी मॉडल बनाने के तरीके पर ट्यूटोरियल वीडियो से शुरुआत की ब्लेंडर. ब्लेंडर 3डी मॉडलिंग (और अधिक) के लिए एक बेहतरीन मुफ्त टूल है जिसे इंस्टॉलेशन की आवश्यकता नहीं है। और यहां एक झटका मेरा इंतजार कर रहा था ... यह पता चला कि मॉडलिंग, एनीमेशन, टेक्सचरिंग बहुत अलग विषय हैं जिन पर आप किताबें लिख सकते हैं। यह पात्रों के लिए विशेष रूप से सच है। उंगलियों, दांतों, आंखों और शरीर के अन्य हिस्सों को मॉडल करने के लिए, आपको शरीर रचना विज्ञान के ज्ञान की आवश्यकता होगी। चेहरे की मांसपेशियाँ कैसे व्यवस्थित होती हैं? लोग कैसे चलते हैं? मुझे प्रत्येक हाथ, पैर, उंगली, पोर में हड्डियाँ "डालनी" पड़ीं!

हंसली, अतिरिक्त हड्डी लीवर को मॉडल करें, ताकि एनीमेशन प्राकृतिक दिखे। ऐसे पाठों के बाद, आपको एहसास होता है कि केवल 30 सेकंड का वीडियो बनाने के लिए एनिमेटेड फिल्मों के निर्माता कितना बड़ा काम करते हैं। लेकिन 3डी फिल्में घंटों तक चलती हैं! और फिर हम सिनेमाघरों से बाहर आते हैं और कुछ ऐसा कहते हैं: “ता, एक घटिया कार्टून/फिल्म! वे बेहतर कर सकते थे...'' मूर्ख!

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

एक वृत्त और एक गोले पर एक बिंदु के निर्देशांक की गणना के लिए सूत्रों की गणना (मेरी नोटबुक से)

खेल 1

• मंच: विंडोज़ (विंडोज़ 7 पर परीक्षण किया गया)
• भाषा: मुझे लगता है कि यह शुद्ध सी में लिखा गया था
• खेल यंत्र: विंडोज़ कंसोल
• प्रेरणा: javidx9
• भंडार: GitHub

सरल साँप खेल

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

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

गेम लूप कुछ इस तरह दिख सकता है:

int main()
   {
      Setup();
      // a game loop
      while (!quit)
      {
          Input();
          Logic();
          Draw();
          Sleep(gameSpeed);  // game timing
      }
      return 0;
   }

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

खेल चक्र. नोटपैड में साँप प्रोग्रामिंग

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

स्क्रीन बफ़र प्राप्त करना (यदि मैं ऐसा कह सकूँ):

// create screen buffer for drawings
   HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
 							   NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
   DWORD dwBytesWritten = 0;
   SetConsoleActiveScreenBuffer(hConsole);

एक निश्चित लाइन स्कोरलाइन (स्कोर प्रदर्शित करने के लिए लाइन) की स्क्रीन पर सीधा आउटपुट:

// draw the score
   WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);

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

खेल 2 पागल टैंक

• मंच: विंडोज़ (विंडोज़ 7 पर परीक्षण किया गया)
• भाषा: सी + +
• खेल यंत्र: विंडोज़ कंसोल
• प्रेरणा: книга गेम प्रोग्रामिंग के माध्यम से C++ की शुरुआत
• भंडार: GitHub

पागल टैंक खेल

कंसोल पर अक्षरों को प्रिंट करना संभवतः सबसे सरल चीज़ है जिसे आप गेम में बदल सकते हैं। लेकिन फिर एक परेशानी सामने आती है: पात्रों की ऊंचाई और चौड़ाई अलग-अलग होती है (ऊंचाई चौड़ाई से अधिक होती है)। इस प्रकार, हर चीज़ असंगत दिखेगी, और नीचे या ऊपर जाना बाएँ या दाएँ जाने की तुलना में बहुत तेज़ लगेगा। यह प्रभाव "स्नेक" (गेम 1) में बहुत ध्यान देने योग्य है। "टैंक" (गेम 2) में ऐसी कोई खामी नहीं है, क्योंकि वहां आउटपुट स्क्रीन पिक्सल को अलग-अलग रंगों से पेंट करके व्यवस्थित किया जाता है। आप कह सकते हैं कि मैंने एक रेंडरर लिखा है। सच है, यह पहले से ही थोड़ा अधिक जटिल है, हालाँकि बहुत अधिक दिलचस्प है।

इस गेम के लिए, स्क्रीन पर पिक्सेल प्रदर्शित करने के लिए मेरे सिस्टम का वर्णन करना पर्याप्त होगा। मुझे लगता है कि यह खेल का मुख्य हिस्सा है। और बाकी सब कुछ आप स्वयं सोच सकते हैं।

तो, आप स्क्रीन पर जो देख रहे हैं वह केवल गतिशील रंगीन आयतों का एक सेट है।

आयताकार सेट

प्रत्येक आयत को संख्याओं से भरे मैट्रिक्स द्वारा दर्शाया गया है। वैसे, मैं एक दिलचस्प बारीकियों पर प्रकाश डाल सकता हूं - खेल में सभी मैट्रिक्स को एक-आयामी सरणी के रूप में प्रोग्राम किया गया है। द्वि-आयामी नहीं, बल्कि एक-आयामी! एक-आयामी सरणियों के साथ काम करना बहुत आसान और तेज़ है।

गेम टैंक मैट्रिक्स का एक उदाहरण

एक-आयामी सरणी के साथ गेम टैंक के मैट्रिक्स का प्रतिनिधित्व करना

एक-आयामी सरणी द्वारा मैट्रिक्स प्रतिनिधित्व का एक अधिक उदाहरणात्मक उदाहरण

लेकिन सरणी के तत्वों तक पहुंच एक डबल लूप में होती है, जैसे कि यह एक-आयामी नहीं, बल्कि दो-आयामी सरणी हो। ऐसा इसलिए किया गया है क्योंकि हम अभी भी मैट्रिसेस के साथ काम कर रहे हैं।

एक डबल लूप में एक-आयामी सरणी को पार करना। Y पंक्ति आईडी है, X स्तंभ आईडी है

कृपया ध्यान दें कि सामान्य मैट्रिक्स पहचानकर्ताओं i, j के बजाय, मैं पहचानकर्ताओं x और y का उपयोग करता हूं। तो, मुझे ऐसा लगता है, यह आंखों के लिए अधिक सुखद और मस्तिष्क के लिए अधिक स्पष्ट है। इसके अलावा, इस तरह के अंकन से द्वि-आयामी छवि के समन्वय अक्षों पर उपयोग किए गए मैट्रिक्स को आसानी से प्रोजेक्ट करना संभव हो जाता है।

अब पिक्सल, रंग और डिस्प्ले के बारे में। आउटपुट के लिए स्ट्रेचडिबिट्स फ़ंक्शन (हेडर: विंडोज़.एच; लाइब्रेरी: gdi32.lib) का उपयोग किया जाता है। अन्य बातों के अलावा, निम्नलिखित को इस फ़ंक्शन में पास किया जाता है: वह उपकरण जिस पर छवि प्रदर्शित होती है (मेरे मामले में, यह विंडोज कंसोल है), छवि को प्रदर्शित करने की शुरुआत के निर्देशांक, इसकी चौड़ाई / ऊंचाई और छवि स्वयं एक बिटमैप (बिटमैप) के रूप में, बाइट्स की एक सरणी द्वारा दर्शाया गया है। बाइट्स की एक सरणी के रूप में बिटमैप!

काम पर StretchDIBits() फ़ंक्शन:

// screen output for game field
   StretchDIBits(
               deviceContext,
               OFFSET_LEFT, OFFSET_TOP,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               0, 0,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               m_p_bitmapMemory, &bitmapInfo,
               DIB_RGB_COLORS,
               SRCCOPY
               );

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

एक m_p_bitmapMemory बिटमैप बनाना:

// create bitmap
   int bitmapMemorySize = (PMATRIX_WIDTH * PMATRIX_HEIGHT) * BYTES_PER_PIXEL;
   void* m_p_bitmapMemory = VirtualAlloc(0, bitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);

मोटे तौर पर कहें तो, बिटमैप में पिक्सेल का एक सेट होता है। सरणी में प्रत्येक चार बाइट्स एक RGB पिक्सेल है। एक बाइट प्रति लाल मान, एक बाइट प्रति हरा मान (जी), और एक बाइट प्रति नीला रंग (बी)। साथ ही, प्रति इंडेंट एक बाइट है। ये तीन रंग - लाल / हरा / नीला (आरजीबी) - अलग-अलग अनुपात में एक दूसरे के साथ मिश्रित होते हैं - और परिणामी पिक्सेल रंग प्राप्त होता है।

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

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

खेल के मैदान के संख्यात्मक मैट्रिक्स (डिजिटल मैट्रिक्स) पर आधारित जानकारी के साथ एक बिटमैप (पिक्सेल मैट्रिक्स) भरने का एक उदाहरण (रंग सूचकांक खेल के सूचकांकों से मेल नहीं खाते)

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

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

खेल के मैदान के संख्यात्मक मैट्रिक्स के आधार पर जानकारी के साथ एक बिटमैप भरना:

// set pixel map variables
   int colorIndex;
   COLORREF color;
   int pitch;
   uint8_t* p_row;
 
   // arrange pixels for game field
   pitch = PMATRIX_WIDTH * BYTES_PER_PIXEL;     // row size in bytes
   p_row = (uint8_t*)m_p_bitmapMemory;       //cast to uint8 for valid pointer arithmetic
   							(to add by 1 byte (8 bits) at a time)   
   for (int y = 0; y < PMATRIX_HEIGHT; ++y)
   {
       uint32_t* p_pixel = (uint32_t*)p_row;
       for (int x = 0; x < PMATRIX_WIDTH; ++x)
       {
           colorIndex = mainDigitalMatrix[y * PMATRIX_WIDTH + x];
           color = Utils::GetColor(colorIndex);
           uint8_t blue = GetBValue(color);
           uint8_t green = GetGValue(color);
           uint8_t red = GetRValue(color);
           uint8_t pixelPadding = 0;
 
           *p_pixel = ((pixelPadding << 24) | (red << 16) | (green << 8) | blue);
           ++p_pixel;
       }
       p_row += pitch;
   }

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

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

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

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

व्यावहारिक भाग के अंत में, मैं अपनी नोटबुक के कुछ स्कैन निकालूंगा। यह दिखाने के लिए कि मैं वास्तव में क्या लिख ​​रहा था, चित्र बना रहा था, गिन रहा था, डिज़ाइन कर रहा था...

टैंक छवि डिजाइन. और प्रत्येक टैंक को स्क्रीन पर कितने पिक्सेल घेरने चाहिए इसकी परिभाषा

अपनी धुरी के चारों ओर टैंक के घूमने के लिए एल्गोरिदम और सूत्रों की गणना

मेरे संग्रह का आरेख (संभवतः स्मृति रिसाव वाला)। संग्रह एक लिंक्ड सूची के रूप में बनाया गया है

और ये खेल में कृत्रिम बुद्धिमत्ता को शामिल करने के निरर्थक प्रयास हैं

Теория

"हजारों मील की यात्रा भी पहले कदम से शुरू होती है" (प्राचीन चीनी ज्ञान)

आइए अभ्यास से सिद्धांत की ओर चलें! आप अपने शौक के लिए समय कैसे निकालते हैं?

1. निर्धारित करें कि आप वास्तव में क्या चाहते हैं (अफसोस, यह सबसे कठिन है)।
2. प्राथमिकताओं चूनना।
3. उच्च प्राथमिकताओं के लिए सभी "अनावश्यक" का त्याग करें।
4. हर दिन अपने लक्ष्य की ओर बढ़ें।
5. यह उम्मीद न करें कि किसी शौक के लिए दो या तीन घंटे का खाली समय होगा।

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

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

और यह याद रखना महत्वपूर्ण है कि आपको 5, 10, 15 मिनट में समय के मुफ्त "चूरा" को कम नहीं समझना चाहिए और अनदेखा नहीं करना चाहिए, एक या दो घंटे तक चलने वाले कुछ बड़े "लॉग" की प्रतीक्षा करें। क्या आप लाइन में खड़े हैं? अपने प्रोजेक्ट के लिए कुछ सोचें. क्या आप एस्केलेटर पर चढ़ रहे हैं? एक नोटबुक में कुछ लिखें. क्या आप बस में खाना खाते हैं? ठीक है, कुछ लेख पढ़ें। हर अवसर का उपयोग करें. YouTube पर बिल्लियों और कुत्तों को देखना बंद करें! अपने दिमाग के साथ खिलवाड़ मत करो!

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

केसी यह भी बताते हैं कि अपना खुद का गेम इंजन विकसित करने से, आपको किसी भी मौजूदा इंजन की बेहतर समझ होगी। फ्रेमवर्क की दुनिया में, जहां हर कोई स्वचालित करने की कोशिश कर रहा है, आप सीखेंगे कि कैसे बनाना है, उपयोग नहीं। कंप्यूटर की प्रकृति को समझें. और आप कहीं अधिक बुद्धिमान और परिपक्व प्रोग्रामर - एक पेशेवर भी बन जायेंगे।

आपके चुने हुए मार्ग पर शुभकामनाएँ! और आइए दुनिया को और अधिक पेशेवर बनाएं।

लेखक: ग्रैनकिन एंड्री, डेवऑप्स

स्रोत: www.habr.com