//IEnumerator HandleTweenDelayed()
//{
// float counter = 0;
// while (counter < delay)
// {
// counter += Time.deltaTime;
// yield return null;
// }
// HandleTween();
//}
//IEnumerator Activate()
//{
// float counter = 0;
// while (counter < delay)
// {
// counter += Time.deltaTime;
// yield return null;
// }
// objectToAnimate.SetActive(true);
//}
public void HandleTween()
{
if (objectToAnimate == null)
{
objectToAnimate = gameObject;
}
switch (animationType)
{
case UIAnimationType.Fade:
Fade();
break;
case UIAnimationType.Move:
Move();
break;
case UIAnimationType.MoveAbsolute:
MoveAbsolute();
break;
case UIAnimationType.Scale:
Scale();
break;
case UIAnimationType.ScaleX:
ScaleX();
break;
case UIAnimationType.ScaleY:
ScaleY();
break;
default:
break;
}
_tweenObject.setDelay(delay);
_tweenObject.setEase(easeType);
if (loop)
{
_tweenObject.loopCount = int.MaxValue;
}
if (pingpong)
{
_tweenObject.setLoopPingPong();
}
}
private void Animate()
{
switch (animationType)
{
case UIAnimationTypes.Fade:
tweenObject = Fade();
break;
case UIAnimationTypes.Move:
tweenObject = Move();
break;
case UIAnimationTypes.Scale:
tweenObject = Scale();
break;
}
tweenObject.setDelay(delay);
tweenObject.setEase(easeType);
if (loop)
{
tweenObject.setLoopClamp();
}
if (pingpong)
{
tweenObject.setLoopPingPong();
}
}
void Start()
{
LTDescr ltDescr = LeanTween.moveLocalY(enterImage.gameObject, enterImage.transform.localPosition.y - 20f, 0.5f);
ltDescr.setIgnoreTimeScale(true);
ltDescr.setLoopPingPong();
ltDescr.setRepeat(-1);
}
public void Execute()
{
switch (tweenType)
{
case TweenType.Move:
{
descr = LeanTween.move(gameObject, to, duration);
}
break;
case TweenType.MoveX:
{
descr = LeanTween.moveX(gameObject, toX, duration);
}
break;
case TweenType.MoveY:
{
descr = LeanTween.moveY(gameObject, toY, duration);
}
break;
case TweenType.Scale:
{
descr = LeanTween.scale(gameObject, to, duration);
}
break;
case TweenType.ScaleX:
{
descr = LeanTween.scaleX(gameObject, toX, duration);
}
break;
case TweenType.ScaleY:
{
descr = LeanTween.scaleY(gameObject, toY, duration);
}
break;
case TweenType.Rotate:
{
descr = LeanTween.rotate(gameObject, new Vector3(0, 0, rotation), duration);
}
break;
}
descr.setDelay(delay).setEase(easeType);
if (loop)
{
descr.loopCount = int.MaxValue;
}
if (pingpong)
{
descr.setLoopPingPong();
}
}
private void PlayHurtEffect()
{
if (WorldBossProxy.instance.IsOpen)
{
LTDescr ltDescr = LeanTween.value(gameObject, Color.white, Color.red, 0.1f);
ltDescr.setOnUpdate(OnUpdateBossHPBarColor);
ltDescr.setRepeat(4);
ltDescr.setLoopPingPong();
}
LeanTween.delayedCall(gameObject, 1, PlayHurtEffect);
}
/// <summary>
/// Animates a value from one value to another.
/// </summary>
/// <param name="data">The tween data.</param>
/// <returns>The started tween reference.</returns>
public Tween StartValueTo(ValueToAnimation data)
{
LeanTweenType easeType = this.tweenTypeDictionary[data.EaseType];
LTDescr item = LeanTween.value(data.GameObject, data.OnUpdate, 0f, 1f, data.Duration).setDelay(data.Delay).setEase(easeType).setOnComplete(data.OnComplete).setUseEstimatedTime(true);
if (data.PingPongLoop)
{
item.setLoopPingPong();
}
return(new Tween(item));
}
private LTDescr ApplySettingsToTween(LTDescr tween)
{
if (_data.useCurve)
{
tween.setEase(_data.curve);
}
if (_loopPingPong)
{
tween.setLoopPingPong();
}
return(tween);
}
public void Init()
{
// Debug.Log("Initializing " + target.gameObject.name + "\n");
if (target == null)
{
Debug.Log("Missing target for " + this.gameObject.name + " LeanTweener\n"); return;
}
LTDescr l = null;
LeanTween.cancel(target);
switch (type)
{
case TweenType.Scale:
target.transform.localScale = init_vector;
l = LeanTween.scale(target, vector, time).setIgnoreTimeScale(ignoreTimeScale);
break;
case TweenType.Rotate:
l = LeanTween.rotateZ(target, value, time).setIgnoreTimeScale(ignoreTimeScale);
break;
case TweenType.ColorChange:
l = LeanTween.color(target, my_color, time).setIgnoreTimeScale(ignoreTimeScale);
break;
default:
return;
}
tweening = true;
if (delay > 0)
{
l.setDelay(delay);
}
if (leantweentype != LeanTweenType.notUsed)
{
l.setEase(leantweentype);
}
if (pingpong > -99)
{
l.setLoopPingPong(pingpong);
}
if (duration != -99)
{
StartCoroutine(StopMeSoon());
}
}
public void Show()
{
rect = GetComponent <RectTransform>();
canvasGroup = GetComponent <CanvasGroup>();
if (objectToAnimate == null)
{
objectToAnimate = gameObject;
}
switch (transitionType)
{
case UITransitionType.Move:
Move();
break;
case UITransitionType.Scale:
Scale();
break;
case UITransitionType.Fade:
Fade();
break;
}
tweenObject.setDelay(delay);
tweenObject.setEase(easeType);
tweenObject.setIgnoreTimeScale(true);
if (loop)
{
tweenObject.loopCount = int.MaxValue;
}
if (pingpong)
{
tweenObject.setLoopPingPong();
}
}
// Code that runs on entering the state.
public override void OnEnter()
{
var len = pathPoints.Length;
Vector3[] tweenVector = new Vector3[len];
for (var i = 0; i < len; i++)
{
tweenVector [i] = pathPoints [i].Value;
}
GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
Fsm.Event(onStartEvent);
LTDescr tween = LeanTween.move(go, tweenVector, time.Value);
LeanTweenID.Value = tween.id;
tween.setOrientToPath(orientToPath.Value);
tween.setAxis(axis.Value);
tween.setEase(easeType);
tween.setDelay(delay.Value);
if (noOfRepeat.Value > 0)
{
tween.setRepeat(noOfRepeat.Value);
}
switch (LoopType)
{
case LTLoop.clamp:
tween.setLoopClamp();
break;
case LTLoop.once:
tween.setLoopOnce();
break;
case LTLoop.pingpong:
tween.setLoopPingPong();
break;
}
tween.setOnComplete(doOnComplete);
tween.setOnUpdate(doOnUpdate);
tween.setUseEstimatedTime(useEstimatedTime.Value);
tween.setUseFrames(useFrames.Value);
}
public void Run()
{
if (playType == PlayType.Cycle)
{
playingAnim = LeanTween.moveSpline(gameObject, animPath, time)
.setOrientToPath(!staticOrientation)
.setLoopClamp();
}
else
{
playingAnim = LeanTween.moveSpline(gameObject, animPath, time)
//.setEase(LeanTweenType.easeOutQuad) // No easing until I sync animation
.setOrientToPath(!staticOrientation)
.setOnComplete(() =>
{
if (OnComplete != null)
{
OnComplete();
}
OnMoveComplete();
if (ueOnComplete != null)
{
ueOnComplete.Invoke();
}
});
if (playType == PlayType.Repeat)
{
playingAnim.setRepeat(repeats);
}
else if (playType == PlayType.PingPong)
{
playingAnim.setLoopPingPong();
}
}
if (animationCycler)
{
animationCycler[startAnimName].speed = startAnimSpeed;
animationCycler[startAnimName].wrapMode = startWrapMode;
animationCycler.clip = animationCycler[startAnimName].clip;
animationCycler.Play();
if (moveSoundPlayer && moveSound)
{
moveSoundPlayer.clip = moveSound;
moveSoundPlayer.Play();
}
}
}
// Code that runs on entering the state.
public override void OnEnter()
{
GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
GameObject tGo = targetGameObject.Value;
if (tGo != null)
{
tempVector = tGo.transform.position;
}
else
{
tempVector = vector.Value;
}
Fsm.Event(onStartEvent);
LTDescr tween = LeanTween.move(go, tempVector, time.Value);
LeanTweenID.Value = tween.id;
tween.setEase(easeType);
tween.setDelay(delay.Value);
if (noOfRepeat.Value > 0)
{
tween.setRepeat(noOfRepeat.Value);
}
switch (LoopType)
{
case LTLoop.clamp:
tween.setLoopClamp();
break;
case LTLoop.once:
tween.setLoopOnce();
break;
case LTLoop.pingpong:
tween.setLoopPingPong();
break;
}
tween.setOnComplete(doOnComplete);
tween.setOnUpdate(doOnUpdate);
tween.setUseEstimatedTime(useEstimatedTime.Value);
tween.setUseFrames(useFrames.Value);
}
void Start()
{
float to = 0f;
float duration = 2f;
// animating alpha to make a dissolve effect of the image.
LTDescr descAlpha = LeanTween.alpha(this.gameObject, to, duration);
descAlpha.setEase(LeanTweenType.linear);
descAlpha.setLoopPingPong();
if (doRotate)
{
LTDescr descRot = LeanTween.rotate(this.gameObject, new Vector3(180f, 30f, 90f), rotDuration);
descRot.setLoopPingPong();
}
}
public void HandleTween()
{
if (ObjectToAnimate == null)
{
ObjectToAnimate = gameObject;
}
switch (AnimationType)
{
case UIAnimationTypes.Fade:
Fade();
break;
case UIAnimationTypes.Move:
MoveAbsolute();
break;
case UIAnimationTypes.Scale:
Scale();
break;
case UIAnimationTypes.ScaleX:
Scale();
break;
case UIAnimationTypes.ScaleY:
Scale();
break;
}
_tweenObject.setDelay(Delay);
_tweenObject.setEase(EaseType);
if (Loop)
{
_tweenObject.loopCount = int.MaxValue;
}
if (PingPong)
{
_tweenObject.setLoopPingPong();
}
}
public void HandleTween()
{
if (_objectToAnimate == null)
{
_objectToAnimate = gameObject;
}
switch (animationType)
{
case AnimationType.MOVE:
MoveAbsolute();
break;
case AnimationType.SCALE:
Scale();
break;
case AnimationType.SCALEX:
Scale();
break;
case AnimationType.SCALEY:
Scale();
break;
default:
throw new ArgumentOutOfRangeException();
}
_tweenObject.setDelay(delay);
_tweenObject.setEase(easeType);
if (loop)
{
_tweenObject.loopCount = int.MaxValue;
}
if (pingpong)
{
_tweenObject.setLoopPingPong();
}
}
private void MoveAnim(Vector3 position, bool againstWall)
{
float distancePercentage = againstWall ? wallBounceDistance : 1;
Vector3 positionDiff = new Vector3(transform.position.x - position.x, transform.position.y - position.y);
positionDiff = positionDiff * distancePercentage;
LTDescr moveLTDescr = LeanTween.move(againstWall ? characterBody : gameObject, transform.position - positionDiff, moveTime).setEaseLinear();
if (againstWall)
{
moveLTDescr.setTime(wallBounceTime);
moveLTDescr.setLoopPingPong(1).setOnComplete(() => IsSafe = true);
}
else
{
moveLTDescr.setOnComplete(() => CheckCurrentTile());
}
}
private void SetTweenSettings()
{
if (!LeanTween.isTweening(id))
{
return;
}
LTDescr descr = LeanTween.descr(id);
if (descr == null)
{
return;
}
if (easeType == LeanTweenType.animationCurve)
{
descr.setEase(animationCurve);
}
else
{
descr.setEase(easeType);
}
descr.setDelay(delay);
if (loop)
{
if (pingPong)
{
descr.setLoopPingPong(loopTimes);
}
else
{
descr.setLoopClamp(loopTimes);
}
}
descr.setOnComplete(() => onCompleteCallback?.Invoke());
descr.setDestroyOnComplete(destroyOnComplete);
}
// Code that runs on entering the state.
public override void OnEnter()
{
GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
Vector3 final = go.transform.localPosition + vector.Value;
Fsm.Event(onStartEvent);
LTDescr tween = LeanTween.moveLocal(go, final, time.Value);
LeanTweenID.Value = tween.id;
tween.setEase(easeType);
tween.setDelay(delay.Value);
if (noOfRepeat.Value > 0)
{
tween.setRepeat(noOfRepeat.Value);
}
switch (LoopType)
{
case LTLoop.clamp:
tween.setLoopClamp();
break;
case LTLoop.once:
tween.setLoopOnce();
break;
case LTLoop.pingpong:
tween.setLoopPingPong();
break;
}
tween.setOnComplete(doOnComplete);
tween.setOnUpdate(doOnUpdate);
tween.setUseEstimatedTime(useEstimatedTime.Value);
tween.setUseFrames(useFrames.Value);
}
public void Show()
{
if (_target == null)
{
_target = gameObject;
}
switch (_animationType)
{
case UIAnimayionTypes.Move:
Move();
break;
case UIAnimayionTypes.Scale:
Scale();
break;
case UIAnimayionTypes.Rotate:
Rotate();
break;
case UIAnimayionTypes.Fade:
Fade();
break;
}
_tweenObj.setDelay(_delay);
_tweenObj.setEase(_easeType);
if (_loop)
{
_tweenObj.setLoopCount(-1);
}
if (_pingPong)
{
_tweenObj.setLoopPingPong();
}
_tweenObj.setOnComplete(() => _onComplete?.Invoke());
}
// Code that runs on entering the state.
public override void OnEnter()
{
GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
float final = go.transform.eulerAngles.x + degrees.Value;
Fsm.Event(onStartEvent);
LTDescr tween = LeanTween.rotate(go.GetComponent <RectTransform>(), final, time.Value);
LeanTweenID.Value = tween.id;
tween.setEase(easeType);
tween.setDelay(delay.Value);
if (noOfRepeat.Value > 0)
{
tween.setRepeat(noOfRepeat.Value);
}
switch (LoopType)
{
case LTLoop.clamp:
tween.setLoopClamp();
break;
case LTLoop.once:
tween.setLoopOnce();
break;
case LTLoop.pingpong:
tween.setLoopPingPong();
break;
}
tween.setOnComplete(doOnComplete);
tween.setUseEstimatedTime(useEstimatedTime.Value);
tween.setUseFrames(useFrames.Value);
}
private void HandleTween()
{
if (objectToAnimate == null)
{
objectToAnimate = gameObject;
}
switch (animationType)
{
case UIAnimationType.Move:
Move();
break;
case UIAnimationType.Rotate:
Rotate();
break;
case UIAnimationType.Scale:
Scale();
break;
case UIAnimationType.Fade:
Fade();
break;
}
tweenObject.setDelay(delay);
tweenObject.setEase(easeType);
if (loop)
{
tweenObject.loopCount = int.MaxValue; //tweenObject.setLoopType()
}
if (pingpong)
{
tweenObject.setLoopPingPong();
}
}
// Code that runs on entering the state.
public override void OnEnter()
{
GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);
Fsm.Event(onStartEvent);
LTDescr tween = LeanTween.value(go, doOnUpdate, fromValue.Value, toValue.Value, time.Value);
LeanTweenID.Value = tween.id;
tween.setEase(easeType);
tween.setDelay(delay.Value);
if (noOfRepeat.Value > 0)
{
tween.setRepeat(noOfRepeat.Value);
}
switch (LoopType)
{
case LTLoop.clamp:
tween.setLoopClamp();
break;
case LTLoop.once:
tween.setLoopOnce();
break;
case LTLoop.pingpong:
tween.setLoopPingPong();
break;
}
tween.setOnComplete(doOnComplete);
tween.setOnUpdate(doOnUpdate);
tween.setUseEstimatedTime(useEstimatedTime.Value);
tween.setUseFrames(useFrames.Value);
}
private void HandleTween()
{
if (_objectToAnimate == null)
{
_objectToAnimate = gameObject;
}
if (_objectToDisable == null)
{
_objectToDisable = gameObject;
}
switch (_animationType)
{
case AnimationType.MoveX:
MoveX();
break;
case AnimationType.MoveY:
MoveY();
break;
case AnimationType.Move:
Move();
break;
case AnimationType.MoveLocalX:
MoveLocalX();
break;
case AnimationType.MoveLocalY:
MoveLocalY();
break;
case AnimationType.MoveLocal:
MoveLocal();
break;
case AnimationType.RotateX:
RotateX();
break;
case AnimationType.RotateY:
RotateY();
break;
case AnimationType.RotateZ:
RotateZ();
break;
case AnimationType.Rotate:
Rotate();
break;
case AnimationType.RotateLocal:
RotateLocal();
break;
case AnimationType.ScaleX:
ScaleX();
break;
case AnimationType.ScaleY:
ScaleY();
break;
case AnimationType.ScaleZ:
ScaleZ();
break;
case AnimationType.Scale:
Scale();
break;
case AnimationType.Alpha:
Fade();
break;
case AnimationType.Color:
Color();
break;
}
_tweenObject.setDelay(_delay);
_tweenObject.setEase(_easeType);
if (_loop)
{
_tweenObject.setLoopCount(int.MaxValue);
}
if (_pingPong)
{
_tweenObject.setLoopPingPong();
}
}
//Handles actual tween logic
public void HandleTween(bool isDisabling, UIAnimationTypes animationType, LeanTweenType easeType, float delay, float duration, bool loop, bool pingpong, bool startPositionOffset)
{
//Checks whether this script should be animating this object
if (objectToAnimate == null)
{
objectToAnimate = gameObject;
}
//Switch for different animation types
switch (animationType)
{
//Fade
case UIAnimationTypes.Fade:
if (isDisabling)
{
//Fade out
Fade(animationSettings.outFrom, animationSettings.outTo, startPositionOffset, duration);
}
else
{
//Fade in
Fade(animationSettings.inFrom, animationSettings.inTo, startPositionOffset, duration);
}
break;
//Move
case UIAnimationTypes.Move:
if (isDisabling)
{
//Move out
MoveAbsolute(animationSettings.outFrom, animationSettings.outTo, duration);
}
else
{
//Move in
MoveAbsolute(animationSettings.inFrom, animationSettings.inTo, duration);
}
break;
//Scale
case UIAnimationTypes.Scale:
if (isDisabling)
{
//Scale out
Scale(animationSettings.outFrom, animationSettings.outTo, startPositionOffset, duration);
}
else
{
//Scale in
Scale(animationSettings.inFrom, animationSettings.inTo, startPositionOffset, duration);
}
break;
}
//Tween settings
tweenObject.setDelay(delay);
tweenObject.setEase(easeType);
//Loop settings
if (loop)
{
tweenObject.loopCount = int.MaxValue;
}
//Ping pong effect
if (pingpong)
{
tweenObject.setLoopPingPong();
}
}
private void HandleTween()
{
switch (animationType)
{
case AnimationType.MoveX:
MoveX();
break;
case AnimationType.MoveY:
MoveY();
break;
case AnimationType.Move:
Move();
break;
case AnimationType.MoveLocalX:
MoveLocalX();
break;
case AnimationType.MoveLocalY:
MoveLocalY();
break;
case AnimationType.MoveLocal:
MoveLocal();
break;
case AnimationType.RotateX:
RotateX();
break;
case AnimationType.RotateY:
RotateY();
break;
case AnimationType.RotateZ:
RotateZ();
break;
case AnimationType.Rotate:
Rotate();
break;
case AnimationType.RotateLocal:
RotateLocal();
break;
case AnimationType.ScaleX:
ScaleX();
break;
case AnimationType.ScaleY:
ScaleY();
break;
case AnimationType.ScaleZ:
ScaleZ();
break;
case AnimationType.Scale:
Scale();
break;
case AnimationType.Alpha:
Fade();
break;
case AnimationType.Color:
Color();
break;
}
_tweenObject.setDelay(delay);
_tweenObject.setEase(easeType);
_tweenObject.setIgnoreTimeScale(useUnscaledTime);
if (loop)
{
_tweenObject.setLoopCount(int.MaxValue);
}
if (pingPong)
{
_tweenObject.setLoopPingPong();
}
}
private void HandleTween()
{
_tweenObject = null;
switch (animationType)
{
case UIAnimationTypes.Fade:
Fade();
break;
case UIAnimationTypes.Move:
MoveAbsolute();
break;
case UIAnimationTypes.Scale:
Scale();
break;
case UIAnimationTypes.ScaleX:
from = new Vector3(from.x, transform.localScale.y, transform.localScale.z);
to = new Vector3(to.x, transform.localScale.y, transform.localScale.z);
Scale();
break;
case UIAnimationTypes.ScaleY:
from = new Vector3(transform.localScale.x, from.y, transform.localScale.z);
to = new Vector3(transform.localScale.x, to.y, transform.localScale.z);
Scale();
break;
case UIAnimationTypes.Rect:
Rect();
break;
}
var delayResult = delay;
if (multiplyDelayByChildIndex)
{
delayResult = delay * transform.GetSiblingIndex();
}
_tweenObject.setDelay(delayResult);
if ((delayResult >= 0f) && hideDuringDelay)
{
CanvasGroup group = objectToAnimate.GetComponent <CanvasGroup>();
if (group == null)
{
group = objectToAnimate.AddComponent <CanvasGroup>();
}
group.alpha = 0;
//Show the object when it starts
_tweenObject.setOnStart(() =>
{
group.alpha = 1;
});
}
_tweenObject.setEase(easeType);
if (loop)
{
_tweenObject.loopCount = int.MaxValue;
}
if (pingpong)
{
_tweenObject.setLoopPingPong();
}
if (onComplete != null)
{
_tweenObject.setOnComplete(onComplete);
}
}
public void HandleTween()
{
if (objectToAnimate == null)
{
objectToAnimate = gameObject;
}
switch (animationType)
{
case UIAnimationTypes.Fade:
Fade();
break;
case UIAnimationTypes.Move:
MoveAbsolute();
break;
case UIAnimationTypes.Scale:
Scale();
break;
case UIAnimationTypes.ScaleX:
from = new Vector3(from.x, transform.localScale.y, transform.localScale.z);
to = new Vector3(to.x, transform.localScale.y, transform.localScale.z);
Scale();
break;
case UIAnimationTypes.ScaleY:
from = new Vector3(transform.localScale.x, from.y, transform.localScale.z);
to = new Vector3(transform.localScale.x, to.y, transform.localScale.z);
Scale();
break;
}
_tweenObject.setDelay(delay);
if ((delay >= 0f) && hideDuringDelay)
{
CanvasGroup group = objectToAnimate.GetComponent <CanvasGroup>();
if (group == null)
{
group = objectToAnimate.AddComponent <CanvasGroup>();
}
group.alpha = 0;
//Show the object when it starts
_tweenObject.setOnStart(() =>
{
group.alpha = 1;
});
}
_tweenObject.setEase(easeType);
if (loop)
{
_tweenObject.loopCount = int.MaxValue;
}
if (pingpong)
{
_tweenObject.setLoopPingPong();
}
}
private void buildTween(LeanTweenItem item, float delayAdd, bool generateCode)
{
float delay = item.delay + delayAdd;
bool code = generateCode;
float d = item.duration;
// Debug.Log("item:"+item.action);
if (item.action == TweenAction.ALPHA)
{
tween = code ? append("alpha", item.to.x, d) : LeanTween.alpha(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.ALPHA_VERTEX)
{
tween = code ? append("alphaVertex", item.to.x, d) : LeanTween.alphaVertex(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE)
{
tween = code ? append("move", item.to, d) : LeanTween.move(gameObject, item.to, d);
}
else if (item.action == TweenAction.MOVE_LOCAL)
{
tween = code ? append("moveLocal", item.to, d) : LeanTween.moveLocal(gameObject, item.to, d);
}
else if (item.action == TweenAction.MOVE_LOCAL_X)
{
tween = code ? append("moveLocalX", item.to.x, d) : LeanTween.moveLocalX(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_LOCAL_Y)
{
tween = code ? append("moveLocalY", item.to.x, d) : LeanTween.moveLocalY(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_LOCAL_Z)
{
tween = code ? append("moveLocalZ", item.to.x, d) : LeanTween.moveLocalZ(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_X)
{
tween = code ? append("moveX", item.to.x, d) : LeanTween.moveX(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_Y)
{
tween = code ? append("moveY", item.to.x, d) : LeanTween.moveY(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_Z)
{
tween = code ? append("moveZ", item.to.x, d) : LeanTween.moveZ(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.MOVE_CURVED)
{
tween = code ? append("move", item.bezierPath ? item.bezierPath.vec3 : null, d) : LeanTween.move(gameObject, item.bezierPath.vec3, d);
if (item.orientToPath)
{
if (code)
{
codeBuild.Append(".setOrientToPath(" + item.orientToPath + ")");
}
else
{
tween.setOrientToPath(item.orientToPath);
}
}
if (item.isPath2d)
{
if (code)
{
codeBuild.Append(".setOrientToPath2d(true)");
}
else
{
tween.setOrientToPath2d(item.isPath2d);
}
}
}
else if (item.action == TweenAction.MOVE_CURVED_LOCAL)
{
tween = code ? append("moveLocal", item.bezierPath ? item.bezierPath.vec3 : null, d) : LeanTween.moveLocal(gameObject, item.bezierPath.vec3, d);
if (item.orientToPath)
{
if (code)
{
codeBuild.Append(".setOrientToPath(" + item.orientToPath + ")");
}
else
{
tween.setOrientToPath(item.orientToPath);
}
}
if (item.isPath2d)
{
if (code)
{
codeBuild.Append(".setOrientToPath2d(true)");
}
else
{
tween.setOrientToPath2d(item.isPath2d);
}
}
}
else if (item.action == TweenAction.MOVE_SPLINE)
{
tween = code ? append("moveSpline", item.splinePath ? item.splinePath.splineVector() : null, d) : LeanTween.moveSpline(gameObject, item.splinePath.splineVector(), d);
if (item.orientToPath)
{
if (code)
{
codeBuild.Append(".setOrientToPath(" + item.orientToPath + ")");
}
else
{
tween.setOrientToPath(item.orientToPath);
}
}
if (item.isPath2d)
{
if (code)
{
codeBuild.Append(".setOrientToPath2d(true)");
}
else
{
tween.setOrientToPath2d(item.isPath2d);
}
}
}
else if (item.action == TweenAction.ROTATE)
{
tween = code ? append("rotate", item.to, d) : LeanTween.rotate(gameObject, item.to, d);
}
else if (item.action == TweenAction.ROTATE_AROUND)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.rotateAround(gameObject, " + vecToStr(item.axis) + ", " + item.to.x + "f , " + d + "f)");
}
else
{
tween = LeanTween.rotateAround(gameObject, item.axis, item.to.x, d);
}
}
else if (item.action == TweenAction.ROTATE_AROUND_LOCAL)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.rotateAroundLocal(gameObject, " + vecToStr(item.axis) + ", " + item.to.x + "f , " + d + "f)");
}
else
{
tween = LeanTween.rotateAroundLocal(gameObject, item.axis, item.to.x, d);
}
}
else if (item.action == TweenAction.ROTATE_LOCAL)
{
tween = code ? append("rotateLocal", item.to, d) : LeanTween.rotateLocal(gameObject, item.to, d);
}
else if (item.action == TweenAction.ROTATE_X)
{
tween = code ? append("rotateX", item.to.x, d) : LeanTween.rotateX(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.ROTATE_Y)
{
tween = code ? append("rotateY", item.to.x, d) : LeanTween.rotateY(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.ROTATE_Z)
{
tween = code ? append("rotateZ", item.to.x, d) : LeanTween.rotateZ(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.SCALE)
{
tween = code ? append("scale", item.to, d) : LeanTween.scale(gameObject, item.to, d);
}
else if (item.action == TweenAction.SCALE_X)
{
tween = code ? append("scaleX", item.to.x, d) : LeanTween.scaleX(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.SCALE_Y)
{
tween = code ? append("scaleY", item.to.x, d) : LeanTween.scaleY(gameObject, item.to.x, d);
}
else if (item.action == TweenAction.SCALE_Z)
{
tween = code ? append("scaleZ", item.to.x, d) : LeanTween.scaleZ(gameObject, item.to.x, d);
}
#if !UNITY_4_3 && !UNITY_4_5
else if (item.action == TweenAction.CANVAS_MOVE)
{
tween = code ? appendRect("move", item.to, d) : LeanTween.move(GetComponent <RectTransform>(), item.to, d);
}
else if (item.action == TweenAction.CANVAS_SCALE)
{
tween = code ? appendRect("scale", item.to, d) : LeanTween.scale(GetComponent <RectTransform>(), item.to, d);
}
else if (item.action == TweenAction.CANVAS_ROTATEAROUND)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.rotateAround(rectTransform, " + vecToStr(item.axis) + ", " + item.to.x + "f , " + d + "f)");
}
else
{
tween = LeanTween.rotateAround(GetComponent <RectTransform>(), item.axis, item.to.x, d);
}
}
else if (item.action == TweenAction.CANVAS_ROTATEAROUND_LOCAL)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.rotateAroundLocal(rectTransform, " + vecToStr(item.axis) + ", " + item.to.x + "f , " + d + "f)");
}
else
{
tween = LeanTween.rotateAroundLocal(GetComponent <RectTransform>(), item.axis, item.to.x, d);
}
}
else if (item.action == TweenAction.CANVAS_ALPHA)
{
tween = code ? appendRect("alpha", item.to.x, d) : LeanTween.alpha(GetComponent <RectTransform>(), item.to.x, d);
}
else if (item.action == TweenAction.CANVAS_COLOR)
{
tween = code ? appendRect("color", item.colorTo, d) : LeanTween.color(GetComponent <RectTransform>(), item.colorTo, d);
}
else if (item.action == TweenAction.TEXT_ALPHA)
{
tween = code ? appendRect("textAlpha", item.to.x, d) : LeanTween.textAlpha(GetComponent <RectTransform>(), item.to.x, d);
}
else if (item.action == TweenAction.TEXT_COLOR)
{
tween = code ? appendRect("textColor", item.colorTo, d) : LeanTween.textColor(GetComponent <RectTransform>(), item.colorTo, d);
}
else if (item.action == TweenAction.CANVAS_PLAYSPRITE)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.play(rectTransform, sprites).setFrameRate(" + item.frameRate + "f)");
}
else
{
tween = LeanTween.play(GetComponent <RectTransform>(), item.sprites).setFrameRate(item.frameRate);
}
}
#endif
else if (item.action == TweenAction.COLOR)
{
tween = code ? append("color", item.colorTo, d) : LeanTween.color(gameObject, item.colorTo, d);
}
else if (item.action == TweenAction.DELAYED_SOUND)
{
if (generateCode)
{
codeBuild.Append(tabs + "LeanTween.delayedSound(gameObject, passAudioClipHere, " + vecToStr(item.from) + ", " + d + "f)");
}
else
{
tween = LeanTween.delayedSound(gameObject, item.audioClip, item.from, item.duration);
}
}
else
{
tween = null;
Debug.Log("The tween '" + item.action.ToString() + "' has not been implemented. info item:" + item);
return;
}
// Append Extras
if (generateCode)
{
if (delay > 0f)
{
codeBuild.Append(".setDelay(" + delay + "f)");
}
}
else
{
tween = tween.setDelay(delay);
}
if (item.ease == LeanTweenType.animationCurve)
{
if (generateCode)
{
codeBuild.Append(".setEase(");
append(item.animationCurve);
codeBuild.Append(")");
}
else
{
tween.setEase(item.animationCurve);
}
}
else
{
if (generateCode)
{
if (item.ease != LeanTweenType.linear)
{
codeBuild.Append(".setEase(LeanTweenType." + item.ease + ")");
}
}
else
{
tween.setEase(item.ease);
}
}
// Debug.Log("curve:"+item.animationCurve+" item.ease:"+item.ease);
if (item.between == LeanTweenBetween.FromTo)
{
if (generateCode)
{
codeBuild.Append(".setFrom(" + item.from + ")");
}
else
{
tween.setFrom(item.from);
}
}
if (item.doesLoop)
{
if (generateCode)
{
codeBuild.Append(".setRepeat(" + item.loopCount + ")");
}
else
{
tween.setRepeat(item.loopCount);
}
if (item.loopType == LeanTweenType.pingPong)
{
if (generateCode)
{
codeBuild.Append(".setLoopPingPong()");
}
else
{
tween.setLoopPingPong();
}
}
}
if (generateCode)
{
codeBuild.Append(";\n");
}
}
private void Start()
{
tweenObject = LeanTween.move(gameObject, transform.position + (Vector3.up * distance), duration);
tweenObject.setLoopPingPong();
tweenObject.setEase(easeType);
}
// -------------------------------------------------------------------------------
private void SetTweenType()
{
switch (TweenType)
{
case LeanTweenType.linear: mTweenDescriptor.setEaseLinear(); break;
case LeanTweenType.easeOutQuad: mTweenDescriptor.setEaseOutQuad(); break;
case LeanTweenType.easeInQuad: mTweenDescriptor.setEaseInQuad(); break;
case LeanTweenType.easeInOutQuad: mTweenDescriptor.setEaseInOutQuad(); break;
case LeanTweenType.easeInCubic: mTweenDescriptor.setEaseInCubic(); break;
case LeanTweenType.easeOutCubic: mTweenDescriptor.setEaseOutCubic(); break;
case LeanTweenType.easeInOutCubic: mTweenDescriptor.setEaseInOutCubic(); break;
case LeanTweenType.easeInQuart: mTweenDescriptor.setEaseInQuart(); break;
case LeanTweenType.easeOutQuart: mTweenDescriptor.setEaseOutQuart(); break;
case LeanTweenType.easeInOutQuart: mTweenDescriptor.setEaseInOutQuart(); break;
case LeanTweenType.easeInQuint: mTweenDescriptor.setEaseInQuint(); break;
case LeanTweenType.easeOutQuint: mTweenDescriptor.setEaseOutQuint(); break;
case LeanTweenType.easeInOutQuint: mTweenDescriptor.setEaseInOutQuint(); break;
case LeanTweenType.easeInSine: mTweenDescriptor.setEaseInSine(); break;
case LeanTweenType.easeOutSine: mTweenDescriptor.setEaseOutSine(); break;
case LeanTweenType.easeInOutSine: mTweenDescriptor.setEaseInOutSine(); break;
case LeanTweenType.easeInExpo: mTweenDescriptor.setEaseInExpo(); break;
case LeanTweenType.easeOutExpo: mTweenDescriptor.setEaseOutExpo(); break;
case LeanTweenType.easeInOutExpo: mTweenDescriptor.setEaseInOutExpo(); break;
case LeanTweenType.easeInCirc: mTweenDescriptor.setEaseInCirc(); break;
case LeanTweenType.easeOutCirc: mTweenDescriptor.setEaseOutCirc(); break;
case LeanTweenType.easeInOutCirc: mTweenDescriptor.setEaseInOutCirc(); break;
case LeanTweenType.easeInBounce: mTweenDescriptor.setEaseInBounce(); break;
case LeanTweenType.easeOutBounce: mTweenDescriptor.setEaseOutBounce(); break;
case LeanTweenType.easeInOutBounce: mTweenDescriptor.setEaseInOutBounce(); break;
case LeanTweenType.easeInBack: mTweenDescriptor.setEaseInBack(); break;
case LeanTweenType.easeOutBack: mTweenDescriptor.setEaseOutBack(); break;
case LeanTweenType.easeInOutBack: mTweenDescriptor.setEaseInOutBack(); break;
case LeanTweenType.easeInElastic: mTweenDescriptor.setEaseInElastic(); break;
case LeanTweenType.easeOutElastic: mTweenDescriptor.setEaseOutElastic(); break;
case LeanTweenType.easeInOutElastic: mTweenDescriptor.setEaseInOutElastic(); break;
case LeanTweenType.easeSpring: mTweenDescriptor.setEaseSpring(); break;
case LeanTweenType.easeShake: mTweenDescriptor.setEaseShake(); break;
case LeanTweenType.punch: mTweenDescriptor.setEasePunch(); break;
case LeanTweenType.once: mTweenDescriptor.setLoopOnce(); break;
case LeanTweenType.clamp: mTweenDescriptor.setLoopClamp(); break;
case LeanTweenType.pingPong: mTweenDescriptor.setLoopPingPong(); break;
case LeanTweenType.animationCurve: Debug.LogError("Can't set AnimationCurve Tween this way..."); break;
default: Debug.LogError("Invalid TweenType specified. Falling back to Linear"); break;
}
}
