AnimationSequence.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
 
#include "Framework/Entity.h"

namespace AnimationSequence
{
template <std::derived_from<Action> a>
auto typical(const std::vector<Entity*>& intendedTargets, float delayBetweenGroups, int groups, a& intendedAction) -> void
{
    for (auto entity : intendedTargets)
    {
        // delayBetweenGroups += current action's initial delay * group
        intendedAction.setInitialDelay(intendedAction.getInitialDelay() + (delayBetweenGroups * groups));
        // attaches newly adjusted action to entity
        entity->addAction(intendedAction);
    }
}

template <std::derived_from<Action> a>
auto standardStagger(const std::vector<Entity*>& intendedTargets, float gapBetweenActions, a& intendedAction) -> void
{
    auto originalInitialDelay = intendedAction.getInitialDelay();
    for (auto i = 0u; i < intendedTargets.size(); ++i)
    {
        // delayBetweenGroups += current action's initial delay * group
        intendedAction.setInitialDelay(originalInitialDelay + ((intendedAction.getDuration() + gapBetweenActions) * i));
        // attaches newly adjusted action to entity
        intendedTargets[i]->addAction(intendedAction);
    }
}

template <std::derived_from<Action> a>
auto slightOverlap(const std::vector<Entity*>& intendedTargets, float overlapAmount, a& intendedAction) -> void
{
    auto originalInitialDelay = intendedAction.getInitialDelay();
    for (auto i = 0u; i < intendedTargets.size(); ++i)
    {
        // delayBetweenGroups += current action's initial delay * group
        auto sumOfPreviousActions = (intendedAction.getDuration() - overlapAmount) * i;
        intendedAction.setInitialDelay(originalInitialDelay + sumOfPreviousActions);
        // attaches newly adjusted action to entity
        intendedTargets[i]->addAction(intendedAction);
    }
}

template <std::derived_from<Action> a>
auto Staircase(const std::vector<Entity*>& intendedTargets, float delayBetweenActions, a& intendedAction) -> void
{
    for (auto i = 0u; i < intendedTargets.size(); ++i)
    {
        // Scale up the action duration depending on how many actions come before it
        intendedAction.setDuration(delayBetweenActions + (delayBetweenActions * i));
        // attaches newly adjusted action to entity
        intendedTargets[i]->addAction(intendedAction);
    }
}

template <std::derived_from<Action> a>
auto Spiral(const std::vector<Entity*>& intendedTargets, float numberOfGroups, a& intendedAction) -> void
{
    for (auto i = 0u; i < intendedTargets.size(); ++i)
    {
        // Scale up the action duration depending on how many actions come before it
        //intendedAction.setDuration(delayBetweenActions + (delayBetweenActions * i));
        // attaches newly adjusted action to entity
        intendedTargets[i]->addAction(intendedAction);
    }
}

template <std::derived_from<Action> a>
auto CreateStagger(const std::vector<a>& intendedAction, float delayBetweenActions) -> void
{
    for  (int i = 0; i < static_cast<int>(intendedAction.size()); ++i)
    {
        intendedAction->setInitialDelay(delayBetweenActions * i);
    }
}

template <std::derived_from<Action> a>
auto SpreadAction(const std::vector<Entity*>& intendedTargets, const a& intendedAction) -> void
{
    for (auto entity : intendedTargets)
    {
        entity->addAction(intendedAction);
    }
}
}