Optimized DOJump methods (now they work with SetDelay and OnUpdate)

UnityTests.Unity5/Assets/_Tests/TempTests.cs

@@ -9,15 +9,20 @@ using UnityEngine.UI;
 
 public class TempTests : BrainBase
 {
-	public Transform trans;
+	public Transform target;
-	public Renderer rend;
+	public float delay = 0;
 
-	IEnumerator Start()
+	void Start()
 	{
-		yield return new WaitForSeconds(1);
+		Tween t = target.DOJump(new Vector3(4, 3, 0), 2, 1, 1).SetRelative();
+		if (delay > 0) t.SetDelay(delay);
+		t.OnStart(()=>Debug.Log("Start"));
+		t.OnComplete(()=>Debug.Log("Complete"));
 
-		DOTween.Sequence()
+
-			.Append(rend.material.DOFade(0, 0.5f))
+		// Tween t = DOTween.Sequence().Append(target.DOMoveX(2, 1).SetRelative());
-			.Append(rend.material.DOFade(1, 1f));
+		// if (delay > 0) t.SetDelay(delay);
+		// t.OnStart(()=>Debug.Log("Start"));
+		// t.OnComplete(()=>Debug.Log("Complete"));
 	}
 }

_DOTween.Assembly/DOTween/Sequence.cs

@@ -39,7 +39,8 @@ namespace DG.Tweening
         internal static Sequence DoPrepend(Sequence inSequence, Tween t)
         {
             if (t.loops == -1) t.loops = 1;
-            float tFullTime = t.delay + (t.duration * t.loops);
+//            float tFullTime = t.delay + (t.duration * t.loops);
+            float tFullTime = t.duration * t.loops;
             inSequence.duration += tFullTime;
             int len = inSequence._sequencedObjs.Count;
             for (int i = 0; i < len; ++i) {
@@ -55,17 +56,17 @@ namespace DG.Tweening
         {
             TweenManager.AddActiveTweenToSequence(t);
 
-            // If t has a delay add it as an interval
+//            // If t has a delay add it as an interval
-            atPosition += t.delay;
+//            atPosition += t.delay;
-            inSequence.lastTweenInsertTime = atPosition;
+//            inSequence.lastTweenInsertTime = atPosition;
 
             t.isSequenced = t.creationLocked = true;
             t.sequenceParent = inSequence;
             if (t.loops == -1) t.loops = 1;
             float tFullTime = t.duration * t.loops;
             t.autoKill = false;
-            t.delay = t.elapsedDelay = 0;
+//            t.delay = t.elapsedDelay = 0;
-            t.delayComplete = true;
+//            t.delayComplete = true;
             t.isSpeedBased = false;
             t.sequencedPosition = atPosition;
             t.sequencedEndPosition = atPosition + tFullTime;

_DOTween.Assembly/DOTween/ShortcutExtensions.cs

@@ -442,13 +442,22 @@ namespace DG.Tweening
             float startPosY = target.position.y;
             float offsetY = -1;
             bool offsetYSet = false;
-            Sequence s = DOTween.Sequence()
+            Sequence s = DOTween.Sequence();
 #if COMPATIBLE
-                .Append(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(endValue.x, 0, 0), duration)
+            s.Append(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(endValue.x, 0, 0), duration)
 #else
-                .Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration)
+            s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration)
 #endif
                     .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                    .OnUpdate(() => {
+                        if (!offsetYSet) {
+                            offsetYSet = false;
+                            offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                        }
+                        Vector3 pos = target.position;
+                        pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                        target.MovePosition(pos);
+                    })
 #if COMPATIBLE
                 ).Join(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(0, 0, endValue.z), duration)
 #else
@@ -463,15 +472,6 @@ namespace DG.Tweening
                     .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad)
                     .SetLoops(numJumps * 2, LoopType.Yoyo).SetRelative()
                 ).SetTarget(target).SetEase(DOTween.defaultEaseType);
-            s.OnUpdate(() => {
-                if (!offsetYSet) {
-                    offsetYSet = false;
-                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
-                }
-                Vector3 pos = target.position;
-                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
-                target.MovePosition(pos);
-            });
             return s;
         }
 
@@ -803,24 +803,26 @@ namespace DG.Tweening
             float startPosY = target.position.y;
             float offsetY = -1;
             bool offsetYSet = false;
