FlockingComponent.hpp

#ifndef FlockingComponent_HPP
#define FlockingComponent_HPP

#include <steeriously/Agent.hpp>
#include <steeriously/SphereObstacle.hpp>
#include <steeriously/Wall.hpp>

namespace steer
{
    class FlockingComponent : public steer::Agent
    {
    public:
        FlockingComponent(steer::BehaviorParameters* params);
        virtual ~FlockingComponent();

        void setParams(steer::BehaviorParameters* params) { m_params = params; };
        steer::BehaviorParameters* getParams() { return m_params; };

        void Update(float dt);

        float getRotation() { return m_rotation; };

        void setNeighbors(std::vector<FlockingComponent*>* n) { m_neighbors = n; };
        std::vector<FlockingComponent*>* getNeighbors() { return m_neighbors; };

        void setObstacles(std::vector<SphereObstacle*>* o) { m_obstacles = o; };
        std::vector<SphereObstacle*>* getObstacles() { return m_obstacles; };

        void setWalls(std::vector<Wall*>* w) { m_walls = w; };
        std::vector<Wall*>* getWalls() { return m_walls; };

        //pure virtual - must implement see Agent.hpp
        virtual bool on(steer::behaviorType behavior) override { return (m_iFlags & behavior) == behavior; };

        void alignmentOn() { m_iFlags |= steer::behaviorType::alignment; };
        void separationOn() { m_iFlags |= steer::behaviorType::separation; };
        void cohesionOn() { m_iFlags |= steer::behaviorType::cohesion; };
        void seekOn() { m_iFlags |= steer::behaviorType::seek; };
        void wanderOn() { m_iFlags |= steer::behaviorType::wander; };
        void wallAvoidanceOn() { m_iFlags |= steer::behaviorType::wallAvoidance; };
        void obstacleAvoidanceOn() { m_iFlags |= steer::behaviorType::obstacleAvoidance; };

        void cohesionOff() { if (on(steer::behaviorType::cohesion)) m_iFlags ^= steer::behaviorType::cohesion; };
        void separationOff() { if (on(steer::behaviorType::separation)) m_iFlags ^= steer::behaviorType::separation; };
        void alignmentOff() { if (on(steer::behaviorType::alignment)) m_iFlags ^= steer::behaviorType::alignment; };
        void seekOff() { if (on(steer::behaviorType::seek)) m_iFlags ^= steer::behaviorType::seek; };
        void wanderOff() { if (on(steer::behaviorType::wander)) m_iFlags ^= steer::behaviorType::wander; };
        void wallAvoidanceOff() { if (on(steer::behaviorType::wallAvoidance)) m_iFlags ^= steer::behaviorType::wallAvoidance; };
        void obstacleAvoidanceOff() { if (on(steer::behaviorType::obstacleAvoidance)) m_iFlags ^= steer::behaviorType::obstacleAvoidance; };

        bool isCohesionOn() { return on(steer::behaviorType::cohesion); };
        bool isSeparationOn() { return on(steer::behaviorType::separation); };
        bool isAlignmentOn() { return on(steer::behaviorType::alignment); };
        bool isSeekOn() { return on(steer::behaviorType::seek); };
        bool isWanderOn() { return on(steer::behaviorType::wander); };
        bool isWallAvoidanceOn() { return on(steer::behaviorType::wallAvoidance); };
        bool isObstacleAvoidanceOn() { return on(steer::behaviorType::obstacleAvoidance); };
        bool isFlockingOn() { return isCohesionOn() && isAlignmentOn() && isSeparationOn() && isSeekOn() && isWanderOn() && isWallAvoidanceOn() && isObstacleAvoidanceOn(); };

        void flockingOn()
        {
            cohesionOn();
            alignmentOn();
            separationOn();
            seekOn();
            wanderOn();
            wallAvoidanceOn();
            obstacleAvoidanceOn();
        };

        void flockingOff()
        {
            cohesionOff();
            alignmentOff();
            separationOff();
            seekOff();
            wanderOff();
            wallAvoidanceOff();
            obstacleAvoidanceOff();
        }

        bool targetAcquired();

        //pure virtual - must implement see Agent.hpp
        virtual Vector2 Calculate() override;

        //optional virtual
        virtual Vector2 calculateWeightedSum() override;

    private:
        float                                           m_weightSeek;
        float                                           m_weightWander;
        float                                           m_weightAlignment;
        float                                           m_weightSeparation;
        float                                           m_weightCohesion;
        float                                           m_weightObstacleAvoidance;
        float                                           m_weightWallAvoidance;
        Uint32                                          m_iFlags;
        float                                           m_rotation;
        std::vector<FlockingComponent*>*                m_neighbors;
        std::vector<SphereObstacle*>*                   m_obstacles;
        std::vector<Wall*>*                             m_walls;
        steer::BehaviorParameters*                      m_params;
    };
}

#endif // FlockingComponent_HPP