Agent.hpp

#ifndef AGENT_HPP
#define AGENT_HPP

#include <vector>

#include <steeriously/BehaviorData.hpp>
#include <steeriously/Utilities.hpp>
#include <steeriously/Vector2.hpp>
#include <steeriously/VectorMath.hpp>

namespace steer //steeriously namespace
{

    class Agent
    {

    public:

        Agent();

        Agent(steer::Vector2 position, float radius, steer::Vector2 velocity, steer::Vector2 heading, steer::Vector2 side, float mass, float maxSpeed, float maxForce, float maxTurnRate);

        Agent(steer::BehaviorParameters* params);

        virtual ~Agent();

        steer::Vector2 getPosition() const { return m_agentPosition; };

        void setPosition(steer::Vector2 newPosition) { m_agentPosition = newPosition; };

        float getBoundingRadius()const { return m_boundingRadius; }

        void setBoundingRadius(float radius) { m_boundingRadius = radius; };

        bool taggedInGroup() const { return m_tag; };

        void Tag() { m_tag = true; };

        void unTag() { m_tag = false; };

        steer::Vector2 getScale() const { return m_scale; };

        void setScale(steer::Vector2 val)
        {
            m_boundingRadius *= MaxOf(val.x, val.y) / MaxOf(m_scale.x, m_scale.y);
            m_scale = val;
        }

        void setScale(float val)
        {
            m_boundingRadius *= (val / MaxOf(m_scale.x, m_scale.y));
            m_scale = steer::Vector2(val, val);
        };

        steer::Vector2 getVelocity() const { return m_velocity; }

        float getMass() const { return m_mass; }

        steer::Vector2 getSide() const { return m_side; }

        void setSide(const steer::Vector2 side) { m_side = side; }

        float getMaxSpeed() const { return m_maxSpeed; }

        void setMaxSpeed(float newSpeed) { m_maxSpeed = newSpeed; }

        float getMaxForce() const { return m_maxForce; }

        void setMaxForce(float maxForce) { m_maxForce = maxForce; }

        steer::Vector2 getForce() const { return m_steeringForce; }

        bool speedMaxedOut() const { return m_maxSpeed*m_maxSpeed >= VectorMath::lengthSquared(m_velocity); }

        float getSpeed() const { return VectorMath::length(m_velocity); }

        float getSpeedSquared() const { return VectorMath::lengthSquared(m_velocity); }

        steer::Vector2 getHeading() const { return m_heading; }

        void setHeading(steer::Vector2 newHeading);

        bool rotateHeadingToFacePosition(steer::Vector2 target);

        float getMaxTurnRate() const { return m_maxTurnRate; }

        void setMaxTurnRate(float maxTurnRate) { m_maxTurnRate = maxTurnRate; }

        float getForwardComponent();

        float getSideComponent();

        void setTarget(const steer::Vector2 target) { m_target = target; };

        steer::Vector2 getTarget() const { return m_target; };

        void setThreatRange(const float range) { m_threatRange = range; };

        float getThreatRange() const { return m_threatRange; };

        void setDecelerationTweaker(const float deceleration) { m_decelerationTweaker = deceleration; };

        float getDecelerationTweaker() const { return m_decelerationTweaker; };

        void setWanderTarget(const steer::Vector2 target) { m_wanderTarget = target; };

        steer::Vector2 getWanderTarget() const { return m_wanderTarget; };

        void setWanderJitter(const float jitter) { m_wanderJitter = jitter; };

        float getWanderJitter() const { return m_wanderJitter; };

        void setWanderRadius(const float radius) { m_wanderRadius = radius; };

        float getWanderRadius() const { return m_wanderRadius; };

        void setWanderDistance(const float distance) { m_wanderDistance = distance; };

        float getWanderDistance() const { return m_wanderDistance; };

        void setDistanceBuffer(const float buffer) { m_distanceBuffer = buffer; };

        float getDistanceBuffer() const { return m_distanceBuffer; };

        void setOffset(const steer::Vector2 offset) { m_offset = offset; };

        steer::Vector2 getOffset() const { return m_offset; }

        void createFeelers();

        float boxLength() const { return m_boxLength; }

        void setBoxLength(const float length) { m_boxLength = length; }

        const std::vector<steer::Vector2>& getFeelers() const { return m_feelers; }

        virtual bool on(steer::behaviorType behavior) = 0;

        virtual void setSummingMethod(Uint32 sumMethod);

        virtual bool accumulateForce(steer::Vector2 &startingForce, steer::Vector2 forceToAdd);

        virtual steer::Vector2 calculateWeightedSum();

        virtual steer::Vector2 calculatePrioritized();

        virtual steer::Vector2 Calculate() = 0;

        float getElapsedTime() { return m_timeElapsed; };

        float setElapsedTime(float e) { m_timeElapsed = e; };

        //all data are public
        //getters/setters provided for anyone that wants them...
        //Since the whole purpose of this library is to
        //keep things easy - public data is the best approach
    public:
        steer::Vector2                              m_agentPosition;
        steer::Vector2                              m_scale;
        bool                                        m_tag;
        float                                       m_boundingRadius;
        steer::Vector2                              m_steeringForce;
        float                                       m_waypointSeekDistanceSquared;
        std::vector<steer::Vector2>                 m_feelers;
        steer::Vector2                              m_velocity;
        steer::Vector2                              m_heading;
        steer::Vector2                              m_side;
        float                                       m_mass;
        float                                       m_timeElapsed;
        steer::Vector2                              m_offset;
        float                                       m_viewDistance;
        Uint32                                      m_deceleration;
        float                                       m_boxLength;
        float                                       m_wallDetectionFeelerLength;
        float                                       m_maxSpeed;
        float                                       m_maxForce;
        float                                       m_maxTurnRate;
        steer::Vector2                              m_target;
        float                                       m_threatRange;
        float                                       m_decelerationTweaker;
        float                                       m_distanceBuffer;
        steer::Vector2                              m_wanderTarget;
        float                                       m_wanderJitter;
        float                                       m_wanderRadius;
        float                                       m_wanderDistance;
    };
} //end steeriously namespace

#endif // AGENT_HPP