First cut of pulling out the relevant parts of my original game to make a little framework.

src/algos/dinkyecs.hpp

@@ -0,0 +1,247 @@
+#pragma once
+
+#include "dbc.hpp"
+#include <any>
+#include <functional>
+#include <queue>
+#include <tuple>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <optional>
+#include <memory>
+
+namespace DinkyECS
+{
+  using Entity = unsigned long;
+
+  const Entity NONE = 0;
+
+  template <typename T>
+    struct ComponentStorage {
+      std::vector<T> data;
+    };
+
+  struct Event {
+    int event = 0;
+    Entity entity = 0;
+    std::any data;
+  };
+
+  using EntityMap = std::unordered_map<Entity, size_t>;
+  using EventQueue = std::queue<Event>;
+  using TypeMap = std::unordered_map<std::type_index, std::any>;
+
+  struct World {
+    unsigned long entity_count = NONE+1;
+    std::unordered_map<std::type_index, EntityMap> $components;
+    std::shared_ptr<TypeMap> $facts = nullptr;
+    std::unordered_map<std::type_index, EventQueue> $events;
+    std::unordered_map<std::type_index, std::any> $component_storages;
+    std::unordered_map<std::type_index, std::queue<size_t>> $free_indices;
+    std::unordered_map<Entity, bool> $constants;
+
+    World() : $facts(std::make_shared<TypeMap>())
+    {}
+
+    Entity entity() { return ++entity_count; }
+
+    void destroy(DinkyECS::Entity entity) {
+      dbc::check(!$constants.contains(entity), "trying to destroy an entity in constants");
+
+      for(auto& [tid, map] : $components) {
+
+        if(map.contains(entity)) {
+          size_t index = map.at(entity);
+          auto& free_queue = $free_indices.at(tid);
+          free_queue.push(index);
+          map.erase(entity);
+        }
+      }
+    }
+
+    void clone_into(DinkyECS::World &to_world) {
+      to_world.$constants = $constants;
+      to_world.$facts = $facts;
+      // BUG*10: entity IDs should be a global counter, not per world
+      to_world.entity_count = entity_count;
+      to_world.$component_storages = $component_storages;
+
+      for(auto [eid, is_set] : $constants) {
+        dbc::check(is_set == true, "is_set was not true? WHAT?!");
+        dbc::check(eid <= entity_count,
+            $F("eid {} is not less than entity_count {}", eid, entity_count));
+
+        for(const auto &[tid, eid_map] : $components) {
+          auto &their_map = to_world.$components[tid];
+          if(eid_map.contains(eid)) {
+            their_map.insert_or_assign(eid, eid_map.at(eid));
+          }
+        }
+      }
+    }
+
+    void make_constant(DinkyECS::Entity entity) {
+      $constants.try_emplace(entity, true);
+    }
+
+    void not_constant(DinkyECS::Entity entity) {
+      $constants.erase(entity);
+    }
+
+    template <typename Comp>
+      size_t make_component() {
+        auto &storage = component_storage_for<Comp>();
+        auto &free_queue = $free_indices.at(std::type_index(typeid(Comp)));
+        size_t index;
+
+        if(!free_queue.empty()) {
+          index = free_queue.front();
+          free_queue.pop();
+        } else {
+          storage.data.emplace_back();
+          index = storage.data.size() - 1;
+        }
+
+        return index;
+      }
+
+    template <typename Comp>
+      ComponentStorage<Comp> &component_storage_for() {
+        auto type_index = std::type_index(typeid(Comp));
+        $component_storages.try_emplace(type_index, ComponentStorage<Comp>{});
+        $free_indices.try_emplace(type_index, std::queue<size_t>{});
+        return std::any_cast<ComponentStorage<Comp> &>(
+            $component_storages.at(type_index));
+      }
+
+    template <typename Comp>
+      EntityMap &entity_map_for() {
+        return $components[std::type_index(typeid(Comp))];
+      }
+
+    template <typename Comp>
+      EventQueue &queue_map_for() {
+        return $events[std::type_index(typeid(Comp))];
+      }
+
+    template <typename Comp>
+      void remove(Entity ent) {
+        EntityMap &map = entity_map_for<Comp>();
+
+        if(map.contains(ent)) {
+          size_t index = map.at(ent);
+          auto& free_queue = $free_indices.at(std::type_index(typeid(Comp)));
+          free_queue.push(index);
+          map.erase(ent);
+        }
+      }
+
+    template <typename Comp>
+      void set_the(Comp val) {
+        $facts->insert_or_assign(std::type_index(typeid(Comp)), val);
+      }
+
+    template <typename Comp>
+      Comp &get_the() {
+        auto comp_id = std::type_index(typeid(Comp));
+        dbc::check($facts->contains(comp_id),
+            $F("!!!! ATTEMPT to access world fact that hasn't been set yet: {}",
+              typeid(Comp).name()));
+
+        // use .at to get std::out_of_range if fact not set
+        std::any &res = $facts->at(comp_id);
+        return std::any_cast<Comp &>(res);
+      }
+
+    template <typename Comp>
+      bool has_the() {
+        auto comp_id = std::type_index(typeid(Comp));
+        return $facts->contains(comp_id);
+      }
+
+    template <typename Comp>
+      void set(Entity ent, Comp val) {
+        EntityMap &map = entity_map_for<Comp>();
+
+        if(has<Comp>(ent)) {
+          get<Comp>(ent) = val;
+          return;
+        }
+
+        map.insert_or_assign(ent, make_component<Comp>());
+        get<Comp>(ent) = val;
+      }
+
+    template <typename Comp>
+      Comp &get(Entity ent) {
+        EntityMap &map = entity_map_for<Comp>();
+        auto &storage = component_storage_for<Comp>();
+        auto index = map.at(ent);
+        return storage.data[index];
+      }
+
+    template <typename Comp>
+      bool has(Entity ent) {
+        EntityMap &map = entity_map_for<Comp>();
+        return map.contains(ent);
+      }
+
+    template <typename Comp>
+      void query(std::function<void(Entity, Comp &)> cb) {
+        EntityMap &map = entity_map_for<Comp>();
+
+        for(auto &[entity, index] : map) {
+          cb(entity, get<Comp>(entity));
+        }
+      }
+
+    template <typename CompA, typename CompB>
+      void query(std::function<void(Entity, CompA &, CompB &)> cb) {
+        EntityMap &map_a = entity_map_for<CompA>();
+        EntityMap &map_b = entity_map_for<CompB>();
+
+        for(auto &[entity, index_a] : map_a) {
+          if(map_b.contains(entity)) {
+            cb(entity, get<CompA>(entity), get<CompB>(entity));
+          }
+        }
+      }
+
+    template <typename Comp>
+      void send(Comp event, Entity entity, std::any data) {
+        EventQueue &queue = queue_map_for<Comp>();
+        queue.push({event, entity, data});
+      }
+
+    template <typename Comp>
+      Event recv() {
+        EventQueue &queue = queue_map_for<Comp>();
+        Event evt = queue.front();
+        queue.pop();
+        return evt;
+      }
+
+    template <typename Comp>
+      bool has_event() {
+        EventQueue &queue = queue_map_for<Comp>();
+        return !queue.empty();
+      }
+
+    /* std::optional can't do references. Don't try it!
+     * Actually, this sucks, either delete it or have it
+     * return pointers (assuming optional can handle pointers)
+     */
+    template <typename Comp>
+      Comp* get_if(DinkyECS::Entity entity) {
+        EntityMap &map = entity_map_for<Comp>();
+        auto &storage = component_storage_for<Comp>();
+        if(map.contains(entity)) {
+          auto index = map.at(entity);
+          return &storage.data[index];
+        } else {
+          return nullptr;
+        }
+      }
+  };
+} // namespace DinkyECS