Right way to migration from LeanTween

[fidarit]

Thanks for creating such an awesome tween library.
I'm currently migrating from LeanTween and I'm not sure how to convert the code below.

        private LTDescr waitWorker;

        public void UpdateState()
        {
            if (waitWorker != null)
                return;

            if (agent.velocity.magnitude < MinSpeedToStartRest)
                waitWorker = agent.gameObject.LeanDelayedCall(GetRestTime(), ChangeTargetPosition);
        }

As a temporary solution, I created own class

      public static class LeanEx
      {
          public static MotionHandle LeanDelayedCall(this GameObject gameObject, float delay, Action action)
          {
              return LeanDelayedCall(delay, action)
                  .AddTo(gameObject);
          }
          
          public static MotionHandle LeanDelayedCall(this Component component, float delay, Action action)
          {
              return LeanDelayedCall(delay, action)
                  .AddTo(component);
          }

          public static MotionHandle LeanDelayedCall(float delay, Action action)
          {
              return LMotion.Create(0f, 1f, delay)
                  .WithOnComplete(action)
                  .RunWithoutBinding();
          }
      }

...and rewrote first code with:

        private MotionHandle waitWorker;

        public void UpdateState()
        {
            if (waitWorker.IsActive())
                return;

            if (agent.velocity.magnitude < MinSpeedToStartRest)
                waitWorker = agent.LeanDelayedCall(GetRestTime(), ChangeTargetPosition);
        }

But I'm not sure that it's correct way.
Any ideas? Or maybe I did the right thing?

[nuskey8]

LitMotion does not have an API equivalent to DelayedCall. This is by design.

I don't think DelayedCall is a feature that a tween library should have. The tween library's responsibility is to implement animations using value interpolation and easing, and is not intended for asynchronous processing. Additionally, delayed processing using callbacks is not the preferred method as it makes exception handling and cancellation difficult. These asynchronous operations should be done with async/await (UniTask is probably the best option).

However, if your purpose is simply to migrate from LeanTween, I think your method is fine. It should work correctly.

[fidarit]

Such a quick answer. Thanks.

In my case, there was a need for some single-line delayedCall functionality, and 4 years ago I didn't find any better solution than LeanTween (it was better to use some tween lib than default Invoke method). Thanks again for the detailed answer

[max-critcrew]

@annulusgames In case you have any example code snippet how you'd handle delayed calls, would love to see them - but no stress :)

[nuskey8]

For example, if you want to execute a process after a few seconds, you can write it as follows using async/await and UniTask. You can add cancellation and exception handling if necessary.

async UniTask DoSomethingAsync(float delay, CancellationToken cancellationToken)
{
    await UniTask.WaitForSeconds(delay, cancellationToken);
    DoSomething();
}