-            Sequence s = DOTween.Sequence()
+
-                .Append(DOTween.To(() => target.position, x => target.position = x, new Vector3(endValue.x, 0, 0), duration)
+
+            Sequence s = DOTween.Sequence();
+            s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector3(endValue.x, 0, 0), duration)
                     .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                    .OnUpdate(() => {
+                        if (!offsetYSet) {
+                            offsetYSet = false;
+                            offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                        }
+                        Vector3 pos = target.position;
+                        pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                        target.position = pos;
+                    })
                 ).Join(DOTween.To(() => target.position, x => target.position = x, new Vector3(0, 0, endValue.z), duration)
                     .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear)
                 ).Join(DOTween.To(() => target.position, x => target.position = x, new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
                     .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
                     .SetLoops(numJumps * 2, LoopType.Yoyo)
                 ).SetTarget(target).SetEase(DOTween.defaultEaseType);
-            s.OnUpdate(() => {
-                if (!offsetYSet) {
-                    offsetYSet = false;
-                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
-                }
-                Vector3 pos = target.position;
-                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
-                target.position = pos;
-            });
             return s;
         }
         /// <summary>Tweens a Transform's localPosition to the given value, while also applying a jump effect along the Y axis.
@@ -837,24 +839,24 @@ namespace DG.Tweening
             float startPosY = target.localPosition.y;
             float offsetY = -1;
             bool offsetYSet = false;
-            Sequence s = DOTween.Sequence()
+            Sequence s = DOTween.Sequence();
-                .Append(DOTween.To(() => target.localPosition, x => target.localPosition = x, new Vector3(endValue.x, 0, 0), duration)
+            s.Append(DOTween.To(() => target.localPosition, x => target.localPosition = x, new Vector3(endValue.x, 0, 0), duration)
                     .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                    .OnUpdate(() => {
+                        if (!offsetYSet) {
+                            offsetYSet = false;
+                            offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                        }
+                        Vector3 pos = target.localPosition;
+                        pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                        target.localPosition = pos;
+                    })
                 ).Join(DOTween.To(() => target.localPosition, x => target.localPosition = x, new Vector3(0, 0, endValue.z), duration)
                     .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear)
                 ).Join(DOTween.To(() => target.localPosition, x => target.localPosition = x, new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
                     .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
                     .SetLoops(numJumps * 2, LoopType.Yoyo)
                 ).SetTarget(target).SetEase(DOTween.defaultEaseType);
-            s.OnUpdate(() => {
-                if (!offsetYSet) {
-                    offsetYSet = false;
-                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
-                }
-                Vector3 pos = target.localPosition;
-                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
-                target.localPosition = pos;
-            });
             return s;
         }
 

_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs

@@ -540,8 +540,12 @@ namespace DG.Tweening
         {
             if (t == null || !t.active || t.creationLocked) return t;
 
-            t.delay = delay;
+            if (t.tweenType == TweenType.Sequence) {
-            t.delayComplete = delay <= 0;
+                (t as Sequence).PrependInterval(delay);
+            } else {
+                t.delay = delay;
+                t.delayComplete = delay <= 0;
+            }
             return t;
         }
 

_DOTween.Assembly/DOTween43/ShortcutExtensions43.cs

@@ -105,13 +105,22 @@ namespace DG.Tweening
             float startPosY = target.position.y;
             float offsetY = -1;
             bool offsetYSet = false;
-            Sequence s = DOTween.Sequence()
+            Sequence s = DOTween.Sequence();
 #if COMPATIBLE
-                .Append(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(endValue.x, 0, 0), duration)
+            s.Append(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(endValue.x, 0, 0), duration)
 #else
-                .Append(DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue.x, 0), duration)
+            s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue.x, 0), duration)
 #endif
                     .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                    .OnUpdate(() => {
+                        if (!offsetYSet) {
+                            offsetYSet = false;
+                            offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                        }
+                        Vector2 pos = target.position;
+                        pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                        target.MovePosition(pos);
+                    })
 #if COMPATIBLE
                 ).Join(DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
 #else
@@ -120,15 +129,6 @@ namespace DG.Tweening
                     .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad)
                     .SetLoops(numJumps * 2, LoopType.Yoyo).SetRelative()
                 ).SetTarget(target).SetEase(DOTween.defaultEaseType);
-            s.OnUpdate(() => {
-                if (!offsetYSet) {
-                    offsetYSet = false;
-                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
-                }
-                Vector2 pos = target.position;
-                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
-                target.MovePosition(pos);
-            });
             return s;
         }