हम 30 मिनट में एक प्लेटफ़ॉर्मर बनाते हैं

आपका स्वागत है! आज हम C ++, Box2D और SFML का उपयोग करके एक प्लेटफ़ॉर्मर लिखेंगे, साथ ही टाइल वाले मैप एडिटर गेम्स के लिए 2 डी मैप एडिटर।



यहाँ परिणाम है (नक्शा 5 मिनट + बनाया गया था शूटिंग के दौरान खेल धीमा हो गया + स्क्रीन इतना फैला नहीं है - Bandicam दोष):



स्रोत और exe - लेख के नीचे।

क्या, कहाँ, कब?

Box2D

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

SFML

क्यों SFML? पहले मैं एसडीएल पुस्तकालय का उपयोग करना चाहता था, लेकिन यह एसएफएमएल की तुलना में क्षमताओं में बहुत सीमित है, मुझे खुद को बहुत कुछ जोड़ना होगा। बचाया समय के लिए SFML के लेखक को धन्यवाद!
हम इसका उपयोग ग्राफिक्स बनाने के लिए करते हैं

टाइल वाला मानचित्र संपादक

टाइल मैप मानचित्र संपादक यहाँ क्या करता है?
क्या आपने कभी गेम के लिए कार्ड बनाने की कोशिश की है? मुझे यकीन है कि आपका पहला कार्ड कुछ ऐसा था।



यह एक बहुत ही अकुशल समाधान है! मैप एडिटर की तरह कुछ लिखना बेहतर होता है, लेकिन सोच में हम समझते हैं कि यह 5 मिनट में नहीं किया जाता है, और ऊपर दिया गया "मैप" काफी है।

टाइल्ड मैप एडिटर एक ऐसा मैप एडिटर है। यह अच्छा है क्योंकि इस संपादक में बनाए गए नक्शे (ऑब्जेक्ट्स, टाइल, उनकी परतें) को एक XML- जैसी .tmx फ़ाइल में सहेजा जा सकता है और फिर इसे एक विशेष C ++ लाइब्रेरी का उपयोग करके पढ़ा जा सकता है। लेकिन सबसे पहली बात।

नक्शा निर्माण

आधिकारिक साइट से टीएमई डाउनलोड करें
एक नया नक्शा बनाएँ "फ़ाइल-> बनाएँ ..."



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

टाइल्स

फिर हम "मैप-> टाइल्स का एक नया सेट ..." पर जाते हैं, हमारी टाइल को लोड करते हैं:



आप कुछ इस तरह से समाप्त करते हैं:



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

परतों को बनाने की प्रक्रिया निम्नलिखित 4 स्क्रीनशॉट में कैप्चर की गई है:





परतों की सूची:

वस्तुएं

TME में एक वस्तु क्या है?
किसी ऑब्जेक्ट का अपना नाम, प्रकार और मानों के साथ पैरामीटर भी होता है।
यह पैनल ऑब्जेक्ट्स के लिए जिम्मेदार है।



आप अच्छी तरह से पता लगा सकते हैं कि प्रत्येक बटन क्या करता है, अपने आप को।
अब एक ऑब्जेक्ट बनाने की कोशिश करते हैं।
"Kolobosha" परत को हटाएं, इसके बजाय वस्तुओं की एक परत बनाएं, उदाहरण के लिए, समान नाम "Kolobosha"। ऑब्जेक्ट के लिए पैनल से "इंसर्ट टाइल ऑब्जेक्ट" चुनें (या आप किसी भी आकार - आकृति का चयन कर सकते हैं), कोलोबोसी टाइल पर क्लिक करें और बस ऑब्जेक्ट को किसी जगह पर रखें।
फिर हम ऑब्जेक्ट पर राइट-क्लिक करें और "ऑब्जेक्ट गुण ..." पर क्लिक करें। ऑब्जेक्ट का नाम बदलकर Kolobosha करें।

