void Awake()
{
if(tweenTarget == null) tweenTarget = this.gameObject;
this.m_fStartTime = Time.realtimeSinceStartup;
this.m_cImage = tweenTarget.GetComponent<Image>();
this.m_delEase = GetEasingFunction(easeType);
}
void Awake()
{
if(tweenTarget == null) tweenTarget = this.gameObject;
this.m_fStartTime = Time.realtimeSinceStartup;
this.m_delEase = GetEasingFunction(easeType);
if(fromnow)
{
from = tweenTarget.transform.localScale;
}
}
private static IEnumerator<bool> BlinkFunction(MultiAdditionalCoroutineSprite sp, int time, double duraiton, EasingFunction easing)
{
while (true)
{
for (int i = 0; i < time; i++)
{
sp.Alpha = easing(i, time, 1, -duraiton);
yield return true;
}
}
}
private static IEasing GetEasingFunctionFor(EasingFunction easingFunction)
{
switch (easingFunction)
{
case EasingFunction.Linear:
return new LinearEasing();
case EasingFunction.Quadratic:
return new QuadraticEasing();
case EasingFunction.Discrete:
return new DiscreteEasing();
default:
throw new ArgumentOutOfRangeException("easingFunction");
}
}
static void addCurve(object library, EasingFunction easingFunction, int resolution, string name)
{
var curvePresetLibraryType = Type.GetType("UnityEditor.CurvePresetLibrary, UnityEditor");
var addMehtod = curvePresetLibraryType.GetMethod("Add");
addMehtod.Invoke(library, new object[]
{
GenerateCurve(easingFunction, resolution),
name
});
}
private static IEnumerator<bool> AlphaFunction(MultiAdditionalCoroutineSprite sp, int time, double alpha, EasingFunction easing)
{
var sa = sp.Alpha;
for (int i = 0; i < time; i++)
{
sp.Alpha = easing(i, time, sa, alpha - sa);
yield return true;
}
sp.Alpha = alpha;
}
public Curve(CurveLoopType preLoop, CurveLoopType postLoop, IEnumerable<CurveKey> keys)
{
this.preLoop = preLoop;
this.postLoop = postLoop;
this.keys = new CurveKeyCollection(keys);
this.keyFirst = (keys == null) ? null : this.keys[0];
this.keyLast = (keys == null) ? null : this.keys[this.keys.Count - 1];
this.length = (keys == null) ? 0f : keyLast.Position - keyFirst.Position;
this.easingFunction = Evaluate;
}
public static AnimationClock AnimateEasingEquation(
DependencyObject element,
DependencyProperty prop,
EasingFunction function,
double to,
int durationMS)
{
double from = double.IsNaN((double)element.GetValue(prop)) ?
0 :
(double)element.GetValue(prop);
AnimationTimeline timeline = GetEasingAnimation(function, EasingMode.EaseIn, from, to, durationMS);
return Animate(element, prop, timeline, durationMS, null, null, null);
}
public void SetTransitionOff(double time, Vector2 start, Vector2 end, float dur, EasingFunction funcX, EasingFunction funcY)
{
startPos = start;
targPos = end;
currPos = startPos;
currPosX = (double)startPos.X;
currPosY = (double)startPos.Y;
easeX = funcX;
easeY = funcY;
startTime = time;
transDuration = dur;
state = TransState.Off;
}
private IEnumerator customEasing(Action cb, Vector3 to, float delay, float duration, EasingFunction function) {
var from = isoObj.Position;
yield return new WaitForSeconds(delay);
float currentLerpTime = 0;
while (currentLerpTime < duration) {
currentLerpTime += Time.deltaTime;
float x = (float)function(currentLerpTime);
isoObj.Position = from + (to - from) * x;
yield return null;
}
currentLerpTime = duration;
isoObj.Position = to;
cb();
}
public void SetTransitionOn(double time, Vector2 start, Vector2 end, float dur, EasingFunction funcX, EasingFunction funcY)
{
startPos = start;
targPos = end;
currPos = startPos;
currPosX = (double)startPos.X;
currPosY = (double)startPos.Y;
easeX = funcX;
easeY = funcY;
startTime = time;
transDuration = dur;
state = TransState.On;
Debug.WriteLine("Item Set to transition on!");
}
public override void Reset()
{
easeType = EaseType.linear;
time = new FsmFloat { Value = 1f };
delay = new FsmFloat { UseVariable = true };
speed = new FsmFloat { UseVariable = true };
reverse = new FsmBool { Value = false };
realTime = false;
finishEvent = null;
ease = null;
runningTime = 0f;
lastTime = 0f;
percentage = 0f;
fromFloats = new float[0];
toFloats = new float[0];
resultFloats = new float[0];
finishAction = false;
start= false;
finished = false;
isRunning = false;
}
public ColorTween(TweenSettings settings, TObject target, TweenGetter <TObject, Color> getter, TweenSetter <TObject, Color> setter, EasingFunction easingFunction, float duration, Color to, bool isRelative)
: base(settings, target, getter, setter, easingFunction, duration, to, isRelative)
{
}
public DoubleTween(TweenSettings settings, TObject target, TweenGetter <TObject, Double> getter, TweenSetter <TObject, Double> setter, EasingFunction easingFunction, float duration, Double to, bool isRelative)
: base(settings, target, getter, setter, easingFunction, duration, to, isRelative)
{
}
private void Awake()
{
TweenManager.Instance.Init();
m_StateMachine = DUCK.FSM.FiniteStateMachine <GameState> .FromEnum();
m_StateMachine.AddTransition(GameState.Initial, GameState.Tap, c_CompleteCmd)
.AddTransition(GameState.Tap, GameState.TapThree, c_CompleteCmd)
.AddTransition(GameState.TapThree, GameState.Hold, c_CompleteCmd)
.AddTransition(GameState.Hold, GameState.HoldThree, c_CompleteCmd)
.AddTransition(GameState.HoldThree, GameState.TapHoldHoldTapHold, c_CompleteCmd)
.AddTransition(GameState.TapHoldHoldTapHold, GameState.DefineWalk, c_CompleteCmd)
.AddTransition(GameState.DefineWalk, GameState.ConfirmWalk, c_ProceedCmd)
.AddTransition(GameState.ConfirmWalk, GameState.DefineWalk, c_CancelCmd)
.AddTransition(GameState.ConfirmWalk, GameState.DefineLeft, c_ConfirmCmd)
.AddTransition(GameState.DefineLeft, GameState.ConfirmLeft, c_ProceedCmd)
.AddTransition(GameState.ConfirmLeft, GameState.DefineLeft, c_CancelCmd)
.AddTransition(GameState.ConfirmLeft, GameState.DefineRight, c_ConfirmCmd)
.AddTransition(GameState.DefineRight, GameState.ConfirmRight, c_ProceedCmd)
.AddTransition(GameState.ConfirmRight, GameState.DefineRight, c_CancelCmd)
.AddTransition(GameState.ConfirmRight, GameState.Free, c_ConfirmCmd);
/*
* .AddTransition(GameState.DefineUp, GameState.ConfirmUp, c_ProceedCmd)
* .AddTransition(GameState.ConfirmUp, GameState.DefineUp, c_CancelCmd)
* .AddTransition(GameState.ConfirmUp, GameState.DefineDown, c_ConfirmCmd)
*
* .AddTransition(GameState.DefineDown, GameState.ConfirmDown, c_ProceedCmd)
* .AddTransition(GameState.ConfirmDown, GameState.DefineDown, c_CancelCmd)
* .AddTransition(GameState.ConfirmDown, GameState.Free, c_ConfirmCmd);
*/
m_StateMachine.OnEnter(GameState.Tap, () =>
{
m_TargetSequence = new List <SignalType>(c_TapSequence);
changeHintText("TAP");
});
m_StateMachine.OnEnter(GameState.TapThree, () =>
{
m_TargetSequence = new List <SignalType>(c_TapThreeSequence);
changeHintText("TAP, TAP, TAP");
});
m_StateMachine.OnEnter(GameState.Hold, () =>
{
m_TargetSequence = new List <SignalType>(c_HoldSequence);
changeHintText("HOLD");
});
m_StateMachine.OnEnter(GameState.HoldThree, () =>
{
m_TargetSequence = new List <SignalType>(c_HoldThreeSequence);
changeHintText("HOLD, HOLD, HOLD");
});
m_StateMachine.OnEnter(GameState.TapHoldHoldTapHold, () =>
{
m_TargetSequence = new List <SignalType>(c_TapHoldHoldTapHoldSequence);
changeHintText("TAP, HOLD, HOLD, TAP, HOLD");
});
m_StateMachine.OnChange(GameState.TapHoldHoldTapHold, GameState.DefineWalk, () =>
{
m_CmdReader.StopRecording();
m_TargetSequence = new List <SignalType>();
TweenManager.Instance.Tween((float progress) =>
{
// hide text
var col = m_HintText.color;
col.a = 1 - progress;
m_HintText.color = col;
}, delay: 0.15f).SetTime(0.25f).SetEndCallback(
() =>
{
var sequenceUIOriginal = m_SequenceUIRoot.anchoredPosition;
TweenManager.Instance.Tween((float progress) =>
{
// move ui, shrink ui
m_MainUI.anchoredPosition = Vector2.LerpUnclamped(Vector2.zero, new Vector2(0, -420), EasingFunction.EaseOutExpo(0, 1, progress));
m_CommandUI.localScale = Vector2.one * EasingFunction.EaseOutExpo(1.5f, 1.0f, progress);
}, delay: 0.1f).SetEase(EasingFunction.Ease.Linear).SetTime(2f).SetEndCallback(
() =>
{
// show player
m_CommandController.transform.localScale = Vector3.zero;
m_CommandController.gameObject.SetActive(true);
TweenManager.Instance.Tween((float progress) =>
{
m_CommandController.transform.localScale = Vector3.one * progress;
}, delay: 0.1f).SetTime(0.8f).SetEase(EasingFunction.Ease.EaseOutBack).SetEndCallback(
() =>
{
// show next mission
changeHintText("DEFINE [WALK/STOP]", () => m_CmdReader.StartRecording());
}
);
});
});
});
m_StateMachine.OnChange(GameState.ConfirmWalk, GameState.DefineWalk, () =>
{
changeHintText("DEFINE [WALK/STOP]");
});
m_StateMachine.OnEnter(GameState.ConfirmWalk, () =>
{
changeHintText("TAP TO [CONFIRM], HOLD TO [CANCEL]");
});
m_StateMachine.OnEnter(GameState.DefineLeft, () =>
{
changeHintText("DEFINE [TURN LEFT]");
});
m_StateMachine.OnEnter(GameState.ConfirmLeft, () =>
{
changeHintText("TAP TO [CONFIRM], HOLD TO [CANCEL]");
});
m_StateMachine.OnEnter(GameState.DefineRight, () =>
{
changeHintText("DEFINE [TURN RIGHT]");
});
m_StateMachine.OnEnter(GameState.ConfirmRight, () =>
{
changeHintText("TAP TO [CONFIRM], HOLD TO [CANCEL]");
});
m_StateMachine.OnEnter(GameState.DefineUp, () =>
{
changeHintText("DEFINE [TURN UP]");
});
m_StateMachine.OnEnter(GameState.ConfirmUp, () =>
{
changeHintText("TAP TO [CONFIRM], HOLD TO [CANCEL]");
});
m_StateMachine.OnEnter(GameState.DefineDown, () =>
{
changeHintText("DEFINE [TURN DOWN]");
});
m_StateMachine.OnEnter(GameState.ConfirmDown, () =>
{
changeHintText("TAP TO [CONFIRM], HOLD TO [CANCEL]");
});
m_StateMachine.OnEnter(GameState.Free, () =>
{
changeHintText("ALL SETUP, READY TO GO");
});
}
public void ScrollTo(int index, float duration, Ease easing) => ScrollTo(index, duration, EasingFunction.Get(easing));
//grab and set generic, neccesary iTween arguments:
void RetrieveArgs(){
foreach (Hashtable item in tweens) {
if((GameObject)item["target"] == gameObject){
tweenArguments=item;
break;
}
}
id=(string)tweenArguments["id"];
type=(string)tweenArguments["type"];
/* GFX47 MOD START */
_name=(string)tweenArguments["name"];
/* GFX47 MOD END */
method=(string)tweenArguments["method"];
if(tweenArguments.Contains("time")){
time=(float)tweenArguments["time"];
}else{
time=Defaults.time;
}
//do we need to use physics, is there a rigidbody?
if(GetComponent<Rigidbody>() != null){
physics=true;
}
if(tweenArguments.Contains("delay")){
delay=(float)tweenArguments["delay"];
}else{
delay=Defaults.delay;
}
if(tweenArguments.Contains("namedcolorvalue")){
//allows namedcolorvalue to be set as either an enum(C# friendly) or a string(JS friendly), string case usage doesn't matter to further increase usability:
if(tweenArguments["namedcolorvalue"].GetType() == typeof(NamedValueColor)){
namedcolorvalue=(NamedValueColor)tweenArguments["namedcolorvalue"];
}else{
try {
namedcolorvalue=(NamedValueColor)Enum.Parse(typeof(NamedValueColor),(string)tweenArguments["namedcolorvalue"],true);
} catch {
Debug.LogWarning("iTween: Unsupported namedcolorvalue supplied! Default will be used.");
namedcolorvalue = MadiTween.NamedValueColor._Color;
}
}
}else{
namedcolorvalue=Defaults.namedColorValue;
}
if(tweenArguments.Contains("looptype")){
//allows loopType to be set as either an enum(C# friendly) or a string(JS friendly), string case usage doesn't matter to further increase usability:
if(tweenArguments["looptype"].GetType() == typeof(LoopType)){
loopType=(LoopType)tweenArguments["looptype"];
}else{
try {
loopType=(LoopType)Enum.Parse(typeof(LoopType),(string)tweenArguments["looptype"],true);
} catch {
Debug.LogWarning("iTween: Unsupported loopType supplied! Default will be used.");
loopType = MadiTween.LoopType.none;
}
}
}else{
loopType = MadiTween.LoopType.none;
}
if(tweenArguments.Contains("easetype")){
//allows easeType to be set as either an enum(C# friendly) or a string(JS friendly), string case usage doesn't matter to further increase usability:
if(tweenArguments["easetype"].GetType() == typeof(EaseType)){
easeType=(EaseType)tweenArguments["easetype"];
}else{
try {
easeType=(EaseType)Enum.Parse(typeof(EaseType),(string)tweenArguments["easetype"],true);
} catch {
Debug.LogWarning("iTween: Unsupported easeType supplied! Default will be used.");
easeType=Defaults.easeType;
}
}
}else{
easeType=Defaults.easeType;
}
if(tweenArguments.Contains("space")){
//allows space to be set as either an enum(C# friendly) or a string(JS friendly), string case usage doesn't matter to further increase usability:
if(tweenArguments["space"].GetType() == typeof(UnityEngine.Space)){
space=(UnityEngine.Space)tweenArguments["space"];
}else{
try {
space=(UnityEngine.Space)Enum.Parse(typeof(UnityEngine.Space),(string)tweenArguments["space"],true);
} catch {
Debug.LogWarning("iTween: Unsupported space supplied! Default will be used.");
space = Defaults.space;
}
}
}else{
space = Defaults.space;
}
if(tweenArguments.Contains("islocal")){
isLocal = (bool)tweenArguments["islocal"];
}else{
isLocal = Defaults.isLocal;
}
// Added by PressPlay
if (tweenArguments.Contains("ignoretimescale"))
{
useRealTime = (bool)tweenArguments["ignoretimescale"];
}
else
{
useRealTime = Defaults.useRealTime;
}
//instantiates a cached ease equation reference:
ease = GetEasingFunction(easeType);
}
public TweenScale(Vector3 scale, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = scale;
}
public static CoroutineFunction<MultiAdditionalCoroutineSprite> VerticalFadeOut(int time, double moving, EasingFunction moveEasing, EasingFunction fadeEasing)
{
return sp => VerticalFadeOutFunction(sp, time, moving, moveEasing, fadeEasing);
}
public static CoroutineFunction<MultiAdditionalCoroutineSprite> Blink(int time, double duraiton, EasingFunction easing)
{
return sp => BlinkFunction(sp, time, duraiton, easing);
}
private static IEnumerator<bool> VerticalFadeOutFunction(MultiAdditionalCoroutineSprite sp, int time, double moving, EasingFunction moveEasing, EasingFunction fadeEasing)
{
var sa = sp.Alpha;
var sy = sp.Y;
for (int i = 0; i < time; i++)
{
sp.Alpha = fadeEasing(i, time, sa, -sa);
sp.Y = moveEasing(i, time, sy, moving);
yield return true;
}
sp.IsDead = true;
}
public static CoroutineFunction<MultiAdditionalCoroutineSprite> Alpha(int time, double alpha, EasingFunction easing)
{
return sp => AlphaFunction(sp, time, alpha, easing);
}
/// <summary>
/// Cache the target image and easing function for use later.
/// </summary>
private void Awake()
{
image = (TargetImage == null) ? GetComponent <Image>() : TargetImage;
easingFunction = EasingFunction.GetEasingFunction(EaseSettings.EasingFunction);
}
public void timedApply(float time, List <TransparencyInterface> unvisitedInterfaces, EasingFunction easingFunction)
{
TransparencyInterface obj = TransparencyController.getTransparencyObject(transparencyObject);
if (obj != null)
{
obj.timedBlend(alphaValue, time, easingFunction);
unvisitedInterfaces.Remove(obj);
}
}
public CombinedEaser (EasingFunction ease1, EasingFunction ease2, EasingFunction combineEase)
{
_ease1 = ease1;
_ease2 = ease2;
_combineEase = combineEase;
}
//get ease function
protected EasingFunction GetEasingFunction(EaseType easeType)
{
EasingFunction ease = null;
switch (easeType)
{
case EaseType.easeInQuad:
ease = new EasingFunction(easeInQuad);
break;
case EaseType.easeOutQuad:
ease = new EasingFunction(easeOutQuad);
break;
case EaseType.easeInOutQuad:
ease = new EasingFunction(easeInOutQuad);
break;
case EaseType.easeInCubic:
ease = new EasingFunction(easeInCubic);
break;
case EaseType.easeOutCubic:
ease = new EasingFunction(easeOutCubic);
break;
case EaseType.easeInOutCubic:
ease = new EasingFunction(easeInOutCubic);
break;
case EaseType.easeInQuart:
ease = new EasingFunction(easeInQuart);
break;
case EaseType.easeOutQuart:
ease = new EasingFunction(easeOutQuart);
break;
case EaseType.easeInOutQuart:
ease = new EasingFunction(easeInOutQuart);
break;
case EaseType.easeInQuint:
ease = new EasingFunction(easeInQuint);
break;
case EaseType.easeOutQuint:
ease = new EasingFunction(easeOutQuint);
break;
case EaseType.easeInOutQuint:
ease = new EasingFunction(easeInOutQuint);
break;
case EaseType.easeInSine:
ease = new EasingFunction(easeInSine);
break;
case EaseType.easeOutSine:
ease = new EasingFunction(easeOutSine);
break;
case EaseType.easeInOutSine:
ease = new EasingFunction(easeInOutSine);
break;
case EaseType.easeInExpo:
ease = new EasingFunction(easeInExpo);
break;
case EaseType.easeOutExpo:
ease = new EasingFunction(easeOutExpo);
break;
case EaseType.easeInOutExpo:
ease = new EasingFunction(easeInOutExpo);
break;
case EaseType.easeInCirc:
ease = new EasingFunction(easeInCirc);
break;
case EaseType.easeOutCirc:
ease = new EasingFunction(easeOutCirc);
break;
case EaseType.easeInOutCirc:
ease = new EasingFunction(easeInOutCirc);
break;
case EaseType.linear:
ease = new EasingFunction(linear);
break;
case EaseType.spring:
ease = new EasingFunction(spring);
break;
/* GFX47 MOD START */
/*case EaseType.bounce:
* ease = new EasingFunction(bounce);
* break;*/
case EaseType.easeInBounce:
ease = new EasingFunction(easeInBounce);
break;
case EaseType.easeOutBounce:
ease = new EasingFunction(easeOutBounce);
break;
case EaseType.easeInOutBounce:
ease = new EasingFunction(easeInOutBounce);
break;
/* GFX47 MOD END */
case EaseType.easeInBack:
ease = new EasingFunction(easeInBack);
break;
case EaseType.easeOutBack:
ease = new EasingFunction(easeOutBack);
break;
case EaseType.easeInOutBack:
ease = new EasingFunction(easeInOutBack);
break;
/* GFX47 MOD START */
/*case EaseType.elastic:
* ease = new EasingFunction(elastic);
* break;*/
case EaseType.easeInElastic:
ease = new EasingFunction(easeInElastic);
break;
case EaseType.easeOutElastic:
ease = new EasingFunction(easeOutElastic);
break;
case EaseType.easeInOutElastic:
ease = new EasingFunction(easeInOutElastic);
break;
/* GFX47 MOD END */
}
return(ease);
}
public TweenAlpha(float _a, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end.a = _a;
_start.a = -1;
}
public static CoroutineFunction<MultiAdditionalCoroutineSprite> VerticalMove(int time, double y, EasingFunction easing)
{
return sp => CursorVerticalMoveFunction(sp, time, y, easing);
}
static AnimationCurve GenerateCurve(EasingFunction easingFunction, int resolution)
{
var curve = new AnimationCurve();
for (var i = 0; i < resolution; ++i)
{
var time = i / (resolution - 1f);
var value = (float)easingFunction(time, 0.0, 1.0, 1.0);
var key = new Keyframe(time, value);
curve.AddKey(key);
}
for (var i = 0; i < resolution; ++i)
{
curve.SmoothTangents(i, 0f);
}
return curve;
}
public static Func<float, float, float, float, float> GetFunc(EasingFunction function)
{
switch (function)
{
case EasingFunction.Linear:
return Easing.Linear;
case EasingFunction.QuadEaseIn:
return Easing.QuadEaseIn;
case EasingFunction.QuadEaseOut:
return Easing.QuadEaseOut;
case EasingFunction.QuadEaseInOut:
return Easing.QuadEaseInOut;
case EasingFunction.QuadEaseOutIn:
return Easing.QuadEaseOutIn;
case EasingFunction.CubicEaseIn:
return Easing.CubicEaseIn;
case EasingFunction.CubicEaseOut:
return Easing.CubicEaseOut;
case EasingFunction.CubicEaseInOut:
return Easing.CubicEaseInOut;
case EasingFunction.CubicEaseOutIn:
return Easing.CubicEaseOutIn;
case EasingFunction.QuartEaseIn:
return Easing.QuartEaseIn;
case EasingFunction.QuartEaseOut:
return Easing.QuartEaseOut;
case EasingFunction.QuartEaseInOut:
return Easing.QuartEaseInOut;
case EasingFunction.QuartEaseOutIn:
return Easing.QuartEaseOutIn;
case EasingFunction.QuintEaseIn:
return Easing.QuintEaseIn;
case EasingFunction.QuintEaseOut:
return Easing.QuintEaseOut;
case EasingFunction.QuintEaseInOut:
return Easing.QuintEaseInOut;
case EasingFunction.QuintEaseOutIn:
return Easing.QuintEaseOutIn;
case EasingFunction.ExpoEaseIn:
return Easing.ExpoEaseIn;
case EasingFunction.ExpoEaseOut:
return Easing.ExpoEaseOut;
case EasingFunction.ExpoEaseInOut:
return Easing.ExpoEaseInOut;
case EasingFunction.ExpoEaseOutIn:
return Easing.ExpoEaseOutIn;
case EasingFunction.SineEaseIn:
return Easing.SineEaseIn;
case EasingFunction.SineEaseOut:
return Easing.SineEaseOut;
case EasingFunction.SineEaseInOut:
return Easing.SineEaseInOut;
case EasingFunction.SineEaseOutIn:
return Easing.SineEaseOutIn;
case EasingFunction.CircEaseIn:
return Easing.CircEaseIn;
case EasingFunction.CircEaseOut:
return Easing.CircEaseOut;
case EasingFunction.CircEaseInOut:
return Easing.CircEaseInOut;
case EasingFunction.CircEaseOutIn:
return Easing.CircEaseOutIn;
case EasingFunction.ElasticEaseIn:
return Easing.ElasticEaseIn;
case EasingFunction.ElasticEaseOut:
return Easing.ElasticEaseOut;
case EasingFunction.ElasticEaseInOut:
return Easing.ElasticEaseInOut;
case EasingFunction.ElasticEaseOutIn:
return Easing.ElasticEaseOutIn;
case EasingFunction.BounceEaseIn:
return Easing.BounceEaseIn;
case EasingFunction.BounceEaseOut:
return Easing.BounceEaseOut;
case EasingFunction.BounceEaseInOut:
return Easing.BounceEaseInOut;
case EasingFunction.BounceEaseOutIn:
return Easing.BounceEaseOutIn;
case EasingFunction.BackEaseIn:
return Easing.BackEaseIn;
case EasingFunction.BackEaseOut:
return Easing.BackEaseOut;
case EasingFunction.BackEaseInOut:
return Easing.BackEaseInOut;
case EasingFunction.BackEaseOutIn:
return Easing.BackEaseOutIn;
default:
return Easing.Linear;
}
}
private static float Out(float value, EasingFunction function)
{
return(1 - function(1 - value));
}
/// <summary>
/// Converts an EasingFunction enum to the corresponding function.
/// </summary>
/// <param name="function">The EasingFunction enum.</param>
/// <returns>The actual easing function.</returns
/// >public int this[int key]
public static float Ease(EasingFunction function, float t, float b, float c, float d)
{
return GetFunc(function)(t,b,c,d);
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationKeyframeBase"/> class.
/// </summary>
/// <param name="time">The keyframe time.</param>
/// <param name="easingFunction">The keyframe's easing function.</param>
public AnimationKeyframeBase(TimeSpan time, EasingFunction easingFunction = null)
{
this.time = time;
this.easingFunction = easingFunction;
}
private static IEnumerator<bool> CursorMoveFunction(MultiAdditionalCoroutineSprite sp, int time, double x, double y, EasingFunction easing)
{
var sy = sp.Y;
var sx = sp.X;
for (int i = 0; i < time; i++)
{
sp.Y = easing(i, time, sy, y - sy);
sp.X = easing(i, time, sx, x - sx);
yield return true;
}
sp.Y = y;
sp.X = x;
}
private void changeHintText(string text, Tweener.EndDelegate endcallback = null)
{
m_HintText.text = text;
TweenManager.Instance.Tween((float progress) =>
{
m_HintText.transform.localScale = Vector3.one * Mathf.LerpUnclamped(1.5f, 1.0f, EasingFunction.EaseOutSine(0, 1, progress));
var col = m_HintText.color;
col.a = progress;
m_HintText.color = col;
}).SetTime(0.45f).SetEase(EasingFunction.Ease.Linear).SetEndCallback(endcallback);
}
/// <summary>
/// Moves the Object from its current position to newPosition using a easingFunction providing a duration this transition should take.
/// After the transition to newPosition is complete the callbackFunction is called.
/// </summary>
/// <param name="newPostion">the new position</param>
/// <param name="easingFunction">easing function used for the transition</param> http://easings.net for further help
/// <param name="callback">called upon finished move</param>
/// <param name="delay">initial delay</param>
protected void moveTo(Vector3 newPostion, EasingFunction easingFunction, Action callback, float delay, float duration) {
StartCoroutine(customEasing(callback, newPostion, delay, duration, easingFunction));
}
private static double CalculateProgress(long startTime, int animationDuration, EasingFunction function)
{
var currentTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
var elapsedTime = (double)currentTime - startTime;
if (function == EasingFunction.CubicEaseOut)
return CubicEaseOut(animationDuration, elapsedTime);
return Linear(animationDuration, elapsedTime);
}
//instantiates a cached ease equation refrence:
protected void SetEasingFunction()
{
switch (easeType)
{
case EaseType.easeInQuad:
ease = new EasingFunction(easeInQuad);
break;
case EaseType.easeOutQuad:
ease = new EasingFunction(easeOutQuad);
break;
case EaseType.easeInOutQuad:
ease = new EasingFunction(easeInOutQuad);
break;
case EaseType.easeInCubic:
ease = new EasingFunction(easeInCubic);
break;
case EaseType.easeOutCubic:
ease = new EasingFunction(easeOutCubic);
break;
case EaseType.easeInOutCubic:
ease = new EasingFunction(easeInOutCubic);
break;
case EaseType.easeInQuart:
ease = new EasingFunction(easeInQuart);
break;
case EaseType.easeOutQuart:
ease = new EasingFunction(easeOutQuart);
break;
case EaseType.easeInOutQuart:
ease = new EasingFunction(easeInOutQuart);
break;
case EaseType.easeInQuint:
ease = new EasingFunction(easeInQuint);
break;
case EaseType.easeOutQuint:
ease = new EasingFunction(easeOutQuint);
break;
case EaseType.easeInOutQuint:
ease = new EasingFunction(easeInOutQuint);
break;
case EaseType.easeInSine:
ease = new EasingFunction(easeInSine);
break;
case EaseType.easeOutSine:
ease = new EasingFunction(easeOutSine);
break;
case EaseType.easeInOutSine:
ease = new EasingFunction(easeInOutSine);
break;
case EaseType.easeInExpo:
ease = new EasingFunction(easeInExpo);
break;
case EaseType.easeOutExpo:
ease = new EasingFunction(easeOutExpo);
break;
case EaseType.easeInOutExpo:
ease = new EasingFunction(easeInOutExpo);
break;
case EaseType.easeInCirc:
ease = new EasingFunction(easeInCirc);
break;
case EaseType.easeOutCirc:
ease = new EasingFunction(easeOutCirc);
break;
case EaseType.easeInOutCirc:
ease = new EasingFunction(easeInOutCirc);
break;
case EaseType.linear:
ease = new EasingFunction(linear);
break;
case EaseType.spring:
ease = new EasingFunction(spring);
break;
case EaseType.bounce:
ease = new EasingFunction(bounce);
break;
case EaseType.easeInBack:
ease = new EasingFunction(easeInBack);
break;
case EaseType.easeOutBack:
ease = new EasingFunction(easeOutBack);
break;
case EaseType.easeInOutBack:
ease = new EasingFunction(easeInOutBack);
break;
case EaseType.elastic:
ease = new EasingFunction(elastic);
break;
}
}
public UInt64Tween(TweenSettings settings, TObject target, TweenGetter <TObject, UInt64> getter, TweenSetter <TObject, UInt64> setter, EasingFunction easingFunction, float duration, UInt64 to, bool isRelative)
: base(settings, target, getter, setter, easingFunction, duration, to, isRelative)
{
}
public TweenMoveTo(Vector3 pos, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = pos;
}
public Vector2Tween(TweenSettings settings, TObject target, TweenGetter <TObject, Vector2> getter, TweenSetter <TObject, Vector2> setter, EasingFunction easingFunction, float duration, Vector2 to, bool isRelative)
: base(settings, target, getter, setter, easingFunction, duration, to, isRelative)
{
}
public TweenSoundFade(float px, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = px;
}
private static double CalculateProgress(long startTime, int animationDuration, EasingFunction function)
{
var currentTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
var elapsedTime = (double)currentTime - startTime;
if (function == EasingFunction.CubicEaseOut)
{
return(CubicEaseOut(animationDuration, elapsedTime));
}
return(Linear(animationDuration, elapsedTime));
}
public TweenTextMeshProUGUI(long start, long to, float del, Func <long, string> stringConvert = null, EasingFunction easeType = null) : base(del, easeType)
{
_start = start;
_end = to;
stringCoverter = stringConvert;
}
public TweenColor(Color _c, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = _c;
}
//instantiates a cached ease equation refrence:
protected void SetEasingFunction(){
switch (easeType){
case EaseType.easeInQuad:
ease = new EasingFunction(easeInQuad);
break;
case EaseType.easeOutQuad:
ease = new EasingFunction(easeOutQuad);
break;
case EaseType.easeInOutQuad:
ease = new EasingFunction(easeInOutQuad);
break;
case EaseType.easeInCubic:
ease = new EasingFunction(easeInCubic);
break;
case EaseType.easeOutCubic:
ease = new EasingFunction(easeOutCubic);
break;
case EaseType.easeInOutCubic:
ease = new EasingFunction(easeInOutCubic);
break;
case EaseType.easeInQuart:
ease = new EasingFunction(easeInQuart);
break;
case EaseType.easeOutQuart:
ease = new EasingFunction(easeOutQuart);
break;
case EaseType.easeInOutQuart:
ease = new EasingFunction(easeInOutQuart);
break;
case EaseType.easeInQuint:
ease = new EasingFunction(easeInQuint);
break;
case EaseType.easeOutQuint:
ease = new EasingFunction(easeOutQuint);
break;
case EaseType.easeInOutQuint:
ease = new EasingFunction(easeInOutQuint);
break;
case EaseType.easeInSine:
ease = new EasingFunction(easeInSine);
break;
case EaseType.easeOutSine:
ease = new EasingFunction(easeOutSine);
break;
case EaseType.easeInOutSine:
ease = new EasingFunction(easeInOutSine);
break;
case EaseType.easeInExpo:
ease = new EasingFunction(easeInExpo);
break;
case EaseType.easeOutExpo:
ease = new EasingFunction(easeOutExpo);
break;
case EaseType.easeInOutExpo:
ease = new EasingFunction(easeInOutExpo);
break;
case EaseType.easeInCirc:
ease = new EasingFunction(easeInCirc);
break;
case EaseType.easeOutCirc:
ease = new EasingFunction(easeOutCirc);
break;
case EaseType.easeInOutCirc:
ease = new EasingFunction(easeInOutCirc);
break;
case EaseType.linear:
ease = new EasingFunction(linear);
break;
case EaseType.spring:
ease = new EasingFunction(spring);
break;
case EaseType.bounce:
ease = new EasingFunction(bounce);
break;
case EaseType.easeInBack:
ease = new EasingFunction(easeInBack);
break;
case EaseType.easeOutBack:
ease = new EasingFunction(easeOutBack);
break;
case EaseType.easeInOutBack:
ease = new EasingFunction(easeInOutBack);
break;
case EaseType.elastic:
ease = new EasingFunction(elastic);
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationKeyframeBase"/> class.
/// </summary>
/// <param name="time">The keyframe time.</param>
/// <param name="easingFunction">The keyframe's easing function.</param>
public AnimationKeyframeBase(TimeSpan time, EasingFunction easingFunction = null)
{
this.time = time;
this.easingFunction = easingFunction;
}
public static ITween Tween(float start, float target, TimeSpan targetRunTime, EasingFunction easingFunction)
{
return new Tween(start, target, targetRunTime, TweenFactory.GetEasingFunctionFor(easingFunction));
}
void IInstruction <T> .SetEase(EasingFunction.Ease type)
{
EaseFunction = EasingFunction.GetEasingFunction(type);
}
public static ParticleController InstantiateParticle(GameObject prefab, float lifetime, Vector2 position, Vector2 velocity, EasingFunction easing)
{
ParticleController particle = InstantiateParticle(prefab, lifetime, position, velocity);
particle.easing = easing;
return(particle);
}
public TweenRotate(float px, float py, float pz, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = new Vector3(px, py, pz);
}
void Start()
{
_func = EasingFunction.GetEasingFunction(colorsEase);
_targetRenderer = gameObject.GetComponent <MeshRenderer>();
}
public Tween(float del, EasingFunction easeType) : base(del, easeType)
{
}
public override void Update(GameTime gameTime)
{
// <UP> key --> Select previous easing function.
if (InputService.IsPressed(Keys.Up, true))
{
_selectedEasingFunctionIndex--;
if (_selectedEasingFunctionIndex < 0)
{
_selectedEasingFunctionIndex = _easingFunctions.Length - 1;
}
}
// <DOWN> key --> Select next easing function.
if (InputService.IsPressed(Keys.Down, true))
{
_selectedEasingFunctionIndex++;
if (_selectedEasingFunctionIndex >= _easingFunctions.Length)
{
_selectedEasingFunctionIndex = 0;
}
}
// <1>, <2>, <3> --> Select easing mode.
if (InputService.IsPressed(Keys.D1, false))
{
_selectedEasingMode = EasingMode.EaseIn;
}
else if (InputService.IsPressed(Keys.D2, false))
{
_selectedEasingMode = EasingMode.EaseOut;
}
else if (InputService.IsPressed(Keys.D3, false))
{
_selectedEasingMode = EasingMode.EaseInOut;
}
if (_animationController.State == AnimationState.Filling)
{
// The current animation has finished - it is now holding the last animation
// value because the fill behavior is set to 'Hold' by default.
// (_fromToAnimation.FillBehavior == FillBehavior.Hold).
// Stop the animation.
_animationController.Stop();
// Switch the From and To values of the horizontal animation to move the sprite back
// to the other screen side.
Rectangle bounds = GraphicsService.GraphicsDevice.Viewport.TitleSafeArea;
if (_animatableFloat.Value < bounds.Center.X)
{
_fromToAnimation.From = bounds.Left + 200;
_fromToAnimation.To = bounds.Right - 200;
}
else
{
_fromToAnimation.From = bounds.Right - 200;
_fromToAnimation.To = bounds.Left + 200;
}
// Set easing function.
_fromToAnimation.EasingFunction = _easingFunctions[_selectedEasingFunctionIndex];
// Set easing mode.
EasingFunction currentEasingFunction = _fromToAnimation.EasingFunction as EasingFunction;
if (currentEasingFunction != null)
{
currentEasingFunction.Mode = _selectedEasingMode;
}
// Start the new animation.
_animationController.Start();
}
base.Update(gameTime);
}
public TweenSlide(float to, float del, EasingFunction easeType = null) : base(del, easeType)
{
_end = to;
}
/// <summary>
/// Performs easing using the specified function.
/// </summary>
/// <param name="amount">The amount.</param>
/// <param name="function">The easing function to use.</param>
/// <returns>The amount eased using the specified function.</returns>
public static double Ease(double amount, EasingFunction function)
{
switch (function)
{
default:
case EasingFunction.Linear: return(Linear(amount));
case EasingFunction.QuadraticEaseOut: return(QuadraticEaseOut(amount));
case EasingFunction.QuadraticEaseIn: return(QuadraticEaseIn(amount));
case EasingFunction.QuadraticEaseInOut: return(QuadraticEaseInOut(amount));
case EasingFunction.CubicEaseIn: return(CubicEaseIn(amount));
case EasingFunction.CubicEaseOut: return(CubicEaseOut(amount));
case EasingFunction.CubicEaseInOut: return(CubicEaseInOut(amount));
case EasingFunction.QuarticEaseIn: return(QuarticEaseIn(amount));
case EasingFunction.QuarticEaseOut: return(QuarticEaseOut(amount));
case EasingFunction.QuarticEaseInOut: return(QuarticEaseInOut(amount));
case EasingFunction.QuinticEaseIn: return(QuinticEaseIn(amount));
case EasingFunction.QuinticEaseOut: return(QuinticEaseOut(amount));
case EasingFunction.QuinticEaseInOut: return(QuinticEaseInOut(amount));
case EasingFunction.SineEaseIn: return(SineEaseIn(amount));
case EasingFunction.SineEaseOut: return(SineEaseOut(amount));
case EasingFunction.SineEaseInOut: return(SineEaseInOut(amount));
case EasingFunction.CircularEaseIn: return(CircularEaseIn(amount));
case EasingFunction.CircularEaseOut: return(CircularEaseOut(amount));
case EasingFunction.CircularEaseInOut: return(CircularEaseInOut(amount));
case EasingFunction.ExponentialEaseIn: return(ExponentialEaseIn(amount));
case EasingFunction.ExponentialEaseOut: return(ExponentialEaseOut(amount));
case EasingFunction.ExponentialEaseInOut: return(ExponentialEaseInOut(amount));
case EasingFunction.ElasticEaseIn: return(ElasticEaseIn(amount));
case EasingFunction.ElasticEaseOut: return(ElasticEaseOut(amount));
case EasingFunction.ElasticEaseInOut: return(ElasticEaseInOut(amount));
case EasingFunction.BackEaseIn: return(BackEaseIn(amount));
case EasingFunction.BackEaseOut: return(BackEaseOut(amount));
case EasingFunction.BackEaseInOut: return(BackEaseInOut(amount));
case EasingFunction.BounceEaseIn: return(BounceEaseIn(amount));
case EasingFunction.BounceEaseOut: return(BounceEaseOut(amount));
case EasingFunction.BounceEaseInOut: return(BounceEaseInOut(amount));
}
}
private IEnumerator MoveToPoint(Transform _transform, Vector2 _newPosition, float _duration, EasingFunction _easingFunc )
{
Vector3 target = _newPosition;
target.z = _transform.position.z;
Vector3 starting = _transform.position;
float startingTime = Time.time;
Vector3 direction = (target - _transform.position).normalized;
float totalDistance = (target - _transform.position).magnitude;
while (Time.time - startingTime < _duration)
{
float movement = Easing.Ease (_easingFunc, Time.time - startingTime, 0, totalDistance, _duration);
_transform.position = starting + direction * movement;
yield return null;
}
_transform.position = target;
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationKeyframe{T}"/> class.
/// </summary>
/// <param name="time">The keyframe time.</param>
/// <param name="easingFunction">The keyframe's easing function.</param>
public AnimationKeyframe(TimeSpan time, EasingFunction easingFunction = null)
: base(time, easingFunction)
{
this.hasValue = false;
}
//instantiates a cached ease equation refrence:
void GetEasingFunction()
{
switch (easeType){
case EaseType.easeInQuad:
ease = new EasingFunction(easeInQuad);
break;
case EaseType.easeOutQuad:
ease = new EasingFunction(easeOutQuad);
break;
case EaseType.easeInOutQuad:
ease = new EasingFunction(easeInOutQuad);
break;
case EaseType.easeInCubic:
ease = new EasingFunction(easeInCubic);
break;
case EaseType.easeOutCubic:
ease = new EasingFunction(easeOutCubic);
break;
case EaseType.easeInOutCubic:
ease = new EasingFunction(easeInOutCubic);
break;
case EaseType.easeInQuart:
ease = new EasingFunction(easeInQuart);
break;
case EaseType.easeOutQuart:
ease = new EasingFunction(easeOutQuart);
break;
case EaseType.easeInOutQuart:
ease = new EasingFunction(easeInOutQuart);
break;
case EaseType.easeInQuint:
ease = new EasingFunction(easeInQuint);
break;
case EaseType.easeOutQuint:
ease = new EasingFunction(easeOutQuint);
break;
case EaseType.easeInOutQuint:
ease = new EasingFunction(easeInOutQuint);
break;
case EaseType.easeInSine:
ease = new EasingFunction(easeInSine);
break;
case EaseType.easeOutSine:
ease = new EasingFunction(easeOutSine);
break;
case EaseType.easeInOutSine:
ease = new EasingFunction(easeInOutSine);
break;
case EaseType.easeInExpo:
ease = new EasingFunction(easeInExpo);
break;
case EaseType.easeOutExpo:
ease = new EasingFunction(easeOutExpo);
break;
case EaseType.easeInOutExpo:
ease = new EasingFunction(easeInOutExpo);
break;
case EaseType.easeInCirc:
ease = new EasingFunction(easeInCirc);
break;
case EaseType.easeOutCirc:
ease = new EasingFunction(easeOutCirc);
break;
case EaseType.easeInOutCirc:
ease = new EasingFunction(easeInOutCirc);
break;
case EaseType.linear:
ease = new EasingFunction(linear);
break;
case EaseType.spring:
ease = new EasingFunction(spring);
break;
/* GFX47 MOD START */
/*case EaseType.bounce:
ease = new EasingFunction(bounce);
break;*/
case EaseType.easeInBounce:
ease = new EasingFunction(easeInBounce);
break;
case EaseType.easeOutBounce:
ease = new EasingFunction(easeOutBounce);
break;
case EaseType.easeInOutBounce:
ease = new EasingFunction(easeInOutBounce);
break;
/* GFX47 MOD END */
case EaseType.easeInBack:
ease = new EasingFunction(easeInBack);
break;
case EaseType.easeOutBack:
ease = new EasingFunction(easeOutBack);
break;
case EaseType.easeInOutBack:
ease = new EasingFunction(easeInOutBack);
break;
/* GFX47 MOD START */
/*case EaseType.elastic:
ease = new EasingFunction(elastic);
break;*/
case EaseType.easeInElastic:
ease = new EasingFunction(easeInElastic);
break;
case EaseType.easeOutElastic:
ease = new EasingFunction(easeOutElastic);
break;
case EaseType.easeInOutElastic:
ease = new EasingFunction(easeInOutElastic);
break;
/* GFX47 MOD END */
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AnimationKeyframe{T}"/> class.
/// </summary>
/// <param name="time">The keyframe time.</param>
/// <param name="value">The keyframe value.</param>
/// <param name="easingFunction">The keyframe's easing function.</param>
public AnimationKeyframe(TimeSpan time, T value, EasingFunction easingFunction = null)
: base(time, easingFunction)
{
this.value = value;
this.hasValue = true;
}
