public RotateAroundRoutine(Vector3 pivot, Vector3 axis, float angle, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
this.pivot = pivot;
this.axis = axis;
this.angle = angle;
this.timeScale = timeScale;
}
/// <summary>
/// Returns a yield instruction which will be invoked on the next time the update is called.
/// (Example: On fixed timescale, it will return 'WaitOnFixedUpdate'
/// </summary>
/// <param name="scale"></param>
/// <returns></returns>
public static YieldInstruction Yield(this StratusTimeScale scale)
{
switch (scale)
{
case StratusTimeScale.Delta:
return(new WaitForFixedUpdate());
case StratusTimeScale.FixedDelta:
return(new WaitForFixedUpdate());
}
throw new System.Exception("Unsupported scale given");
}
/// <summary>
/// Returns the current time based on the type (from Unity's 'Time' class)
/// </summary>
/// <param name="scale"></param>
/// <returns></returns>
public static float GetTime(this StratusTimeScale scale)
{
float time = 0f;
switch (scale)
{
case StratusTimeScale.Delta:
time = Time.deltaTime;
break;
case StratusTimeScale.FixedDelta:
time = Time.fixedDeltaTime;
break;
}
return(time);
}
//------------------------------------------------------------------------/
// Private Methods
//------------------------------------------------------------------------/
private void RemoveBehaviour(MonoBehaviour behaviour, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Dictionary <float, FrequencyUpdateBatch> selected = null;
switch (timeScale)
{
case StratusTimeScale.Delta: selected = update; break;
case StratusTimeScale.FixedDelta: selected = fixedUpdate; break;
}
foreach (var kp in selected)
{
kp.Value.Remove(behaviour);
}
}
//------------------------------------------------------------------------/
// CTOR
//------------------------------------------------------------------------/
public StratusActionGroup(StratusTimeScale mode = StratusTimeScale.Delta) : base(mode)
{
}
public static IEnumerator CrossFadeAlpha(Image image, float alpha, float duration, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Color startColor = image.color;
Color endColor = image.color.ScaleAlpha(alpha);
System.Action <float> func = (float t) =>
{
image.color = Color.Lerp(startColor, endColor, t);
};
yield return(Lerp(func, duration, timeScale));
}
public static IEnumerator Interpolate(Vector3 initialValue, Vector3 finalValue, float duration, System.Action <Vector3> setter, StratusEase ease = StratusEase.Linear, System.Action onFinished = null, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Vector3 diff = finalValue - initialValue;
StratusEasing.EaseFunction easeFunc = ease.ToFunction();
System.Action <float> lerp = (float t) =>
{
Vector3 currentValue = initialValue + diff * easeFunc(t);
setter.Invoke(currentValue);
};
yield return(Lerp(lerp, duration, timeScale));
setter.Invoke(finalValue);
onFinished?.Invoke();
}
public static IEnumerator Interpolate(bool initialValue, bool finalValue, float duration, System.Action <bool> setter, System.Action onFinished = null, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
yield return(new WaitForSeconds(duration));
setter.Invoke(finalValue);
onFinished?.Invoke();
}
public StratusActionSequence(StratusTimeScale mode = StratusTimeScale.Delta) : base(mode)
{
}
/// <summary>
/// Rotates the transform to have its forward aligned towards a target until cancelled
/// </summary>
/// <param name="transform"></param>
/// <param name="target"></param>
/// <param name="speed"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Track(Transform transform, Transform target, float speed, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
while (true)
{
Vector3 lookAtVec = target.position - transform.position;
float dt = timeScale.GetTime();
transform.forward = Vector3.Lerp(transform.forward, lookAtVec, dt * speed);
yield return(timeScale.Yield());
}
}
/// <summary>
/// Rotates the transform to have its forward aligned towards a target over a specified duration
/// </summary>
/// <param name="transform"></param>
/// <param name="targetPosition"></param>
/// <param name="duration"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator LookAt(Transform transform, Transform target, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Quaternion startingRot = transform.rotation;
System.Action <float> func = (float t) =>
{
Vector3 lookAtVec = target.position - transform.position;
Quaternion nextRot = Quaternion.LookRotation(lookAtVec);
transform.rotation = Quaternion.Lerp(startingRot, nextRot, t);
};
//IEnumerator lerp = Lerp(func, duration);
//yield return lerp;
yield return(Lerp(func, duration, timeScale));
}
/// <summary>
/// Follows the specified target while the given condition is true
/// </summary>
/// <param name="transform"></param>
/// <param name="target"></param>
/// <param name="speed"></param>
/// <param name="condition"></param>
/// <param name="stopDistance"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator FollowWhile(Transform transform, Transform target, float speed, System.Func <bool> condition, float stopDistance = 0.0f, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
while (condition.Invoke())
{
FollowProcedure(transform, target, speed, stopDistance, timeScale.GetTime());
yield return(timeScale.Yield());
}
}
/// <summary>
/// The transform will follow the specified target at a specified speed for a given duration
/// until the duration elapses
/// </summary>
/// <param name="transform"></param>
/// <param name="target"></param>
/// <param name="speed"></param>
/// <param name="duration"></param>
/// <param name="stopDistance"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator FollowUntil(Transform transform, Transform target, float speed, float duration, float stopDistance = 0.0f, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
while (duration > 0f)
{
float dt = timeScale.GetTime();
duration -= dt;
FollowProcedure(transform, target, speed, stopDistance, dt);
yield return(timeScale.Yield());
}
}
/// <summary>
/// Makes the transform follow the specified target at a specified speed and given distance until cancelled.
/// Optionally, it can be forced to maintain the given distance
/// </summary>
/// <param name="transform"></param>
/// <param name="target"></param>
/// <param name="speed"></param>
/// <param name="distance"></param>
/// <param name="maintainDistance"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Follow(Transform transform, Transform target, float speed, float distance = 0.0f, bool maintainDistance = false, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
while (true)
{
FollowProcedure(transform, target, speed, distance, timeScale.GetTime(), maintainDistance);
yield return(timeScale.Yield());
}
}
/// <summary>
/// Moves the transform from its current position to the target position over a specified duration by translation
/// </summary>
/// <param name="transform"></param>
/// <param name="endPos"></param>
/// <param name="duration"></param>
/// <returns></returns>
public static IEnumerator MoveTo(Transform transform, Vector3 endPos, float duration, float distFromTarget = 0f, System.Action onFinished = null, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Vector3 startPos = transform.position;
if (distFromTarget > 0f)
{
endPos = startPos.CalculatePositionAtDistanceFromTarget(endPos, distFromTarget);
}
System.Action <float> func = (float t) =>
{
Vector3 nextPos = Vector3.Lerp(startPos, endPos, t);
transform.position = nextPos;
};
//IEnumerator lerp = Lerp(func, duration);
//yield return lerp;
yield return(Lerp(func, duration, timeScale));
onFinished?.Invoke();
}
//------------------------------------------------------------------------/
// Static Methods
//------------------------------------------------------------------------/
/// <summary>
/// Subscribes a method to be invoked with the given frequency on the given timescale
/// </summary>
/// <param name="frequency"></param>
/// <param name="action"></param>
/// <param name="behaviour"></param>
/// <param name="timeScale"></param>
public static void Add(float frequency, System.Action action, MonoBehaviour behaviour, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
instance.AddAction(frequency, action, behaviour, timeScale);
}
/// <summary>
/// Removes all subscribed methods for this behaviour on the given timescale
/// </summary>
/// <param name="frequency"></param>
/// <param name="action"></param>
/// <param name="behaviour"></param>
/// <param name="timeScale"></param>
public static void Remove(MonoBehaviour behaviour, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
instance.RemoveBehaviour(behaviour, timeScale);
}
/// <summary>
/// Applies the given curve to the transform's scale over a given duration
/// </summary>
/// <param name="transform"></param>
/// <param name="curve"></param>
/// <param name="duration"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Scale(Transform transform, AnimationCurve curve, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Vector3 startingVal = transform.localScale;
Vector3 endinvgVal = startingVal * curve.Evaluate(duration);
System.Action <float> scalingFunc = (float t) =>
{
Vector3 nextVal = Vector3.Lerp(startingVal, endinvgVal, curve.Evaluate(t));
transform.localScale = nextVal;
};
yield return(Lerp(scalingFunc, duration, timeScale));
}
public void AddAction(float frequency, System.Action action, MonoBehaviour behaviour, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Dictionary <float, FrequencyUpdateBatch> selected = null;
switch (timeScale)
{
case StratusTimeScale.Delta: selected = update; break;
case StratusTimeScale.FixedDelta: selected = fixedUpdate; break;
}
if (!selected.ContainsKey(frequency))
{
selected.Add(frequency, new FrequencyUpdateBatch(frequency));
}
selected[frequency].Add(action, behaviour);
}
/// <summary>
/// Applies the scalar to the transform's current scale over a given duration
/// </summary>
/// <param name="transform"></param>
/// <param name="scalar"></param>
/// <param name="duration"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Scale(Transform transform, float scalar, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Vector3 startingVal = transform.localScale;
Vector3 endingVal = transform.localScale * scalar;
System.Action <float> func = (float t) => ScaleProcedure(transform, startingVal, endingVal, t);
yield return(Lerp(func, duration, timeScale));
}
//--------------------------------------------------------------------------------------------/
// Messags
//--------------------------------------------------------------------------------------------/
public StratusActionDriver(GameObject source, StratusTimeScale mode = StratusTimeScale.Delta) : base(mode)
{
this.source = source;
}
/// <summary>
/// Applies the given scalars to the transform's scale in sequence over a given duration
/// </summary>
/// <param name="transform"></param>
/// <param name="scalars"></param>
/// <param name="totalDuration"></param>
/// <param name="repeat"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Scale(Transform transform, float[] scalars, float totalDuration, bool repeat = false, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Vector3 originalScale = transform.localScale;
float durationForEach = totalDuration / scalars.Length;
do
{
foreach (var scalar in scalars)
{
Vector3 scale = originalScale * scalar;
//Trace.Script("Scaling to " + scale);
yield return(Scale(transform, scale, durationForEach, timeScale));
}
} while (repeat);
}
public static IEnumerator Rotate(Transform transform, Vector3 rotation, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Quaternion initialRotation = transform.rotation;
Quaternion targetRotation = Quaternion.Euler(rotation);
System.Action <float> func = (float t) =>
{
transform.rotation = Quaternion.Lerp(initialRotation, targetRotation, t);
};
yield return(Lerp(func, duration));
}
/// <summary>
/// Applies the given scales to the transformation in sequence over a given duration
/// </summary>
/// <param name="transform"></param>
/// <param name="scalingCurves"></param>
/// <param name="totalDuration"></param>
/// <param name="repeat"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator Scale(Transform transform, AnimationCurve[] scalingCurves, float totalDuration, bool repeat = false, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
Vector3 originalScale = transform.localScale;
float durationForEach = totalDuration / scalingCurves.Length;
do
{
foreach (var scale in scalingCurves)
{
StratusDebug.Log("Scaling to " + scale);
yield return(Scale(transform, scale, durationForEach, timeScale));
}
} while (repeat);
}
public static IEnumerator Lerp <T>(T initialValue, T finalValue, float duration, System.Action <T> setter, System.Func <T, T, float, T> lerpFunction, System.Action onFinished = null, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
System.Action <float> lerp = (float t) =>
{
T currentValue = lerpFunction(initialValue, finalValue, t);
setter.Invoke(currentValue);
};
yield return(Lerp(lerp, duration, timeScale));
setter.Invoke(finalValue);
onFinished?.Invoke();
}
/// <summary>
/// Rotates around a given pivot to a given angle in degrees over a specified duration
/// </summary>
/// <param name="transform"></param>
/// <param name="pivot"></param>
/// <param name="axis"></param>
/// <param name="degrees"></param>
/// <param name="duration"></param>
/// <param name="timeScale"></param>
/// <returns></returns>
public static IEnumerator RotateAround(Transform transform, Vector3 pivot, Vector3 axis, float degrees, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
float angularSpeed = degrees / duration;
float elapsed = 0f;
System.Action <float> func = (float t) =>
{
float time = timeScale.GetTime();
elapsed += time;
if (elapsed >= duration)
{
time = time - (elapsed - duration);
}
float nextAngle = angularSpeed * time;
transform.RotateAround(pivot, axis, nextAngle);
};
if (duration <= 0f)
{
transform.RotateAround(pivot, axis, degrees);
}
else
{
yield return(Lerp(func, duration));
}
}
public static IEnumerator Blend(Light light, Color color, float intensity, float range, float duration, StratusTimeScale timeScale = StratusTimeScale.Delta)
{
Color startColor = light.color;
float startRange = light.range;
float startIntensity = light.intensity;
System.Action <float> func = (float t) =>
{
light.color = Color.Lerp(startColor, color, t);
light.range = Lerp(startRange, range, t);
light.intensity = Lerp(startIntensity, intensity, t);
};
yield return(Lerp(func, duration, timeScale));
}
/// <summary>
/// Rotates around a given pivot until cancelled
/// </summary>
/// <param name="transform"></param>
/// <param name="pivot"></param>
/// <param name="axis"></param>
/// <param name="degrees"></param>
/// <returns></returns>
public static IEnumerator RotateAround(Transform transform, Vector3 pivot, Vector3 axis, float degrees, System.Action onFinished = null, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
while (true)
{
float step = degrees * timeScale.GetTime();
transform.RotateAround(pivot, axis, step);
yield return(timeScale.Yield());
}
}
//---------------------------------------------------------------------/
// Messages
//---------------------------------------------------------------------/
public StratusActionSet(StratusTimeScale mode)
{
this.timescale = mode;
}
/// <summary>
/// A routine that given a duration, returns an increasing elapsed time (until it reaches the target duration)
/// </summary>
/// <param name="onUpdate"></param>
/// <param name="duration"></param>
/// <returns></returns>
public static IEnumerator Elapse(System.Action <float> onUpdate, float duration, StratusTimeScale timeScale = StratusTimeScale.FixedDelta)
{
float elapsed = 0f;
while (elapsed < duration)
{
elapsed += timeScale.GetTime();
onUpdate(elapsed);
yield return(null);
}
}
