लेखन सी ++ गेम्स, भाग 1/3 - एक मिनी-फ्रेमवर्क लिखना

लेखन सी ++ गेम्स, भाग 2/3 - राज्य-आधारित प्रोग्रामिंग
हम सी ++, भाग 3/3 - शैली के क्लासिक्स में गेम लिखते हैं

नमस्कार, हबहार!

हब पर गेम बनाने पर कई सबक नहीं हैं, घरेलू डेवलपर्स का समर्थन क्यों नहीं करते हैं?
मैं आपको अपने पाठ प्रस्तुत करता हूं जो आपको सिखाते हैं कि एसडीएल का उपयोग करके सी ++ में गेम कैसे बनाएं!

आपको क्या जानना है

• C ++ का कम से कम एक बुनियादी ज्ञान (हम विजुअल स्टूडियो का उपयोग करेंगे)
• धैर्य

इस भाग के बारे में क्या है?

• हम सभी खेलों के लिए एक रूपरेखा तैयार करेंगे, हम एक रेंडर के रूप में एसडीएल का उपयोग करेंगे। यह ग्राफिक्स के लिए एक पुस्तकालय है।

अगले पोस्ट में और भी एक्शन होगा, यह सिर्फ तैयारी है :)

क्यों SDL?

मैंने इस लाइब्रेरी को सीखने के लिए सबसे आसान और सबसे तेज़ चुना। दरअसल, सर्पिल के 100,000 पुनर्मुद्रण के लिए ओपनजीएल या डायरेक्टएक्स पर पहले पढ़ा लेख से बहुत समय बीत जाएगा।

अब आप शुरू कर सकते हैं।

1.1। शुरू कर दिया

एसडीएल को आधिकारिक साइट से डाउनलोड करें।
हम Visual Studio में एक Win32 प्रोजेक्ट बनाते हैं, SDL लिबास और इंक्लूड कनेक्ट करते हैं (यदि आप नहीं जानते कि यह कैसे करना है, तो Google आपकी मदद करेगा!)

मल्टी-बाइट कैरेक्टर एन्कोडिंग का उपयोग करना भी आवश्यक है। ऐसा करने के लिए, प्रोजेक्ट-> गुण-> कॉन्फ़िगरेशन गुण-> वर्ण सेट-> मल्टीबाइट एन्कोडिंग का उपयोग करें।

Main.cpp फ़ाइल बनाएँ

#include <Windows.h> int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) { return 0; } 

वह अभी तक कुछ नहीं कर रहा है।

शव के राजा और भगवान - खेल कक्षा
Game.h

 #ifndef _GAME_H_ #define _GAME_H_ class Game { private: bool run; public: Game(); int Execute(); void Exit(); }; #endif 

Game.cpp

 #include "Game.h" Game::Game() { run = true; } int Game::Execute() { while(run); return 0; } void Game::Exit() { run = false; } 

हम फ़ाइल Project.h बनाते हैं, यह भविष्य में हमारे लिए बहुत उपयोगी होगा

 #ifndef _PROJECT_H_ #define _PROJECT_H_ #include <Windows.h> #include "Game.h" #endif 

मुख्य बदलें

 #include "Project.h" int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) { Game game; return game.Execute(); } 

पहले से ही थोड़ा बेहतर है, लेकिन फिर भी किसी तरह बहुत कुछ नहीं।

1.2। ग्राफिक्स

हम चित्र बनाने के लिए ग्राफिक्स और छवि प्रदान करने के लिए 2 कक्षाएं - ग्राफिक्स के रूप में कई बनाते हैं

Graphics.h

 #ifndef _GRAPHICS_H_ #define _GRAPHICS_H_ #include "Project.h" #include "Image.h" class Image; class Graphics { private: SDL_Surface* Screen; public: Graphics(int width, int height); Image* NewImage(char* file); Image* NewImage(char* file, int r, int g, int b); bool DrawImage(Image* img, int x, int y); bool DrawImage(Image* img, int x, int y, int startX, int startY, int endX, int endY); void Flip(); }; #endif 

Image.h

 #ifndef _IMAGE_H #define _IMAGE_H #include "Project.h" class Image { private: SDL_Surface* surf; public: friend class Graphics; int GetWidth(); int GetHeight(); }; #endif 

