Alpha 5

.gitignore

@@ -9,6 +9,7 @@
 /[Bb]uilds/
 /[Ll]ogs/
 /[Mm]emoryCaptures/
+/[Uu]serSettings/
 
 # Never ignore Asset meta data
 !/[Aa]ssets/**/*.meta

.wakatime-project

@@ -0,0 +1,2 @@
+ProjectExa
+

Assets/Editor/DefaultColors.colors

@@ -0,0 +1,27 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &1
+MonoBehaviour:
+  m_ObjectHideFlags: 52
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 12323, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: DefaultColors
+  m_EditorClassIdentifier: 
+  m_Presets:
+  - m_Name: 
+    m_Color: {r: 0.15686275, g: 0.15686275, b: 0.19607843, a: 1}
+  - m_Name: 
+    m_Color: {r: 0.23529412, g: 0.23529412, b: 0.27450982, a: 1}
+  - m_Name: 
+    m_Color: {r: 0.39215687, g: 0.39215687, b: 0.43137255, a: 1}
+  - m_Name: 
+    m_Color: {r: 0.8627451, g: 0.8627451, b: 0.8627451, a: 1}
+  - m_Name: 
+    m_Color: {r: 0.29411766, g: 0.7254902, b: 0.7058824, a: 1}
+  - m_Name: 
+    m_Color: {r: 0.7058824, g: 0.27450982, b: 0.29411766, a: 1}

Assets/Plugins/.gitignore

@@ -0,0 +1 @@
+Vectrosity

Assets/Plugins/DOTween/Modules/DOTweenModulePhysics2D.cs

@@ -9,102 +9,130 @@
 
 #pragma warning disable 1591
 
-namespace DG.Tweening
-{
-    public static class DOTweenModulePhysics2D
-    {
-        #region Shortcuts
+namespace DG.Tweening {
+    public static class DOTweenModulePhysics2D {
+    #region Shortcuts
 
-        #region Rigidbody2D Shortcuts
+    #region Rigidbody2D Shortcuts
 
-        /// <summary>Tweens a Rigidbody2D's position to the given value.
-        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <summary>
+        ///     Tweens a Rigidbody2D's position to the given value.
+        ///     Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations
+        /// </summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="duration">The duration of the tween</param>
         /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false)
-        {
-            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false) {
+            var t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
             t.SetOptions(snapping).SetTarget(target);
+
             return t;
         }
 
-        /// <summary>Tweens a Rigidbody2D's X position to the given value.
-        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <summary>
+        ///     Tweens a Rigidbody2D's X position to the given value.
+        ///     Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations
+        /// </summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="duration">The duration of the tween</param>
         /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
-        {
-            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration);
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false) {
+            var t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration);
             t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+
             return t;
         }
 
-        /// <summary>Tweens a Rigidbody2D's Y position to the given value.
-        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <summary>
+        ///     Tweens a Rigidbody2D's Y position to the given value.
+        ///     Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations
+        /// </summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="duration">The duration of the tween</param>
         /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
-        {
-            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration);
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false) {
+            var t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration);
             t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+
             return t;
         }
 
-        /// <summary>Tweens a Rigidbody2D's rotation to the given value.
-        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        public static TweenerCore<float, float, FloatOptions> DORotate(this Rigidbody2D target, float endValue, float duration)
-        {
-            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
+        /// <summary>
+        ///     Tweens a Rigidbody2D's rotation to the given value.
+        ///     Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations
+        /// </summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DORotate(this Rigidbody2D target, float endValue, float duration) {
+            var t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
             t.SetTarget(target);
+
             return t;
         }
 
-        #region Special
+    #region Special
 
-        /// <summary>Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
-        /// Returns a Sequence instead of a Tweener.
-        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
-        /// <para>IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position</para></summary>
+        /// <summary>
+        ///     Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
+        ///     Returns a Sequence instead of a Tweener.
+        ///     Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
+        ///     <para>
+        ///         IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set
+        ///         the position
+        ///     </para>
+        /// </summary>
         /// <param name="endValue">The end value to reach</param>
         /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
         /// <param name="numJumps">Total number of jumps</param>
         /// <param name="duration">The duration of the tween</param>
         /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
-        {
-            if (numJumps < 1) numJumps = 1;
+        public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) {
+            if (numJumps < 1) {
+                numJumps = 1;
+            }
+
             float startPosY = 0;
             float offsetY = -1;
-            bool offsetYSet = false;
-            Sequence s = DOTween.Sequence();
+            var offsetYSet = false;
+            var s = DOTween.Sequence();
+
             Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
-                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetOptions(AxisConstraint.Y, snapping)
+                .SetEase(Ease.OutQuad)
+                .SetRelative()
                 .SetLoops(numJumps * 2, LoopType.Yoyo)
                 .OnStart(() => startPosY = target.position.y);
-            s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration)
-                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
-                ).Join(yTween)
-                .SetTarget(target).SetEase(DOTween.defaultEaseType);
-            yTween.OnUpdate(() =>
-            {
-                if (!offsetYSet)
-                {
-                    offsetYSet = true;
-                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+
+            s.Append(
+                    DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration)
+                        .SetOptions(AxisConstraint.X, snapping)
+                        .SetEase(Ease.Linear)
+                )
+                .Join(yTween)
+                .SetTarget(target)
+                .SetEase(DOTween.defaultEaseType);
+
+            yTween.OnUpdate(
+                () => {
+                    if (!offsetYSet) {
+                        offsetYSet = true;
+                        offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                    }
+
+                    Vector3 pos = target.position;
+                    pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
+                    target.MovePosition(pos);
                 }
-                Vector3 pos = target.position;
-                pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
-                target.MovePosition(pos);
-            });
+            );
+
             return s;
         }
 
-        #endregion Special
+    #endregion Special
 
-        #endregion Rigidbody2D Shortcuts
+    #endregion Rigidbody2D Shortcuts
 
-        #endregion Shortcuts
+    #endregion Shortcuts
     }
 }