AnimationComponent.cpp

#include "AnimationComponent.h"
#include <deki/assets/AssetManager.h>
#include "FrameAnimationMsgPack.h"
#include "Sprite.h"
#include <deki/LogSystem.h>
#include <deki/Time.h>
#include <deki/Object.h>

namespace Deki2D
{

AnimationComponent::AnimationComponent(SpriteComponent* spriteComp)
    : spriteComponent(spriteComp),
      animationData(nullptr),
      ownsAnimationData(false),
      currentSequence(0),
      currentFrame(0),
      frameStartTime(0),
      isPlaying(false),
      hasFinished(false),
      playOnceOverride(false),
      completionCallback(nullptr)
{
}

AnimationComponent::~AnimationComponent()
{
    if (animationData && ownsAnimationData)
    {
        delete animationData;
    }
    animationData = nullptr;
}

void AnimationComponent::Awake()
{
    Setup();
}

void AnimationComponent::Setup()
{
    if (animation.ptr && !animationData)
    {
        animationData = animation.Get();
        ownsAnimationData = false;
    }

    // Find the sprite component on the same object when none is set
    if (!spriteComponent)
    {
        Deki::Object* owner = GetOwner();
        if (owner)
        {
            spriteComponent = owner->GetComponent<SpriteComponent>();
        }
    }

    // Start the first sequence
    if (animationData && spriteComponent && !animationData->animations.empty())
    {
        isPlaying = true;
        currentSequence = 0;
        currentFrame = 0;
        frameStartTime = 0;
        ApplyCurrentFrame();
    }
}

void AnimationComponent::Update()
{
    clockMs += Deki::Time::GetDeltaTimeF();
    // +1 so the clock is never 0, which frameStartTime uses for "not started".
    UpdateAnimation(static_cast<uint32_t>(clockMs) + 1);
}

void AnimationComponent::Play(bool restartIfPlaying)
{
    const FrameAnimSequence* seq = GetCurrentSequence();
    if (!seq || seq->frames.empty())
    {
        return;
    }

    if (isPlaying && !restartIfPlaying)
    {
        return;
    }

    currentFrame = 0;
    frameStartTime = 0;
    isPlaying = true;
    hasFinished = false;
    playOnceOverride = false;

    ApplyCurrentFrame();
}

bool AnimationComponent::PlayAnimation(const char* name, bool restartIfPlaying)
{
    int index = FindAnimationIndex(name);
    if (index < 0)
    {
        return false;
    }

    if (currentSequence == index && isPlaying && !restartIfPlaying)
    {
        return true;
    }

    currentSequence = index;
    currentFrame = 0;
    frameStartTime = 0;
    isPlaying = true;
    hasFinished = false;
    playOnceOverride = false;

    ApplyCurrentFrame();
    return true;
}

void AnimationComponent::PlayOnce()
{
    const FrameAnimSequence* seq = GetCurrentSequence();
    if (!seq || seq->frames.empty())
    {
        return;
    }

    currentFrame = 0;
    frameStartTime = 0;
    isPlaying = true;
    hasFinished = false;
    playOnceOverride = true;

    ApplyCurrentFrame();
}

bool AnimationComponent::PlayAnimationOnce(const char* name)
{
    int index = FindAnimationIndex(name);
    if (index < 0)
    {
        return false;
    }

    currentSequence = index;
    currentFrame = 0;
    frameStartTime = 0;
    isPlaying = true;
    hasFinished = false;
    playOnceOverride = true;

    ApplyCurrentFrame();
    return true;
}

bool AnimationComponent::SetAnimation(const char* name)
{
    int index = FindAnimationIndex(name);
    if (index < 0)
    {
        return false;
    }

    currentSequence = index;
    currentFrame = 0;
    frameStartTime = 0;
    hasFinished = false;

    ApplyCurrentFrame();
    return true;
}

const char* AnimationComponent::GetCurrentAnimationName() const
{
    const FrameAnimSequence* seq = GetCurrentSequence();
    return seq ? seq->name.c_str() : "";
}

int AnimationComponent::GetAnimationCount() const
{
    return animationData ? static_cast<int>(animationData->animations.size()) : 0;
}

const char* AnimationComponent::GetAnimationName(int index) const
{
    if (!animationData || index < 0 || index >= static_cast<int>(animationData->animations.size()))
    {
        return "";
    }
    return animationData->animations[index].name.c_str();
}

void AnimationComponent::Stop()
{
    isPlaying = false;
    currentFrame = 0;
    hasFinished = false;

    ApplyCurrentFrame();
}

void AnimationComponent::Pause()
{
    isPlaying = false;
}

void AnimationComponent::Resume()
{
    const FrameAnimSequence* seq = GetCurrentSequence();
    if (seq && !seq->frames.empty())
    {
        isPlaying = true;
    }
}

void AnimationComponent::UpdateAnimation(uint32_t currentTime)
{
    const FrameAnimSequence* seq = GetCurrentSequence();
    if (!isPlaying || !seq || seq->frames.empty())
    {
        return;
    }

    // A single frame never changes
    if (seq->frames.size() == 1)
    {
        return;
    }

    // 0 means the sequence has just started: its first frame starts now
    if (frameStartTime == 0)
    {
        frameStartTime = currentTime;
    }

    uint32_t elapsed = currentTime - frameStartTime;
    const size_t frameCount = seq->frames.size();
    bool advanced = false;

    while (elapsed >= static_cast<uint32_t>(seq->frames[currentFrame].duration))
    {
        elapsed -= static_cast<uint32_t>(seq->frames[currentFrame].duration);
        currentFrame++;
        advanced = true;

        if (currentFrame >= static_cast<int32_t>(frameCount))
        {
            if (seq->loop && !playOnceOverride)
            {
                currentFrame = 0;
            }
            else
            {
                currentFrame = static_cast<int32_t>(frameCount - 1);
                isPlaying = false;
                hasFinished = true;
                playOnceOverride = false;

                if (completionCallback)
                {
                    completionCallback();
                    completionCallback = nullptr;
                }
                elapsed = 0;
                break;
            }
        }
    }

    if (advanced)
    {
        frameStartTime = currentTime - elapsed;
        ApplyCurrentFrame();
    }
}

const FrameAnimSequence* AnimationComponent::GetCurrentSequence() const
{
    if (!animationData || currentSequence < 0 ||
        currentSequence >= static_cast<int32_t>(animationData->animations.size()))
    {
        return nullptr;
    }
    return &animationData->animations[currentSequence];
}

int AnimationComponent::FindAnimationIndex(const char* name) const
{
    if (!animationData || !name)
    {
        return -1;
    }

    for (size_t i = 0; i < animationData->animations.size(); ++i)
    {
        if (animationData->animations[i].name == name)
        {
            return static_cast<int>(i);
        }
    }
    return -1;
}

void AnimationComponent::ApplyCurrentFrame()
{
    if (!spriteComponent || !spriteComponent->sprite)
    {
        return;
    }

    const FrameAnimSequence* seq = GetCurrentSequence();
    if (!seq)
    {
        return;
    }

    if (currentFrame < 0 || currentFrame >= static_cast<int32_t>(seq->frames.size()))
    {
        return;
    }

    const auto& frameData = seq->frames[currentFrame];

    Sprite* sprite = spriteComponent->sprite.Get();
    if (!sprite)
    {
        DEKI_LOG_ERROR("AnimationComponent::ApplyCurrentFrame - sprite is not a Sprite");
        return;
    }

    const uint64_t epoch = Deki::AssetManager::Get() ? Deki::AssetManager::Get()->GetEpoch() : 0;
    if (resolvedSprite != sprite || resolvedData != animationData || resolvedEpoch != epoch)
    {
        ResolveFrames(sprite);
    }

    const SpriteFrame* spriteFrame = nullptr;
    if (currentSequence >= 0 && currentSequence < static_cast<int32_t>(resolvedFrames.size()) &&
        currentFrame < static_cast<int32_t>(resolvedFrames[currentSequence].size()))
    {
        spriteFrame = resolvedFrames[currentSequence][currentFrame];
    }
    if (!spriteFrame)
    {
        // ResolveFrames already reported the missing frame once; this runs
        // at animation rate, so it stays quiet.
        (void)frameData;
        return;
    }

    spriteComponent->SetFrame(*spriteFrame);
}

void AnimationComponent::ResolveFrames(const Sprite* sprite)
{
    resolvedFrames.clear();
    resolvedSprite = sprite;
    resolvedData = animationData;
    resolvedEpoch = Deki::AssetManager::Get() ? Deki::AssetManager::Get()->GetEpoch() : 0;
    if (!sprite || !animationData)
    {
        return;
    }

    resolvedFrames.resize(animationData->animations.size());
    for (size_t s = 0; s < animationData->animations.size(); ++s)
    {
        const FrameAnimSequence& seq = animationData->animations[s];
        auto& out = resolvedFrames[s];
        out.resize(seq.frames.size(), nullptr);
        for (size_t f = 0; f < seq.frames.size(); ++f)
        {
            out[f] = sprite->FindFrame(seq.frames[f].frameGuid);
            if (!out[f])
            {
                DEKI_LOG_ERROR(
                    "AnimationComponent: animation '%s' frame %zu references frame %s, which the sprite does not have",
                    seq.name.c_str(), f, seq.frames[f].frameGuid.c_str());
            }
        }
    }
}

void AnimationComponent::InitializeToFirstFrame()
{
    if (!spriteComponent || !spriteComponent->sprite || !animationData)
    {
        return;
    }

    if (animationData->animations.empty())
    {
        return;
    }

    currentSequence = 0;
    currentFrame = 0;
    ApplyCurrentFrame();
}

}  // namespace Deki2D