Action.h

Go to the documentation of this file.

// File: Action.h
// Description: A class that sets a variable to a value over a time interval for a game object
// Author(s): Ori Balashov (ori.balashov@digipen.edu): Filled out most of the functionality
//            Aidan Hartman (aidan.hartman@digipen.edu): Helped Ori with type erasure
// 2025 / 09 / 11
// (C) Digipen 2025
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
 
#include <algorithm>
#include <numbers>
 
#include "Entity.h"
#include "Component/Sprite.h"
#include "Component/Transform.h"
 
// Early declaration for the basic ease so the constructor knows what to use
namespace ac
{
inline static const std::function LinearEase = [](float current, float total)
{
    return current / total;
};
 
}
 
template <typename T>
class Action
{
public:
    Action(T start, T end, float totalTime, GameObject* actionOwner,
           std::function<void(GameObject*, const T&)> funcToCall,
           std::function<float(float, float)> EasingFunction = ac::LinearEase)
        : startValue(std::move(start))
        , endValue(std::move(end))
        , totalDuration(totalTime)
        , currentTime(0)
        , changingObject(actionOwner)
        , dataUpdate(funcToCall)
        , easingFunction(EasingFunction)
    {
    }
 
    auto update(float dt) -> void
    {
        // Increase how far we are in doing the action, clamped to our total duration so we don't go over
        currentTime = std::min<float>(currentTime + dt, totalDuration);
        // Get a percentage of our progress, clamped to 1 so we don't go over
        auto easing = easingFunction(currentTime, totalDuration);
        if (changingObject->destroyed() || changingObject->getInternalParent() == nullptr || changingObject->
            getInternalParent()->destroyed())
        {
            return;
        }
        // Increase the value we want to change
        dataUpdate(changingObject, startValue + (endValue - startValue) * easing);
    }
 
    auto shouldRemove() const -> bool
    {
        return currentTime >= totalDuration - 0.01
                || changingObject->destroyed()
                || changingObject->getInternalParent() == nullptr
                || changingObject->getInternalParent()->destroyed();
    }
 
    auto render() const -> void
    {
    }
 
    auto setOwner(GameObject* newObject) -> void
    {
        changingObject = newObject;
    }
 
private:
    T startValue;
    T endValue;
    float totalDuration;
    float currentTime;
    GameObject* changingObject;
 
    std::function<void(GameObject*, const T&)> dataUpdate;
    std::function<float(float, float)> easingFunction;
 
};
 
namespace ac
{

 
#pragma region actions
inline static const std::function TranslateAction = [](GameObject* parent, const Point2D& newTranslation)
{
    assert(parent && "TranslateAction given a nullptr");
    if (auto parentAsEntity = dynamic_cast<Entity*>(parent))
    {
        if (auto parentTransform = parentAsEntity->GetComponent<Transform>(Component::cTransform))
        {
            parentTransform->translation(newTranslation);
        }
    }
 
};
 
inline static const std::function ScaleAction = [](GameObject* parent, const Vector4D& newScale)
{
    assert(parent && "TranslateAction given a nullptr");
    if (auto parentAsEntity = dynamic_cast<Entity*>(parent))
    {
        if (auto parentTransform = parentAsEntity->GetComponent<Transform>(Component::cTransform))
        {
            parentTransform->scale(newScale);
        }
    }
 
};
 
inline static const std::function SetColorAction = [](GameObject* parent, const Vector4D& newColor)
{
    assert(parent && "SetColorAction given a nullptr");
    if (auto parentAsEntity = dynamic_cast<Entity*>(parent))
    {
        if (auto parentSprite = parentAsEntity->GetComponent<Sprite>(Component::cSprite))
        {
            parentSprite->color() = newColor;
        }
    }
 
};
#pragma endregion
 
#pragma region ease_functions
 
// Note: the code for these functions is taken from https://easings.net/

inline static const std::function easeInOutBack = [](float current, float total)
{
    constexpr auto c1 = 1.70158f;
    constexpr auto c2 = c1 * 1.525f;
 
    auto progress = current / total;
 
    if (progress < 0.5f)
    {
        return (pow(2 * total, 2) * ((c2 + 1) * 2 * total - c2)) / 2;
    }
 
    return (pow(2 * total - 2, 2) * ((c2 + 1) * (total * 2 - 2) + c2) + 2) / 2;
 
 
};
 
inline static const std::function easeOutElastic = [](float current, float total)
{
 
    auto progress = current / total;
 
    if (progress == 0 || progress == 1)
    {
        return progress;
    }
    return static_cast<float>(pow(2, -10 * progress) * sin((progress * 10 - 0.75f) * (2 * std::numbers::pi / 3.f)) + 1);
 
};

inline static const std::function easeOutBounce = [](float current, float total)
{
    constexpr auto n1 = 7.5625f;
 
    if (current < 1 / total)
    {
        return n1 * current * current;
    }
 
    if (current < 2 / total)
    {
        return n1 * (current -= 1.5f / total) * current + 0.75f;
    }
 
    if (current < 2.5f / total)
    {
        return n1 * (current -= 2.25f / total) * current + 0.9375f;
    }
    return n1 * (current -= 2.625f / total) * current + 0.984375f;
};
 
inline static const std::function EaseInOutBounce = [](float current, float total)
{
    return current < 0.5f
            ? (1 - easeOutBounce(total, 1 - 2 * current)) / 2
            : (1 + easeOutBounce(total, 2 * current - 1)) / 2;
};
#pragma endregion
 
}