//creates a new tween with given arguments that moves along the path
private void CreateTween()
{
//prepare DOTween's parameters, you can look them up here
//http://dotween.demigiant.com/documentation.php
TweenParams parms = new TweenParams();
//differ between speed or time based tweening
if (timeValue == TimeValue.speed)
{
parms.SetSpeedBased();
}
if (loopType == LoopType.yoyo)
{
parms.SetLoops(-1, DG.Tweening.LoopType.Yoyo);
}
//apply ease type or animation curve
if (easeType == DG.Tweening.Ease.INTERNAL_Custom)
{
parms.SetEase(animEaseType);
}
else
{
parms.SetEase(easeType);
}
if (moveToPath)
{
parms.OnWaypointChange(OnWaypointReached);
}
else
{
if (loopType == LoopType.yoyo)
{
parms.OnStepComplete(ReachedEnd);
}
transform.position = wpPos[0];
parms.OnWaypointChange(OnWaypointChange);
parms.OnComplete(ReachedEnd);
}
tween = transform.DOPath(wpPos, originSpeed, pathType, pathMode, 1)
.SetAs(parms)
.SetOptions(false, lockPosition, lockRotation)
.SetLookAt(lookAhead);
if (!moveToPath && startPoint > 0)
{
GoToWaypoint(startPoint);
startPoint = 0;
}
//continue new tween with adjusted speed if it was changed before
if (originSpeed != speed)
{
ChangeSpeed(speed);
}
}
public void ApplyTo(TweenParams tweenParams)
{
if (UseCustomCurve)
{
tweenParams.SetEase(curve);
}
else
{
tweenParams.SetEase(ease);
}
}
private static int SetEase(IntPtr L)
{
int result;
try
{
int num = LuaDLL.lua_gettop(L);
if (num == 2 && TypeChecker.CheckTypes(L, 1, typeof(TweenParams), typeof(EaseFunction)))
{
TweenParams tweenParams = (TweenParams)ToLua.ToObject(L, 1);
LuaTypes luaTypes = LuaDLL.lua_type(L, 2);
EaseFunction ease;
if (luaTypes != LuaTypes.LUA_TFUNCTION)
{
ease = (EaseFunction)ToLua.ToObject(L, 2);
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 2);
ease = (DelegateFactory.CreateDelegate(typeof(EaseFunction), func) as EaseFunction);
}
TweenParams o = tweenParams.SetEase(ease);
ToLua.PushObject(L, o);
result = 1;
}
else if (num == 2 && TypeChecker.CheckTypes(L, 1, typeof(TweenParams), typeof(AnimationCurve)))
{
TweenParams tweenParams2 = (TweenParams)ToLua.ToObject(L, 1);
AnimationCurve ease2 = (AnimationCurve)ToLua.ToObject(L, 2);
TweenParams o2 = tweenParams2.SetEase(ease2);
ToLua.PushObject(L, o2);
result = 1;
}
else if (num == 4 && TypeChecker.CheckTypes(L, 1, typeof(TweenParams), typeof(Ease), typeof(float?), typeof(float?)))
{
TweenParams tweenParams3 = (TweenParams)ToLua.ToObject(L, 1);
Ease ease3 = (Ease)((int)ToLua.ToObject(L, 2));
float? overshootOrAmplitude = (float?)ToLua.ToObject(L, 3);
float? period = (float?)ToLua.ToObject(L, 4);
TweenParams o3 = tweenParams3.SetEase(ease3, overshootOrAmplitude, period);
ToLua.PushObject(L, o3);
result = 1;
}
else
{
result = LuaDLL.luaL_throw(L, "invalid arguments to method: DG.Tweening.TweenParams.SetEase");
}
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
public override void OnEnter()
{
var _target = Fsm.GetOwnerDefaultTarget(gameObject);
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetRecyclable(setRecycle.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenCameraRectTo]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>\",this.Owner");
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(Fsm.GetOwnerDefaultTarget(gameObject));
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
// Easy part to edit for other DotTween actions --->
switch (dotweenTypeSelect)
{
case doTweenType.pixelRect:
_target.GetComponent <Camera>().DOPixelRect(to.Value, duration.Value).SetAs(setFinal);
break;
case doTweenType.rect:
_target.GetComponent <Camera>().DORect(to.Value, duration.Value).SetAs(setFinal);
break;
}
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
//creates a new tween with given arguments that moves along the path
private void CreateTween()
{
//prepare DOTween's parameters, you can look them up here
//http://dotween.demigiant.com/documentation.php
TweenParams parms = new TweenParams();
//differ between speed or time based tweening
if (timeValue == TimeValue.speed)
{
parms.SetSpeedBased();
}
if (loopType == LoopType.yoyo)
{
parms.SetLoops(-1, DG.Tweening.LoopType.Yoyo);
}
//apply ease type or animation curve
if (easeType == DG.Tweening.Ease.Unset)
{
parms.SetEase(animEaseType);
}
else
{
parms.SetEase(easeType);
}
if (moveToPath)
{
parms.OnWaypointChange(OnWaypointReached);
}
else
{
//on looptype random initialize random order of waypoints
if (loopType == LoopType.random)
{
RandomizeWaypoints();
}
else if (loopType == LoopType.yoyo)
{
parms.OnStepComplete(ReachedEnd);
}
Vector3 startPos = wpPos[0];
if (local)
{
startPos = pathContainer.transform.TransformPoint(startPos);
}
transform.position = startPos;
parms.OnWaypointChange(OnWaypointChange);
parms.OnComplete(ReachedEnd);
}
if (pathMode == DG.Tweening.PathMode.Ignore &&
waypointRotation != RotationType.none)
{
if (rotationTarget == null)
{
rotationTarget = transform;
}
parms.OnUpdate(OnWaypointRotation);
}
if (local)
{
tween = transform.DOLocalPath(wpPos, originSpeed, pathType, pathMode)
.SetAs(parms)
.SetOptions(closeLoop, lockPosition, lockRotation)
.SetLookAt(lookAhead);
}
else
{
tween = transform.DOPath(wpPos, originSpeed, pathType, pathMode)
.SetAs(parms)
.SetOptions(closeLoop, lockPosition, lockRotation)
.SetLookAt(lookAhead);
}
if (!moveToPath && startPoint > 0)
{
GoToWaypoint(startPoint);
startPoint = 0;
}
//continue new tween with adjusted speed if it was changed before
if (originSpeed != speed)
{
ChangeSpeed(speed);
}
}
void Start()
{
DOTween.logBehaviour = LogBehaviour.ErrorsOnly;
txtInfo.text = txtInfo.text.Replace("#N", loops.ToString("N0"));
// Set RectOffset since it can't be set before
rectOffsetToTween = new RectOffset(0, 0, 0, 0);
TweenParams tp = new TweenParams();
tp.SetLoops(loops, loopType).SetAutoKill(false);
if (ease == Ease.INTERNAL_Custom)
{
tp.SetEase(easeCurve);
}
else
{
tp.SetEase(ease);
}
// Transform tweens
tweens = new Tween[targets.Length - 1];
for (int i = 0; i < targets.Length; ++i)
{
Transform t = targets[i];
switch (i)
{
case 0:
tweens[i] = DOTween.To(() => t.position, x => t.position = x, new Vector3(0, 5f, 0), 1.5f).SetAs(tp).SetRelative().SetUpdate(true).SetAutoKill(true);
break;
case 1:
// Red cube (rotation)
tweens[i] = DOTween.To(() => t.rotation, x => t.rotation = x, toRotation, 1.5f).SetAs(tp).SetRelative();
break;
case 2:
tweens[i] = DOTween.To(() => t.position, x => t.position = x, new Vector3(0, 5f, 0), 1.5f).SetAs(tp).SetOptions(true).SetRelative().SetAutoKill(true);
break;
case 3:
// Vector3Array (not stored)
Vector3[] path = new[] {
new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 0, 0), new Vector3(0, -1, 0)
};
float[] durations = new[] { 0.5f, 0.5f, 0.5f, 0.5f };
DOTween.ToArray(() => t.position, x => t.position = x, path, durations)
.SetAs(tp).SetRelative().Pause();
continue;
}
Tween tween = tweens[i];
tween.OnStart(() => Debug.Log("OnStart: " + t.name))
.OnPlay(() => Debug.Log("OnPlay: " + t.name))
.OnPause(() => Debug.Log("OnPause: " + t.name))
.OnComplete(() => Debug.Log("OnComplete: " + t.name))
.Pause();
switch (i)
{
case 0:
tween.SetId(intId);
// tween.OnStart(()=>tweens[2].Kill());
break;
case 1:
tween.SetId(stringId);
break;
case 2:
tween.SetId(this);
break;
}
}
// Additional tweens //////////////////////////
// Float
DOTween.To(() => floatToTween, x => floatToTween = x, 100, 1.5f).SetAs(tp).Pause();
// Double
DOTween.To(() => doubleToTween, x => doubleToTween = x, 100, 1.5f).SetAs(tp).Pause();
// Int
DOTween.To(() => intToTween, x => intToTween = x, 100, 1.5f).SetAs(tp).Pause();
// Uint
DOTween.To(() => uintToTween, x => uintToTween = x, 50, 1.5f).SetAs(tp).Pause();
// Long
DOTween.To(() => longToTween, x => longToTween = x, 9223372036854775807L, 1.5f).SetAs(tp).Pause();
// Ulong
DOTween.To(() => ulongToTween, x => ulongToTween = x, 18446744073709551615UL, 1.5f).SetAs(tp).Pause();
// Vector2
DOTween.To(() => vector2toTween, x => vector2toTween = x, new Vector2(50, 100), 1.5f).SetAs(tp).Pause();
// Vector4
DOTween.To(() => vector4toTween, x => vector4toTween = x, new Vector4(50, 100, 150, 200), 1.5f).SetAs(tp).Pause();
// Rect
DOTween.To(() => rectToTween, x => rectToTween = x, new Rect(10, 20, 50, 100), 1.5f).SetAs(tp).Pause();
// RectOffset
DOTween.To(() => rectOffsetToTween, x => rectOffsetToTween = x, new RectOffset(10, 20, 50, 100), 1.5f).SetAs(tp).Pause();
// Color
DOTween.To(() => guiTexColor.color, x => guiTexColor.color = x, Color.green, 1.5f).SetAs(tp).Pause();
// Alpha
DOTween.ToAlpha(() => guiTexAlpha.color, x => guiTexAlpha.color = x, 0f, 1.5f).SetAs(tp).Pause();
// String
DOTween.To(() => stringToTween0, x => stringToTween0 = x, "Hello I'm a new string!", 1.5f).SetAs(tp).Pause();
// String
DOTween.To(() => stringToTween1, x => stringToTween1 = x, "Hello I'm a new string!", 1.5f).SetAs(tp).Pause();
// String (relative)
DOTween.To(() => stringToTween2, x => stringToTween2 = x, "Hello I'm a new string!", 1.5f).SetAs(tp).SetRelative().Pause();
if (tweenLightAndCam)
{
// Camera
Camera.main.DOColor(toCamColor, 1.5f).SetAs(tp).Pause();
// Light
mainLight.DOColor(toLightColor, 1.5f).SetAs(tp).Pause();
mainLight.DOIntensity(4, 1.5f).SetAs(tp).Pause();
}
// SpriteRenderer
spriteRenderer.DOColor(toSpriteColor, 1.5f).SetAs(tp).Pause();
// Specular material tween
specularSphere.GetComponent <Renderer>().material.DOColor(Color.green, "_SpecColor", 1.5f).SetAs(tp).Pause();
// Rotate towards
targetToDoLookAt.DOLookAt(specularSphere.transform.position, 1.5f).SetAs(tp).Pause();
targetToDoLookFrom.DOLookAt(specularSphere.transform.position, 1.5f).From().SetAs(tp).Pause();
}
public override void OnEnter()
{
if (duration.Value == 0)
{
Debug.LogWarning("<b>[DotweenShakeTransformTo]</b><color=#E9E581ff>!!! Duration cannot be 0 !!! </color>", this.Owner);
Finish();
}
var _target = Fsm.GetOwnerDefaultTarget(gameObject);
if (_target != null)
{
Vector3 Vector3setup = to.IsNone ? new Vector3(x.Value, y.Value, z.Value) : to.Value;
if (!x.IsNone)
{
Vector3setup.x = x.Value;
}
if (!y.IsNone)
{
Vector3setup.y = y.Value;
}
if (!z.IsNone)
{
Vector3setup.z = z.Value;
}
to.Value = Vector3setup;
}
if (elasticity.Value > 180f)
{
elasticity.Value = 180f;
}
if (elasticity.Value < 0f)
{
elasticity.Value = 0f;
}
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
if (toObject.Value != null)
{
var go = toObject.Value;
to.Value = go.transform.position;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenShakeTransformTo]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(Fsm.GetOwnerDefaultTarget(gameObject));
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
// Easy part to edit for other DotTween actions --->
switch (dotweenTypeSelect)
{
case doTweenType.DoShakePosition:
if (shakeBy.IsNone)
{
_target.transform.DOShakePosition(duration.Value, to.Value, vibrato.Value, elasticity.Value, snapping.Value, fadeOut.Value).SetAs(setFinal);
}
else
{
_target.transform.DOShakePosition(duration.Value, shakeBy.Value, vibrato.Value, elasticity.Value, snapping.Value, fadeOut.Value).SetAs(setFinal);
}
break;
case doTweenType.DoShakeRotation:
if (shakeBy.IsNone)
{
_target.transform.DOShakeRotation(duration.Value, to.Value, vibrato.Value, elasticity.Value, fadeOut.Value).SetAs(setFinal);
}
else
{
_target.transform.DOShakeRotation(duration.Value, shakeBy.Value, vibrato.Value, elasticity.Value, fadeOut.Value).SetAs(setFinal);
}
break;
case doTweenType.DoShakeScale:
if (shakeBy.IsNone)
{
_target.transform.DOShakeScale(duration.Value, to.Value, vibrato.Value, elasticity.Value, fadeOut.Value).SetAs(setFinal);
}
else
{
_target.transform.DOShakeScale(duration.Value, shakeBy.Value, vibrato.Value, elasticity.Value, fadeOut.Value).SetAs(setFinal);
}
break;
}
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
protected virtual void Start()
{
if (_started)
{
return;
}
if (HasScaleAnimation)
{
_defaultScale = _transform.localScale;
if (MultiplyOriginal)
{
_unselectedScale = _defaultScale * UnselectedScaleMultiplier;
_selectedScale = _defaultScale * SelectedScaleMultiplier;
_disabledScale = _defaultScale * DisabledScaleMultiplier;
}
else
{
_unselectedScale = UnselectedTargetScale;
_selectedScale = SelectedTargetScale;
_disabledScale = DisabledTargetScale;
}
}
if (HasColorAnimation)
{
var tempWidgets = GetComponentsInChildren <UIWidget>(true);
for (byte i = 0; i < tempWidgets.Length; i++)
{
if (HasHighlightAnimation)
{
if (tempWidgets[i] == (UIWidget)HighlightSprite)
{
continue;
}
}
_childWidgets.Add(tempWidgets[i]);
}
_defaultColor = new Color[_childWidgets.Count];
for (byte i = 0; i < _defaultColor.Length; i++)
{
_defaultColor[i] = _childWidgets[i].color;
}
_unselectedColor = new Color[_defaultColor.Length];
for (byte i = 0; i < _unselectedColor.Length; i++)
{
if (OverrideColors)
{
_unselectedColor[i] = UnselectedColor;
}
else
{
_unselectedColor[i] = _defaultColor[i] * (UnselectedColor * 2);
_unselectedColor[i].a = _defaultColor[i].a;
}
}
_selectedColor = new Color[_defaultColor.Length];
for (byte i = 0; i < _selectedColor.Length; i++)
{
if (OverrideColors)
{
_selectedColor[i] = SelectedColor;
}
else
{
_selectedColor[i] = _defaultColor[i] * (SelectedColor * 2);
_selectedColor[i].a = _defaultColor[i].a;
}
}
_disabledColor = new Color[_defaultColor.Length];
for (byte i = 0; i < _disabledColor.Length; i++)
{
if (OverrideColors)
{
_disabledColor[i] = DisabledColor;
}
else
{
_disabledColor[i] = _defaultColor[i] * (DisabledColor * 2);
_disabledColor[i].a = _defaultColor[i].a;
}
}
_tweenColor = new Tweener[_defaultColor.Length];
}
if (HasHighlightAnimation)
{
HighlightSprite.alpha = 0;
}
_tweenParams = new TweenParams();
_tweenParams.SetEase(Ease.InOutSine).SetUpdate(true);
_started = true;
}
public override void OnEnter()
{
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetRecyclable(setRecycle.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
if (scrambleTypeSelect != scrambleType.None && scrambleChars.Value.Length > 0 && scrambleChars.Value.Length < 10)
{
Debug.LogWarning("<b>[DotweenEaseString]</b><color=#FF9900ff!!! Use as many characters as possible (minimum 10) in 'Scramble Chars' because DOTween uses a fast scramble mode which gives better results with more characters. !!! </color>", this.Owner);
}
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenEaseString]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(this.Owner);
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
switch (scrambleTypeSelect)
{
case scrambleType.None:
scrambleTypeSelected = ScrambleMode.None;
break;
case scrambleType.All:
scrambleTypeSelected = ScrambleMode.All;
break;
case scrambleType.Custom:
scrambleTypeSelected = ScrambleMode.Custom;
break;
case scrambleType.Lowercase:
scrambleTypeSelected = ScrambleMode.Lowercase;
break;
case scrambleType.Numerals:
scrambleTypeSelected = ScrambleMode.Numerals;
break;
case scrambleType.Uppercase:
scrambleTypeSelected = ScrambleMode.Uppercase;
break;
}
// Easy part fromValue edit for other DotTween actions --->
DOTween.To(() => fromValue.Value, x => resultValue.Value = x, toValue.Value, duration.Value).SetOptions(richTextOn.Value, scrambleTypeSelected, scrambleChars.Value).SetAs(setFinal);
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
public override void OnEnter()
{
var _target = Fsm.GetOwnerDefaultTarget(gameObject);
if (_target != null)
{
Vector2 Vector2setup = to.IsNone ? new Vector2(x.Value, y.Value) : to.Value;
if (!x.IsNone)
{
Vector2setup.x = x.Value;
}
if (!y.IsNone)
{
Vector2setup.y = y.Value;
}
to.Value = Vector2setup;
}
rigidBody = _target.GetComponent <Rigidbody2D>();
if (rigidBody == null)
{
Debug.LogWarning("<b>[DotweenJumpRigidbody2dTo]</b><color=#FF9900ff>Missing Rigidbody component</color>", this.Owner);
return;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenCamera]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(Fsm.GetOwnerDefaultTarget(gameObject));
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
// Easy part to edit for other DotTween actions --->
switch (dotweenTypeSelect)
{
case doTweenType.DoMove:
rigidBody.DOMove(to.Value, duration.Value, snapping.Value).SetAs(setFinal);
break;
case doTweenType.DoMoveX:
float x = to.Value.x;
rigidBody.DOMoveX(x, duration.Value, snapping.Value).SetAs(setFinal);
break;
case doTweenType.DoMoveY:
float y = to.Value.y;
rigidBody.DOMoveY(y, duration.Value, snapping.Value).SetAs(setFinal);
break;
}
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
public override void OnEnter()
{
var _target = Fsm.GetOwnerDefaultTarget(gameObject);
if (_target != null)
{
Vector3 Vector3setup = to.IsNone ? new Vector3(x.Value, y.Value, z.Value) : to.Value;
if (!x.IsNone)
{
Vector3setup.x = x.Value;
}
if (!y.IsNone)
{
Vector3setup.y = y.Value;
}
if (!z.IsNone)
{
Vector3setup.z = z.Value;
}
to.Value = Vector3setup;
}
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
if (lookat.Value != null)
{
var go = lookat.Value;
to.Value = go.transform.position;
}
if (UpDirection.IsNone == true)
{
UpDirection.Value = new Vector3(0, 1, 0);
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenRotateLookAtTransformTo]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(Fsm.GetOwnerDefaultTarget(gameObject));
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
switch (axisConstraintSelect)
{
case AxisConstraintSelect.None:
axisData = AxisConstraint.None;
break;
case AxisConstraintSelect.X:
axisData = AxisConstraint.X;
break;
case AxisConstraintSelect.Y:
axisData = AxisConstraint.Y;
break;
case AxisConstraintSelect.Z:
axisData = AxisConstraint.Z;
break;
case AxisConstraintSelect.W:
axisData = AxisConstraint.W;
break;
}
// Easy part to edit for other DotTween actions --->
_target.transform.DOLookAt(to.Value, duration.Value, axisData, UpDirection.Value).SetAs(setFinal);
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
void PlayAnimation(bool isEnter = true, Action callback = null)
{
if (m_CurrentTweener != null && m_CurrentTweener.IsPlaying())
{
m_CurrentTweener.Kill();
}
float overDisRatio = 1.2f;
float aniTime = isEnter ? 1f : 0.5f;
Vector2 endPos = m_StartAnchorePos;
TweenParams aniParams = new TweenParams();
aniParams.SetEase(isEnter ? Ease.OutBack : Ease.OutCubic);
aniParams.SetDelay(isEnter ? 0.1f * m_Priority : 0);
aniParams.OnComplete(() =>
{
if (null != callback)
{
callback();
}
});
if (!isEnter)
{
m_MainObjRectTrans.anchoredPosition = m_StartAnchorePos;
}
switch (m_DirType)
{
case SideButtonDirType.Left_Top:
case SideButtonDirType.Left_Bottom:
Vector2 tempLeftPos = new Vector2(-m_ContentRect.anchoredPosition.x - m_MainObjRectTrans.rect.width, m_StartAnchorePos.y);
if (isEnter)
{
m_MainObjRectTrans.anchoredPosition = tempLeftPos;
}
else
{
endPos = tempLeftPos;
}
break;
case SideButtonDirType.Right:
Vector2 tempRightPos = new Vector2(m_StartAnchorePos.x + m_ContentRect.rect.width * overDisRatio, m_StartAnchorePos.y);
if (isEnter)
{
m_MainObjRectTrans.anchoredPosition = tempRightPos;
}
else
{
endPos = tempRightPos;
}
break;
case SideButtonDirType.Bottom:
Vector2 tempBottomPos = new Vector2(m_StartAnchorePos.x, m_StartAnchorePos.y - m_ContentRect.rect.width * overDisRatio);
if (isEnter)
{
m_MainObjRectTrans.anchoredPosition = tempBottomPos;
}
else
{
endPos = tempBottomPos;
}
break;
}
m_CurrentTweener = m_MainObjRectTrans.DOAnchorPos(endPos, aniTime).SetAs(aniParams);
}
public override void OnEnter()
{
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetRecyclable(setRecycle.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenEaseVector2]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(this.Owner);
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
switch (constraint)
{
case Constraint.None:
axisSetup = AxisConstraint.None;
break;
case Constraint.AxisConstraintX:
axisSetup = AxisConstraint.X;
break;
case Constraint.AxisConstraintY:
axisSetup = AxisConstraint.Y;
break;
}
// Easy part fromValue edit for other DotTween actions --->
DOTween.To(() => fromValue.Value, x => resultValue.Value = x, toValue.Value, duration.Value).SetOptions(axisSetup, snapping.Value).SetAs(setFinal);
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}
public void BeginMoveByPos(
Vector3 fromPosition,
bool isUIPos,
Vector3 targetPos,
int easeType,
float speed,
Action onEnd
)
{
this.mEnd = onEnd;
var parent = this.transform.parent as RectTransform;
Vector3 fromScreenPosition;
if (isUIPos)
{
fromScreenPosition = RectTransformUtility.WorldToScreenPoint(null, fromPosition);
}
else
{
fromScreenPosition = Camera.main.WorldToScreenPoint(fromPosition);
}
// var cameraViewPostion = Camera.main.WorldToViewportPoint(fromPosition);
mFromLocalPosition = Vector2.zero;
RectTransformUtility.ScreenPointToLocalPointInRectangle(parent, fromScreenPosition, null, out mFromLocalPosition);
// Debug.LogError("cameraViewPostion" + cameraViewPostion+ "cameraFromPostion" + cameraFromPostion + "fromPosition" + fromPosition + "fromScreenPostion " + fromScreenPostion + " fromLocalPosition: "+ fromLocalPosition);
var toScreenPostion = RectTransformUtility.WorldToScreenPoint(null, targetPos);
var cameraToPosition = Camera.main.WorldToScreenPoint(targetPos);
mToLocalPosition = Vector2.zero;
RectTransformUtility.ScreenPointToLocalPointInRectangle(parent, toScreenPostion, null, out mToLocalPosition);
//Debug.LogError("cameraToPosition"+ cameraToPosition+" toScreenPostion " + toScreenPostion + " toLocalPosition: " + toLocalPosition);
List <Vector3> listBoPint = new List <Vector3>();
// Vector2 range = UnityEngine.Random.insideUnitCircle;
int factor = -1;// UnityEngine.Random.Range(0, 1) > 0.5f?1:-1;
var length = (mFromLocalPosition + mToLocalPosition).magnitude;
listBoPint.Add(mFromLocalPosition);
// listBoPint.Add(fromLocalPosition+ new Vector2(factor* length * 0.05f, factor* length * 0.05f));
var temp = (mFromLocalPosition - mToLocalPosition).normalized;
var normal = new Vector2(temp.y, -temp.x) * factor;
listBoPint.Add(mFromLocalPosition + (mToLocalPosition - mFromLocalPosition) * 0.25f + normal * length * 0.05f);
listBoPint.Add((mFromLocalPosition + mToLocalPosition) * 0.5f + normal * length * 0.075f);
listBoPint.Add(mFromLocalPosition + (mToLocalPosition - mFromLocalPosition) * 0.75f + normal * length * 0.05f);
// listBoPint.Add((fromPosition + ToPosition) / 3f + new Vector3(range.x * 50, range.y * 50, 0));
// listBoPint.Add((fromPosition + ToPosition) * 2 / 3f + new Vector3(range.x * 50, range.y * 50, 0));
listBoPint.Add(mToLocalPosition);
Vector3[] path = GeneralPath(listBoPint);
TweenParams parms = new TweenParams();
parms.SetSpeedBased();
parms.SetEase((Ease)easeType);
parms.OnStepComplete(OnReachEnd);
parms.OnUpdate(onMoveUpdate);
transform.localPosition = mFromLocalPosition;
mTween = transform.DOLocalPath(path, speed, DG.Tweening.PathType.CatmullRom, DG.Tweening.PathMode.Ignore)
.SetAs(parms);
// .SetOptions(false, DG.Tweening.AxisConstraint.None, DG.Tweening.AxisConstraint.None)
// .SetLookAt(0, Vector3.forward, Vector3.up);
transform.localScale = Vector3.one;
mTotalLength = (mFromLocalPosition - mToLocalPosition).magnitude;
mTween.Play();
}
// Token: 0x06000749 RID: 1865 RVA: 0x00030738 File Offset: 0x0002EB38
private void CreateTween()
{
TweenParams tweenParams = new TweenParams();
if (this.timeValue == splineMove.TimeValue.speed)
{
tweenParams.SetSpeedBased(true);
}
if (this.loopType == splineMove.LoopType.yoyo)
{
tweenParams.SetLoops(-1, new DG.Tweening.LoopType?(DG.Tweening.LoopType.Yoyo));
}
if (this.easeType == Ease.INTERNAL_Custom)
{
tweenParams.SetEase(this.animEaseType);
}
else
{
tweenParams.SetEase(this.easeType, null, null);
}
if (this.moveToPath)
{
tweenParams.OnWaypointChange(new TweenCallback <int>(this.OnWaypointReached));
}
else
{
if (this.loopType == splineMove.LoopType.random)
{
this.RandomizeWaypoints();
}
else if (this.loopType == splineMove.LoopType.yoyo)
{
tweenParams.OnStepComplete(new TweenCallback(this.ReachedEnd));
}
Vector3 position = this.wpPos[0];
if (this.local)
{
position = this.pathContainer.transform.TransformPoint(position);
}
base.transform.position = position;
tweenParams.OnWaypointChange(new TweenCallback <int>(this.OnWaypointChange));
tweenParams.OnComplete(new TweenCallback(this.ReachedEnd));
}
if (this.local)
{
this.tween = base.transform.DOLocalPath(this.wpPos, this.originSpeed, this.pathType, this.pathMode, 10, null).SetAs(tweenParams).SetOptions(this.closeLoop, this.lockPosition, this.lockRotation).SetLookAt(this.lookAhead, null, null);
}
else
{
this.tween = base.transform.DOPath(this.wpPos, this.originSpeed, this.pathType, this.pathMode, 10, null).SetAs(tweenParams).SetOptions(this.closeLoop, this.lockPosition, this.lockRotation).SetLookAt(this.lookAhead, null, null);
}
if (!this.moveToPath && this.startPoint > 0)
{
this.GoToWaypoint(this.startPoint);
this.startPoint = 0;
}
if (this.originSpeed != this.speed)
{
this.ChangeSpeed(this.speed);
}
}
public override void OnEnter()
{
var _target = Fsm.GetOwnerDefaultTarget(gameObject);
if (_target != null)
{
if (transforms.Length >= 2)
{
waypoints = new Vector3[transforms.Length];
for (int i = 0; i < transforms.Length; i++)
{
if (transforms[i].IsNone)
{
waypoints[waypoints.Length - 1 - i] = vectors[i].IsNone ? Vector3.zero : vectors[i].Value;
}
else
{
if (transforms[i].Value == null)
{
waypoints[waypoints.Length - 1 - i] = vectors[i].IsNone ? Vector3.zero : vectors[i].Value;
}
else
{
waypoints[waypoints.Length - 1 - i] = (dotweenTypeSelect == doTweenType.DoPath ? transforms[i].Value.transform.position : transforms[i].Value.transform.localPosition) + (vectors[i].IsNone ? Vector3.zero : vectors[i].Value);
}
}
}
}
}
if (loopDontFinish.Value == true)
{
settingLoops = -1;
}
else
{
settingLoops = loopsQuantity.Value;
}
setFinal = new TweenParams().SetDelay(setDelay.Value).SetAutoKill(setAutoKill.Value).SetSpeedBased(isSpeedBased.Value).SetRelative(setRelative.Value).OnComplete(MyCallback);
switch (loopTypeSelect)
{
case loopType.None:
if (settingLoops > 0 || settingLoops < 0)
{
Debug.LogWarning("<b>[DotweenPathTransformTo]</b><color=#FF9900ff>!!! Loop Time is set but no 'Loop Type' is selected !!! </color>", this.Owner);
}
break;
case loopType.Yoyo:
setFinal.SetLoops(settingLoops, LoopType.Yoyo);
break;
case loopType.Restart:
setFinal.SetLoops(settingLoops, LoopType.Restart);
break;
case loopType.Incremental:
setFinal.SetLoops(settingLoops, LoopType.Incremental);
break;
}
if (!tag.IsNone)
{
setFinal.SetId(tag.Value);
}
bool _isNullOrEmpty = orInputID.IsNone || orInputID == null || string.IsNullOrEmpty(orInputID.Value);
if (_isNullOrEmpty == false)
{
setFinal.SetId(orInputID.Value);
}
bool obj_isNullOrEmpty = gameObjectId.IsNone || gameObjectId.Value == false;
if (obj_isNullOrEmpty == false)
{
setFinal.SetId(Fsm.GetOwnerDefaultTarget(gameObject));
}
switch (easeTypeSelect)
{
case setEaseType.none:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Linear);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Linear));
}
break;
case setEaseType.InSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InSine));
}
break;
case setEaseType.OutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InOutSine:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutSine);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutSine));
}
break;
case setEaseType.InQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuad));
}
break;
case setEaseType.OutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuad));
}
break;
case setEaseType.InOutQuad:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuad);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuad));
}
break;
case setEaseType.InCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCubic));
}
break;
case setEaseType.OutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCubic));
}
break;
case setEaseType.InOutCubic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCubic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCubic));
}
break;
case setEaseType.InQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuart));
}
break;
case setEaseType.OutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuart));
}
break;
case setEaseType.InOutQuart:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuart);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuart));
}
break;
case setEaseType.InQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InQuint));
}
break;
case setEaseType.OutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutQuint));
}
break;
case setEaseType.InOutQuint:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutQuint);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutQuint));
}
break;
case setEaseType.InExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InExpo));
}
break;
case setEaseType.OutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutExpo));
}
break;
case setEaseType.InOutExpo:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutExpo);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutExpo));
}
break;
case setEaseType.InCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InCirc));
}
break;
case setEaseType.OutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutCirc));
}
break;
case setEaseType.InOutCirc:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutCirc);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutCirc));
}
break;
case setEaseType.InElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InElastic));
}
break;
case setEaseType.OutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutElastic));
}
break;
case setEaseType.InOutElastic:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutElastic);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutElastic));
}
break;
case setEaseType.InBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBack));
}
break;
case setEaseType.OutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBack));
}
break;
case setEaseType.InOutBack:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBack);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBack));
}
break;
case setEaseType.InBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InBounce));
}
break;
case setEaseType.OutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutBounce));
}
break;
case setEaseType.InOutBounce:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutBounce);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutBounce));
}
break;
case setEaseType.Flash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.Flash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.Flash));
}
break;
case setEaseType.InFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InFlash));
}
break;
case setEaseType.OutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.OutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.OutFlash));
}
break;
case setEaseType.InOutFlash:
if (enableEaseFactory.Value == false)
{
setFinal.SetEase(Ease.InOutFlash);
}
if (enableEaseFactory.Value == true)
{
setFinal.SetEase(EaseFactory.StopMotion(easeFactoryFps.Value, Ease.InOutFlash));
}
break;
case setEaseType.AnimationCurve:
setFinal.SetEase(animationCurve.curve);
break;
}
// Update + TimeScale
switch (updateTypeSelect)
{
case updateType.Normal:
setFinal.SetUpdate(UpdateType.Normal, isTimeIndependent.Value);
break;
case updateType.Fixed:
setFinal.SetUpdate(UpdateType.Fixed, isTimeIndependent.Value);
break;
case updateType.Late:
setFinal.SetUpdate(UpdateType.Late, isTimeIndependent.Value);
break;
}
switch (pathTypeSelect)
{
case doPathType.CatmullRom:
pathTypeSelected = PathType.CatmullRom;
break;
case doPathType.Linear:
pathTypeSelected = PathType.Linear;
break;
}
switch (pathModeSelect)
{
case doPathMode.Full3D:
pathModeSelected = PathMode.Full3D;
break;
case doPathMode.Ignore:
pathModeSelected = PathMode.Ignore;
break;
case doPathMode.Sidescroller2D:
pathModeSelected = PathMode.Sidescroller2D;
break;
case doPathMode.TopDown2D:
pathModeSelected = PathMode.TopDown2D;
break;
}
// Easy part to edit for other DotTween actions --->
switch (dotweenTypeSelect)
{
case doTweenType.DoPath:
if (gizmoOff.Value == true)
{
_target.transform.DOPath(waypoints, duration.Value, pathTypeSelected, pathModeSelected, resolution.Value).SetAs(setFinal);
}
else
{
_target.transform.DOPath(waypoints, duration.Value, pathTypeSelected, pathModeSelected, resolution.Value, gizmoColor.Value).SetAs(setFinal);
}
break;
case doTweenType.DoLocalPath:
if (gizmoOff.Value == true)
{
_target.transform.DOLocalPath(waypoints, duration.Value, pathTypeSelected, pathModeSelected, resolution.Value).SetAs(setFinal);
}
else
{
_target.transform.DOLocalPath(waypoints, duration.Value, pathTypeSelected, pathModeSelected, resolution.Value, gizmoColor.Value).SetAs(setFinal);
}
break;
}
// <---
if (startEvent != null)
{
Fsm.Event(startEvent);
Finish();
}
}