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



यह अल्पज्ञात फ्लड-इट होगा। यह विचार अत्यंत सरल है:
पूरे क्षेत्र को एक रंग में रंगना आवश्यक है, इस तथ्य के बावजूद कि आप ऊपरी बाएँ वर्ग से सटे एक ही रंग के पूरे हिस्से को पेंट कर सकते हैं।

प्रारंभ

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

SDL_Init(SDL_INIT_VIDEO) 

यदि आपको अन्य प्रणालियों की आवश्यकता है, तो आप इस सूची का उपयोग कर सकते हैं:

• SDL_INIT_AUDIO
• SDL_INIT_VIDEO
• SDL_INIT_TIMER
• SDL_INIT_CDROM
• SDL_INIT_JOYSTICK
• SDL_INIT_EVERYTHING - सभी उपप्रणालियों का आरंभ
• SDL_INIT_NOPARACHUTE - घातक संकेतों को न पकड़ें
• SDL_INIT_EVENTTHREAD - इवेंट मैनेजर को एक अलग थ्रेड में चलाएँ

ओह, अगर यहां सब कुछ इतना सरल था। वास्तव में, यह हमेशा सफल नहीं हो सकता है, और यदि यह विफल रहता है तो आपको दुर्घटना की आवश्यकता होगी और इसके लिए आपको केवल SDL_Init द्वारा लौटाए गए मान की निगरानी करने की आवश्यकता है - विफलता के मामले में, एक नकारात्मक संख्या हमेशा वापस आ जाती है।

 if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { printf( "Unable to init SDL"); return 1; } 

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

 if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { printf( "Unable to init SDL: %s", SDL_GetError()); return 1; } 

सतह

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

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

तो, एक सतह बनाने के रूप में निम्नानुसार है

 SDL_Surface * screen = SDL_SetVideoMode(550, 420, 16, SDL_HWSURFACE | SDL_DOUBLEBUF); /// 550x420 —     .    16-.     -  SDL_HWSURFACE //     ,   SDL_SWSURFACE( ) 

फिर से, हमें वांछित परिणाम नहीं मिल सकता है। हम फिर से एक त्रुटि संदेश प्रदर्शित करेंगे और यदि कोई सतह नहीं है तो निष्पादन समाप्त कर देंगे।

 If (!screen) { printf("Can't set videomode: %s", SDL_GetError()); return 1; } 

छवि

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

 int InitImages() { for (int i = 0; i < 6; i++) //    6  { char path[20]; for (int j = 0; j < 20; j++) path[j] = 0; sprintf(path, "Block%d.bmp", i); block[i] = SDL_LoadBMP(path); //  BMP     block[i] if (!block[i]) return -1; } return 1; } 

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

इन उद्देश्यों के लिए, SDL_BlitSurface है, जो निर्देशांक X1, y1 और आयाम w के साथ एक सतह से आयत को फिर से लिख सकता है, x2, y2 के स्थान पर दूसरी सतह पर h। किसी तरह बहुत सारे पैरामीटर, और इसके अलावा, निर्देशांक प्रमुख संख्याओं में प्रेषित नहीं होते हैं। चूंकि हम केवल स्क्रीन की सतह पर सब कुछ प्रदर्शित करेंगे, हम एक छोटी सी प्रक्रिया लिखेंगे

 void DrawImage(SDL_Surface * img, int x, int y, int w, int h, int sx, int sy) { SDL_Rect desc; // ,    . desc.x = x; desc.y = y; SDL_Rect src; //  . src.x = sx; src.y = sy; src.w = w; src.h = h; SDL_BlitSurface(img, &src, screen, &desc); } 

आइए पारित मापदंडों का विश्लेषण करें:
img - सतह, जिसका एक हिस्सा हम जोड़ देंगे। X, Y वे निर्देशांक हैं जिन्हें आप प्रदर्शित करना चाहते हैं। एसएक्स, एसवाई, डब्ल्यू, एच - प्रदर्शित आयत के पैरामीटर (कोण निर्देशांक और आकार)। संचरित मूल्यों का जादू यह है कि निर्देशांक को SDL_Rect प्रकार (आयत से) में सेट किया जाना चाहिए, जिसमें 4 मान हैं - X, Y, W, H. खैर, नए प्रकार में निर्देशांक सेट करने के बाद, ओवरलैपिंग का प्रदर्शन किया जाता है।

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

 void GenMap() { for (int i = 0; i < maps; i++) for (int j = 0; j < maps; j++) map[i][j] = rand() % 6; } 

ब्लॉक के निर्देशांक के अनुसार छवि को उसके सही स्थान पर प्रदर्शित करने वाली एक और प्रक्रिया जोड़ें (ब्लॉक एक्स के लिए, वाई यह ब्लॉक के लिए 30 * X, 30 * Y, 30 * (X + 1), 30 * (Y + 1) के साथ एक आयत होगी। 30x30 पिक्सेल)।

 void DrawBlock(int x, int y) { DrawImage(block[map[x][y]], 30 * x, 30 * y, 30, 30, 0, 0); //    30*x, 30*y  30x30 } 

और उसी समय, हम पूरे क्षेत्र का निर्माण करेंगे

 void DrawMap() { for (int i = 0; i < maps; i++) // maps(map size) —   . for (int j = 0; j < maps; j++) DrawBlock(i, j); } 

क्या हुआ, यह जाँचने का समय। हम एक क्षेत्र उत्पन्न करते हैं, घटाते हैं, और ... कुछ नहीं! ऐसा कैसे? ऐसा लगता है कि सब कुछ सही है, लेकिन ... स्क्रीन बफर, इसे प्रदर्शित करने के लिए मत भूलना। यह बस किया जाता है

  GenMap(); DrawMap(); SDL_Flip(screen); 

यह SDL_Flip है जो स्क्रीन के साथ वांछित कार्रवाई करेगा। और अब आप परिणाम देख सकते हैं:


महान, सब कुछ काम करता है।
यह, शायद, इस लेख में रहने लायक है। यहां जारी है ।