// тип интерполяции
	public enum Tween
	{
		Linear,
		Cubicin,
		Cubicout
	}
 
	public class ComponentTween
	{
		public float dir = 1;    // вспомогательный указатель в какую сторону движется tween
		public int steps = 1;    // кол-во шагов. -1 значит анимация бесконечна
		public Tween type;       // тип интерполяции
		public float time_step;  // время на шаг
		public float time;       // текущее время
		public TweenBase source; // источник анимации
	}
 
	static partial class Component
	{
		public const string Tween = "Game.Source.ComponentTween";

		public static ref ComponentTween componentTween(in this ent entity) =>
			ref Storage<ComponentTween>.components[entity.id];
	}

	sealed class StorageComponentTween : Storage<ComponentTween>
	{
		public override ComponentTween Create() => new ComponentTween();
		// Use for cleaning components that were removed at the current frame.
		public override void Dispose(indexes disposed)
		{
			foreach (var id in disposed)
			{
				ref var component = ref components[id];
				component.steps = 1;
				component.time  = 0f;
				component.source.Dispose();
				component.source = null;
			}
		}
	}

	public static partial class TweenExtension
	{
		static void SetTween(TweenBase source, float time_step, int steps = 1, Tween tween_type = Tween.Linear)
		{
			var entity = Entity.Create();
			var cTween = entity.Set<ComponentTween>();
			cTween.time      = 0;
			cTween.dir       = 1;
			cTween.steps     = steps;
			cTween.source    = source;
			cTween.time_step = time_step;
			cTween.type      = tween_type;
		}
	}

	public abstract class TweenBase
	{
		// задержка перед запуском твина
		public float delay;
		// метод реализации твина
                // возвращаем bool чтобы иметь возможность оборвать твин в нештатной ситуации
		public abstract bool Handle(float step);
		// чистимся если надо
		public abstract void Dispose();

		// удобно выставляем задержку
		public TweenBase setDelay(float arg)
		{
			delay = arg;
			return this;
		}
	}

sealed class ProcessorTween : Processor<ComponentTween>, ITick
  {
    public void Tick(float delta)
    {
      foreach (ent entity in source)
      {
        var     cTween = entity.componentTween();
        ref var t      = ref cTween.time;
        ref var dir    = ref cTween.dir;
        ref var delay  = ref cTween.source.delay;
        ref var steps  = ref cTween.steps;

        // если шагов осталось 0 то убрать компонент tween, игнорируем выполнение кода на кадре.
        if (steps == 0)
        {
          entity.Remove<ComponentTween>();
          continue;
        }

        // если задержка твина больше 0 то игнорируем выполнение кода на кадре
        if ((delay -= delta) > 0.0f) continue;

        // Умножая на dir мы указываем в каком направлении сдвигать время 
        t += delta / cTween.time_step * dir;

        // Если направление 1 и время равно 1 то отнять шаг и сменить направление
        if (dir == 1)
        {
          if (t >= 1)
          {
            --steps;
            dir *= -1;
            t   =  1;
          }
        }
        // если направление -1 и время равно 0 то отнять шаг и сменить направление
        else
        {
          if (t <= 0)
          {
            --steps;
            dir *= -1;
            t   =  0;
          }
        }

        // передать интерполяцию времени t в источник твина. Если твин вернул false то удалить компонент твина.
        if (!cTween.source.Handle(math.calculateTween(cTween.type, t, 0, 1)))
          entity.Remove<ComponentTween>();
      }
    }
  }

 public static class math
  {
    public static float calculateTween(Tween type, float t, float from, float to)
    {
      switch (type)
      {
        case Tween.Linear:
          return from + (to - from) * t;
        case Tween.Cubicin:
          return from + (to - from) * t * t * t;
        case Tween.Cubicout:
        {
          var tt = t - 1;
          return from + (to - from) * (tt * tt * tt + 1);
        }
      }

      return 0;
    }
}

 if (Input.GetKeyDown(KeyCode.P))
      {
        var spr = GameObject.Find("GameObject").GetComponent<SpriteRenderer>();
        spr.doColor(Color.red, 0.1f, 4).setDelay(1.0f);
      }

public class TweenColor : TweenBase
  {
    // Наш спрайт рендерер
    public SpriteRenderer renderer;
    // начальный цвет
    public Color val_from;
    // конечный цвет
    public Color val_to;

    // step - это интерполированное время шага от 0 до 1
    public override bool Handle(float step)
    {
      if (renderer == null) return false;
      // Формула замены цвета
      renderer.color = new Color(val_from.r + (val_to.r - val_from.r) * step, val_from.g + (val_to.g - val_from.g) * step, val_from.b + (val_to.b - val_from.b) * step, val_from.a + (val_to.a - val_from.a) * step);
      // Это тоже самое что и код выше
      // renderer.color = Color.Lerp(val_from, val_to, step);
      return true;
    }
    // Убиваем ссылку на спрайт рендерер
    public override void Dispose() => renderer = null;
  }

public static partial class TweenExtension
{
 public static TweenBase doColor(this SpriteRenderer renderer, Color to, float time_step, int steps, Tween tween_type = Tween.Linear)
    {
      var source = new TweenColor();
      source.renderer = renderer;
      source.val_to   = to;
      source.val_from = renderer.color;
      SetTween(source, time_step, steps, tween_type);
      return source;
    }
}

 if (Input.GetKeyDown(KeyCode.P))
      {
        var spr = GameObject.Find("GameObject").GetComponent<SpriteRenderer>();
        spr.doColor(Color.red, 2f, 1);
        spr = GameObject.Find("GameObject (1)").GetComponent<SpriteRenderer>();
        spr.doColor(Color.green, 2f, 1, Tween.Cubicin);
        spr = GameObject.Find("GameObject (2)").GetComponent<SpriteRenderer>();
        spr.doColor(Color.magenta, 2f, 1, Tween.Cubicout);
      }