Task

// task.h

#ifndef task_h__
#define task_h__

namespace Evanescent
{
    class Unit;
    /*!
    * @class AbstractTask
    *
    * @brief Abstrakte Basisklasse für Aufgaben.
    *
    * @author NachoMan
    */
    class AbstractTask
    {
        void doCopy(const AbstractTask& rhs);
        size_t currentTask_;
        bool hasSubTasksCompleted_;
    protected:
        std::vector<std::unique_ptr<AbstractTask> > subTasks_;

        AbstractTask();
        AbstractTask(const AbstractTask& rhs);
        const AbstractTask& operator=(const AbstractTask& rhs);

    public:
        virtual ~AbstractTask();
        /**
        * @brief Ruft myUpdate der subTasks in richtiger Reihenfolge auf
        */
        void update(Unit& unit, const float frametime);

        /**
        * @brief setzt hasSubTasksCompleted_ zurück
        */
        void restart();

        void addTask(AbstractTask *task);

        /**
        * @brief Update für die Unit.
        */
        virtual void myUpdate(Unit& unit, const float frametime) = 0;

        bool isCompleted();
        virtual bool shouldBeDestroyedIfComplete() = 0;

        virtual AbstractTask* getCopy() = 0;

    private:
        virtual bool myIsCompleted() = 0;
    };

    /*!
    * @class IdleTask
    *
    * @brief Unit macht nichts.
    *
    * @author NachoMan
    */
    class IdleTask : public AbstractTask
    {
    public:
        virtual void myUpdate(Unit& unit, const float frametime)
        {
        }

        virtual bool shouldBeDestroyedIfComplete(){return false;}

        virtual AbstractTask* getCopy(){return new IdleTask(*this);}

    private:
        virtual bool myIsCompleted(){return true;}
    };

    /*!
    * @class MoveTask
    *
    * @brief Unit bewegt sich zum übergebenen Punkt.
    *
    * @author NachoMan
    */
    class MoveTask : public AbstractTask
    {
        sf::Vector2f targetPosition_;
        bool completed_;
    public:

        MoveTask(const sf::Vector2f& targetPosition);

        virtual void myUpdate(Unit& unit, const float frametime);

        virtual bool shouldBeDestroyedIfComplete();

        virtual AbstractTask* getCopy(){return new MoveTask(*this);}

    private:
        virtual bool myIsCompleted();
    };
}

#endif // task_h__

// .cpp

#include "task.h"
#include "unit.h"
#include "util.h"

namespace Evanescent
{

void AbstractTask::doCopy( const AbstractTask& rhs )
{
    currentTask_ = rhs.currentTask_;
    subTasks_.clear();
    subTasks_.reserve(rhs.subTasks_.size());
    std::vector<std::unique_ptr<AbstractTask> >::const_iterator endIt(rhs.subTasks_.end());
    for(std::vector<std::unique_ptr<AbstractTask> >::const_iterator it(rhs.subTasks_.begin()); it != endIt; ++it)
    {
        subTasks_.push_back(std::unique_ptr<AbstractTask>((*it)->getCopy()));
    }
}

AbstractTask::AbstractTask()
    :currentTask_(0),
    subTasks_(),
    hasSubTasksCompleted_(true)
{
}

AbstractTask::AbstractTask( const AbstractTask& rhs )
{
    doCopy(rhs);
}

const AbstractTask& AbstractTask::operator=( const AbstractTask& rhs )
{
    doCopy(rhs);
    return *this;
}

AbstractTask::~AbstractTask()
{
}

void AbstractTask::update( Unit& unit, const float frametime )
{
    if(!hasSubTasksCompleted_ && !subTasks_.empty())
    {
        if(subTasks_.size() <= currentTask_)
        {
            currentTask_ = 0;
            hasSubTasksCompleted_ = true;
        }
        else
        {
            std::vector<std::unique_ptr<AbstractTask> >::iterator task(subTasks_.begin()+currentTask_);
            while((*task)->isCompleted())
            {
                if(subTasks_.size() <= ++currentTask_)
                {
                    currentTask_ = 0;
                    hasSubTasksCompleted_ = true;
                    return;
                }
                task = subTasks_.begin()+currentTask_;
            }
            (*task)->update(unit, frametime);
            if((*task)->isCompleted())
            {
                if((*task)->shouldBeDestroyedIfComplete())
                {
                    task = subTasks_.erase(task);
                }
                else
                {
                    ++currentTask_;
                }
            }
        }
    }
    else
    {
        myUpdate(unit, frametime);
    }
}

void AbstractTask::restart()
{
    hasSubTasksCompleted_ = false;
    std::vector<std::unique_ptr<AbstractTask> >::iterator endIt(subTasks_.end());
    for(std::vector<std::unique_ptr<AbstractTask> >::iterator it(subTasks_.begin()); it != endIt; ++it)
    {
        (*it)->restart();
    }
}

void AbstractTask::addTask( AbstractTask *task )
{
    subTasks_.push_back(std::unique_ptr<AbstractTask>(task));
    hasSubTasksCompleted_ = false;
}

bool AbstractTask::isCompleted()
{
    return hasSubTasksCompleted_ && myIsCompleted();
}

MoveTask::MoveTask(const sf::Vector2f& target)
    :targetPosition_(target),
    completed_(false)
{
}

void MoveTask::myUpdate( Unit& unit, const float frametime )
{
    sf::Vector2f moveVector;
    {
        sf::Lock lock(unit.mutex_);
        moveVector.x = targetPosition_.x-(unit.rect_.left+unit.rect_.width/2.f);
        moveVector.y = targetPosition_.y-(unit.rect_.top+unit.rect_.height/2.f);
    }
    float squaredLength = calcSquaredLength(moveVector);
    if(squaredLength > 4.0f && squaredLength > unit.speed_*frametime*unit.speed_*frametime)
    {
        float distance = std::sqrt(squaredLength);
        unit.rect_.left += moveVector.x/distance*unit.speed_*frametime;
        unit.rect_.top += moveVector.y/distance*unit.speed_*frametime;
    }
    else
    {
        completed_ = true;
    }
}

bool MoveTask::shouldBeDestroyedIfComplete()
{
    return true;
}

bool MoveTask::myIsCompleted()
{
    return completed_;
}

}