SBomber/include/Bomb.h

@@ -6,7 +6,7 @@ class Bomb : public DynamicObject
 {
 public:
 
-	static const uint16_t BombCost = 10;
+	static const uint16_t BombCost = 10; // ñòîèìîñòü áîìáû â î÷êàõ
 
 	void Draw() const override;
 
@@ -14,17 +14,3 @@ private:
 
 };
 
-class BombDecorator: public DynamicObject
-{
-public:
-    BombDecorator(DynamicObject *bomb) : m_bomb(bomb)
-    {
-    }
-    void Move(uint16_t time) override;
-    void Draw() const override;
-
-    void SetPos(double nx, double ny) override;
-    uint16_t GetWidth() const override;
-private:
-    DynamicObject *m_bomb;
-};

SBomber/include/GameObject.h

@@ -2,39 +2,23 @@
 
 #include <cstdint>
 
-class GameObject
+class GameObject {
-{
 public:
-    GameObject() : x(0.0), y(0.0), width(0)
+  GameObject() : x(0.0), y(0.0), width(0) {}
-    {
-    }
   virtual ~GameObject() = default;
 
   virtual void Draw() const = 0;
 
-    virtual inline void SetPos(double nx, double ny)
+  inline void SetPos(double nx, double ny) {
-    {
     x = nx;
     y = ny;
   }
 
-    virtual inline double GetY() const
+  inline double GetY() const { return y; }
-    {
+  inline double GetX() const { return x; }
-        return y;
-    }
-    virtual inline double GetX() const
-    {
-        return x;
-    }
 
-    virtual inline void SetWidth(uint16_t widthN)
+  inline void SetWidth(uint16_t widthN) { width = widthN; }
-    {
+  inline uint16_t GetWidth() const { return width; }
-        width = widthN;
-    }
-    virtual inline uint16_t GetWidth() const
-    {
-        return width;
-    }
 
 protected:
   double x, y;

SBomber/include/MyTools.h

@@ -3,75 +3,16 @@
 #include <string>
 #include <cstring>
 
-#include <iostream>
+namespace MyTools {
-#include <vector>
 
-namespace MyTools
+void OpenLogFile(const std::string& FN);
-{
 
-//    void OpenLogFile(const std::string &FN);
+void CloseLogFile();
-//    void CloseLogFile();
-//    void WriteToLog(const std::string &str);
-//    void WriteToLog(const std::string &str, int n);
-//    void WriteToLog(const std::string &str, double d);
 
-    class Logger
+void WriteToLog(const std::string& str);
-    {
-    public:
-        virtual void OpenLogFile(const std::string &FN) = 0;
-        virtual void CloseLogFile() = 0;
-        virtual void WriteToLog(const std::string &str) = 0;
-        virtual void WriteToLog(const std::string &str, int n) = 0;
-        virtual void WriteToLog(const std::string &str, double d) = 0;
-        virtual ~Logger() {}
-    };
 
-    class FileLoggerSingleton: public Logger
+void WriteToLog(const std::string& str, int n);
-    {
-    public:
-        static FileLoggerSingleton& getInstance()
-        {
-            static FileLoggerSingleton _instance;
-            return _instance;
-        }
 
-        void OpenLogFile(const std::string &FN) override;
+void WriteToLog(const std::string& str, double d);
-        void CloseLogFile() override;
-        void WriteToLog(const std::string &str) override;
-        void WriteToLog(const std::string &str, int n) override;
-        void WriteToLog(const std::string &str, double d) override;
-    private:
-        FileLoggerSingleton() {}
-        FileLoggerSingleton(const FileLoggerSingleton&) = delete;
-        FileLoggerSingleton& operator=(const FileLoggerSingleton&) = delete;
-        FileLoggerSingleton& operator=(FileLoggerSingleton&&) = delete;
-    };
 
-    class LoggerSingleton: public Logger
+}; // namespace MyTools
-    {
-    public:
-        static LoggerSingleton& getInstance()
-        {
-            static LoggerSingleton _instance;
-            return _instance;
-        }
-
-        void OpenLogFile(const std::string &FN) override;
-        void CloseLogFile() override;
-        void WriteToLog(const std::string &str) override;
-        void WriteToLog(const std::string &str, int n) override;
-        void WriteToLog(const std::string &str, double d) override;
-        ~LoggerSingleton();
-
-    private:
-        LoggerSingleton() {}
-        LoggerSingleton(const LoggerSingleton&) = delete;
-        LoggerSingleton& operator=(const LoggerSingleton&) = delete;
-        LoggerSingleton& operator=(LoggerSingleton&&) = delete;
-        FileLoggerSingleton& LoadLoggerSingletone();
-
-        FileLoggerSingleton *_logger = NULL;
-        std::vector<double> times;
-    };
-
-} // namespace MyTools

SBomber/include/SBomber.h

@@ -11,13 +11,11 @@
 class SBomber
 {
 public:
+
     SBomber();
     ~SBomber();
     
-    inline bool GetExitFlag() const
+    inline bool GetExitFlag() const { return exitFlag; }
-    {
-        return exitFlag;
-    }
 
     void ProcessKBHit();
     void TimeStart();
@@ -27,23 +25,22 @@ public:
     void MoveObjects();
     void CheckObjects();
 
-    void run();
-
 private:
+
     void CheckPlaneAndLevelGUI();
     void CheckBombsAndGround();
-    void CheckDestoyableObjects(Bomb *pBomb);
+    void  CheckDestoyableObjects(Bomb* pBomb);
 
-//    void DeleteDynamicObj(DynamicObject *pBomb);
+    void  DeleteDynamicObj(DynamicObject * pBomb);
-//    void DeleteStaticObj(GameObject *pObj);
+    void  DeleteStaticObj(GameObject* pObj);
 
-    Ground* FindGround() const;
+    Ground * FindGround() const;
-    Plane* FindPlane() const;
+    Plane * FindPlane() const;
-    LevelGUI* FindLevelGUI() const;
+    LevelGUI * FindLevelGUI() const;
     std::vector<DestroyableGroundObject*> FindDestoyableGroundObjects() const;
     std::vector<Bomb*> FindAllBombs() const;
 
-//    void DropBomb();
+    void DropBomb();
 
     std::vector<DynamicObject*> vecDynamicObj;
     std::vector<GameObject*> vecStaticObj;

SBomber/include/Timer.h

@@ -1,46 +0,0 @@
-/*
- * Timer.h
- *
- *  Created on: 21 дек. 2021 г.
- *      Author: alexander
- */
-
-#pragma once
-
-#include <chrono>
-
-class Timer
-{
-public:
-    static Timer& getInstance()
-    {
-        static Timer _instance;
-        return _instance;
-    }
-
-    void start()
-    {
-        m_beg = clock_t::now();
-    }
-
-    double end() const
-    {
-        return elapsed() * 1000;
-    }
-
-private:
-    using clock_t = std::chrono::high_resolution_clock;
-    using second_t = std::chrono::duration<double, std::ratio<1> >;
-
-    std::chrono::time_point<clock_t> m_beg;
-
-    double elapsed() const
-    {
-        return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
-    }
-
-    Timer() {}
-    Timer(const Timer&) = delete;
-    Timer& operator=(const Timer&) = delete;
-    Timer& operator=(Timer&&) = delete;
-};

SBomber/main.cpp

@@ -2,14 +2,60 @@
 #include "MyTools.h"
 #include "ScreenSingleton.h"
 
+#include <iostream>
+#include <fstream>
+#include <unistd.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+
+int _kbhit()
+{
+    static const int STDIN = 0;
+    static bool initialized = false;
+
+    if (!initialized)
+    {
+        // Use termios to turn off line buffering
+        termios term;
+        tcgetattr(STDIN, &term);
+        term.c_lflag &= ~ICANON;
+        tcsetattr(STDIN, TCSANOW, &term);
+        setbuf(stdin, NULL);
+        initialized = true;
+    }
+
+    int bytesWaiting;
+    ioctl(STDIN, FIONREAD, &bytesWaiting);
+    return bytesWaiting;
+}
+
 int main(void)
 {
-    MyTools::LoggerSingleton::getInstance().OpenLogFile("log.txt");
+    MyTools::OpenLogFile("log.txt");
 
     SBomber game;
-    game.run();
 
-    MyTools::LoggerSingleton::getInstance().CloseLogFile();
+    do
+    {
+        game.TimeStart();
+
+        if (_kbhit())
+        {
+            game.ProcessKBHit();
+        }
+
+        ScreenSingleton::getInstance().ClrScr();
+
+        game.DrawFrame();
+        game.MoveObjects();
+        game.CheckObjects();
+
+        game.TimeFinish();
+
+    } while (!game.GetExitFlag());
+
+    MyTools::CloseLogFile();
 
     return 0;
 }

SBomber/src/Bomb.cpp

@@ -7,26 +7,3 @@ void Bomb::Draw() const {
   ScreenSingleton::getInstance().GotoXY(x, y);
   std::cout << "*";
 }
-
-void BombDecorator::Move(uint16_t time)
-{
-    m_bomb->Move(time * 1.6);
-}
-
-void BombDecorator::Draw() const
-{
-    m_bomb->Draw();
-    // Некоторое изменение внешнего вида бомбы
-    ScreenSingleton::getInstance().GotoXY(m_bomb->GetX(), m_bomb->GetY() - 1);
-    std::cout << "|";
-}
-
-void BombDecorator::SetPos(double nx, double ny)
-{
-    m_bomb->SetPos(nx, ny);
-}
-
-uint16_t BombDecorator::GetWidth() const
-{
-    return m_bomb->GetWidth();
-}

SBomber/src/MyTools.cpp

@@ -9,110 +9,42 @@
 #include <time.h>
 #include <stdio.h>
 
-#include <numeric>
-#include "Timer.h"
 
-namespace MyTools
+namespace MyTools {
-{
 
-    std::ofstream logOut;
+std::ofstream logOut;
 
-    void FileLoggerSingleton::OpenLogFile(const std::string &FN)
+void OpenLogFile(const std::string &FN) { logOut.open(FN, std::ios_base::out); }
-    {
-        logOut.open(FN, std::ios_base::out);
-    }
 
-    void FileLoggerSingleton::CloseLogFile()
+void CloseLogFile() {
-    {
+  if (logOut.is_open()) {
-        if (logOut.is_open())
-        {
     logOut.close();
   }
-    }
+}
 
-    std::string GetCurDateTime()
+std::string GetCurDateTime() {
-    {
   auto cur = std::chrono::system_clock::now();
   time_t time = std::chrono::system_clock::to_time_t(cur);
-        char *buf = ctime(&time);
+  char* buf = ctime(&time);
   return std::string(buf);
-    }
+}
 
-    void FileLoggerSingleton::WriteToLog(const std::string &str)
+void WriteToLog(const std::string &str) {
-    {
+  if (logOut.is_open()) {
-        if (logOut.is_open())
-        {
     logOut << GetCurDateTime() << " - " << str << std::endl;
   }
-    }
+}
 
-    void FileLoggerSingleton::WriteToLog(const std::string &str, int n)
+void WriteToLog(const std::string &str, int n) {
-    {
+  if (logOut.is_open()) {
-        if (logOut.is_open())
-        {
     logOut << GetCurDateTime() << " - " << str << n << std::endl;
   }
-    }
+}
 
-    void FileLoggerSingleton::WriteToLog(const std::string &str, double d)
+void WriteToLog(const std::string &str, double d) {
-    {
+  if (logOut.is_open()) {
-        if (logOut.is_open())
-        {
     logOut << GetCurDateTime() << " - " << str << d << std::endl;
   }
-    }
+}
-
-    void LoggerSingleton::OpenLogFile(const std::string &FN)
-    {
-        Timer::getInstance().start();
-        LoadLoggerSingletone().OpenLogFile(FN);
-        times.push_back(Timer::getInstance().end());
-    }
-
-    void LoggerSingleton::CloseLogFile()
-    {
-        Timer::getInstance().start();
-        LoadLoggerSingletone().CloseLogFile();
-        times.push_back(Timer::getInstance().end());
-    }
-
-    void LoggerSingleton::WriteToLog(const std::string &str)
-    {
-        Timer::getInstance().start();
-        LoadLoggerSingletone().WriteToLog(str);
-        times.push_back(Timer::getInstance().end());
-    }
-
-    void LoggerSingleton::WriteToLog(const std::string &str, int n)
-    {
-        Timer::getInstance().start();
-        LoadLoggerSingletone().WriteToLog(str, n);
-        times.push_back(Timer::getInstance().end());
-    }
-
-    void LoggerSingleton::WriteToLog(const std::string &str, double d)
-    {
-        Timer::getInstance().start();
-        LoadLoggerSingletone().WriteToLog(str, d);
-        times.push_back(Timer::getInstance().end());
-    }
-
-    LoggerSingleton::~LoggerSingleton()
-    {
-        if (times.size())
-        {
-            std::cout << "Среднее время выполнения операций: " << std::accumulate(times.begin(), times.end(), 0.0) / times.size() << " секунд" << std::endl;
-        }
-    }
-
-    FileLoggerSingleton& LoggerSingleton::LoadLoggerSingletone()
-    {
-        if (!_logger)
-        {
-            _logger = &FileLoggerSingleton::getInstance();
-        }
-
-        return *_logger;
-    }
 
 } // namespace MyTools

SBomber/src/SBomber.cpp

@@ -1,3 +1,4 @@
+
 #include "MyTools.h"
 #include "SBomber.h"
 #include "Bomb.h"
@@ -9,61 +10,18 @@
 #include <chrono>
 #include <thread>
 
-#include <iostream>
+SBomber::SBomber()
-#include <fstream>
+  : exitFlag(false), startTime(0), finishTime(0), deltaTime(0), passedTime(0),
-#include <unistd.h>
+    fps(0), bombsNumber(10), score(0) {
-#include <fcntl.h>
+  MyTools::WriteToLog(std::string(__func__) + " was invoked");
-#include <termios.h>
-#include <sys/ioctl.h>
 
-int _kbhit()
+  Plane* p = new Plane;
-{
-    static const int STDIN = 0;
-    static bool initialized = false;
-
-    if (!initialized)
-    {
-        // Use termios to turn off line buffering
-        termios term;
-        tcgetattr(STDIN, &term);
-        term.c_lflag &= ~ICANON;
-        tcsetattr(STDIN, TCSANOW, &term);
-        setbuf(stdin, NULL);
-        initialized = true;
-    }
-
-    int bytesWaiting;
-    ioctl(STDIN, FIONREAD, &bytesWaiting);
-    return bytesWaiting;
-}
-
-class IFactory
-{
-public:
-    virtual ~IFactory() {}
-
-    DynamicObject* createPlane() const
-    {
-        Plane *p = createPlaneInstance();
   p->SetDirection(1, 0.1);
   p->SetSpeed(4);
   p->SetPos(5, 10);
-        return p;
+  vecDynamicObj.push_back(p);
-    }
 
-    DynamicObject* createBomb(const double x, const double y) const
+  LevelGUI* pGUI = new LevelGUI;
-    {
-        Bomb *pBomb = createBombInstance();
-        pBomb->SetDirection(0.3, 1);
-        pBomb->SetSpeed(2);
-        pBomb->SetPos(x, y);
-        pBomb->SetWidth(SMALL_CRATER_SIZE);
-        return pBomb;
-    }
-
-    GameObject* createUI(const uint64_t passedTime, const uint64_t fps, const uint16_t bombsNumber, const int16_t score) const
-    {
-        LevelGUI *pGUI = createUIInstance();
   pGUI->SetParam(passedTime, fps, bombsNumber, score);
   const uint16_t maxX = ScreenSingleton::getInstance().GetMaxX();
   const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
@@ -73,310 +31,137 @@ public:
   pGUI->SetWidth(width);
   pGUI->SetHeight(maxY - 4);
   pGUI->SetFinishX(offset + width - 4);
-        return pGUI;
+  vecStaticObj.push_back(pGUI);
-    }
 
-    virtual GameObject* createHouse(double posX) const
+  Ground* pGr = new Ground;
-    {
-        const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
-        const uint16_t groundY = maxY - 5;
-        House *pHouse = createHouseInstance();
-        pHouse->SetWidth(13);
-        pHouse->SetPos(posX, groundY - 1);
-        return pHouse;
-    }
-
-    virtual GameObject* createGround() const
-    {
-        const uint16_t maxX = ScreenSingleton::getInstance().GetMaxX();
-        const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
-        const uint16_t offset = 3;
-        const uint16_t width = maxX - 7;
-        Ground *pGr = createGroundInstance();
   const uint16_t groundY = maxY - 5;
   pGr->SetPos(offset + 1, groundY);
   pGr->SetWidth(width - 2);
-        return pGr;
+  vecStaticObj.push_back(pGr);
-    }
 
-    virtual GameObject* createTank(double posX) const
+  Tank* pTank = new Tank;
-    {
-        const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
-        const uint16_t groundY = maxY - 5;
-        Tank *pTank = createTankInstance();
   pTank->SetWidth(13);
-        pTank->SetPos(posX, groundY - 1);
+  pTank->SetPos(30, groundY - 1);
-        return pTank;
+  vecStaticObj.push_back(pTank);
-    }
-private:
-    virtual Plane* createPlaneInstance() const = 0;
-    virtual Bomb* createBombInstance() const = 0;
-    virtual LevelGUI* createUIInstance() const = 0;
-    virtual Ground* createGroundInstance() const = 0;
-    virtual Tank* createTankInstance() const = 0;
-    virtual House* createHouseInstance() const = 0;
-};
 
-class RegularFactory : public IFactory
+  pTank = new Tank;
-{
+  pTank->SetWidth(13);
-    Plane* createPlaneInstance() const override
+  pTank->SetPos(50, groundY - 1);
-    {
+  vecStaticObj.push_back(pTank);
-        return new Plane;
-    }
 
-    Bomb* createBombInstance() const override
+  House* pHouse = new House;
-    {
+  pHouse->SetWidth(13);
-        return new Bomb;
+  pHouse->SetPos(80, groundY - 1);
-    }
+  vecStaticObj.push_back(pHouse);
 
-    LevelGUI* createUIInstance() const override
+  /*
-    {
+  Bomb* pBomb = new Bomb;
-        return new LevelGUI;
+  pBomb->SetDirection(0.3, 1);
-    }
+  pBomb->SetSpeed(2);
-    Ground* createGroundInstance() const override
+  pBomb->SetPos(51, 5);
-    {
+  pBomb->SetSize(SMALL_CRATER_SIZE);
-        return new Ground;
+  vecDynamicObj.push_back(pBomb);
-    }
+  */
-
-    Tank* createTankInstance() const override
-    {
-        return new Tank;
-    }
-
-    House* createHouseInstance() const override
-    {
-        return new House;
-    }
-};
-
-class Command
-{
-public:
-    virtual ~Command() {}
-    virtual void Execute() = 0;
-};
-
-template <class Object>
-class DeleteCommand : public Command
-{
-public:
-    DeleteCommand(std::vector<Object*>& vecObj) : m_vecObj(vecObj), m_pObj(nullptr) {}
-    void setObj(Object *pObj)
-    {
-        m_pObj = pObj;
-    }
-    void Execute()
-    {
-        if (!m_pObj)
-        {
-            return;
-        }
-
-        auto it = m_vecObj.begin();
-        for (; it != m_vecObj.end(); it++)
-        {
-            if (*it == m_pObj)
-            {
-                m_vecObj.erase(it);
-                break;
-            }
-        }
-    }
-private:
-    std::vector<Object*>& m_vecObj;
-    Object *m_pObj;
-};
-
-class DropCommand : public Command
-{
-public:
-    DropCommand(std::vector<DynamicObject*>& vecDynamicObj) : m_vecDynamicObj(vecDynamicObj), m_pPlane(nullptr), m_bombsNumber(nullptr), m_score(nullptr) {}
-    void setParams(Plane *pPlane, uint16_t *bombsNumber, int16_t *score)
-    {
-        m_pPlane = pPlane;
-        m_bombsNumber = bombsNumber;
-        m_score = score;
-    }
-    void Execute()
-    {
-        if (*m_bombsNumber > 0)
-        {
-            MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
-
-            double x = m_pPlane->GetX() + 4;
-            double y = m_pPlane->GetY() + 2;
-
-            auto pFactory = new RegularFactory;
-            m_vecDynamicObj.push_back(pFactory->createBomb(x, y));
-            delete pFactory;
-
-            (*m_bombsNumber)--;
-            *m_score -= Bomb::BombCost;
-        }
-    }
-private:
-    std::vector<DynamicObject*>& m_vecDynamicObj;
-    Plane *m_pPlane;
-    uint16_t *m_bombsNumber;
-    int16_t *m_score;
-};
-
-class DropBigCommand : public Command
-{
-public:
-    DropBigCommand(std::vector<DynamicObject*>& vecDynamicObj) : m_vecDynamicObj(vecDynamicObj), m_pPlane(nullptr), m_bombsNumber(nullptr), m_score(nullptr) {}
-    void setParams(Plane *pPlane, uint16_t *bombsNumber, int16_t *score)
-    {
-        m_pPlane = pPlane;
-        m_bombsNumber = bombsNumber;
-        m_score = score;
-    }
-    void Execute()
-    {
-        if (*m_bombsNumber > 0)
-        {
-            MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
-
-            double x = m_pPlane->GetX() + 4;
-            double y = m_pPlane->GetY() + 2;
-
-            auto pFactory = new RegularFactory;
-            m_vecDynamicObj.push_back(new BombDecorator(pFactory->createBomb(x, y)));
-            delete pFactory;
-
-            (*m_bombsNumber)--;
-            *m_score -= Bomb::BombCost;
-        }
-    }
-private:
-    std::vector<DynamicObject*>& m_vecDynamicObj;
-    Plane *m_pPlane;
-    uint16_t *m_bombsNumber;
-    int16_t *m_score;
-};
-
-SBomber::SBomber() : exitFlag(false), startTime(0), finishTime(0), deltaTime(0), passedTime(0), fps(0), bombsNumber(10), score(0)
-{
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
-
-    auto pFactory = new RegularFactory;
-
-    vecDynamicObj.push_back(pFactory->createPlane());
-    vecStaticObj.push_back(pFactory->createUI(passedTime, fps, bombsNumber, score));
-    vecStaticObj.push_back(pFactory->createGround());
-    vecStaticObj.push_back(pFactory->createTank(30));
-    vecStaticObj.push_back(pFactory->createTank(50));
-    vecStaticObj.push_back(pFactory->createHouse(80));
-
-    delete pFactory;
 }
 
-SBomber::~SBomber()
+SBomber::~SBomber() {
-{
+  for (size_t i = 0; i < vecDynamicObj.size(); i++) {
-    for (size_t i = 0; i < vecDynamicObj.size(); i++)
+    if (vecDynamicObj[i] != nullptr) {
-    {
-        if (vecDynamicObj[i] != nullptr)
-        {
       delete vecDynamicObj[i];
     }
   }
 
-    for (size_t i = 0; i < vecStaticObj.size(); i++)
+  for (size_t i = 0; i < vecStaticObj.size(); i++) {
-    {
+    if (vecStaticObj[i] != nullptr) {
-        if (vecStaticObj[i] != nullptr)
-        {
       delete vecStaticObj[i];
     }
   }
 }
 
-void SBomber::MoveObjects()
+void SBomber::MoveObjects() {
-{
+  MyTools::WriteToLog(std::string(__func__) + " was invoked");
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
 
-    for (size_t i = 0; i < vecDynamicObj.size(); i++)
+  for (size_t i = 0; i < vecDynamicObj.size(); i++) {
-    {
+    if (vecDynamicObj[i] != nullptr) {
-        if (vecDynamicObj[i] != nullptr)
-        {
       vecDynamicObj[i]->Move(deltaTime);
     }
   }
-}
+};
-;
 
-void SBomber::CheckObjects()
+void SBomber::CheckObjects() {
-{
+  MyTools::WriteToLog(std::string(__func__) + " was invoked");
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
 
   CheckPlaneAndLevelGUI();
   CheckBombsAndGround();
-}
+};
-;
 
-void SBomber::CheckPlaneAndLevelGUI()
+void SBomber::CheckPlaneAndLevelGUI() {
-{
+  if (FindPlane()->GetX() > FindLevelGUI()->GetFinishX()) {
-    if (FindPlane()->GetX() > FindLevelGUI()->GetFinishX())
-    {
     exitFlag = true;
   }
 }
 
-void SBomber::CheckBombsAndGround()
+void SBomber::CheckBombsAndGround() {
-{
   std::vector<Bomb*> vecBombs = FindAllBombs();
-    Ground *pGround = FindGround();
+  Ground* pGround = FindGround();
   const double y = pGround->GetY();
-    for (size_t i = 0; i < vecBombs.size(); i++)
+  for (size_t i = 0; i < vecBombs.size(); i++) {
-    {
+    if (vecBombs[i]->GetY() >= y) {
-        if (vecBombs[i]->GetY() >= y)
-        {
       pGround->AddCrater(vecBombs[i]->GetX());
       CheckDestoyableObjects(vecBombs[i]);
-
+      DeleteDynamicObj(vecBombs[i]);
-            DeleteCommand<DynamicObject> delCom(SBomber::vecDynamicObj);
-            delCom.setObj(vecBombs[i]);
-            delCom.Execute();
     }
   }
 }
 
-void SBomber::CheckDestoyableObjects(Bomb *pBomb)
+void SBomber::CheckDestoyableObjects(Bomb* pBomb) {
-{
+  std::vector<DestroyableGroundObject*> vecDestoyableObjects =
-    std::vector<DestroyableGroundObject*> vecDestoyableObjects = FindDestoyableGroundObjects();
+      FindDestoyableGroundObjects();
   const double size = pBomb->GetWidth();
   const double size_2 = size / 2;
-    for (size_t i = 0; i < vecDestoyableObjects.size(); i++)
+  for (size_t i = 0; i < vecDestoyableObjects.size(); i++) {
-    {
     const double x1 = pBomb->GetX() - size_2;
     const double x2 = x1 + size;
-        if (vecDestoyableObjects[i]->isInside(x1, x2))
+    if (vecDestoyableObjects[i]->isInside(x1, x2)) {
-        {
       score += vecDestoyableObjects[i]->GetScore();
-
+      DeleteStaticObj(vecDestoyableObjects[i]);
-            DeleteCommand<GameObject> delCom(SBomber::vecStaticObj);
-            delCom.setObj(vecDestoyableObjects[i]);
-            delCom.Execute();
     }
   }
 }
 
-std::vector<DestroyableGroundObject*> SBomber::FindDestoyableGroundObjects() const
+void SBomber::DeleteDynamicObj(DynamicObject* pObj) {
-{
+  auto it = vecDynamicObj.begin();
+  for (; it != vecDynamicObj.end(); it++) {
+    if (*it == pObj) {
+      vecDynamicObj.erase(it);
+      break;
+    }
+  }
+}
+
+void SBomber::DeleteStaticObj(GameObject* pObj) {
+  auto it = vecStaticObj.begin();
+  for (; it != vecStaticObj.end(); it++) {
+    if (*it == pObj) {
+      vecStaticObj.erase(it);
+      break;
+    }
+  }
+}
+
+std::vector<DestroyableGroundObject*> SBomber::FindDestoyableGroundObjects() const {
   std::vector<DestroyableGroundObject*> vec;
-    Tank *pTank;
+  Tank* pTank;
-    House *pHouse;
+  House* pHouse;
-    for (size_t i = 0; i < vecStaticObj.size(); i++)
+  for (size_t i = 0; i < vecStaticObj.size(); i++) {
-    {
     pTank = dynamic_cast<Tank*>(vecStaticObj[i]);
-        if (pTank != nullptr)
+    if (pTank != nullptr) {
-        {
       vec.push_back(pTank);
       continue;
     }
 
     pHouse = dynamic_cast<House*>(vecStaticObj[i]);
-        if (pHouse != nullptr)
+    if (pHouse != nullptr) {
-        {
       vec.push_back(pHouse);
       continue;
     }
@@ -385,15 +170,12 @@ std::vector<DestroyableGroundObject*> SBomber::FindDestoyableGroundObjects() con
   return vec;
 }
 
-Ground* SBomber::FindGround() const
+Ground* SBomber::FindGround() const {
-{
+  Ground* pGround;
-    Ground *pGround;
 
-    for (size_t i = 0; i < vecStaticObj.size(); i++)
+  for (size_t i = 0; i < vecStaticObj.size(); i++) {
-    {
     pGround = dynamic_cast<Ground*>(vecStaticObj[i]);
-        if (pGround != nullptr)
+    if (pGround != nullptr) {
-        {
       return pGround;
     }
   }
@@ -401,15 +183,12 @@ Ground* SBomber::FindGround() const
   return nullptr;
 }
 
-std::vector<Bomb*> SBomber::FindAllBombs() const
+std::vector<Bomb*> SBomber::FindAllBombs() const {
-{
   std::vector<Bomb*> vecBombs;
 
-    for (size_t i = 0; i < vecDynamicObj.size(); i++)
+  for (size_t i = 0; i < vecDynamicObj.size(); i++) {
-    {
+    Bomb* pBomb = dynamic_cast<Bomb*>(vecDynamicObj[i]);
-        Bomb *pBomb = dynamic_cast<Bomb*>(vecDynamicObj[i]);
+    if (pBomb != nullptr) {
-        if (pBomb != nullptr)
-        {
       vecBombs.push_back(pBomb);
     }
   }
@@ -417,13 +196,10 @@ std::vector<Bomb*> SBomber::FindAllBombs() const
   return vecBombs;
 }
 
-Plane* SBomber::FindPlane() const
+Plane* SBomber::FindPlane() const {
-{
+  for (size_t i = 0; i < vecDynamicObj.size(); i++) {
-    for (size_t i = 0; i < vecDynamicObj.size(); i++)
+    Plane* p = dynamic_cast<Plane*>(vecDynamicObj[i]);
-    {
+    if (p != nullptr) {
-        Plane *p = dynamic_cast<Plane*>(vecDynamicObj[i]);
-        if (p != nullptr)
-        {
       return p;
     }
   }
@@ -431,13 +207,10 @@ Plane* SBomber::FindPlane() const
   return nullptr;
 }
 
-LevelGUI* SBomber::FindLevelGUI() const
+LevelGUI* SBomber::FindLevelGUI() const {
-{
+  for (size_t i = 0; i < vecStaticObj.size(); i++) {
-    for (size_t i = 0; i < vecStaticObj.size(); i++)
+    LevelGUI* p = dynamic_cast<LevelGUI*>(vecStaticObj[i]);
-    {
+    if (p != nullptr) {
-        LevelGUI *p = dynamic_cast<LevelGUI*>(vecStaticObj[i]);
-        if (p != nullptr)
-        {
       return p;
     }
   }
@@ -445,63 +218,53 @@ LevelGUI* SBomber::FindLevelGUI() const
   return nullptr;
 }
 
-void SBomber::ProcessKBHit()
+void SBomber::ProcessKBHit() {
-{
   int c = getchar();
 
-    if (c == 224)
+  if (c == 224) {
-    {
     c = getchar();
   }
 
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked. key = ", c);
+  MyTools::WriteToLog(std::string(__func__) + " was invoked. key = ", c);
+
+  switch (c) {
 
-    switch (c)
-    {
     case 27: // esc
       exitFlag = true;
       break;
+
     case 72: // up
       FindPlane()->ChangePlaneY(-0.25);
       break;
+
     case 80: // down
       FindPlane()->ChangePlaneY(0.25);
       break;
+
     case 'b':
-        {
+      DropBomb();
-            DropCommand dropCom(SBomber::vecDynamicObj);
-            dropCom.setParams(FindPlane(), &bombsNumber, &score);
-            dropCom.Execute();
       break;
-        }
+
     case 'B':
-        {
+      DropBomb();
-            DropBigCommand dropCom(SBomber::vecDynamicObj);
-            dropCom.setParams(FindPlane(), &bombsNumber, &score);
-            dropCom.Execute();
       break;
-        }
+
     default:
       break;
   }
 }
 
-void SBomber::DrawFrame()
+void SBomber::DrawFrame() {
-{
+  MyTools::WriteToLog(std::string(__func__) + " was invoked");
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
 
-    for (size_t i = 0; i < vecDynamicObj.size(); i++)
+  for (size_t i = 0; i < vecDynamicObj.size(); i++) {
-    {
+    if (vecDynamicObj[i] != nullptr) {
-        if (vecDynamicObj[i] != nullptr)
-        {
       vecDynamicObj[i]->Draw();
     }
   }
 
-    for (size_t i = 0; i < vecStaticObj.size(); i++)
+  for (size_t i = 0; i < vecStaticObj.size(); i++) {
-    {
+    if (vecStaticObj[i] != nullptr) {
-        if (vecStaticObj[i] != nullptr)
-        {
       vecStaticObj[i]->Draw();
     }
   }
@@ -512,39 +275,37 @@ void SBomber::DrawFrame()
   FindLevelGUI()->SetParam(passedTime, fps, bombsNumber, score);
 }
 
-void SBomber::TimeStart()
+void SBomber::TimeStart() {
-{
+  MyTools::WriteToLog(std::string(__func__) + " was invoked");
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
+  startTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-    startTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+      std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 }
 
-void SBomber::TimeFinish()
+void SBomber::TimeFinish() {
-{
+  finishTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-    finishTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+      std::chrono::high_resolution_clock::now().time_since_epoch()).count();
   deltaTime = uint16_t(finishTime - startTime);
   passedTime += deltaTime;
 
-    MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " deltaTime = ", (int) deltaTime);
+  MyTools::WriteToLog(std::string(__func__) + " deltaTime = ", (int)deltaTime);
 }
 
-void SBomber::run()
+void SBomber::DropBomb() {
-{
+  if (bombsNumber > 0) {
-    do
+    MyTools::WriteToLog(std::string(__func__) + " was invoked");
-    {
-        TimeStart();
 
-        if (_kbhit())
+    Plane* pPlane = FindPlane();
-        {
+    double x = pPlane->GetX() + 4;
-            ProcessKBHit();
+    double y = pPlane->GetY() + 2;
+
+    Bomb* pBomb = new Bomb;
+    pBomb->SetDirection(0.3, 1);
+    pBomb->SetSpeed(2);
+    pBomb->SetPos(x, y);
+    pBomb->SetWidth(SMALL_CRATER_SIZE);
+
+    vecDynamicObj.push_back(pBomb);
+    bombsNumber--;
+    score -= Bomb::BombCost;
   }
-
-        ScreenSingleton::getInstance().ClrScr();
-
-        DrawFrame();
-        MoveObjects();
-        CheckObjects();
-
-        TimeFinish();
-
-    } while (!GetExitFlag());
 }

SBomber/src/ScreenSingleton.cpp

@@ -33,15 +33,15 @@ IScreen& getInternalInstance() {
 class ScreenSingletonProxy : public IScreen {
 public:
   virtual void ClrScr() override {
-    MyTools::LoggerSingleton::getInstance().WriteToLog("ClrScr invoke begin");
+    MyTools::WriteToLog("ClrScr invoke begin");
     getInternalInstance().ClrScr();
-    MyTools::LoggerSingleton::getInstance().WriteToLog("ClrScr invoke end");
+    MyTools::WriteToLog("ClrScr invoke end");
   }
   virtual void GotoXY(double x, double y) override {
 
-    MyTools::LoggerSingleton::getInstance().WriteToLog("GotoXY invoke begin");
+    MyTools::WriteToLog("GotoXY invoke begin");
     getInternalInstance().GotoXY(x, y);
-    MyTools::LoggerSingleton::getInstance().WriteToLog("GotoXY invoke end");
+    MyTools::WriteToLog("GotoXY invoke end");
   }
   virtual uint16_t GetMaxX() override {
     return getInternalInstance().GetMaxX();