Example of allowing multiple components of the same type to be queried.

src/dawn/scene/Scene.hpp

@@ -22,6 +22,9 @@ namespace Dawn {
   template<class T>
   T * _sceneForwardGetComponent(SceneItem *item);
 
+  template<class T>
+  std::vector<T*> _sceneForwardGetComponents(SceneItem *item);
+
   class Scene {
     private:
       sceneitemid_t nextId;

src/dawn/scene/SceneItem.hpp

@@ -78,6 +78,27 @@ namespace Dawn {
         }
         return nullptr;
       }
+      
+      /**
+       * Returns all components attached to this SceneItem that match the 
+       * queried component type. This method will return an array of shared
+       * pointers to the components, or an empty array if the item does not have
+       * any components of the queried type.
+       * 
+       * @tparam T Type of component to be fetched.
+       * @return An array of pointers to the components.
+       */
+      template<class T>
+      std::vector<T*> getComponents() {
+        std::vector<T*> components;
+        auto it = this->components.begin();
+        while(it != this->components.end()) {
+          T *castedAs = dynamic_cast<T*>(*it);
+          if(castedAs != nullptr) components.push_back(castedAs);
+          ++it;
+        }
+        return components;
+      }
 
       /**
        * Finds a (direct) child of this component that has a matching component.

src/dawn/scene/SceneItemComponent.hpp

@@ -79,10 +79,13 @@ namespace Dawn {
       virtual ~SceneItemComponent();
   };
 
-  
-
   template<class T>
   T * _sceneForwardGetComponent(SceneItem *item) {
     return item->getComponent<T>();
   }
+
+  template<class T>
+  T * _sceneForwardGetComponents(SceneItem *item) {
+    return item->getComponents<T>();
+  }
 }

src/dawnrose/scene/components/entity/EntityMove.cpp

@@ -23,11 +23,18 @@ void EntityMove::onStart() {
   assertNotNull(this->entityHealth);
 
   useEvent([&](float_t delta) {
+    
     // Don't move if stunned or attacking.
     if(entityHealth->isStunned()) return;
 
     // Don't move if no move.
     if(direction.x == 0 && direction.y == 0) return;
+
+    // If attacking, don't move? Will likely change this later.
+    auto attacks = item->getComponents<EntityAttackBase>();
+    for(auto attack : attacks) {
+      if(attack->isAttacking()) return;
+    }
     
     // Move
     float_t angle = atan2(direction.y, direction.x);

src/dawnrose/scene/components/entity/EntityMove.hpp

@@ -7,6 +7,7 @@
 #include "scene/SceneItemComponent.hpp"
 #include "scene/components/physics/2d/CharacterController2D.hpp"
 #include "scene/components/entity/EntityHealth.hpp"
+#include "scene/components/entity/EntityAttackBase.hpp"
 
 namespace Dawn {
   class EntityMove : public SceneItemComponent {