Project.h संशोधित करें

 #ifndef _PROJECT_H_ #define _PROJECT_H_ #pragma comment(lib,"SDL.lib") #include <Windows.h> #include <SDL.h> #include "Game.h" #include "Graphics.h" #include "Image.h" #endif 

SDL_Surface - छवि जानकारी संग्रहीत करने के लिए SDL का एक वर्ग
ग्राफिक्स पर विचार करें
NewImage - छवियों को लोड करने के लिए 2 विकल्प हैं। पहला विकल्प सिर्फ तस्वीर को लोड करता है, और दूसरा उसके बाद तस्वीर को पारदर्शिता भी देता है। यदि हमारे पास चित्र में एक लाल रंग की पृष्ठभूमि है, तो आर = 255, जी = 0, बी = 0 दर्ज करें
DrawImage - चित्र बनाने के लिए भी 2 विकल्प। पहला चित्र पूरा खींचता है, दूसरा चित्र का एकमात्र भाग है। startX, startY - चित्र के भाग की शुरुआत के निर्देशांक। endX, endY - छवि भाग के अंत निर्देशांक। यदि चित्र एटलस का उपयोग किया जाता है तो यह ड्राइंग विधि उपयोग की जाती है। यहाँ एक एटलस का उदाहरण दिया गया है:


(छवि interesnoe.info वेब संसाधन से ली गई है)

छवि पर विचार करें
वह बस अपनी सतह रखता है और अपने निजी सदस्यों को ग्राफिक्स वर्ग तक पहुंच प्रदान करता है, और वह सतह को बदल देता है।
यह मूल रूप से SDL_Surface पर एक आवरण है। वह चित्र का आकार भी देता है।

Graphics.cpp

 #include "Graphics.h" Graphics::Graphics(int width, int height) { SDL_Init(SDL_INIT_EVERYTHING); Screen = SDL_SetVideoMode(width,height,32,SDL_HWSURFACE|SDL_DOUBLEBUF); } Image* Graphics::NewImage(char* file) { Image* image = new Image(); image->surf = SDL_DisplayFormat(SDL_LoadBMP(file)); return image; } Image* Graphics::NewImage(char* file, int r, int g, int b) { Image* image = new Image(); image->surf = SDL_DisplayFormat(SDL_LoadBMP(file)); SDL_SetColorKey(image->surf, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB(image->surf->format, r, g, b)); return image; } bool Graphics::DrawImage(Image* img, int x, int y) { if(Screen == NULL || img->surf == NULL) return false; SDL_Rect Area; Area.x = x; Area.y = y; SDL_BlitSurface(img->surf, NULL, Screen, &Area); return true; } bool Graphics::DrawImage(Image* img, int x, int y, int startX, int startY, int endX, int endY) { if(Screen == NULL || img->surf == NULL) return false; SDL_Rect Area; Area.x = x; Area.y = y; SDL_Rect SrcArea; SrcArea.x = startX; SrcArea.y = startY; SrcArea.w = endX; SrcArea.h = endY; SDL_BlitSurface(img->surf, &SrcArea, Screen, &Area); return true; } void Graphics::Flip() { SDL_Flip(Screen); SDL_FillRect(Screen,NULL, 0x000000); } 

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

Image.cpp

 #include "Image.h" int Image::GetWidth() { return surf->w; } int Image::GetHeight() { return surf->h; } 

नहीं, आप सब कुछ सही कर रहे हैं, यह फाइल इस तरह होनी चाहिए :)

Game.h, Game.cpp और main.cpp को बदलने की आवश्यकता है
Game.h

 #ifndef _GAME_H_ #define _GAME_H_ #include "Project.h" class Graphics; class Game { private: bool run; Graphics* graphics; public: Game(); int Execute(int width, int height); void Exit(); }; #endif 

यहां हम ग्राफिक्स के लिए एक पॉइंटर जोड़ते हैं और एक्सक्यूट में हम एक स्क्रीन आकार जोड़ते हैं

Game.cpp

 #include "Game.h" Game::Game() { run = true; } int Game::Execute(int width, int height) { graphics = new Graphics(width,height); while(run); SDL_Quit(); return 0; } void Game::Exit() { run = false; } 

