Work in progress

src/engine.cpp

@@ -62,10 +62,6 @@ std::shared_ptr<graphics::renderer> engine::renderer() const noexcept {
   return _renderer;
 }
 
-std::shared_ptr<framework::world> engine::world() const noexcept {
-  return _world;
-}
-
 int32_t engine::height() const noexcept {
   return _window->height();
 }
@@ -114,10 +110,6 @@ void engine::set_renderer(std::shared_ptr<graphics::renderer> renderer) noexcept
   _renderer = std::move(renderer);
 }
 
-void engine::set_world(std::shared_ptr<framework::world> world) noexcept {
-  _world = std::move(world);
-}
-
 void engine::add_loopable(std::shared_ptr<loopable> loopable) noexcept {
   _loopables.emplace_back(std::move(loopable));
 }
@@ -161,7 +153,6 @@ void engine::_loop() noexcept {
   _resourcemanager->update(delta);
   _scenemanager->update(delta);
   _eventmanager->update(delta);
-  _world->update(delta);
   _overlay->update(delta);
   _entitymanager->update(delta);
 
@@ -172,7 +163,6 @@ void engine::_loop() noexcept {
   _renderer->begin();
   _scenemanager->draw();
   _entitymanager->draw();
-  _world->draw();
   _overlay->draw();
   _renderer->end();
 }

src/engine.hpp

@@ -21,7 +21,6 @@ class engine : public input::eventreceiver {
   std::shared_ptr<audio::soundmanager> soundmanager() const noexcept;
   std::shared_ptr<graphics::window> window() const noexcept;
   std::shared_ptr<graphics::renderer> renderer() const noexcept;
-  std::shared_ptr<framework::world> world() const noexcept;
 
   int32_t height() const noexcept;
   int32_t width() const noexcept;
@@ -36,7 +35,6 @@ class engine : public input::eventreceiver {
   void set_statemanager(std::shared_ptr<framework::statemanager> statemanager) noexcept;
   void set_window(std::shared_ptr<graphics::window> window) noexcept;
   void set_renderer(std::shared_ptr<graphics::renderer> renderer) noexcept;
-  void set_world(std::shared_ptr<framework::world> world) noexcept;
 
   void add_loopable(std::shared_ptr<loopable> loopable) noexcept;
   void flush() const noexcept;
@@ -63,7 +61,6 @@ class engine : public input::eventreceiver {
   std::shared_ptr<framework::statemanager> _statemanager;
   std::shared_ptr<graphics::renderer> _renderer;
   std::shared_ptr<graphics::window> _window;
-  std::shared_ptr<framework::world> _world;
   std::shared_ptr<graphics::fontfactory> _fontfactory;
 };
 }

src/enginefactory.cpp

@@ -52,8 +52,7 @@ std::shared_ptr<engine> enginefactory::create() const noexcept {
   const auto overlay = std::make_shared<graphics::overlay>(renderer);
   const auto scenemanager = std::make_shared<framework::scenemanager>(resourcemanager->pixmappool());
   const auto statemanager = std::make_shared<framework::statemanager>();
-  const auto world = std::make_shared<framework::world>(_gravity, renderer);
-  const auto entitymanager = std::make_shared<framework::entitymanager>(world, resourcemanager);
+  const auto entitymanager = std::make_shared<framework::entitymanager>(resourcemanager);
   const auto fontfactory = std::make_shared<graphics::fontfactory>(renderer);
 
   engine->set_audiodevice(std::move(audiodevice));
@@ -65,7 +64,6 @@ std::shared_ptr<engine> enginefactory::create() const noexcept {
   engine->set_scenemanager(std::move(scenemanager));
   engine->set_statemanager(std::move(statemanager));
   engine->set_window(std::move(window));
-  engine->set_world(std::move(world));
   engine->set_fontfactory(fontfactory);
 
   engine->eventmanager()->add_receiver(engine->entitymanager());

src/entity.cpp

@@ -29,6 +29,10 @@ const entityprops &entity::props() const noexcept {
   return _props;
 }
 
+geometry::point entity::position() const noexcept {
+  return _props.position;
+}
+
 int32_t entity::x() const noexcept {
   return _props.position.x();
 }
@@ -99,7 +103,8 @@ void entity::draw() const noexcept {
   const auto &source = animation.frame;
   const auto &offset = animation.offset;
   geometry::rect destination{_props.position + offset, source.size()};
-  destination.scale(_props.size.scale()); // TODO calc this on spawn
+
+  destination.scale(_props.size.scale());
 
   _props.spritesheet->draw(
       source,
@@ -123,15 +128,19 @@ void entity::set_placement(int32_t x, int32_t y) noexcept {
 }
 
 void entity::set_onupdate(const std::function<void(std::shared_ptr<entity>)> &fn) noexcept {
-  _onupdate = fn;
+  _onupdate = std::move(fn);
 }
 
 void entity::set_onanimationfinished(const std::function<void(std::shared_ptr<entity>)> &fn) noexcept {
-  _onanimationfinished = fn;
+  _onanimationfinished = std::move(fn);
 }
 
 void entity::set_onmail(const std::function<void(std::shared_ptr<entity>, const std::string &)> &fn) noexcept {
-  _onmail = fn;
+  _onmail = std::move(fn);
+}
+
+void entity::set_oncollision(const std::string &kind, const std::function<void(std::shared_ptr<entity>, uint64_t)> &fn) noexcept {
+  _collisionmapping[kind] = std::move(fn);
 }
 
 void entity::set_reflection(graphics::reflection reflection) noexcept {
@@ -173,7 +182,3 @@ void entity::on_email(const std::string &message) {
 memory::kv &entity::kv() noexcept {
   return _kv;
 }
-
-// memory::kv &entity::kv() noexcept {
-//   return _kv;
-// }

src/entity.hpp

@@ -25,6 +25,7 @@ class entity : public std::enable_shared_from_this<entity> {
   const entityprops &props() const noexcept;
   void set_props(entityprops props) noexcept;
 
+  geometry::point position() const noexcept;
   int32_t x() const noexcept;
   int32_t y() const noexcept;
 
@@ -37,6 +38,7 @@ class entity : public std::enable_shared_from_this<entity> {
   void set_onupdate(const std::function<void(std::shared_ptr<entity>)> &fn) noexcept;
   void set_onanimationfinished(const std::function<void(std::shared_ptr<entity>)> &fn) noexcept;
   void set_onmail(const std::function<void(std::shared_ptr<entity>, const std::string &)> &fn) noexcept;
+  void set_oncollision(const std::string &kind, const std::function<void(std::shared_ptr<entity>, uint64_t)> &fn) noexcept;
 
   void set_reflection(graphics::reflection reflection) noexcept;
   void set_action(const std::string &action);
@@ -58,5 +60,6 @@ class entity : public std::enable_shared_from_this<entity> {
   std::function<void(std::shared_ptr<entity>)> _onupdate;
   std::function<void(std::shared_ptr<entity>)> _onanimationfinished;
   std::function<void(std::shared_ptr<entity>, const std::string &)> _onmail;
+  std::unordered_map<std::string, std::function<void(std::shared_ptr<entity>, uint64_t)>> _collisionmapping;
 };
 }

src/entitymanager.cpp

@@ -1,12 +1,13 @@
 #include "entitymanager.hpp"
+#include "common.hpp"
 
 using namespace framework;
 
 using json = nlohmann::json;
 
-entitymanager::entitymanager(std::shared_ptr<world> world, std::shared_ptr<resourcemanager> resourcemanager) noexcept
-    : _world(std::move(world)),
-      _resourcemanager(std::move(resourcemanager)) {}
+entitymanager::entitymanager(std::shared_ptr<resourcemanager> resourcemanager) noexcept
+    : _resourcemanager{std::move(resourcemanager)} {
+}
 
 std::shared_ptr<entity> entitymanager::spawn(const std::string &kind) {
   const auto buffer = storage::io::read((std::ostringstream() << "entities/" << kind << ".json").str());
@@ -63,18 +64,6 @@ void entitymanager::destroy(const std::shared_ptr<entity> entity) noexcept {
     return;
   }
 
-  // auto &props = entity->props();
-
-  // if (props.body) {
-  //   cpSpaceRemoveBody(_world->space().get(), props.body.get());
-  //   props.body.reset();
-  // }
-
-  // if (props.shape) {
-  //   cpSpaceRemoveShape(_world->space().get(), props.shape.get());
-  //   props.shape.reset();
-  // }
-
   _entities.remove(entity);
 }
 
@@ -90,6 +79,41 @@ void entitymanager::update(float_t delta) noexcept {
   for (const auto &entity : _entities) {
     entity->update(delta);
   }
+
+  std::unordered_map<std::string, std::vector<std::shared_ptr<entity>>> mapping;
+  for (const auto &entity : _entities) {
+    mapping[entity->kind()].emplace_back(entity);
+  }
+
+  for (const auto &entity1 : _entities) {
+    if (entity1->_collisionmapping.empty()) [[unlikely]]
+      continue;
+
+    const auto &pos1 = entity1->position();
+    const auto &size1 = entity1->size().resized();
+
+    for (const auto &[kind, callback] : entity1->_collisionmapping) {
+      if (auto it = mapping.find(kind); it != mapping.end()) [[likely]] {
+        const auto &mapping = it->second;
+
+        for (const auto &entity2 : mapping) {
+          if (entity1 == entity2) [[unlikely]]
+            continue;
+
+          const auto &pos2 = entity2->position();
+          const auto &size2 = entity2->size().resized();
+
+          if (pos1.x() < pos2.x() + size2.width() &&
+              pos1.x() + size1.width() > pos2.x() &&
+              pos1.y() < pos2.y() + size2.height() &&
+              pos1.y() + size1.height() > pos2.y()) [[likely]] {
+
+            callback(entity1, entity2->id());
+          }
+        }
+      }
+    }
+  }
 }
 
 void entitymanager::draw() noexcept {

src/entitymanager.hpp

@@ -3,12 +3,11 @@
 #include "common.hpp"
 #include "event.hpp"
 #include "eventreceiver.hpp"
-#include "world.hpp"
 
 namespace framework {
 class entitymanager : public input::eventreceiver {
 public:
-  entitymanager(std::shared_ptr<world> world, std::shared_ptr<resourcemanager> resourcemanager) noexcept;
+  explicit entitymanager(std::shared_ptr<resourcemanager> resourcemanager) noexcept;
   ~entitymanager() = default;
 
   std::shared_ptr<entity> spawn(const std::string &kind);
@@ -25,7 +24,6 @@ class entitymanager : public input::eventreceiver {
   virtual void on_mail(const input::mailevent &event) noexcept override;
 
 private:
-  std::shared_ptr<world> _world;
   std::shared_ptr<resourcemanager> _resourcemanager;
   std::list<std::shared_ptr<entity>> _entities;
   std::atomic<uint64_t> _counter{0};

src/entityprops.hpp

@@ -10,29 +10,6 @@
 
 namespace framework {
 
-enum bodytype : int8_t {
-  stationary = 0,
-  dynamic = 1,
-  kinematic = 2,
-};
-
-NLOHMANN_JSON_SERIALIZE_ENUM(bodytype, {{stationary, "stationary"}, {dynamic, "dynamic"}, {kinematic, "kinematic"}})
-
-enum collisiontype : uint8_t {
-  player = 1,
-  enemy = 2,
-  playerbullet = 3,
-  enemybullet = 4,
-  wall = 5
-};
-
-struct collision {
-  collisiontype type;
-  std::optional<std::string> from;
-};
-
-void from_json(const nlohmann::json &j, collision &c);
-
 struct keyframe {
   geometry::rect frame;
   geometry::point offset;

src/scriptengine.cpp

@@ -270,6 +270,7 @@ void scriptengine::run() {
       "on_update", &entity::set_onupdate,
       "on_animationfinished", &entity::set_onanimationfinished,
       "on_mail", &entity::set_onmail,
+      "on_collision", &entity::set_oncollision,
       "reflection", sol::property([](entity &e) -> reflectionproxy { return reflectionproxy{e}; }),
       "action", sol::property([](entity &e) -> actionproxy { return actionproxy{e}; }),
       "placement", sol::property([](entity &e) -> placementproxy { return placementproxy{e}; }),

src/size.hpp

@@ -26,7 +26,7 @@ class size {
   friend void from_json(const nlohmann::json &j, size &s) noexcept;
 
 private:
-  float_t _scale{0.0};
+  float_t _scale{.0};
   int32_t _width{0};
   int32_t _height{0};
 };

src/unmarshalling.cpp

@@ -24,28 +24,3 @@ void from_json(const nlohmann::json &j, rect &r) noexcept {
   r._size = geometry::size{j.at("width").get<int>(), j.at("height").get<int>()};
 }
 }
-
-namespace framework {
-void from_json(const nlohmann::json &j, collision &c) {
-  const auto type = j.at("type").get<std::string>();
-
-  if (type == "bullet") {
-    const auto from = j.at("from").get<std::string>();
-    if (from == "player") {
-      c.type = playerbullet;
-    } else if (from == "enemy") {
-      c.type = enemybullet;
-    } else [[unlikely]] {
-      throw std::invalid_argument("[collision] Invalid 'from' value for bullet");
-    }
-  } else if (type == "player") {
-    c.type = player;
-  } else if (type == "enemy") {
-    c.type = enemy;
-  } else if (type == "wall") {
-    c.type = wall;
-  } else {
-    throw std::invalid_argument("[collision] Invalid 'type' value");
-  }
-}
-}