Compare commits

..

No commits in common. "lesson_2" and "master" have entirely different histories.

12 changed files with 320394 additions and 1818 deletions

View File

@ -6,7 +6,7 @@ class Bomb : public DynamicObject
{ {
public: public:
static const uint16_t BombCost = 10; static const uint16_t BombCost = 10; // ñòîèìîñòü áîìáû â î÷êàõ
void Draw() const override; 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;
};

View File

@ -2,41 +2,25 @@
#include <cstdint> #include <cstdint>
class GameObject class GameObject {
{
public: public:
GameObject() : x(0.0), y(0.0), width(0) GameObject() : x(0.0), y(0.0), width(0) {}
{ virtual ~GameObject() = default;
}
virtual ~GameObject() = default;
virtual void Draw() const = 0; virtual void Draw() const = 0;
virtual inline void SetPos(double nx, double ny) inline void SetPos(double nx, double ny) {
{ x = nx;
x = nx; y = ny;
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: protected:
double x, y; double x, y;
uint16_t width; uint16_t width;
}; };

View File

@ -3,75 +3,16 @@
#include <string> #include <string>
#include <cstring> #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

View File

@ -11,13 +11,11 @@
class SBomber class SBomber
{ {
public: public:
SBomber(); SBomber();
~SBomber(); ~SBomber();
inline bool GetExitFlag() const inline bool GetExitFlag() const { return exitFlag; }
{
return exitFlag;
}
void ProcessKBHit(); void ProcessKBHit();
void TimeStart(); void TimeStart();
@ -27,30 +25,29 @@ public:
void MoveObjects(); void MoveObjects();
void CheckObjects(); void CheckObjects();
void run();
private: private:
void CheckPlaneAndLevelGUI(); void CheckPlaneAndLevelGUI();
void CheckBombsAndGround(); 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<DestroyableGroundObject*> FindDestoyableGroundObjects() const;
std::vector<Bomb*> FindAllBombs() const; std::vector<Bomb*> FindAllBombs() const;
// void DropBomb(); void DropBomb();
std::vector<DynamicObject*> vecDynamicObj; std::vector<DynamicObject*> vecDynamicObj;
std::vector<GameObject*> vecStaticObj; std::vector<GameObject*> vecStaticObj;
bool exitFlag; bool exitFlag;
uint64_t startTime, finishTime, passedTime; uint64_t startTime, finishTime, passedTime;
uint16_t bombsNumber, deltaTime, fps; uint16_t bombsNumber, deltaTime, fps;
int16_t score; int16_t score;
}; };

View File

@ -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;
};

320028
SBomber/log.txt Normal file

File diff suppressed because it is too large Load Diff

View File

@ -2,14 +2,60 @@
#include "MyTools.h" #include "MyTools.h"
#include "ScreenSingleton.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) int main(void)
{ {
MyTools::LoggerSingleton::getInstance().OpenLogFile("log.txt"); MyTools::OpenLogFile("log.txt");
SBomber game; 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; return 0;
} }

View File

@ -7,26 +7,3 @@ void Bomb::Draw() const {
ScreenSingleton::getInstance().GotoXY(x, y); ScreenSingleton::getInstance().GotoXY(x, y);
std::cout << "*"; 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();
}

View File

@ -9,110 +9,42 @@
#include <time.h> #include <time.h>
#include <stdio.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();
{ }
logOut.close(); }
}
}
std::string GetCurDateTime() std::string GetCurDateTime() {
{ auto cur = std::chrono::system_clock::now();
auto cur = std::chrono::system_clock::now(); time_t time = std::chrono::system_clock::to_time_t(cur);
time_t time = std::chrono::system_clock::to_time_t(cur); char* buf = ctime(&time);
char *buf = ctime(&time); return std::string(buf);
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;
{ }
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;
{ }
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;
{ }
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 } // namespace MyTools

View File

@ -1,3 +1,4 @@
#include "MyTools.h" #include "MyTools.h"
#include "SBomber.h" #include "SBomber.h"
#include "Bomb.h" #include "Bomb.h"
@ -9,542 +10,302 @@
#include <chrono> #include <chrono>
#include <thread> #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;
{ p->SetDirection(1, 0.1);
static const int STDIN = 0; p->SetSpeed(4);
static bool initialized = false; p->SetPos(5, 10);
vecDynamicObj.push_back(p);
if (!initialized) LevelGUI* pGUI = new LevelGUI;
{ pGUI->SetParam(passedTime, fps, bombsNumber, score);
// Use termios to turn off line buffering const uint16_t maxX = ScreenSingleton::getInstance().GetMaxX();
termios term; const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
tcgetattr(STDIN, &term); const uint16_t offset = 3;
term.c_lflag &= ~ICANON; const uint16_t width = maxX - 7;
tcsetattr(STDIN, TCSANOW, &term); pGUI->SetPos(offset, offset);
setbuf(stdin, NULL); pGUI->SetWidth(width);
initialized = true; pGUI->SetHeight(maxY - 4);
} pGUI->SetFinishX(offset + width - 4);
vecStaticObj.push_back(pGUI);
int bytesWaiting; Ground* pGr = new Ground;
ioctl(STDIN, FIONREAD, &bytesWaiting); const uint16_t groundY = maxY - 5;
return bytesWaiting; pGr->SetPos(offset + 1, groundY);
pGr->SetWidth(width - 2);
vecStaticObj.push_back(pGr);
Tank* pTank = new Tank;
pTank->SetWidth(13);
pTank->SetPos(30, groundY - 1);
vecStaticObj.push_back(pTank);
pTank = new Tank;
pTank->SetWidth(13);
pTank->SetPos(50, groundY - 1);
vecStaticObj.push_back(pTank);
House* pHouse = new House;
pHouse->SetWidth(13);
pHouse->SetPos(80, groundY - 1);
vecStaticObj.push_back(pHouse);
/*
Bomb* pBomb = new Bomb;
pBomb->SetDirection(0.3, 1);
pBomb->SetSpeed(2);
pBomb->SetPos(51, 5);
pBomb->SetSize(SMALL_CRATER_SIZE);
vecDynamicObj.push_back(pBomb);
*/
} }
class IFactory SBomber::~SBomber() {
{ for (size_t i = 0; i < vecDynamicObj.size(); i++) {
public: if (vecDynamicObj[i] != nullptr) {
virtual ~IFactory() {} delete vecDynamicObj[i];
DynamicObject* createPlane() const
{
Plane *p = createPlaneInstance();
p->SetDirection(1, 0.1);
p->SetSpeed(4);
p->SetPos(5, 10);
return p;
} }
}
DynamicObject* createBomb(const double x, const double y) const for (size_t i = 0; i < vecStaticObj.size(); i++) {
{ if (vecStaticObj[i] != nullptr) {
Bomb *pBomb = createBombInstance(); delete vecStaticObj[i];
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 void SBomber::MoveObjects() {
{ MyTools::WriteToLog(std::string(__func__) + " was invoked");
LevelGUI *pGUI = createUIInstance();
pGUI->SetParam(passedTime, fps, bombsNumber, score);
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;
pGUI->SetPos(offset, offset);
pGUI->SetWidth(width);
pGUI->SetHeight(maxY - 4);
pGUI->SetFinishX(offset + width - 4);
return pGUI;
}
virtual GameObject* createHouse(double posX) const for (size_t i = 0; i < vecDynamicObj.size(); i++) {
{ if (vecDynamicObj[i] != nullptr) {
const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY(); vecDynamicObj[i]->Move(deltaTime);
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;
}
virtual GameObject* createTank(double posX) const
{
const uint16_t maxY = ScreenSingleton::getInstance().GetMaxY();
const uint16_t groundY = maxY - 5;
Tank *pTank = createTankInstance();
pTank->SetWidth(13);
pTank->SetPos(posX, groundY - 1);
return 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 void SBomber::CheckObjects() {
{ MyTools::WriteToLog(std::string(__func__) + " was invoked");
Plane* createPlaneInstance() const override
{
return new Plane;
}
Bomb* createBombInstance() const override CheckPlaneAndLevelGUI();
{ CheckBombsAndGround();
return new Bomb;
}
LevelGUI* createUIInstance() const override
{
return new LevelGUI;
}
Ground* createGroundInstance() const override
{
return new Ground;
}
Tank* createTankInstance() const override
{
return new Tank;
}
House* createHouseInstance() const override
{
return new House;
}
}; };
class Command void SBomber::CheckPlaneAndLevelGUI() {
{ if (FindPlane()->GetX() > FindLevelGUI()->GetFinishX()) {
public: exitFlag = true;
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() void SBomber::CheckBombsAndGround() {
{ std::vector<Bomb*> vecBombs = FindAllBombs();
for (size_t i = 0; i < vecDynamicObj.size(); i++) Ground* pGround = FindGround();
{ const double y = pGround->GetY();
if (vecDynamicObj[i] != nullptr) for (size_t i = 0; i < vecBombs.size(); i++) {
{ if (vecBombs[i]->GetY() >= y) {
delete vecDynamicObj[i]; pGround->AddCrater(vecBombs[i]->GetX());
} CheckDestoyableObjects(vecBombs[i]);
DeleteDynamicObj(vecBombs[i]);
}
}
}
void SBomber::CheckDestoyableObjects(Bomb* pBomb) {
std::vector<DestroyableGroundObject*> vecDestoyableObjects =
FindDestoyableGroundObjects();
const double size = pBomb->GetWidth();
const double size_2 = size / 2;
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)) {
score += vecDestoyableObjects[i]->GetScore();
DeleteStaticObj(vecDestoyableObjects[i]);
}
}
}
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;
House* pHouse;
for (size_t i = 0; i < vecStaticObj.size(); i++) {
pTank = dynamic_cast<Tank*>(vecStaticObj[i]);
if (pTank != nullptr) {
vec.push_back(pTank);
continue;
} }
for (size_t i = 0; i < vecStaticObj.size(); i++) pHouse = dynamic_cast<House*>(vecStaticObj[i]);
{ if (pHouse != nullptr) {
if (vecStaticObj[i] != nullptr) vec.push_back(pHouse);
{ continue;
delete vecStaticObj[i];
}
} }
}
return vec;
} }
void SBomber::MoveObjects() Ground* SBomber::FindGround() const {
{ Ground* pGround;
MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
for (size_t i = 0; i < vecDynamicObj.size(); i++) for (size_t i = 0; i < vecStaticObj.size(); i++) {
{ pGround = dynamic_cast<Ground*>(vecStaticObj[i]);
if (vecDynamicObj[i] != nullptr) if (pGround != nullptr) {
{ return pGround;
vecDynamicObj[i]->Move(deltaTime);
}
} }
}
return nullptr;
} }
;
void SBomber::CheckObjects() std::vector<Bomb*> SBomber::FindAllBombs() const {
{ std::vector<Bomb*> vecBombs;
MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
CheckPlaneAndLevelGUI(); for (size_t i = 0; i < vecDynamicObj.size(); i++) {
CheckBombsAndGround(); Bomb* pBomb = dynamic_cast<Bomb*>(vecDynamicObj[i]);
} if (pBomb != nullptr) {
; vecBombs.push_back(pBomb);
void SBomber::CheckPlaneAndLevelGUI()
{
if (FindPlane()->GetX() > FindLevelGUI()->GetFinishX())
{
exitFlag = true;
} }
}
return vecBombs;
} }
void SBomber::CheckBombsAndGround() Plane* SBomber::FindPlane() const {
{ for (size_t i = 0; i < vecDynamicObj.size(); i++) {
std::vector<Bomb*> vecBombs = FindAllBombs(); Plane* p = dynamic_cast<Plane*>(vecDynamicObj[i]);
Ground *pGround = FindGround(); if (p != nullptr) {
const double y = pGround->GetY(); return p;
for (size_t i = 0; i < vecBombs.size(); i++)
{
if (vecBombs[i]->GetY() >= y)
{
pGround->AddCrater(vecBombs[i]->GetX());
CheckDestoyableObjects(vecBombs[i]);
DeleteCommand<DynamicObject> delCom(SBomber::vecDynamicObj);
delCom.setObj(vecBombs[i]);
delCom.Execute();
}
} }
}
return nullptr;
} }
void SBomber::CheckDestoyableObjects(Bomb *pBomb) LevelGUI* SBomber::FindLevelGUI() const {
{ for (size_t i = 0; i < vecStaticObj.size(); i++) {
std::vector<DestroyableGroundObject*> vecDestoyableObjects = FindDestoyableGroundObjects(); LevelGUI* p = dynamic_cast<LevelGUI*>(vecStaticObj[i]);
const double size = pBomb->GetWidth(); if (p != nullptr) {
const double size_2 = size / 2; return p;
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))
{
score += vecDestoyableObjects[i]->GetScore();
DeleteCommand<GameObject> delCom(SBomber::vecStaticObj);
delCom.setObj(vecDestoyableObjects[i]);
delCom.Execute();
}
} }
}
return nullptr;
} }
std::vector<DestroyableGroundObject*> SBomber::FindDestoyableGroundObjects() const void SBomber::ProcessKBHit() {
{ int c = getchar();
std::vector<DestroyableGroundObject*> vec;
Tank *pTank;
House *pHouse;
for (size_t i = 0; i < vecStaticObj.size(); i++)
{
pTank = dynamic_cast<Tank*>(vecStaticObj[i]);
if (pTank != nullptr)
{
vec.push_back(pTank);
continue;
}
pHouse = dynamic_cast<House*>(vecStaticObj[i]); if (c == 224) {
if (pHouse != nullptr) c = getchar();
{ }
vec.push_back(pHouse);
continue; MyTools::WriteToLog(std::string(__func__) + " was invoked. key = ", 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();
break;
case 'B':
DropBomb();
break;
default:
break;
}
}
void SBomber::DrawFrame() {
MyTools::WriteToLog(std::string(__func__) + " was invoked");
for (size_t i = 0; i < vecDynamicObj.size(); i++) {
if (vecDynamicObj[i] != nullptr) {
vecDynamicObj[i]->Draw();
} }
}
return vec; for (size_t i = 0; i < vecStaticObj.size(); i++) {
} if (vecStaticObj[i] != nullptr) {
vecStaticObj[i]->Draw();
Ground* SBomber::FindGround() const
{
Ground *pGround;
for (size_t i = 0; i < vecStaticObj.size(); i++)
{
pGround = dynamic_cast<Ground*>(vecStaticObj[i]);
if (pGround != nullptr)
{
return pGround;
}
} }
}
return nullptr; ScreenSingleton::getInstance().GotoXY(0, 0);
fps++;
FindLevelGUI()->SetParam(passedTime, fps, bombsNumber, score);
} }
std::vector<Bomb*> SBomber::FindAllBombs() const void SBomber::TimeStart() {
{ MyTools::WriteToLog(std::string(__func__) + " was invoked");
std::vector<Bomb*> vecBombs; startTime = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::high_resolution_clock::now().time_since_epoch()).count();
for (size_t i = 0; i < vecDynamicObj.size(); i++)
{
Bomb *pBomb = dynamic_cast<Bomb*>(vecDynamicObj[i]);
if (pBomb != nullptr)
{
vecBombs.push_back(pBomb);
}
}
return vecBombs;
} }
Plane* SBomber::FindPlane() const void SBomber::TimeFinish() {
{ finishTime = std::chrono::duration_cast<std::chrono::milliseconds>(
for (size_t i = 0; i < vecDynamicObj.size(); i++) std::chrono::high_resolution_clock::now().time_since_epoch()).count();
{ deltaTime = uint16_t(finishTime - startTime);
Plane *p = dynamic_cast<Plane*>(vecDynamicObj[i]); passedTime += deltaTime;
if (p != nullptr)
{
return p;
}
}
return nullptr; MyTools::WriteToLog(std::string(__func__) + " deltaTime = ", (int)deltaTime);
} }
LevelGUI* SBomber::FindLevelGUI() const void SBomber::DropBomb() {
{ if (bombsNumber > 0) {
for (size_t i = 0; i < vecStaticObj.size(); i++) MyTools::WriteToLog(std::string(__func__) + " was invoked");
{
LevelGUI *p = dynamic_cast<LevelGUI*>(vecStaticObj[i]);
if (p != nullptr)
{
return p;
}
}
return nullptr; Plane* pPlane = FindPlane();
} double x = pPlane->GetX() + 4;
double y = pPlane->GetY() + 2;
void SBomber::ProcessKBHit()
{ Bomb* pBomb = new Bomb;
int c = getchar(); pBomb->SetDirection(0.3, 1);
pBomb->SetSpeed(2);
if (c == 224) pBomb->SetPos(x, y);
{ pBomb->SetWidth(SMALL_CRATER_SIZE);
c = getchar();
} vecDynamicObj.push_back(pBomb);
bombsNumber--;
MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked. key = ", c); score -= Bomb::BombCost;
}
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':
{
DropCommand dropCom(SBomber::vecDynamicObj);
dropCom.setParams(FindPlane(), &bombsNumber, &score);
dropCom.Execute();
break;
}
case 'B':
{
DropBigCommand dropCom(SBomber::vecDynamicObj);
dropCom.setParams(FindPlane(), &bombsNumber, &score);
dropCom.Execute();
break;
}
default:
break;
}
}
void SBomber::DrawFrame()
{
MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
for (size_t i = 0; i < vecDynamicObj.size(); i++)
{
if (vecDynamicObj[i] != nullptr)
{
vecDynamicObj[i]->Draw();
}
}
for (size_t i = 0; i < vecStaticObj.size(); i++)
{
if (vecStaticObj[i] != nullptr)
{
vecStaticObj[i]->Draw();
}
}
ScreenSingleton::getInstance().GotoXY(0, 0);
fps++;
FindLevelGUI()->SetParam(passedTime, fps, bombsNumber, score);
}
void SBomber::TimeStart()
{
MyTools::LoggerSingleton::getInstance().WriteToLog(std::string(__func__) + " was invoked");
startTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
}
void SBomber::TimeFinish()
{
finishTime = std::chrono::duration_cast<std::chrono::milliseconds>(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);
}
void SBomber::run()
{
do
{
TimeStart();
if (_kbhit())
{
ProcessKBHit();
}
ScreenSingleton::getInstance().ClrScr();
DrawFrame();
MoveObjects();
CheckObjects();
TimeFinish();
} while (!GetExitFlag());
} }

View File

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

1030
hw2.patch

File diff suppressed because it is too large Load Diff