Merge pull request #129 from zackthehuman/entity_removal_on_destroy

Emit ComponentRemovedEvent<T> on Entity::destroy()

7 files changed, 248 insertions, 182 deletions

diff --git a/README.md b/README.md
index 90057da..db124ce 100644
--- a/README.md
+++ b/README.md
@@ -290,6 +290,7 @@ Several events are emitted by EntityX itself:
 - Event objects are destroyed after delivery, so references should not be retained.
 - A single class can receive any number of types of events by implementing a ``receive(const EventType &)`` method for each event type.
 - Any class implementing `Receiver` can receive events, but typical usage is to make `System`s also be `Receiver`s.
+- When an `Entity` is destroyed it will cause all of its components to be removed. This triggers `ComponentRemovedEvent`s to be triggered for each of its components. These events are triggered before the `EntityDestroyedEvent`.
 
 ### Manager (tying it all together)
 
diff --git a/entityx/ComponentHandle.h b/entityx/ComponentHandle.h
new file mode 100644
index 0000000..9406705
--- /dev/null
+++ b/entityx/ComponentHandle.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2012 Alec Thomas <alec@swapoff.org>
+ * All rights reserved.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.
+ *
+ * Author: Alec Thomas <alec@swapoff.org>
+ */
+
+#pragma once
+
+namespace entityx {
+
+class EntityManager;
+
+/**
+ * A ComponentHandle<C> is a wrapper around an instance of a component.
+ *
+ * It provides safe access to components. The handle will be invalidated under
+ * the following conditions:
+ *
+ * - If a component is removed from its host entity.
+ * - If its host entity is destroyed.
+ */
+template <typename C, typename EM>
+class ComponentHandle {
+public:
+  typedef C ComponentType;
+
+  ComponentHandle() : manager_(nullptr) {}
+
+  bool valid() const;
+  operator bool() const;
+
+  C *operator -> ();
+  const C *operator -> () const;
+
+  C *get();
+  const C *get() const;
+
+  /**
+   * Remove the component from its entity and destroy it.
+   */
+  void remove();
+
+  bool operator == (const ComponentHandle<C> &other) const {
+    return manager_ == other.manager_ && id_ == other.id_;
+  }
+
+  bool operator != (const ComponentHandle<C> &other) const {
+    return !(*this == other);
+  }
+
+private:
+  friend class EntityManager;
+
+  ComponentHandle(EM *manager, Entity::Id id) :
+      manager_(manager), id_(id) {}
+
+  EM *manager_;
+  Entity::Id id_;
+};
+
+}
diff --git a/entityx/Entity.h b/entityx/Entity.h
index 3d0b96f..5e9b17d 100644
--- a/entityx/Entity.h
+++ b/entityx/Entity.h
@@ -27,12 +27,14 @@
 #include <utility>
 #include <vector>
 #include <type_traits>
- #include <functional>
+#include <functional>
 
 #include "entityx/help/Pool.h"
+#include "entityx/EntityClass.h"
 #include "entityx/config.h"
 #include "entityx/Event.h"
 #include "entityx/help/NonCopyable.h"