फिर मैप को सेव करें।

सामान्य तौर पर, मानचित्र संपादकों में कुछ भी पुरातन नहीं होता है। यह कार्ड पढ़ने के लिए आगे बढ़ने का समय है।

कार्ड रीडर

XML फ़ाइलों को पढ़ने के लिए एक उत्कृष्ट TinyXML पुस्तकालय बनाया गया है , इसके स्रोतों को डाउनलोड करें।

Visual Studio प्रोजेक्ट बनाएँ। TinyXML फ़ाइलों को शामिल करें (या xmltest.cpp :) को छोड़कर, प्रोजेक्ट में इन सभी फ़ाइलों को धकेलें
अब हम "प्रोजेक्ट-> प्रॉपर्टीज" में शामिल''वाई और लिब'ई SFML को जोड़ते हैं। यदि आप नहीं जानते कि यह कैसे करना है, तो Google में आपका स्वागत है।

मैप्स के लिए Level.h बनाएँ

 #ifndef LEVEL_H #define LEVEL_H #pragma comment(lib,"Box2D.lib") #pragma comment(lib,"sfml-graphics.lib") #pragma comment(lib,"sfml-window.lib") #pragma comment(lib,"sfml-system.lib") #include <string> #include <vector> #include <map> #include <SFML/Graphics.hpp> 

यह फ़ाइल की शुरुआत है।

अगला वस्तु की संरचना है

 struct Object { int GetPropertyInt(std::string name); float GetPropertyFloat(std::string name); std::string GetPropertyString(std::string name); std::string name; std::string type; sf::Rect<int> rect; std::map<std::string, std::string> properties; sf::Sprite sprite; }; 

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

अब परत संरचना आती है - यह बहुत सरल है

 struct Layer { int opacity; std::vector<sf::Sprite> tiles; }; 

परत में पारदर्शिता है (हाँ, हाँ, हम पारभासी परतें बना सकते हैं!) और टाइल्स की एक सूची।

अगला स्तर वर्ग आता है:

 class Level { public: bool LoadFromFile(std::string filename); Object GetObject(std::string name); std::vector<Object> GetObjects(std::string name); void Draw(sf::RenderWindow &window); sf::Vector2i GetTileSize(); private: int width, height, tileWidth, tileHeight; int firstTileID; sf::Rect<float> drawingBounds; sf::Texture tilesetImage; std::vector<Object> objects; std::vector<Layer> layers; }; #endif 

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

अब Level.cpp बनाएं:

 #include "level.h" #include <iostream> #include "tinyxml.h" 

पहले हम वस्तुओं की संरचना की प्रक्रिया करते हैं

 int Object::GetPropertyInt(std::string name) { return atoi(properties[name].c_str()); } float Object::GetPropertyFloat(std::string name) { return strtod(properties[name].c_str(), NULL); } std::string Object::GetPropertyString(std::string name) { return properties[name]; } 

लेयर कार्यान्वयन के लिए आवश्यक नहीं है, स्तर पर जाएं:



अन्य स्तर के कार्य:

 Object Level::GetObject(std::string name) { //       for (int i = 0; i < objects.size(); i++) if (objects[i].name == name) return objects[i]; } std::vector<Object> Level::GetObjects(std::string name) { //      std::vector<Object> vec; for(int i = 0; i < objects.size(); i++) if(objects[i].name == name) vec.push_back(objects[i]); return vec; } sf::Vector2i Level::GetTileSize() { return sf::Vector2i(tileWidth, tileHeight); } void Level::Draw(sf::RenderWindow &window) { //    (  !) for(int layer = 0; layer < layers.size(); layer++) for(int tile = 0; tile < layers[layer].tiles.size(); tile++) window.draw(layers[layer].tiles[tile]); } 

Level.h के साथ यह खत्म हो गया है!

हम इसका परीक्षण करेंगे।
Main.cpp बनाएं और लिखें:

 #include "level.h" int main() { Level level; level.LoadFromFile("test.tmx"); sf::RenderWindow window; window.create(sf::VideoMode(800, 600), "Level.h test"); while(window.isOpen()) { sf::Event event; while(window.pollEvent(event)) { if(event.type == sf::Event::Closed) window.close(); } window.clear(); level.Draw(window); window.display(); } return 0; } 

नक्शा कुछ भी दिख सकता है!

आप वस्तुओं के साथ चारों ओर खेल सकते हैं:



main.cpp

 #include "level.h" #include <iostream> int main() { Level level; level.LoadFromFile("test.tmx"); Object kolobosha = level.GetObject("Kolobosha"); std::cout << kolobosha.name << std::endl; std::cout << kolobosha.type << std::endl; std::cout << kolobosha.GetPropertyInt("health") << std::endl; std::cout << kolobosha.GetPropertyString("mood") << std::endl; sf::RenderWindow window; window.create(sf::VideoMode(800, 600), "Kolobosha adventures"); while(window.isOpen()) { sf::Event event; while(window.pollEvent(event)) { if(event.type == sf::Event::Closed) window.close(); } window.clear(); level.Draw(window); window.display(); } return 0; } 

परिणाम:



जब आप वस्तुओं के साथ खेलते हैं, तो यह Box2D का समय होता है:

बक्से, बक्से

हम एक 3 डी कार्रवाई platformer बनाना चाहते हैं, सार है ...
नक्शे पर ऑब्जेक्ट्स हैं - नाम के साथ खिलाड़ी - खिलाड़ी, दुश्मन - दुश्मन, ब्लॉक - ब्लॉक, पैसा - सिक्के।
हम खिलाड़ी को लोड करते हैं, उसे कीस्ट्रोक्स और न्यूटन की ताकत का पालन करते हैं।
दुश्मन पीछे-पीछे जाते हैं, खिलाड़ी को बहुत करीब से धक्का देते हैं और अगर खिलाड़ी उन पर कूदता है तो मर जाता है
ब्लॉक "स्थिर" हवा में स्थिर वस्तुओं के रूप में तय किए जाते हैं, खिलाड़ी उन पर कूद सकता है
सिक्के कुछ भी नहीं देते हैं, वे बस गायब हो जाते हैं जब वे एक खिलाड़ी से टकराते हैं

ओपन मेन.ह, जो वहां लिखा गया था उसे मिटा दें, और लिखें:

 #include "level.h" #include <Box2D\Box2D.h> #include <iostream> #include <random> Object player; b2Body* playerBody; std::vector<Object> coin; std::vector<b2Body*> coinBody; std::vector<Object> enemy; std::vector<b2Body*> enemyBody; 

यहाँ हमारे पास level.h और Box2D.h जुड़े हुए हैं। कंसोल के आउटपुट के लिए iostream की आवश्यकता होती है, यादृच्छिक - दुश्मन के आंदोलन की दिशा उत्पन्न करने के लिए।
अगले खिलाड़ी और वैक्टर हैं, प्रत्येक दुश्मन, सिक्का, खिलाड़ी अपनी वस्तु और b2Body (Box2D में शरीर) पर निर्भर करता है।

ध्यान दें - ब्लॉक ऐसा करने वाले नहीं हैं, क्योंकि वे केवल बॉक्स 2 डी भौतिकी स्तर पर खिलाड़ी के साथ बातचीत करते हैं, और खेल तर्क में नहीं।

अगला:

 int main() { srand(time(NULL)); Level lvl; lvl.LoadFromFile("platformer.tmx"); b2Vec2 gravity(0.0f, 1.0f); b2World world(gravity); sf::Vector2i tileSize = lvl.GetTileSize(); 

रैंडमाइजेशन के लिए srand (समय (NULL)) की आवश्यकता होती है।

हम नक्शा लोड करते हैं, बी 2 वर्ल्ड बनाते हैं, इसे गुरुत्वाकर्षण को स्थानांतरित करते हैं। वैसे, गुरुत्वाकर्षण आपको किसी भी दिशा से आ सकता है, और (0.10) से गुरुत्वाकर्षण (0.1) की तुलना में मजबूत कार्य करता है। फिर हम उन टाइलों का आकार लेते हैं जिनकी हमें आवश्यकता होती है

अगला, ब्लॉक बॉडी बनाएं:

  std::vector<Object> block = lvl.GetObjects("block"); for(int i = 0; i < block.size(); i++) { b2BodyDef bodyDef; bodyDef.type = b2_staticBody; bodyDef.position.Set(block[i].rect.left + tileSize.x / 2 * (block[i].rect.width / tileSize.x - 1), block[i].rect.top + tileSize.y / 2 * (block[i].rect.height / tileSize.y - 1)); b2Body* body = world.CreateBody(&bodyDef); b2PolygonShape shape; shape.SetAsBox(block[i].rect.width / 2, block[i].rect.height / 2); body->CreateFixture(&shape,1.0f); } 

 bodyDef.type = b2_staticBody; 

ब्लॉक स्थिर निकाय हैं, उनका कोई द्रव्यमान नहीं है और हवा में लटका हुआ है:

 bodyDef.position.Set(block[i].rect.left + tileSize.x / 2 * (block[i].rect.width / tileSize.x - 1), block[i].rect.top + tileSize.y / 2 * (block[i].rect.height / tileSize.y - 1)); 

यहां हमने ब्लॉकों की स्थिति निर्धारित की है। तथ्य यह है कि यदि आप केवल इंगित करते हैं कि स्थिति वस्तु के समान है, तो हम एक कपटी गलती का सामना करेंगे।

 b2Body* body = world.CreateBody(&bodyDef); 

दुनिया में ब्लॉक बॉडी बनाएं। इसके अलावा, हम शरीर के साथ काम नहीं करते हैं (इस अर्थ में, हम इसे कहीं भी संग्रहीत नहीं करते हैं):

 b2PolygonShape shape; shape.SetAsBox(block[i].rect.width / 2, block[i].rect.height / 2); 

प्रत्येक शरीर के कई आकार होते हैं - आंकड़े। मैं इस विषय का विस्तार से विश्लेषण नहीं करूंगा, क्योंकि ब्लॉक (और बाकी निकायों) के लिए केवल एक आयत पर्याप्त है।

 body->CreateFixture(&shape,1.0f); 

हम आकृति को शरीर से जोड़ते हैं।

फिर हम कुछ मतभेदों के साथ दुश्मनों, सिक्कों और खिलाड़ी के साथ भी ऐसा ही करते हैं:

  coin = lvl.GetObjects("coin"); for(int i = 0; i < coin.size(); i++) { b2BodyDef bodyDef; bodyDef.type = b2_dynamicBody; bodyDef.position.Set(coin[i].rect.left + tileSize.x / 2 * (coin[i].rect.width / tileSize.x - 1), coin[i].rect.top + tileSize.y / 2 * (coin[i].rect.height / tileSize.y - 1)); bodyDef.fixedRotation = true; b2Body* body = world.CreateBody(&bodyDef); b2PolygonShape shape; shape.SetAsBox(coin[i].rect.width / 2, coin[i].rect.height / 2); body->CreateFixture(&shape,1.0f); coinBody.push_back(body); } enemy = lvl.GetObjects("enemy"); for(int i = 0; i < enemy.size(); i++) { b2BodyDef bodyDef; bodyDef.type = b2_dynamicBody; bodyDef.position.Set(enemy[i].rect.left + tileSize.x / 2 * (enemy[i].rect.width / tileSize.x - 1), enemy[i].rect.top + tileSize.y / 2 * (enemy[i].rect.height / tileSize.y - 1)); bodyDef.fixedRotation = true; b2Body* body = world.CreateBody(&bodyDef); b2PolygonShape shape; shape.SetAsBox(enemy[i].rect.width / 2, enemy[i].rect.height / 2); body->CreateFixture(&shape,1.0f); enemyBody.push_back(body); } player = lvl.GetObject("player"); b2BodyDef bodyDef; bodyDef.type = b2_dynamicBody; bodyDef.position.Set(player.rect.left, player.rect.top); bodyDef.fixedRotation = true; playerBody = world.CreateBody(&bodyDef); b2PolygonShape shape; shape.SetAsBox(player.rect.width / 2, player.rect.height / 2); b2FixtureDef fixtureDef; fixtureDef.shape = &shape; fixtureDef.density = 1.0f; fixtureDef.friction = 0.3f; playerBody->CreateFixture(&fixtureDef); 

 bodyDef.fixedRotation = true; 

इसका मतलब है कि शरीर घूम नहीं सकता है।

सभी निकाय बनाए जाते हैं, यह शेड्यूल को इनिशियलाइज़ करने के लिए रहता है!

  sf::Vector2i screenSize(800, 600); sf::RenderWindow window; window.create(sf::VideoMode(screenSize.x, screenSize.y), "Game"); 

अच्छी तरह से समझा कोड निर्दिष्ट आकार और शीर्षक के साथ एक खिड़की बनाता है:

  sf::View view; view.reset(sf::FloatRect(0.0f, 0.0f, screenSize.x, screenSize.y)); view.setViewport(sf::FloatRect(0.0f, 0.0f, 2.0f, 2.0f)); 

यहां हम विंडो के लिए एक दृश्य बनाते हैं।

यह क्यों आवश्यक है? गेम को पिक्सेल शैली देने के लिए, हम sf :: व्यू का उपयोग करके स्क्रीन का आकार 2 गुणा करते हैं और सभी चित्र 2 गुना अधिक और व्यापक रूप से खींचे जाते हैं।

  while(window.isOpen()) { sf::Event evt; while(window.pollEvent(evt)) { switch(evt.type) { case sf::Event::Closed: window.close(); break; 

लाल X पर क्लिक करने से विंडो बंद हो जाती है। ऐसा कोड पहले था:

  case sf::Event::KeyPressed: if(evt.key.code == sf::Keyboard::W) playerBody->SetLinearVelocity(b2Vec2(0.0f, -15.0f)); if(evt.key.code == sf::Keyboard::D) playerBody->SetLinearVelocity(b2Vec2(5.0f, 0.0f)); if(evt.key.code == sf::Keyboard::A) playerBody->SetLinearVelocity(b2Vec2(-5.0f, 0.0f)); break; 

पहले से ही अधिक दिलचस्प है! हम WAD कुंजियों को दबाकर खिलाड़ी को गति प्रदान करते हैं:

 world.Step(1.0f / 60.0f, 1, 1); 

यहां हम Box2D की भौतिक दुनिया को अपडेट करते हैं। पहला तर्क दुनिया को अपडेट करने की आवृत्ति (प्रत्येक 1/60 सेकंड) लेता है, साथ ही साथ वेग की संख्या और स्थिति परिवर्तन भी होता है। पिछले दो तर्कों का मूल्य जितना अधिक होगा, उतना ही यथार्थवादी खेल का भौतिकी है। चूंकि हमारे पास कोई जटिल आकार नहीं है, जैसा कि एंग्रीबर्ड्स में है, लेकिन केवल आयतें हैं, हमें केवल एक बार की आवश्यकता है।

  for(b2ContactEdge* ce = playerBody->GetContactList(); ce; ce = ce->next) { b2Contact* c = ce->contact; 

यहां हम अन्य निकायों के साथ खिलाड़ी की टक्कर को संभालते हैं:

  for(int i = 0; i < coinBody.size(); i++) if(c->GetFixtureA() == coinBody[i]->GetFixtureList()) { coinBody[i]->DestroyFixture(coinBody[i]->GetFixtureList()); coin.erase(coin.begin() + i); coinBody.erase(coinBody.begin() + i); } 

सिक्का टकराव से निपटने।
यदि कोई सिक्का किसी खिलाड़ी से टकराता है, तो वह बस नष्ट हो जाता है और वैक्टर से मिट जाता है:

  for(int i = 0; i < enemyBody.size(); i++) if(c->GetFixtureA() == enemyBody[i]->GetFixtureList()) { if(playerBody->GetPosition().y < enemyBody[i]->GetPosition().y) { playerBody->SetLinearVelocity(b2Vec2(0.0f, -10.0f)); enemyBody[i]->DestroyFixture(enemyBody[i]->GetFixtureList()); enemy.erase(enemy.begin() + i); enemyBody.erase(enemyBody.begin() + i); } 

यदि दुश्मन किसी खिलाड़ी से टकराता है, तो यह जांचा जाता है कि दुश्मन खिलाड़ी अधिक है या नहीं। यदि खिलाड़ी दुश्मन से लंबा है, तो उसे मिटा दिया जाता है, और खिलाड़ी कूद जाता है।

यदि अन्यथा, खिलाड़ी दुश्मन को उछाल देता है:

  else { int tmp = (playerBody->GetPosition().x < enemyBody[i]->GetPosition().x) ? -1 : 1; playerBody->SetLinearVelocity(b2Vec2(10.0f * tmp, 0.0f)); } } } 

खिलाड़ी दुश्मन के सापेक्ष उसकी वर्तमान स्थिति के अनुसार दाएं या बाएं चलता है।

  for(int i = 0; i < enemyBody.size(); i++) { if(enemyBody[i]->GetLinearVelocity() == b2Vec2_zero) { int tmp = (rand() % 2 == 1) ? 1 : -1; enemyBody[i]->SetLinearVelocity(b2Vec2(5.0f * tmp, 0.0f)); } } 

यदि दुश्मन की गति 0 है, तो गति उसे फिर से दी जाती है - वह या तो दाईं ओर या बाईं ओर जाता है। नेत्रहीन, यह एक झटकेदार आंदोलन की तरह दिखता है।

  b2Vec2 pos = playerBody->GetPosition(); view.setCenter(pos.x + screenSize.x / 4, pos.y + screenSize.y / 4); window.setView(view); 

ग्राफिक्स के साथ काम करें। हम खिलाड़ी की स्थिति लेते हैं, दृश्य के केंद्र को बदलते हैं और अपने दृश्य का उपयोग करते हैं

  player.sprite.setPosition(pos.x, pos.y); for(int i = 0; i < coin.size(); i++) coin[i].sprite.setPosition(coinBody[i]->GetPosition().x, coinBody[i]->GetPosition().y); for(int i = 0; i < enemy.size(); i++) enemy[i].sprite.setPosition(enemyBody[i]->GetPosition().x, enemyBody[i]->GetPosition().y); 

B2Body से प्राप्त पदों के लिए खिलाड़ी के स्प्राइट्स, सिक्कों और दुश्मनों को सेट करें:

  window.clear(); lvl.Draw(window); window.draw(player.sprite); for(int i = 0; i < coin.size(); i++) window.draw(coin[i].sprite); for(int i = 0; i < enemy.size(); i++) window.draw(enemy[i].sprite); window.display(); 

हम खिड़कियां साफ करते हैं, नक्शा टाइलें खींचते हैं, फिर खिलाड़ी, सिक्के और दुश्मन, जिसके बाद हम खिड़की पेश करते हैं।

  } return 0; } 

हो गया!

नमूना नक्शा:

स्रोत कोड

https://github.com/Izaron/Platformer

धन्यवाद

इस विषय के लेखक को
SFML लेखकों के लिए
Box2D लेखक
लेखक TinyXml