SFML खेल को फिर से बनाना

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

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

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

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

खैर, अंतिम वर्ग जिसकी हमें आवश्यकता है - यह खिलाड़ी के साथ बातचीत के लिए जिम्मेदार वर्ग है - यह नियंत्रक है। यहां यह कहा जाना चाहिए कि MVC की शास्त्रीय विचारधारा में, नियंत्रक को सीधे प्रतिनिधित्व के साथ बातचीत नहीं करनी चाहिए। इसे केवल मॉडल पर कार्य करना चाहिए, और दृश्य मॉडल से डेटा को स्वयं या संदेश प्रणाली के संकेत द्वारा पढ़ता है। लेकिन यह दृष्टिकोण मुझे इस मामले में कुछ हद तक बेमानी लगा, इसलिए मैंने नियंत्रक को सीधे दृश्य के साथ जोड़ा। इसलिए यह मान लेना अधिक सही होगा कि हमारे पास एमवीपी की विचारधारा के अनुसार एक नियंत्रक नहीं है, लेकिन प्रस्तुतकर्ता है। वर्ग हालांकि, मैंने गेमकंट्रोलर को बुलाया।

खैर, अब इन कक्षाओं में अपना कोड बिखेरने की मजेदार बात पर आते हैं।

क्लास एसेट्स

#pragma once #include <SFML/Graphics.hpp> class Assets { public: sf::Font font; public: static Assets& Instance() { static Assets s; return s; } void Load(); private: Assets() {}; ~Assets() {}; Assets(Assets const&) = delete; Assets& operator= (Assets const&) = delete; }; 

मैंने कक्षा में जो कुछ भी जोड़ा है, उससे यह लोड किए गए फ़ॉन्ट को संग्रहीत करने के लिए फ़ॉन्ट वर्ग के एक सदस्य और इसे लोड करने के लिए लोड विधि की घोषणा है। बाकी सब कुछ एक सिंगलटन मायर्स कार्यान्वयन है।

लोड विधि भी बहुत सरल है:

 void Assets::Load() { if (!font.loadFromFile("calibri.ttf")) throw; } 

यदि यह विफल रहता है, तो कैलिब्री फॉन्ट को लोड करने का प्रयास करता है और एक अपवाद फेंकता है।

गेममॉडल क्लास

 #pragma once enum class Direction { Left = 0, Right = 1, Up = 2, Down = 3 }; class GameModel { public: static const int SIZE = 4; //      static const int ARRAY_SIZE = SIZE * SIZE; //   static const int FIELD_SIZE = 500; //      static const int CELL_SIZE = 120; //     protected: int elements[ARRAY_SIZE]; int empty_index; bool solved; public: GameModel(); void Init(); bool Check(); void Move(Direction direction); bool IsSolved() { return solved; } int* Elements() { return elements; } }; 

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

सिद्धांत में, मॉडल के सभी तरीकों को पिछले लेख में वर्णित किया गया था, इसलिए मैं यहां नहीं दोहराऊंगा। केवल एक चीज मैं कहूंगा कि प्रस्तुति वर्ग की जरूरतों के लिए मॉडल में IsSolved और Elements गेटर्स जोड़े गए थे।