+#include "entityx/ComponentHandle.h"
 
 namespace entityx {
 
@@ -41,185 +43,6 @@ typedef std::uint64_t uint64_t;
 
 class EntityManager;
 
-
-template <typename C, typename EM = EntityManager>
-class ComponentHandle;
-
-
-
-/** A convenience handle around an Entity::Id.
- *
- * If an entity is destroyed, any copies will be invalidated. Use valid() to
- * check for validity before using.
- *
- * Create entities with `EntityManager`:
- *
- *     Entity entity = entity_manager->create();
- */
-class Entity {
-public:
-  struct Id {
-    Id() : id_(0) {}
-    explicit Id(uint64_t id) : id_(id) {}
-    Id(uint32_t index, uint32_t version) : id_(uint64_t(index) | uint64_t(version) << 32UL) {}
-
-    uint64_t id() const { return id_; }
-
-    bool operator == (const Id &other) const { return id_ == other.id_; }
-    bool operator != (const Id &other) const { return id_ != other.id_; }
-    bool operator < (const Id &other) const { return id_ < other.id_; }
-
-    uint32_t index() const { return id_ & 0xffffffffUL; }
-    uint32_t version() const { return id_ >> 32; }
-
-  private:
-    friend class EntityManager;
-
-    uint64_t id_;
-  };
-
-
-  /**
-   * Id of an invalid Entity.
-   */
-  static const Id INVALID;
-
-  Entity() = default;
-  Entity(EntityManager *manager, Entity::Id id) : manager_(manager), id_(id) {}
-  Entity(const Entity &other) = default;
-  Entity &operator = (const Entity &other) = default;
-
-  /**
-   * Check if Entity handle is invalid.
-   */
-  operator bool() const {
-    return valid();
-  }
-
-  bool operator == (const Entity &other) const {
-    return other.manager_ == manager_ && other.id_ == id_;
-  }
-
-  bool operator != (const Entity &other) const {
-    return !(other == *this);
-  }
-
-  bool operator < (const Entity &other) const {
-    return other.id_ < id_;
-  }
-
-  /**
-   * Is this Entity handle valid?
-   *
-   * In older versions of EntityX, there were no guarantees around entity
-   * validity if a previously allocated entity slot was reassigned. That is no
-   * longer the case: if a slot is reassigned, old Entity::Id's will be
-   * invalid.
-   */
-  bool valid() const;
-
-  /**
-   * Invalidate Entity handle, disassociating it from an EntityManager and invalidating its ID.
-   *
-   * Note that this does *not* affect the underlying entity and its
-   * components. Use destroy() to destroy the associated Entity and components.
-   */
-  void invalidate();
-
-  Id id() const { return id_; }
-
-  template <typename C, typename ... Args>
-  ComponentHandle<C> assign(Args && ... args);
-
-  template <typename C>
-  ComponentHandle<C> assign_from_copy(const C &component);
-
-  template <typename C, typename ... Args>
-  ComponentHandle<C> replace(Args && ... args);
-
-  template <typename C>
-  void remove();
-
-  template <typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type>
-  ComponentHandle<C> component();
-
-  template <typename C, typename = typename std::enable_if<std::is_const<C>::value>::type>
-  const ComponentHandle<C, const EntityManager> component() const;
-
-  template <typename ... Components>
-  std::tuple<ComponentHandle<Components>...> components();
-
-  template <typename ... Components>
-  std::tuple<ComponentHandle<const Components, const EntityManager>...> components() const;
-
-  template <typename C>
-  bool has_component() const;
-
-  template <typename A, typename ... Args>
-  void unpack(ComponentHandle<A> &a, ComponentHandle<Args> & ... args);
-
-  /**
-   * Destroy and invalidate this Entity.
-   */
-  void destroy();
-
-  std::bitset<entityx::MAX_COMPONENTS> component_mask() const;
-
- private:
-  EntityManager *manager_ = nullptr;
-  Entity::Id id_ = INVALID;
-};
-
-
-/**
- * A ComponentHandle<C> is a wrapper around an instance of a component.
- *
- * It provides safe access to components. The handle will be invalidated under
- * the following conditions:
- *
- * - If a component is removed from its host entity.
- * - If its host entity is destroyed.
- */
-template <typename C, typename EM>
-class ComponentHandle {
-public:
-  typedef C ComponentType;
-
-  ComponentHandle() : manager_(nullptr) {}
-
-  bool valid() const;
-  operator bool() const;
-
-  C *operator -> ();
-  const C *operator -> () const;
-
-  C *get();
-  const C *get() const;
-
-  /**
-   * Remove the component from its entity and destroy it.
-   */
-  void remove();
-
-  bool operator == (const ComponentHandle<C> &other) const {
-    return manager_ == other.manager_ && id_ == other.id_;
-  }
-
-  bool operator != (const ComponentHandle<C> &other) const {
-    return !(*this == other);
-  }
-
-private:
-  friend class EntityManager;
-
-  ComponentHandle(EM *manager, Entity::Id id) :
-      manager_(manager), id_(id) {}
-
-  EM *manager_;
-  Entity::Id id_;
-};
-
-
 /**
  * Base component class, only used for insertion into collections.
  *
@@ -558,12 +381,14 @@ class EntityManager : entityx::help::NonCopyable {
     assert_valid(entity);
     uint32_t index = entity.index();
     auto mask = entity_component_mask_[entity.index()];
-    event_manager_.emit<EntityDestroyedEvent>(Entity(this, entity));
     for (size_t i = 0; i < component_pools_.size(); i++) {
       BasePool *pool = component_pools_[i];
-      if (pool && mask.test(i))
+      if (pool && mask.test(i)) {
+        pool->remove_component(Entity(this, entity));
         pool->destroy(index);
+      }
     }
+    event_manager_.emit<EntityDestroyedEvent>(Entity(this, entity));
     entity_component_mask_[index].reset();
     entity_version_[index]++;
     free_list_.push_back(index);
diff --git a/entityx/EntityClass.h b/entityx/EntityClass.h
new file mode 100644
index 0000000..94a2a02
--- /dev/null
+++ b/entityx/EntityClass.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2012 Alec Thomas <alec@swapoff.org>
+ * All rights reserved.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.
+ *
+ * Author: Alec Thomas <alec@swapoff.org>
+ */
+
+#pragma once
+
+#include <bitset>
+#include "entityx/config.h"
+
+namespace entityx {
+
+class EntityManager;
+
+template <typename C, typename EM = EntityManager>
+class ComponentHandle;
+
+/** A convenience handle around an Entity::Id.
+ *
+ * If an entity is destroyed, any copies will be invalidated. Use valid() to
+ * check for validity before using.
+ *
+ * Create entities with `EntityManager`:
+ *
+ *     Entity entity = entity_manager->create();
+ */
+class Entity {
+public:
+  struct Id {
+    Id() : id_(0) {}
+    explicit Id(uint64_t id) : id_(id) {}
+    Id(uint32_t index, uint32_t version) : id_(uint64_t(index) | uint64_t(version) << 32UL) {}
+
+    uint64_t id() const { return id_; }
+
+    bool operator == (const Id &other) const { return id_ == other.id_; }
+    bool operator != (const Id &other) const { return id_ != other.id_; }
+    bool operator < (const Id &other) const { return id_ < other.id_; }
+
+    uint32_t index() const { return id_ & 0xffffffffUL; }
+    uint32_t version() const { return id_ >> 32; }
+
+  private:
+    friend class EntityManager;
+
+    uint64_t id_;
+  };
+
+
+  /**
+   * Id of an invalid Entity.
+   */
+  static const Id INVALID;
+
+  Entity() = default;
+  Entity(EntityManager *manager, Entity::Id id) : manager_(manager), id_(id) {}
+  Entity(const Entity &other) = default;
+  Entity &operator = (const Entity &other) = default;
+
+  /**
+   * Check if Entity handle is invalid.
+   */
+  operator bool() const {
+    return valid();
+  }
+
+  bool operator == (const Entity &other) const {
+    return other.manager_ == manager_ && other.id_ == id_;
+  }
+
+  bool operator != (const Entity &other) const {
+    return !(other == *this);
+  }
+
+  bool operator < (const Entity &other) const {
+    return other.id_ < id_;
+  }
+
+  /**
+   * Is this Entity handle valid?
+   *
+   * In older versions of EntityX, there were no guarantees around entity
+   * validity if a previously allocated entity slot was reassigned. That is no
+   * longer the case: if a slot is reassigned, old Entity::Id's will be
+   * invalid.
+   */
+  bool valid() const;
+
+  /**
+   * Invalidate Entity handle, disassociating it from an EntityManager and invalidating its ID.
+   *
+   * Note that this does *not* affect the underlying entity and its
+   * components. Use destroy() to destroy the associated Entity and components.
+   */
+  void invalidate();
+
+  Id id() const { return id_; }
+
+  template <typename C, typename ... Args>
+  ComponentHandle<C> assign(Args && ... args);
+
+  template <typename C>
+  ComponentHandle<C> assign_from_copy(const C &component);
+
+  template <typename C, typename ... Args>
+  ComponentHandle<C> replace(Args && ... args);
+
+  template <typename C>
+  void remove();
+
+  template <typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type>
+  ComponentHandle<C> component();
+
+  template <typename C, typename = typename std::enable_if<std::is_const<C>::value>::type>
+  const ComponentHandle<C, const EntityManager> component() const;
+
+  template <typename ... Components>
+  std::tuple<ComponentHandle<Components>...> components();
+
+  template <typename ... Components>
+  std::tuple<ComponentHandle<const Components, const EntityManager>...> components() const;
+
+  template <typename C>
+  bool has_component() const;
+
+  template <typename A, typename ... Args>
+  void unpack(ComponentHandle<A> &a, ComponentHandle<Args> & ... args);
+
+  /**
+   * Destroy and invalidate this Entity.
+   */
+  void destroy();
+
+  std::bitset<entityx::MAX_COMPONENTS> component_mask() const;
+
+ private:
+  EntityManager *manager_ = nullptr;
+  Entity::Id id_ = INVALID;
+};
+
+}
diff --git a/entityx/Entity_test.cc b/entityx/Entity_test.cc
index 2076ed7..e07a567 100644
--- a/entityx/Entity_test.cc
+++ b/entityx/Entity_test.cc
@@ -405,6 +405,27 @@ TEST_CASE_METHOD(EntityManagerFixture, "TestComponentRemovedEvent") {
   REQUIRE(!(e.component<Direction>()));
 }
 
+TEST_CASE_METHOD(EntityManagerFixture, "TestComponentRemovedEventOnEntityDestroyed") {
+  struct ComponentRemovedReceiver : public Receiver<ComponentRemovedReceiver> {
+    void receive(const ComponentRemovedEvent<Direction> &event) {
+      removed = true;
+    }
+
+    bool removed = false;
+  };
+
+  ComponentRemovedReceiver receiver;
+  ev.subscribe<ComponentRemovedEvent<Direction>>(receiver);
+
+  REQUIRE(!(receiver.removed));
+
+  Entity e = em.create();
+  e.assign<Direction>(1.0, 2.0);
+  e.destroy();
+
+  REQUIRE(receiver.removed);
+}
+
 TEST_CASE_METHOD(EntityManagerFixture, "TestEntityAssignment") {
   Entity a, b;
   a = em.create();
diff --git a/entityx/help/Pool.h b/entityx/help/Pool.h
index f217ec2..b28e4e7 100644
--- a/entityx/help/Pool.h
+++ b/entityx/help/Pool.h
@@ -14,6 +14,8 @@
 #include <cassert>
 #include <vector>
 
+#include "entityx/EntityClass.h"
+
 namespace entityx {
 
 /**
@@ -63,6 +65,7 @@ class BasePool {
   }
 
   virtual void destroy(std::size_t n) = 0;
+  virtual void remove_component(Entity entity) = 0;
 
  protected:
   std::vector<char *> blocks_;
@@ -90,6 +93,10 @@ class Pool : public BasePool {
     T *ptr = static_cast<T*>(get(n));
     ptr->~T();
   }
+
+  virtual void remove_component(Entity entity) override {
+    entity.remove<T>();
+  }
 };
 
 }  // namespace entityx
diff --git a/entityx/help/Pool_test.cc b/entityx/help/Pool_test.cc
index 56ca85a..1092068 100644
--- a/entityx/help/Pool_test.cc
+++ b/entityx/help/Pool_test.cc
@@ -13,6 +13,7 @@
 #include <vector>
 #include "entityx/3rdparty/catch.hpp"
 #include "entityx/help/Pool.h"
+#include "entityx/Entity.h"
 
 struct Position {
   explicit Position(int *ptr = nullptr) : ptr(ptr) {