Installed Surge, fixed compile errors, moved a bunch of external stuff into folder

Assets/External/Pixelplacement/Surge/Tween/Helpers/TweenBase.cs

@@ -0,0 +1,273 @@
+/// <summary>
+/// SURGE FRAMEWORK
+/// Author: Bob Berkebile
+/// Email: bobb@pixelplacement.com
+/// 
+/// Base class for tweens.
+/// 
+/// </summary>
+
+using UnityEngine;
+using System;
+using Pixelplacement;
+
+#pragma warning disable 0168
+
+namespace Pixelplacement.TweenSystem
+{
+    public abstract class TweenBase
+    {
+        //Public Variables:
+        public int targetInstanceID;
+        public Tween.TweenType tweenType;
+
+        //Public Properties:
+        public Tween.TweenStatus Status {get; private set;}
+        public float Duration {get; private set;}
+        public AnimationCurve Curve {get; private set;}
+        public Keyframe[] CurveKeys { get; private set; }
+        public bool ObeyTimescale {get; private set;}
+        public Action StartCallback {get; private set;}
+        public Action CompleteCallback {get; private set;}
+        public float Delay {get; private set;}
+        public Tween.LoopType LoopType {get; private set;}
+        public float Percentage {get; private set; }
+
+        //Protected Variables:
+        protected float elapsedTime = 0.0f;
+
+        //Public Methods:
+        /// <summary>
+        /// Stop/pauses the tween.
+        /// </summary>
+        public void Stop ()
+        {
+            Status = Tween.TweenStatus.Stopped;
+            Tick ();
+        }
+
+        /// <summary>
+        /// Starts or restarts a tween - interrupts a delay and allows a canceled or finished tween to restart.
+        /// </summary>
+        public void Start ()
+        {
+            elapsedTime = 0.0f;
+
+            if (Status == Tween.TweenStatus.Canceled || Status == Tween.TweenStatus.Finished || Status == Tween.TweenStatus.Stopped)
+            {
+                Status = Tween.TweenStatus.Running;
+                Operation (0);
+                Tween.Instance.ExecuteTween (this);
+            }
+        }
+
+        /// <summary>
+        /// Resumes a stopped/paused tween.
+        /// </summary>
+        public void Resume()
+        {
+            if (Status != Tween.TweenStatus.Stopped) return;
+            
+            if (Status == Tween.TweenStatus.Stopped)
+            {
+                Status = Tween.TweenStatus.Running;
+                Tween.Instance.ExecuteTween(this);
+            }
+        }
+
+        /// <summary>
+        /// Rewind the tween.
+        /// </summary>
+        public void Rewind ()
+        {
+            Cancel ();
+            Operation (0);
+        }
+
+        /// <summary>
+        /// Rewind the tween and stop.
+        /// </summary>
+        public void Cancel ()
+        {
+            Status = Tween.TweenStatus.Canceled;
+            Tick ();
+        }
+
+        /// <summary>
+        /// Fast forward the tween and stop.
+        /// </summary>
+        public void Finish ()
+        {
+            Status = Tween.TweenStatus.Finished;
+            Tick ();
+        }
+
+        /// <summary>
+        /// Used internally to update the tween and report status to the main system.
+        /// </summary>
+        public void Tick ()
+        {
+            //stop where we are:
+            if (Status == Tween.TweenStatus.Stopped) 
+            {
+                CleanUp();
+                return;
+            }
+
+            //rewind operation and stop:
+            if (Status == Tween.TweenStatus.Canceled)
+            {
+                Operation (0);
+                Percentage = 0;
+                CleanUp();
+                return;
+            }
+
+            //fast forward operation and stop:
+            if (Status == Tween.TweenStatus.Finished) 
+            {
+                Operation (1);
+                Percentage = 1;
+                if (CompleteCallback != null) CompleteCallback ();
+                CleanUp();
+                return;
+            }
+
+            float progress = 0.0f;
+            
+            //calculate:
+            if (ObeyTimescale) 
+            {
+                elapsedTime += Time.deltaTime;
+            }else{
+                elapsedTime += Time.unscaledDeltaTime;
+            }
+            progress = Math.Max(elapsedTime, 0f);
+
+            //percentage:
+            float percentage = Mathf.Min(progress / Duration, 1);
+  
+            //delayed?
+            if (percentage == 0 && Status != Tween.TweenStatus.Delayed) Status = Tween.TweenStatus.Delayed;
+
+            //running?
+            if (percentage > 0 && Status == Tween.TweenStatus.Delayed) 
+            {
+                if (SetStartValue ())
+                {
+                    if (StartCallback != null) StartCallback ();
+                    Status = Tween.TweenStatus.Running;	
+                }else{
+                    CleanUp();
+                    return;
+                }
+            }
+
+            //evaluate:
+            float curveValue = percentage;
+
+            //using a curve?
+            if (Curve != null && CurveKeys.Length > 0) curveValue = TweenUtilities.EvaluateCurve (Curve, percentage);
+        
+            //perform operation with minimal overhead of a try/catch to account for anything that has been destroyed while tweening:
+            if (Status == Tween.TweenStatus.Running) 
+            {
+                try {
+                    Operation (curveValue);
+                    Percentage = curveValue;
+                } catch (Exception ex) {
+                    CleanUp();
+                    return;
+                }
+            }
+
+            //tween complete:
+            if (percentage == 1)
+            {
+                if (CompleteCallback != null)
+                {
+                    CompleteCallback();
+                }
+
+                switch (LoopType) 
+                {
+                case Tween.LoopType.Loop:
+                    Loop ();
+                    break;
+
+                case Tween.LoopType.PingPong:
+                    PingPong ();
+                    break;
+
+                default:
+                    Status = Tween.TweenStatus.Finished;
+                    CleanUp();
+                    return;
+                }
+            }
+        }
+        
+        //Private Methods:
+        private void CleanUp()
+        {
+            if (Tween.activeTweens.Contains(this))
+            {
+                Tween.activeTweens.Remove(this);
+            }
+        }
+
+        //Protected Methods:
+        /// <summary>
+        /// Resets the start time.
+        /// </summary>
+        protected void ResetStartTime ()
+        {
+            elapsedTime = -Delay;
+        }
+
+        /// <summary>
+        /// Sets the essential properties that all tweens need and should be called from their constructor. If targetInstanceID is -1 then this tween won't interrupt tweens of the same type on the same target.
+        /// </summary>
+        protected void SetEssentials (Tween.TweenType tweenType, int targetInstanceID, float duration, float delay, bool obeyTimeScale, AnimationCurve curve, Tween.LoopType loop, Action startCallback, Action completeCallback)
+        {
+            this.tweenType = tweenType;
+            this.targetInstanceID = targetInstanceID;
+
+            if (delay > 0)
+                Status = Tween.TweenStatus.Delayed;
+
+            Duration = duration;
+            Delay = delay;
+            Curve = curve;
+
+            CurveKeys = curve == null ? null : curve.keys;
+            StartCallback = startCallback;
+            CompleteCallback = completeCallback;
+            LoopType = loop;
+            ObeyTimescale = obeyTimeScale;
+
+            ResetStartTime ();
+        }
+
+        //Abstract Methods:
+        /// <summary>
+        /// Override this method to carry out the initialization required for the tween.
+        /// </summary>
+        protected abstract bool SetStartValue ();
+
+        /// <summary>
+        /// Override this method to carry out the processing required for the tween.
+        /// </summary>
+        protected abstract void Operation (float percentage);
+
+        /// <summary>
+        /// Override this method to carry out a standard loop.
+        /// </summary>
+        public abstract void Loop ();
+
+        /// <summary>
+        /// Override this method to carry out a ping pong loop.
+        /// </summary>
+        public abstract void PingPong ();
+    }
+}