MovementController.Scripted.cs

using System.Numerics;
using Gondwana.Physics.Movement.Easing;
using Gondwana.Physics.Movement.Scripted;
 
namespace Gondwana.Physics.Movement;

public sealed partial class MovementController
{
    private Action<ScriptedMovement>? _scriptCompleted;

    public MovementController OnBeginning(Action callback)
    {
        ArgumentNullException.ThrowIfNull(callback);
 
        return OnBeginning(_ => callback());
    }

    public MovementController OnBeginning(
        Action<ScriptedMovement> callback)
    {
        ArgumentNullException.ThrowIfNull(callback);
 
        if (!IsScripted)
        {
            throw new InvalidOperationException(
                "OnBeginning must be called while a scripted movement is active.");
        }
 
        callback(_state.Script);
 
        return this;
    }

    public MovementController OnComplete(Action callback)
    {
        ArgumentNullException.ThrowIfNull(callback);
 
        return OnComplete(_ => callback());
    }

    public MovementController OnComplete(
        Action<ScriptedMovement> callback)
    {
        ArgumentNullException.ThrowIfNull(callback);
 
        if (!IsScripted)
        {
            throw new InvalidOperationException(
                "OnComplete must be called while a scripted movement is active.");
        }
 
        _scriptCompleted += callback;
 
        return this;
    }

    public MovementController MoveTo(
        Vector2 target,
        float durationSec,
        Func<float, float>? easing = null,
        float snapEpsilon = 0.5f)
    {
        return StartScript(new ScriptedMovement
        {
            Type = MovementScriptType.TweenTo,
            Origin = _mover.GetPosition(),
            Target = target,
            DurationSec = MathF.Max(0f, durationSec),
            ElapsedSec = 0f,
            SnapEpsilon = MathF.Max(0f, snapEpsilon),
            Easing = easing
        });
    }

    public MovementController MoveTo(
        Vector2 target,
        float seconds,
        EasingKind easingKind,
        float snapEpsilon = 0.5f)
    {
        var easingFunc = EasingFunctions.From(easingKind);
 
        return MoveTo(
            target,
            seconds,
            easingFunc,
            snapEpsilon);
    }

    public MovementController MoveBy(
        Vector2 delta,
        float durationSec,
        Func<float, float>? easing = null,
        float snapEpsilon = 0.5f)
    {
        var goal = _mover.GetPosition() + delta;
 
        return MoveTo(
            goal,
            durationSec,
            easing,
            snapEpsilon);
    }

    public MovementController MoveBy(
        Vector2 delta,
        float durationSec,
        EasingKind easingKind,
        float snapEpsilon = 0.5f)
    {
        var goal = _mover.GetPosition() + delta;
 
        return MoveTo(
            goal,
            durationSec,
            easingKind,
            snapEpsilon);
    }

    public MovementController MoveBy(
        Vector2 delta,
        float speedPerSec,
        float snapEpsilon = 0.5f)
    {
        var goal = _mover.GetPosition() + delta;
 
        return MoveToward(
            goal,
            MathF.Max(0f, speedPerSec),
            snapEpsilon);
    }

    public MovementController MoveToward(
        Vector2 target,
        float speedPerSec,
        float snapEpsilon = 0.5f)
    {
        return StartScript(new ScriptedMovement
        {
            Type = MovementScriptType.Toward,
            Target = target,
            SpeedPerSec = MathF.Max(0f, speedPerSec),
            SnapEpsilon = MathF.Max(0f, snapEpsilon)
        });
    }

    public void CancelScript()
    {
        if (!IsScripted)
        {
            _scriptCompleted = null;
            return;
        }
 
        var script = _state.Script;
 
        // Clear the old script before invoking external code so that an event
        // handler can safely begin a new movement.
        _state.Script = default;
        _scriptCompleted = null;
 
        ScriptedMovementStopped?.Invoke(script);
    }
 
