What would be the next steps I should take to progress and develop this ecs? #pragma once

#include <cstdint>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <bitset>
#include <typeinfo>

#include “System.h”
#include “Archetype.h”
#include “ComponentMask.h”


typedef std::vector<int> ArchetypeId;

class ECS
{
private:

typedef std::unordered_map<std::uint8_t, std::vector<SystemBase*>>
SystemsArrayMap;

typedef std::unordered_map<std::size_t, ComponentBase*>
ComponentTypeIdBaseMap;

struct Record
{
Archetype* archetype;
std::size_t index;
};

typedef std::unordered_map<std::size_t, Record> EntityArchetypeMap;

typedef std::vector<Archetype*> ArchetypesArray;

typedef std::unordered_map<std::size_t, ComponentMask> ComponentMasks;


public:
explicit ECS();

~ECS();

void Update(const std::uint8_t layer, const std::uint32_t delta);

void RegisterEntity(const uint32_t entityId);

void DestroyEntity(const std::uint32_t entityId);

template <class C>
void RegisterComponent();

template <class C>
bool IsComponentRegistered();

template<class C, typename… Args>
C* AddComponent(const uint32_t entityId, Args&&… args);

template<class C>
void RemoveComponent(const uint32_t entityId);

template<class C>
C* GetComponent(const uint32_t entityId);

template<class C>
bool HasComponent(const uint32_t entityId);

void RegisterSystem(const std::uint8_t& layer, SystemBase* system);

void UnregisterSystem(const std::uint8_t& layer, SystemBase* system);

template<class… Cs>
std::vector<uint32_t> GetEntitiesWithComponents();

Archetype* GetArchetype(const ComponentMask& compMask);

std::uint32_t GetNewId();

private:
std::uint32_t entityIdCounter;

SystemsArrayMap systems;

EntityArchetypeMap entityArchetypeMap;

ArchetypesArray archetypes;

ComponentMasks componentMasks;

ComponentTypeIdBaseMap componentMap;

void Reallocate(const ComponentBase* compbase, const size_t& newCompSize, Archetype* arch, size_t index);
void TransferComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex);
void SwapComponentData(const ComponentBase* compbase, Archetype* arch, size_t i, size_t entityIndex);
void RemoveAndAllocateComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex);
};

class SystemBase
{
public:
virtual ~SystemBase() {}

virtual ComponentMask GetComponentMask() const = 0;

virtual void Update(const std::uint32_t elapsedTime, Archetype* archetype) = 0;

};

class ECS;
template<class… Cs>
class System : public SystemBase
{
public:

friend class ECS;
typedef std::function<void(const std::uint32_t, const std::vector<uint32_t>&, Cs*…)> Func;

System(ECS& ecs, const std::uint8_t& layer);

virtual ComponentMask GetComponentMask() const override;

void Action(Func func);

protected:

template<std::size_t Index1, typename T, typename… Ts>
std::enable_if_t<Index1 == sizeof…(Cs)>
Update(const std::uint32_t elapsedMilliseconds,
const ComponentMask& componentMask,
const std::vector<uint32_t>& entityIds,
T& t,
Ts… ts);



template<std::size_t Index1, typename T, typename… Ts>
std::enable_if_t<Index1 != sizeof…(Cs)>
Update(const std::uint32_t elapsedMilliseconds,
const ComponentMask& componentMask,
const std::vector<uint32_t>& entityIds,
T& t,
Ts… ts);

virtual void Update(const std::uint32_t elapsedMilliseconds,
Archetype* archetype) override;




ECS& ecs_;
ComponentMask componentMask_;
Func func_;
bool funcStatus_;
};

template<class… Cs>
System<Cs…>::System(ECS& ecs, const std::uint8_t& layer)
: ecs_(ecs), funcStatus_(false)
{
ecs_.RegisterSystem(layer, this);
((componentMask_.AddComponent(GetTypeID<Cs>())), …);
}

typedef unsigned char* ComponentData;
typedef std::vector<int> ArchetypeId;

struct Archetype
{
ComponentMask componentMask;
std::vector<ComponentData> componentData;
std::vector<uint32_t> entityIds;
std::vector<std::size_t> componentDataSize;
};class ComponentBase
{
public:
virtual ~ComponentBase() {}
virtual void DestroyData(unsigned char* data) const = 0;
virtual void MoveData(unsigned char* source, unsigned char* destination) const = 0;
virtual void ConstructData(unsigned char* data) const = 0;
virtual std::size_t GetSize() const = 0;
};

template<class C>
class Component : public ComponentBase
{
public:
virtual void DestroyData(unsigned char* data) const override;

virtual void MoveData(unsigned char* source, unsigned char* destination) const override;

virtual void ConstructData(unsigned char* data) const override;

virtual std::size_t GetSize() const override;

static std::size_t GetTypeID();
};

template<class C>
void Component<C>::DestroyData(unsigned char* data) const
{
C* dataLocation = std::launder(reinterpret_cast<C*>(data));

dataLocation->~C();
}

template<class C>
void Component<C>::ConstructData(unsigned char* data) const
{
new (&data[0]) C();
}

template<class C>
void Component<C>::MoveData(unsigned char* source, unsigned char* destination) const
{
new (&destination[0]) C(std::move(std::bit_cast<C>(source)));
}

template<class C>
std::size_t Component<C>::GetSize() const
{
return sizeof©;
}


template<class C>
std::size_t Component<C>::GetTypeID()
{
return TypeIdGenerator<ComponentBase>::GetNewID<C>();
}

template <class C>
std::size_t GetTypeID() {
return TypeIdGenerator<ComponentBase>::GetNewID<C>();
}