ccore/include/core/Components.h

#ifndef CORE_COMPONENTS_H
#define CORE_COMPONENTS_H

#include "core/HashMap.h"
#include "core/List.h"

LIST(size_t, Size)

typedef size_t Entity;

#define COMPONENTS(T, N)                                                       \
    typedef struct {                                                           \
        CoreHashMap entityToIndex;                                             \
        ListSize indexToEntity;                                                \
        List##N components;                                                    \
    } Components;                                                              \
                                                                               \
    typedef struct {                                                           \
        Entity entity;                                                         \
        T* component;                                                          \
    } ComponentNode;                                                           \
                                                                               \
    typedef struct {                                                           \
        const Entity* indexToEntity;                                           \
        const Entity* indexToEntityEnd;                                        \
        T* component;                                                          \
        T* componentEnd;                                                       \
        ComponentNode node;                                                    \
    } ComponentIterator;                                                       \
                                                                               \
    void initComponents(Components* c);                                        \
    void destroyComponents(Components* c);                                     \
    T* getOrAddComponent(Components* c, Entity e);                             \
    T* searchComponent(Components* c, Entity e);                               \
    bool removeComponent(Components* c, Entity e);                             \
    void initComponentIterator(ComponentIterator* ci, Components* c);          \
    bool hasNextComponentNode(ComponentIterator* ci);                          \
    ComponentNode* nextComponentNode(ComponentIterator* ci);                   \
    T* getComponentsStart(Components* c);                                      \
    T* getComponentsEnd(Components* c);

#define COMPONENTS_SOURCE(T, N)                                                \
    void initComponents(Components* c) {                                       \
        coreInitHashMap(&c->entityToIndex, sizeof(Entity), sizeof(size_t));    \
        initListSize(&c->indexToEntity);                                       \
        initList##N(&c->components);                                           \
    }                                                                          \
                                                                               \
    void destroyComponents(Components* c) {                                    \
        coreDestroyHashMap(&c->entityToIndex);                                 \
        destroyListSize(&c->indexToEntity);                                    \
        destroyList##N(&c->components);                                        \
    }                                                                          \
                                                                               \
    T* getOrAddComponent(Components* c, Entity e) {                            \
        void* component = searchComponent(c, e);                               \
        if(component != nullptr) {                                             \
            return component;                                                  \
        }                                                                      \
        size_t index = c->components.length;                                   \
        corePutHashMapPair(&c->entityToIndex, &e, &index);                     \
        addListDataSize(&c->indexToEntity, e);                                 \
        return addEmptyListData##N(&c->components);                            \
    }                                                                          \
                                                                               \
    T* searchComponent(Components* c, Entity e) {                              \
        size_t* index = coreSearchHashMapKey(&c->entityToIndex, &e);           \
        if(index == nullptr) {                                                 \
            return nullptr;                                                    \
        }                                                                      \
        return getListIndex##N(&c->components, *index);                        \
    }                                                                          \
                                                                               \
    bool removeComponent(Components* c, Entity e) {                            \
        size_t* indexP = coreSearchHashMapKey(&c->entityToIndex, &e);          \
        if(indexP == nullptr) {                                                \
            return false;                                                      \
        }                                                                      \
        size_t lastIndex = c->components.length - 1;                           \
        size_t index = *indexP;                                                \
        coreRemoveHashMapKey(&c->entityToIndex, &e);                           \
        removeListIndexBySwap##N(&c->components, index);                       \
        if(index == lastIndex) {                                               \
            removeListIndexBySwapSize(&c->indexToEntity, index);               \
            return true;                                                       \
        }                                                                      \
        Entity other = *getListIndexSize(&c->indexToEntity, lastIndex);        \
        removeListIndexBySwapSize(&c->indexToEntity, index);                   \
        corePutHashMapPair(&c->entityToIndex, &other, &index);                 \
        return true;                                                           \
    }                                                                          \
                                                                               \
    void initComponentIterator(ComponentIterator* ci, Components* c) {         \
        ci->indexToEntity = getListStartSize(&c->indexToEntity);               \
        ci->indexToEntityEnd = getListEndSize(&c->indexToEntity);              \
        ci->component = getListStart##N(&c->components);                       \
        ci->componentEnd = getListEnd##N(&c->components);                      \
        ci->node = (ComponentNode){0};                                         \
    }                                                                          \
                                                                               \
    bool hasNextComponentNode(ComponentIterator* ci) {                         \
        return ci->indexToEntity != ci->indexToEntityEnd;                      \
    }                                                                          \
                                                                               \
    ComponentNode* nextComponentNode(ComponentIterator* ci) {                  \
        ci->node.component = ci->component;                                    \
        ci->node.entity = *ci->indexToEntity;                                  \
        ci->indexToEntity++;                                                   \
        ci->component++;                                                       \
        return &ci->node;                                                      \
    }                                                                          \
                                                                               \
    T* getComponentsStart(Components* c) {                                     \
        return getListStart##N(&c->components);                                \
    }                                                                          \
                                                                               \
    T* getComponentsEnd(Components* c) {                                       \
        return getListEnd##N(&c->components);                                  \
    }

#endif