    private MovementController StartScript(
        ScriptedMovement script)
    {
        // A newly assigned script supersedes any completion callback associated
        // with the previously active script.
        _scriptCompleted = null;
 
        _state.Script = script;
 
        // Scripted movement overrides integrated movement.
        _state.Acceleration = Vector2.Zero;
        _state.Velocity = Vector2.Zero;
 
        ScriptedMovementStarted?.Invoke(script);
 
        return this;
    }
 
    private bool AdvanceScripted(float dt)
    {
        switch (_state.Script.Type)
        {
            case MovementScriptType.None:
                return false;
 
            case MovementScriptType.TweenTo:
                return AdvanceTween(dt);
 
            case MovementScriptType.Toward:
                return AdvanceToward(dt);
 
            default:
                return false;
        }
    }
 
    private bool AdvanceTween(float dt)
    {
        if (_state.Script.DurationSec <= 0f)
        {
            _mover.SetPosition(_state.Script.Target);
 
            _state.Acceleration = Vector2.Zero;
            _state.Velocity = Vector2.Zero;
 
            Step(0f);
            CompleteScript();
 
            return true;
        }
 
        _state.Script.ElapsedSec += MathF.Max(0f, dt);
 
        float t = Math.Clamp(
            _state.Script.ElapsedSec / _state.Script.DurationSec,
            0f,
            1f);
 
        if (_state.Script.Easing is not null)
        {
            t = Math.Clamp(
                _state.Script.Easing(t),
                0f,
                1f);
        }
 
        var pos = Vector2.Lerp(
            _state.Script.Origin,
            _state.Script.Target,
            t);
 
        _mover.SetPosition(pos);
 
        _state.Acceleration = Vector2.Zero;
        _state.Velocity = Vector2.Zero;
 
        Step(0f);
 
        var snapDistanceSquared =
            _state.Script.SnapEpsilon *
            _state.Script.SnapEpsilon;
 
        bool reachedTarget =
            Vector2.DistanceSquared(
                pos,
                _state.Script.Target) <= snapDistanceSquared;
 
        if (reachedTarget || t >= 1f)
        {
            _mover.SetPosition(_state.Script.Target);
 
            _state.Acceleration = Vector2.Zero;
            _state.Velocity = Vector2.Zero;
 
            Step(0f);
            CompleteScript();
        }
 
        return true;
    }
 
    private bool AdvanceToward(float dt)
    {
        var current = _mover.GetPosition();
        var to = _state.Script.Target - current;
        var distance = to.Length();
 
        if (distance <= _state.Script.SnapEpsilon ||
            _state.Script.SpeedPerSec <= 0f ||
            dt <= 0f)
        {
            _mover.SetPosition(_state.Script.Target);
 
            _state.Velocity = Vector2.Zero;
            _state.Acceleration = Vector2.Zero;
 
            Step(0f);
            CompleteScript();
 
            return true;
        }
 
        var stepLength =
            _state.Script.SpeedPerSec * dt;
 
        if (stepLength >= distance)
        {
            _mover.SetPosition(_state.Script.Target);
 
            _state.Velocity = Vector2.Zero;
            _state.Acceleration = Vector2.Zero;
 
            Step(0f);
            CompleteScript();
 
            return true;
        }
 
        var direction = to / distance;
 
        _state.Acceleration = Vector2.Zero;
        _state.Velocity =
            direction *
            _state.Script.SpeedPerSec;
 
        Step(dt);
 
        return true;
    }
 
    private void CompleteScript()
    {
        var script = _state.Script;
        var completed = _scriptCompleted;
 
        // Clear the completed movement before invoking external code.
        // Event handlers and callbacks may safely begin another movement
        // without that new movement subsequently being erased.
        _state.Script = default;
        _scriptCompleted = null;
 
        ScriptedMovementStopped?.Invoke(script);
        completed?.Invoke(script);
    }
}