GameDev как хобби

Args>
auto members(Args&&... args)
{
return std::make_tuple(std::forward(args)...);
}
template
Member

member(const char* name, T Class::* ptr)
{
return Member(name, ptr);
}

template <>
inline auto registerMembers()
{
return members(
member("name", &Engine::Object::getName),
member("position", &Engine::Object::position),
member("IsActive", &Engine::Object::IsActive)
);
}

MetaStuff

inventory;
AnimationManager animManager;
DebugWindows dw_a;

sf::Transformable PointOfFire;

public:
Actor() = delete;
Actor(sf::Image&, sf::Vector2f, sf::IntRect, std::string, sf::RenderWindow& ,Level&):Entity(img,pos,n)
~Actor() = default;

sf::Vector2f getPointOfFire();
void handleEvent(sf::Event& e);
void checkClashes(float time);
void RotateToMouse(float speed, sf::RenderWindow& window);
void update(float time) override;
void getDamage(float dmg);

friend class DebugWindow;
friend auto meta::registerMembers();
};

inv;
std::vector::iterator iter;

public:
~Inventory();

void baseIni()
{
inv.push_back(new

Gun("M9", 2, 2, 0.7));
inv.push_back(new Gun("AR-15", 8, 12, 3.9));
inv.push_back(new Gun("RPG", 15, 1, 6.3));
inv.push_back(new Heal("HP", 20));
}
void AddItem(Item* i) { inv.push_back(i); }
void delItem(std::string Name);
void nextItem() { (Count >= inv.size() - 1) ? Count = 0 : Count++;}

template
T* getItemByName(std::string Name);
template
T* getItem(int index);

std::string getItemName(int num) const;
std::vector getArrayItem() { return inv; }
};

class Item : public Engine::Object
{
public:
Item() = default;
Item(std::string name) : Object(name) { type = ItemType::item; weight = 0; }
virtual ~Item();
float getWeight();
ItemType getType();
protected:
ItemType type;
float weight;
};

неполон!
if (Engine::VStaticContainer::ShowDemoWindows)
{
if (ImGui::Begin("DebugWindows", NULL))
{

if (ImGui::TreeNode((void*)ptr, nameTree.c_str()))
{
meta::doForAllMembers(
[&](const auto& member)
{
std::string field = "";
switch (checkType())
{
case Engine::INT:
field = (std::string)member.getName() + ": %.i";
ImGui::Text(field.c_str(), member.get(*ptr));
break;
}
}
);
ImGui::TreePop();
}
}
ImGui::End();
}
}

template
class DebugWindows
{
public:
DebugWindows();
~DebugWindows();

void set(T* p)
{
ptr = p;
static_assert(meta::isRegistered(), "!");
}
void draw(std::string nameTree, bool isFirstDraw = false);

private:
template
valueType checkType();
T* ptr;
sf::Vector2f size = { 400,400 };
};

все анимации
public:
AnimationManager() = default;
~AnimationManager();

template
T*

GetCurrAnimation();
template
T GetAnimationByName(std::string NAME);

void SetCurrAnimation(Animation&& ANIM);
void LoadAnimation_x(std::string fileName);

sf::IntRect& AnimUpdate(float TIME);
const std::list& getAnimationList();
};

class AnimationXml final : public Animation
{
public:
std::vector frames;
sf::IntRect& tick(float time) override
{
frame += 0.009 * time;
if (frame > 19) frame = 0;
return frames[frame];
}
};

AnimationManager

class Animation
{
public:
float frame; ///< кол-во кадров
float frameCount;
float speed; ///< скорость анимации
std::string name;
sf::Vector2f scale;

virtual sf::IntRect& tick(float time) = 0;
};

lua_State* L;
A*

testWindow;
Engine::Menu* m;
sf::RenderWindow* window;
sf::Clock deltaClock;
sf::View camera;
appState state;
timer time;

public:
Game(sf::RenderWindow& w);
~Game();
void startGame();
void update();
void draw();
void handleEvent(sf::Event& e);
};

*open);
static void SimpleText(sf::Vector2f position, bool *open, std::string name, std::string

text = "");
static void Text(sf::Vector2f position, bool *open, std::string name, std::string text = "");
};

неполон!
public:
DebuggingSystem() = default;
~DebuggingSystem() = default;

static void

setWindow(sf::RenderWindow& w) { window = &w; }
void draw(sf::RenderTarget& target = *window);
void pushRectangle(std::pair e);
void levelObjects(std::vector objs);
void handleEvent(sf::Event& event);
};

{
auto x = z.second.left;
auto y = z.second.top;

sf::VertexArray

triangle(sf::LinesStrip, 5);
triangle[0] = sf::Vector2f(x, y);
triangle[0].color = sf::Color::Blue;

ImGUI::SimpleText(sf::Vector2f(x * 1.92, y * 1.92), &overlay, "D_Window_" + std::to_string(count)); ///< 1.92 – const, т.к viewport = (0, 0, 1000, 563)
count++;
target.draw(triangle);
}
Console::AppLog::Draw("LogConsole", &LogConsole); ///< Отрисовывает консоль логов
}

AppLog
{
private:
static bool ScrollToBottom;
static vector

Buffer;
static std::string items[5]; ///< Строковое представление Console::logType
public:
static void Clear() { Buffer.clear(); Buffer.shrink_to_fit(); }

static void addLog(Log log);
static void addLog(std::string s, logType t)
{ Buffer.emplace_back(Log(s + "\n", t)); }
static void Draw(const char* title, bool *p_open);
};

text;
std::string oneFrameText;
public:
A() = delete;
A(std::string n);

void addText(std::string

t);
void addText_l(std::string t);
void addWindow(bool isOpen);
};

.addFunction("addWindow", &A::addWindow)
.addFunction("addText", &A::addText_l)
.endClass();

luabridge::push(L, testWindow);
lua_setglobal(L, "L_testWindow");
testWindow->addText("Text

From C++");
}

Регистрация класса

SetVolume(float);
void PlaySongByName(std::string);
void LoadMusic(std::string, std::string);
void Update();
};
void Engine::AudioPlayer::GetMusic()
{
std::string path = "Music/";

for (auto & p : fs::directory_iterator(path))
{
auto fileName = p.path().filename().generic_string();
const size_t pos = fileName.find_last_of(".");
fileName.erase(pos, 4);
LoadMusic(fileName, p.path().generic_string());
}
}

void Engine::AudioPlayer::LoadMusic(std::string name, std::string patch)
{
auto Mus = new Music;
Mus->openFromFile(patch);
Mus->setVolume(volume);
Console::AppLog::addLog("Load music at path(" + patch + ")", Console::logType::system);
musList.emplace_back(name, Mus);
}

p->inventr.GetCurrItem();
if((PlayerShootClock.getElapsedTime().asMilliseconds() >= item->rechargeTime()) && (ammo > 0))
{

isShoot = true;
PlayerShootClock.restart();
}
}
}