Activities.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2021 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 <cassert>
#include <functional>
#include <vector>

#include "Activity.h"
#include "CoreApi.h"
#include "Ref.h"
#include "Tween.h"
#include "Vector.h"

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

  class GF_CORE_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();
    }

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

  private:
    Tween<float> m_tween;
  };


  class GF_CORE_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();
    }

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

  private:
    void normalize();

  private:
    Tween<float> m_tween;
  };


  class GF_CORE_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();
    }

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

  private:
    Tween<Vector2f> m_tween;
  };


  class GF_CORE_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();
    }

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

  private:
    Tween<Color4f> m_tween;
  };


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

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

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


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

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

  private:
    Time m_elapsed;
    Time m_duration;
  };


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

    void addActivity(Activity& activity);

    void clear();

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

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


  class GF_CORE_API RepeatActivity : public Activity {
  public:
    RepeatActivity(Activity& activity, int repeat = 0);

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

  private:
    Ref<Activity> m_activity;
    int m_count;
    int m_repeat;
  };

  enum class ActivityFinish {
    Any,  
    All,  
  };

  class GF_CORE_API ParallelActivity : public Activity {
  public:

    ParallelActivity(ActivityFinish finish = ActivityFinish::Any);

    void addActivity(Activity& activity);

    void clear();

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

  private:
    ActivityFinish m_finish;
    ActivityStatus m_status;
    std::vector<Ref<Activity>> m_activities;
  };

  namespace activity {
    inline
    ValueActivity value(float origin, float target, float& value, Time duration, Easing easing = Ease::linear) {
      return ValueActivity(origin, target, value, duration, easing);
    }

    inline
    RotateToActivity rotateTo(float origin, float target, float& angle, Time duration, Easing easing = Ease::linear) {
      return RotateToActivity(origin, target, angle, duration, easing);
    }

    inline
    MoveToActivity moveTo(Vector2f origin, Vector2f target, Vector2f& position, Time duration, Easing easing = Ease::linear) {
      return MoveToActivity(origin, target, position, duration, easing);
    }

    inline
    ColorActivity color(Color4f origin, Color4f target, Color4f& color, Time duration, Easing easing = Ease::linear) {
      return ColorActivity(origin, target, color, duration, easing);
    }

    inline
    CallbackActivity call(std::function<void()> callback) {
      return CallbackActivity(std::move(callback));
    }

    inline
    DelayActivity delay(Time duration) {
      return DelayActivity(duration);
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    // inspired by https://accu.org/journals/overload/25/139/williams_2382/

    template<typename Tuple, std::size_t I>
    Activity& activityTupleGet(Tuple& tuple) {
      return std::get<I>(tuple);
    }

    template<typename Tuple, typename Indices = std::make_index_sequence<std::tuple_size_v<Tuple>>>
    struct ActivityTupleGetters;

    template<typename Tuple, std::size_t ... Indices>
    struct ActivityTupleGetters<Tuple, std::index_sequence<Indices...>>
    {
      using Getter = Activity& (*)(Tuple&);
      static inline constexpr Getter table[std::tuple_size_v<Tuple>] = { &activityTupleGet<Tuple, Indices>... };
    };

    template<typename Tuple>
    Activity& activityTupleGetIth(Tuple& tuple, std::size_t i) {
      assert(i < std::tuple_size_v<Tuple>);
      return ActivityTupleGetters<Tuple>::table[i](tuple);
    }

#endif

    template<typename... Args>
    class SequenceActivityEx : public Activity {
    public:
      SequenceActivityEx(Args... activities)
      : m_current(0)
      , m_activities(std::forward<Args>(activities)...)
      {
      }

      ActivityStatus run(Time time) override {
        if (m_current == sizeof... (Args)) {
          return ActivityStatus::Finished;
        }

        Activity& currentActivity = activityTupleGetIth(m_activities, m_current);
        auto status = currentActivity.run(time);

        if (status == ActivityStatus::Finished) {
          m_current++;
        }

        return m_current == sizeof... (Args) ? ActivityStatus::Finished : ActivityStatus::Running;
      }

      void restart() override {
        m_current = 0;

        for (std::size_t i = 0; i < sizeof ... (Args); ++i) {
          activityTupleGetIth(m_activities, i).restart();
        }
      }

    private:
      std::size_t m_current;
      std::tuple<Args...> m_activities;
    };

    template<typename... Args>
    SequenceActivityEx<Args...> sequence(Args... activities) {
      return SequenceActivityEx<Args...>(std::forward<Args>(activities)...);
    }

    template<typename Other>
    class RepeatActivityEx : public Activity {
    public:
      RepeatActivityEx(Other activity, int repeat)
      : m_activity(std::move(activity))
      , m_count(0)
      , m_repeat(repeat)
      {
      }

      ActivityStatus run(Time time) override {
        if (m_count > 0 && m_repeat == m_count) {
          return ActivityStatus::Finished;
        }

        auto status = m_activity.run(time);

        if (status == ActivityStatus::Finished) {
          m_activity.restart();
          m_count++;
        }

        return (m_repeat > 0 && m_repeat == m_count) ? ActivityStatus::Finished : ActivityStatus::Running;
      }

      void restart() override {
        m_count = 0;
        m_activity.restart();
      }

    private:
      Other m_activity;
      int m_count;
      int m_repeat;
    };

    template<typename Other>
    RepeatActivityEx<Other> repeat(Other activity, int repeat = 0) {
      return RepeatActivityEx<Other>(std::move(activity), repeat);
    }

    template<typename... Args>
    class ParallelActivityEx : public Activity {
    public:
      ParallelActivityEx(ActivityFinish finish, Args... activities)
      : m_finish(finish)
      , m_status(ActivityStatus::Running)
      , m_activities(std::forward<Args>(activities)...)
      {
      }

      ActivityStatus run(Time time) override {
        if (m_status == ActivityStatus::Finished) {
          return ActivityStatus::Finished;
        }

        std::size_t finished = 0;

        for (std::size_t i = 0; i < sizeof ... (Args); ++i) {
          auto status = activityTupleGetIth(m_activities, i).run(time);

          if (status == ActivityStatus::Finished) {
            finished++;
          }
        }

        switch (m_finish) {
          case ActivityFinish::Any:
            if (finished > 0) {
              m_status = ActivityStatus::Finished;
            }
            break;

          case ActivityFinish::All:
            if (finished == sizeof ... (Args)) {
              m_status = ActivityStatus::Finished;
            }
            break;
        }

        return m_status;
      }

      void restart() override {
        m_status = ActivityStatus::Running;

        for (std::size_t i = 0; i < sizeof ... (Args); ++i) {
          activityTupleGetIth(m_activities, i).restart();
        }
      }


    private:
      ActivityFinish m_finish;
      ActivityStatus m_status;
      std::tuple<Args...> m_activities;
    };

    template<typename... Args>
    ParallelActivityEx<Args...> parallelAny(Args... activities) {
      return ParallelActivityEx<Args...>(ActivityFinish::Any, std::forward<Args>(activities)...);
    }

    template<typename... Args>
    ParallelActivityEx<Args...> parallelAll(Args... activities) {
      return ParallelActivityEx<Args...>(ActivityFinish::All, std::forward<Args>(activities)...);
    }

    class AnyActivity : public Activity {
    public:
      template<typename Other>
      explicit AnyActivity(Other other)
      : m_activity(std::make_unique<Other>(std::move(other)))
      {
      }

      ActivityStatus run(Time time) override {
        return m_activity->run(time);
      }

      void restart() override {
        m_activity->restart();
      }

    private:
      std::unique_ptr<Activity> m_activity;
    };

  }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_ACTIVITIES_H