ECSystem.h

#pragma once

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>
#include <bitset>
#include <array>

class Comp;
class Entity;

using CompID = std::size_t;

inline CompID getCompTypeID()
{
	static CompID ultimulID = 0;
	return ultimulID++;
}

template <typename T> inline CompID getCompTypeID() noexcept
{
	static CompID typeID = getCompTypeID();
	return typeID;
}

constexpr std::size_t maxComps = 32;

using CompBitSet = std::bitset<maxComps>;
using CompArray = std::array<Comp*, maxComps>;

class Comp
{
public:
	Entity* entity;
	virtual void init() {}
	virtual void update() {}
	virtual void draw() {}
	virtual ~Comp() {}

};

class Entity {
private:
	bool active = true;
	std::vector<std::unique_ptr<Comp>> comps;
	CompArray compArray;
	CompBitSet compBitSet;
public:
	void update() {
		for (auto& c : comps) c->update();

	}
	void draw() {
		for (auto& c : comps) c->draw();
	}
	bool isActive() const { return active; }
	void destroy() { active = false; }
	template <typename T> bool hasComp() const
	{
		return compBitSet[getCompTypeID<T>];

	}
	template <typename T, typename... TArgs>
	T& addComp(TArgs&&... mArgs)
	{
		T* c(new T(std::forward<TArgs>(mArgs)...));
		c->entity = this;
		std::unique_ptr<Comp> uPtr{ c };
		comps.emplace_back(std::move(uPtr));
		compArray[getCompTypeID<T>()] = c;
		compBitSet[getCompTypeID<T>()] = true;

		c->init();
		return *c;
	}
	template<typename T> T& getComp() const
	{
		auto ptr(compArray[getCompTypeID<T>()]);
		return *static_cast<T*>(ptr);
	}
};

class Manager
{
private:
	std::vector<std::unique_ptr<Entity>> entities;
public:
	void update() {
		for (auto& e : entities) e->update();

	}
	void draw() {
		for (auto& e : entities) e->draw();
	}

	void refresh() {
		entities.erase(std::remove_if(std::begin(entities), std::end(entities),
			[](const std::unique_ptr<Entity> &mEntity)
		{
			return !mEntity->isActive();
		}),
			std::end(entities));
	}

	Entity& addEntity()
	{
		Entity* e = new Entity();
		std::unique_ptr<Entity> uPtr{ e };
		entities.emplace_back(std::move(uPtr));
		return *e;
	}
};