कुछ खास नहीं, बस SDL_Quit फ़ंक्शन को SDL को खाली करने के लिए छोड़ दें

main.cpp

 #include "Project.h" int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) { Game game; return game.Execute(500,350); } 

यहां हम 500 से 350 तक की स्क्रीन मापते हैं।

1.3। प्रविष्टि

हमें कीबोर्ड इनपुट के साथ काम करने की आवश्यकता है

Input.h बनाएँ

 #ifndef _INPUT_H_ #define _INPUT_H_ #include "Project.h" class Input { private: SDL_Event evt; public: void Update(); bool IsMouseButtonDown(byte key); bool IsMouseButtonUp(byte key); POINT GetButtonDownCoords(); bool IsKeyDown(byte key); bool IsKeyUp(byte key); byte GetPressedKey(); bool IsExit(); }; #endif 

SDL_Event किसी घटना का एक वर्ग है, हम इसे इनपुट में रखते हैं ताकि हर चक्र में इस वर्ग का ऑब्जेक्ट न बनाया जा सके
नीचे ऐसे तरीके दिए गए हैं जो विशेष रुचि के नहीं हैं। नोट: डाउन के साथ समाप्त होने वाली विधियों को तब बुलाया जाता है जब कुंजी को दबाया गया हो, और जब कॉल किया जाता है, तो समाप्ति के साथ।

Input.cpp

 #include "Input.h" void Input::Update() { while(SDL_PollEvent(&evt)); } bool Input::IsMouseButtonDown(byte key) { if(evt.type == SDL_MOUSEBUTTONDOWN) if(evt.button.button == key) return true; return false; } bool Input::IsMouseButtonUp(byte key) { if(evt.type == SDL_MOUSEBUTTONUP) if(evt.button.button == key) return true; return false; } POINT Input::GetButtonDownCoords() { POINT point; point.x = evt.button.x; point.y = evt.button.y; return point; } bool Input::IsKeyDown(byte key) { return (evt.type == SDL_KEYDOWN && evt.key.keysym.sym == key); } bool Input::IsKeyUp(byte key) { return (evt.type == SDL_KEYUP && evt.key.keysym.sym == key); } byte Input::GetPressedKey() { return evt.key.keysym.sym; } bool Input::IsExit() { return (evt.type == SDL_QUIT); } 

यहां हम अपने ईवेंट ऑब्जेक्ट को अपडेट फ़ंक्शन में संसाधित करते हैं, और बाकी फ़ंक्शन केवल ईवेंट के प्रकार और उसके मूल्यों की जांच करते हैं।

अब हम Game.h और Game.cpp को बदलते हैं

 #ifndef _GAME_H_ #define _GAME_H_ #include "Project.h" #include "Graphics.h" class Graphics; #include "Input.h" class Input; class Game { private: bool run; Graphics* graphics; Input* input; public: Game(); int Execute(int width, int height); Graphics* GetGraphics(); Input* GetInput(); void Exit(); }; #endif 

जैसा कि आप देख सकते हैं, हमने इनपुट में एक पॉइंटर जोड़ा और ग्राफिक्स और इनपुट रिटर्न के तरीके बनाए

Game.cpp

 #include "Game.h" Game::Game() { run = true; } int Game::Execute(int width, int height) { graphics = new Graphics(width,height); input = new Input(); while(run) { input->Update(); } delete graphics; delete input; SDL_Quit(); return 0; } Graphics* Game::GetGraphics() { return graphics; } Input* Game::GetInput() { return input; } void Game::Exit() { run = false; } 

1.4। परिणाम

यह पहला पाठ था। यदि आप इस स्थान पर पहुंच गए हैं, तो मैं आपको बधाई देता हूं! आपके पास प्रोग्रामर में अंतर्निहित होगा :) बहुत अधिक जानने के लिए बाद के पाठों के लिए लेख की शुरुआत में लिंक देखें!

सभी प्रश्नों के लिए, पीएम से संपर्क करें, और यदि आप हब पर पंजीकृत होने के लिए अशुभ हैं, तो ईमेल पर लिखें