[BUGFIX] Callbacks added to a Sequence now always respect the insertion order even if they're placed at the same exact time

UnityTests.Unity5/Assets/_Tests/EmptySequences.cs

@@ -25,8 +25,10 @@ public class EmptySequences : BrainBase
         if (createSequenceA) {
             a = DOTween.Sequence()
                 .AppendCallback(() => Debug.Log("A callback 1/2"))
-//                .AppendInterval(1f)
+                .AppendInterval(1f)
                 .AppendCallback(() => Debug.Log("A callback 2/2 (1 sec delay)"))
+                .InsertCallback(0, () => Debug.Log("A callback 0 A"))
+                .InsertCallback(0, () => Debug.Log("A callback 0 B"))
                 .OnStart(() => Debug.Log("A OnStart"))
                 .OnStepComplete(() => Debug.Log("A OnStepComplete"))
                 .OnComplete(() => Debug.Log("A OnComplete"))

_DOTween.Assembly/DOTween/DOTween.cs

@@ -32,7 +32,7 @@ namespace DG.Tweening
     public class DOTween
     {
         /// <summary>DOTween's version</summary>
-        public static readonly string Version = "1.2.065"; // Last version before modules: 1.1.755
+        public static readonly string Version = "1.2.070"; // Last version before modules: 1.1.755
 
         ///////////////////////////////////////////////
         // Options ////////////////////////////////////

_DOTween.Assembly/DOTween/Sequence.cs

@@ -166,7 +166,8 @@ namespace DG.Tweening
             s.startupDone = true;
             s.fullDuration = s.loops > -1 ? s.duration * s.loops : Mathf.Infinity;
             // Order sequencedObjs by start position
-            s._sequencedObjs.Sort(SortSequencedObjs);
+            StableSortSequencedObjs(s._sequencedObjs);
+//            s._sequencedObjs.Sort(SortSequencedObjs); // Quicker old method that didn't implement stable sort
             // Set relative nested tweens
             if (s.isRelative) {
                 for (int len = s.sequencedTweens.Count, i = 0; i < len; ++i) {
@@ -347,11 +348,26 @@ namespace DG.Tweening
             return false;
         }
 
-        static int SortSequencedObjs(ABSSequentiable a, ABSSequentiable b)
+        static void StableSortSequencedObjs(List<ABSSequentiable> list)
         {
-            if (a.sequencedPosition > b.sequencedPosition) return 1;
+            int len = list.Count;
-            if (a.sequencedPosition < b.sequencedPosition) return -1;
+            for (int i = 1; i < len; i++) {
-            return 0;
+                int j = i;
+                ABSSequentiable temp = list[i];
+                while (j > 0 && list[j - 1].sequencedPosition > temp.sequencedPosition) {
+                    list[j] = list[j - 1];
+                    j = j - 1;
+                }
+                list[j] = temp;
+            }
         }
+
+//        // Quicker but doesn't implement stable sort
+//        static int SortSequencedObjs(ABSSequentiable a, ABSSequentiable b)
+//        {
+//            if (a.sequencedPosition > b.sequencedPosition) return 1;
+//            if (a.sequencedPosition < b.sequencedPosition) return -1;
+//            return 0;
+//        }
     }
 }