गेमरेंडर क्लास

 #pragma once #include <SFML/Graphics.hpp> #include "GameModel.h" class GameRender : public sf::Drawable, public sf::Transformable { GameModel *m_game; sf::RenderWindow m_window; sf::Text m_text; public: GameRender(GameModel *game); ~GameRender(); sf::RenderWindow& window() { return m_window; }; bool Init(); void Render(); public: virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const; }; 

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

 GameRender::GameRender(GameModel *game) { m_game = game; Init(); } bool GameRender::Init() { setPosition(50.f, 50.f); //    600  600    60    m_window.create(sf::VideoMode(600, 600), "15"); m_window.setFramerateLimit(60); //     m_text = sf::Text("F2 - New Game / Esc - Exit / Arrow Keys - Move Tile", Assets::Instance().font, 20); m_text.setFillColor(sf::Color::Cyan); m_text.setPosition(5.f, 5.f); return true; } 

विंडो और खेल मैदान की स्थिति को खींचने के लिए गेम कंट्रोलर में मैसेज प्रोसेसिंग लूप से रेंडर () विधि को बुलाया जाएगा:

 void GameRender::Render() { m_window.clear(); m_window.draw(*this); m_window.draw(m_text); m_window.display(); } void GameRender::draw(sf::RenderTarget& target, sf::RenderStates states) const { states.transform *= getTransform(); sf::Color color = sf::Color(200, 100, 200); //     sf::RectangleShape shape(sf::Vector2f(GameModel::FIELD_SIZE, GameModel::FIELD_SIZE)); shape.setOutlineThickness(2.f); shape.setOutlineColor(color); shape.setFillColor(sf::Color::Transparent); target.draw(shape, states); //       shape.setSize(sf::Vector2f(GameModel::CELL_SIZE - 2, GameModel::CELL_SIZE - 2)); shape.setOutlineThickness(2.f); shape.setOutlineColor(color); shape.setFillColor(sf::Color::Transparent); //        sf::Text text("", Assets::Instance().font, 52); int *elements = m_game->Elements(); for (unsigned int i = 0; i < GameModel::ARRAY_SIZE; i++) { shape.setOutlineColor(color); text.setFillColor(color); text.setString(std::to_string(elements[i])); if (m_game->IsSolved()) { //      shape.setOutlineColor(sf::Color::Cyan); text.setFillColor(sf::Color::Cyan); } else if (elements[i] == i + 1) { //        text.setFillColor(sf::Color::Green); } //   ,   if (elements[i] > 0) { //      sf::Vector2f position(i % GameModel::SIZE * GameModel::CELL_SIZE + 10.f, i / GameModel::SIZE * GameModel::CELL_SIZE + 10.f); shape.setPosition(position); //     text.setPosition(position.x + 30.f + (elements[i] < 10 ? 15.f : 0.f), position.y + 25.f); target.draw(shape, states); target.draw(text, states); } } } 

गेमकंट्रोलर क्लास

खेल में इस्तेमाल किया जाने वाला अंतिम वर्ग नियंत्रक है।

 #pragma once #include <SFML/Graphics.hpp> #include "GameRender.h" class GameController { GameModel *m_game; GameRender *m_render; public: GameController(GameModel *game, GameRender *render); ~GameController(); void Run(); }; 

कक्षा काफी सरल है और इसमें केवल एक ही विधि है जो गेम लॉन्च करती है - रन () विधि। कंस्ट्रक्टर में, नियंत्रक मॉडल क्लास और गेम प्रेजेंटेशन क्लास के उदाहरणों के लिए पॉइंटर्स को स्वीकार करता है और स्टोर करता है।

रन () विधि में खेल का मुख्य चक्र होता है - संदेश को संसाधित करना और प्रस्तुति कक्षा में कॉलिंग विंडो।

 void GameController::Run() { sf::Event event; int move_counter = 0; //       while (m_render->window().isOpen()) { while (m_render->window().pollEvent(event)) { if (event.type == sf::Event::Closed) m_render->window().close(); if (event.type == sf::Event::KeyPressed) { //    -    if (event.key.code == sf::Keyboard::Escape) m_render->window().close(); if (event.key.code == sf::Keyboard::Left) m_game->Move(Direction::Left); if (event.key.code == sf::Keyboard::Right) m_game->Move(Direction::Right); if (event.key.code == sf::Keyboard::Up) m_game->Move(Direction::Up); if (event.key.code == sf::Keyboard::Down) m_game->Move(Direction::Down); //   if (event.key.code == sf::Keyboard::F2) { m_game->Init(); move_counter = 100; } } } //     ,    if (move_counter-- > 0) m_game->Move((Direction)(rand() % 4)); //      m_render->Render(); } } 

और अंत में, मुख्य () फ़ंक्शन रहता है

 #include "Assets.h" #include "GameModel.h" #include "GameRender.h" #include "GameController.h" int main() { Assets::Instance().Load(); //   GameModel game; //    GameRender render(&game); //   GameController controller(&game, &render); //   controller.Run(); //   return 0; } 

इसमें, सिर्फ ऑब्जेक्ट बनाना और गेम लॉन्च करना।

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

अंत में, मैं कोड अपघटन के लिए कुछ नियम बनाने की कोशिश करूँगा।

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

कार्यक्रम के सभी स्रोतों को यहां लिया जा सकता है ।