Activities.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2018 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_ACTIVITIES_H
#define GF_ACTIVITIES_H

#include <functional>
#include <vector>

#include "Activity.h"
#include "Portability.h"
#include "Tween.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  class GF_API ValueActivity : public Activity {
  public:
    ValueActivity(float origin, float target, float& value, Time duration, Easing easing = Ease::linear);

    void setOrigin(float origin) {
      m_tween.setOrigin(origin);
    }

    float getOrigin() const noexcept {
      return m_tween.getOrigin();
    }

    void setTarget(float target) {
      m_tween.setTarget(target);
    }

    float getTarget() const noexcept {
      return m_tween.getTarget();
    }

    void setDuration(Time duration) {
      m_tween.setDuration(duration);
    }

    Time getDuration() const noexcept {
      return m_tween.getDuration();
    }

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Tween<float> m_tween;
  };


  class GF_API RotateToActivity : public Activity {
  public:
    RotateToActivity(float origin, float target, float& angle, Time duration, Easing easing = Ease::linear);

    void setOrigin(float origin) {
      m_tween.setOrigin(origin);
      normalize();
    }

    float getOrigin() const noexcept {
      return m_tween.getOrigin();
    }

    void setTarget(float target) {
      m_tween.setTarget(target);
      normalize();
    }

    float getTarget() const noexcept {
      return m_tween.getTarget();
    }

    void setDuration(Time duration) {
      m_tween.setDuration(duration);
    }

    Time getDuration() const noexcept {
      return m_tween.getDuration();
    }

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    void normalize();

  private:
    Tween<float> m_tween;
  };


  class GF_API MoveToActivity : public Activity {
  public:
    MoveToActivity(Vector2f origin, Vector2f target, Vector2f& position, Time duration, Easing easing = Ease::linear);

    void setOrigin(Vector2f origin) {
      m_tween.setOrigin(origin);
    }

    Vector2f getOrigin() const noexcept {
      return m_tween.getOrigin();
    }

    void setTarget(Vector2f target) {
      m_tween.setTarget(target);
    }

    Vector2f getTarget() const noexcept {
      return m_tween.getTarget();
    }

    void setDuration(Time duration) {
      m_tween.setDuration(duration);
    }

    Time getDuration() const noexcept {
      return m_tween.getDuration();
    }

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Tween<Vector2f> m_tween;
  };


  class GF_API ColorActivity : public Activity {
  public:
    ColorActivity(Color4f origin, Color4f target, Color4f& color, Time duration, Easing easing = Ease::linear);

    void setOrigin(Color4f origin) {
      m_tween.setOrigin(origin);
    }

    Color4f getOrigin() const noexcept {
      return m_tween.getOrigin();
    }

    void setTarget(Color4f target) {
      m_tween.setTarget(target);
    }

    Color4f getTarget() const noexcept {
      return m_tween.getTarget();
    }

    void setDuration(Time duration) {
      m_tween.setDuration(duration);
    }

    Time getDuration() const noexcept {
      return m_tween.getDuration();
    }

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Tween<Color4f> m_tween;
  };


  class GF_API CallbackActivity : public Activity {
  public:
    CallbackActivity(std::function<void()> callback);

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    std::function<void()> m_callback;
    bool m_called;
  };


  class GF_API DelayActivity : public Activity {
  public:
    DelayActivity(Time duration);

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Time m_elapsed;
    Time m_duration;
  };


  class GF_API SequenceActivity : public Activity {
  public:
    SequenceActivity();

    void addActivity(Activity& activity);

    void clear();

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    std::size_t m_current;
    std::vector<Activity*> m_activities;
  };


  class GF_API RepeatActivity : public Activity {
  public:
    RepeatActivity(Activity& activity, unsigned repeat = 0);

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Activity& m_activity;
    unsigned m_count;
    unsigned m_repeat;
  };


  class GF_API RepeatedSequenceActivity : public Activity {
  public:
    RepeatedSequenceActivity(unsigned repeat = 0);

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    SequenceActivity m_sequence;
    RepeatActivity m_repeat;
  };


  class GF_API ParallelActivity : public Activity {
  public:
    enum class Finish {
      Any,  
      All,  
    };

    ParallelActivity(Finish finish = Finish::Any);

    void addActivity(Activity& activity);

    void clear();

    virtual ActivityStatus run(Time time) override;
    virtual void restart() override;

  private:
    Finish m_finish;
    ActivityStatus m_status;
    std::vector<Activity*> m_activities;
  };


#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_ACTIVITIES_H