|
public setOnUpdate ( object>.Action |
||
| onUpdate | object>.Action | |
| Résultat | LTDescr | |
private void FadeOut()
{
LTDescr fadeLTdescr = LeanTween.value(gameObject, 1f, 0f, 1.6f);
fadeLTdescr.setIgnoreTimeScale(true);
fadeLTdescr.setOnUpdate(OnMaskAlphaUpdate);
fadeLTdescr.setOnComplete(OnFadeOutComplete);
}
private void FadeInUI()
{
LTDescr ltDescr = LeanTween.value(gameObject, 0, 1, showUITime);
ltDescr.setIgnoreTimeScale(true);
ltDescr.setOnUpdate(OnUpdateUIAlpha);
StartCoroutine("ShowNoticeView");
}
private void ZoomIn()
{
LTDescr ltDescr = LeanTween.value(gameObject, 20f, 1f, 0.6f);
ltDescr.tweenType = LeanTweenType.easeOutQuad;
ltDescr.setIgnoreTimeScale(true);
ltDescr.setOnUpdate(OnMaskScaleUpdate);
ltDescr.setOnComplete(OnMaskScaleComplete);
}
private void FadeIn()
{
LTDescr fadeLTdescr = LeanTween.value(gameObject, 0f, 1f, 0.6f);
fadeLTdescr.tweenType = LeanTweenType.easeOutQuad;
fadeLTdescr.setIgnoreTimeScale(true);
fadeLTdescr.setOnUpdate(OnMaskAlphaUpdate);
fadeLTdescr.setOnComplete(OnFadeInComplete);
}
public void UpdateLoadProgress(float progress)
{
LeanTween.cancel(gameObject);
float time = Mathf.Max(progress - loadProgressSlider.value, 0.2f);
LTDescr ltDescr = LeanTween.value(gameObject, loadProgressSlider.value, progress, time);
ltDescr.setOnUpdate(OnProgressUpdate);
ltDescr.setOnComplete(OnUpdateLoadProgressComplete);
}
public void startAction()
{
_canvasGroup.alpha = fromAlpha;
LTDescr ltDescr = LeanTween.value(gameObject, fromAlpha, toAlpha, time);
ltDescr.setDelay(delay);
ltDescr.setEase(LeanTweenType.easeInOutSine);
ltDescr.setOnUpdate(OnUpdateFloat);
}
private void PlayAlphaAnimation(float toAlpha, float time, float delay)
{
LTDescr ltDescr = LeanTween.value(gameObject, 1, toAlpha, time);
ltDescr.tweenType = LeanTweenType.easeInOutSine;
ltDescr.setIgnoreTimeScale(true);
ltDescr.setOnUpdate(OnUpdateAlpha);
ltDescr.setOnComplete(OnAlphaAnimationComplemte);
ltDescr.setDelay(delay);
}
public void StartAction()
{
_canvasGroup.alpha = 0f;
LTDescr ltDescr = LeanTween.value(gameObject, 0, 1, time);
ltDescr.setDelay(delay);
ltDescr.setEase(LeanTweenType.easeInOutSine);
ltDescr.setOnUpdate(OnUpdateFloat);
ltDescr.setIgnoreTimeScale(true);
}
public static LTDescr Biezer(GameObject obj, Vector3 p0, Vector3 p1, Vector3 p2, float time)
{
LTDescr tween = LeanTween.value(obj, 0, 1, time);
tween.setOnUpdate(t =>
{
Vector3 p = XMath.SampleBezierCurve(p0, p1, p2, t);
obj.transform.position = p;
});
return(tween);
}
void Start()
{
//copyrightText.CrossFadeAlpha(1, crossFadeDuration, true);
LTDescr ltdescr = LeanTween.value(copyrightText.gameObject, 0, 1, crossFadeDuration);
ltdescr.setOnUpdate(SetUpdateTextColor);
LTDescr crossFadeLTDescr = LeanTween.delayedCall(crossFadeDelay + crossFadeDuration, StartCrossFade);
crossFadeLTDescr.setIgnoreTimeScale(true);
}
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);
}
private void OnWorldTreeDungeonInfosUpdateHandler()
{
RegenerateWorldDungeonButton();
ClickWorldTreeDungeonButtonHandler(_worldTreeDungeonButtonDictionary.GetValue(WorldTreeProxy.instance.UnlockedWorldTreeDungeonInfo.dungeonID));
LTDescr ltDescr = LeanTween.value(gameObject, 0, 1, 0.6f);
ltDescr.setIgnoreTimeScale(true);
ltDescr.setOnUpdate(OnWorldTreeCanvasGroupAlphaUpdate);
Observers.Facade.Instance.SendNotification(string.Format("{0}::{1}", PREFAB_PATH, "OnViewReady"));
}
// Use this for initialization
void Start()
{
LTDescr tween = LeanTween.move(this.gameObject, new Vector3(0, 3, 0), 3);
tween.setFrom(new Vector3(0, -5, 0));
tween.setDelay(2);
tween.setEase(LeanTweenType.easeInBounce);
tween.setOnUpdate(EscreveValor);
tween.setEase(LeanTweenType.easeOutQuad);
}
void triggerAnimation(Vector3 end, Vector3 relativeDirection, Vector3 dir, Vector3 cross)
{
isAttacking = true;
m_attacker.GetComponent <Collider>().isTrigger = true;
List <Vector3> list = new List <Vector3>();
list.Add(m_attacker.transform.position);
this.getRelativeDirection(list, relativeDirection, end, dir, cross);
list.Add(end);
float duration = attackDuration;
if (relativeDirection == Vector3.forward)
{
duration *= 1.5f;
}
else if (relativeDirection == Vector3.back)
{
duration *= 0.5f;
}
LTDescr tween = LeanTween.move(m_attacker.gameObject, list.ToArray(), duration);
int id = tween.id;
//tween.setEaseInCubic();
tween.setOnUpdate((float val) => {
Collider [] colliders = Physics.OverlapSphere(m_attacker.transform.position, shieldCollisionSize);
foreach (Collider col in colliders)
{
if (col.tag == "Shield")
{
//Increment Combo and lose a Max Combo
IncrementCombo();
SetMaxCombo(GetMaxCombo() - 1);
m_defender.GetComponent <Beyblade>().TakeDamage(m_attacker.m_comboDamage - m_defender.m_comboDefense);
LeanTween.cancel(m_attacker.gameObject, tween.id);
this.nextTween(end, relativeDirection, list, dir, duration);
break;
}
}
});
tween.setOnComplete(() =>
{
IncrementCombo();
m_attacker.GetComponent <Beyblade>().PlaySound(1, 0.7f);
m_defender.GetComponent <Beyblade>().TakeDamage(m_attacker.m_comboDamage);
this.nextTween(end, relativeDirection, list, dir, duration);
this.tweenEnemyKnockback(relativeDirection, dir, cross);
});
}
private void ExecutarAnimacao()
{
LTDescr tween = LeanTween.scale(this.painel, Vector3.one, 0.35f);
tween.setFrom(Vector3.one * 2);
tween.setEase(LeanTweenType.easeOutBack);
int pontuacao = ControladorPontuacao.GetPontuacao();
tween = LeanTween.value(0, pontuacao, 3);
tween.setEase(LeanTweenType.easeOutCubic);
tween.setOnUpdate(EscreveValor);
}
// 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 virtual void Cancel()
{
if (toggleState)
{
toggleState = false;
shoulderView.Raise();
rangeIndicator.gameObject.SetActive(false);
player.ToggleLook(true);
cursorEffect.Stop();
lightIntensity = cursorLight.intensity;
lightHandle = LeanTween.value(cursorLight.intensity, 0, Mathf.Pow(cursorEffect.GetFloat("Lifetime"), 2));
lightHandle.setOnUpdate((value) => cursorLight.intensity = value);
effectHandle = Timing.CallDelayed(Mathf.Pow(cursorEffect.GetFloat("Lifetime"), 2), () => cursor.gameObject.SetActive(false));
}
}
// 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);
}
private void MoveHeadRootFromRight()
{
headRoot.localScale = new Vector3(-1, 1, 1);
headRoot.anchorMin = new Vector2(1, 0.5f);
headRoot.anchorMax = new Vector2(1, 0.5f);
headRoot.pivot = new Vector2(0, 0.5f);
headRoot.anchoredPosition = new Vector2(headRoot.rect.size.x, headRoot.anchoredPosition.y);
Vector2 idealAnchoredPosition = new Vector2(0, headRoot.anchoredPosition.y);
LTDescr ltDescr = LeanTween.value(gameObject, headRoot.anchoredPosition, idealAnchoredPosition, 0.2f);
ltDescr.setOnUpdate((Action <Vector2>)OnHeadRootMove);
ltDescr.setIgnoreTimeScale(true);
LTDescr delayedCallDescr = LeanTween.delayedCall(1.5f, HideCore);
delayedCallDescr.setIgnoreTimeScale(true);
}
IEnumerator UIMoveRelativeCoroutine(LTDescr leanTweenValue, RectTransform rectTransform, Vector3 to, float time)
{
float elapsedTime = 0f;
float tweeningValue = 0;
float lastTweenValue = 0;
leanTweenValue.setOnUpdate((float value) => tweeningValue = value);
Vector3 originalPosition = rectTransform.position;
while (LeanTween.isTweening(leanTweenValue.id) && rectTransform != null && elapsedTime < time + leanTweenValue.delay + 2)
{
float deltaTween = tweeningValue - lastTweenValue;
elapsedTime += Time.deltaTime;
rectTransform.position = rectTransform.position + to * deltaTween;
lastTweenValue = tweeningValue;
yield return(null);
}
}
public void Blend(AnimationScriptPlayable playable, float duration, AnimationCurve transitionCurve)
{
if (tweening && lastTween != null)
{
lastTween.callOnCompletes();
lastTween.setOnUpdate((float value) => { });
lastTween.setOnComplete(() => { });
// LeanTween.pause(lastTween.id);
}
// tweenPlayable = AnimatorControllerPlayable.Create(playableGraph, ac);
tweenPlayable = playable;
mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
mixerPlayable.ConnectInput(0, activePlayable, 0);
mixerPlayable.ConnectInput(1, tweenPlayable, 0);
// Plays the Graph.
mixerPlayable.SetInputWeight(0, 1);
playableOutput.SetSourcePlayable(mixerPlayable);
lastTween = LeanTween
.value(playerController.gameObject, 0f, 1f, duration)
.setEase(transitionCurve)
.setOnUpdate((float value) =>
{
mixerPlayable.SetInputWeight(0, 1f - value);
mixerPlayable.SetInputWeight(1, value);
})
.setOnComplete(() =>
{
tweening = false;
playableGraph.Disconnect(mixerPlayable, 0);
playableGraph.Disconnect(mixerPlayable, 1);
playableOutput.SetSourcePlayable(tweenPlayable);
var prevActive = activePlayable;
activePlayable = tweenPlayable;
// prevActive.Destroy();
mixerPlayable.Destroy();
});
tweening = true;
}
// 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);
}
IEnumerator DynamicOrbitCoroutine(LTDescr leanTweenValue, RectTransform rectTransform, Vector3 center, LTDescr radiusValueTween, float radians, float time, float?startingRadians)
{
float tweeningValue = 0f;
float elapsedTime = 0f;
float radius = Vector2.Distance(rectTransform.position, center);
leanTweenValue.setOnUpdate((float value) => tweeningValue = value);
radiusValueTween.setOnUpdate((float value) => radius = value);
float startingRadiansAssigned = 0;
if (startingRadians == null)
{
Vector2 differenceVector = rectTransform.position - center;
if (radius > 0)
{
startingRadiansAssigned = Mathf.Asin(differenceVector.normalized.y / 1);
if ((rectTransform.position.x - center.x) < 0)
{
startingRadiansAssigned = Mathf.PI - startingRadiansAssigned;
}
}
}
else
{
startingRadiansAssigned = (float)startingRadians;
}
while (LeanTween.isTweening(leanTweenValue.id) && rectTransform != null && elapsedTime < time + leanTweenValue.delay + 2)
{
elapsedTime += Time.deltaTime;
float currentRadians = tweeningValue * radians + startingRadiansAssigned;
float xPos = radius * Mathf.Cos(currentRadians);
float yPos = radius * Mathf.Sin(currentRadians);
rectTransform.position = new Vector3(center.x + xPos, center.y + yPos, rectTransform.position.z);
yield return(null);
}
}
IEnumerator UIShakeCoroutine(LTDescr leanTweenValue, RectTransform rectTransform, float magnitude, float rateOfChange, float time)
{
float elapsedTime = 0f;
float tweeningValue = 0;
leanTweenValue.setOnUpdate((float value) => tweeningValue = value);
float lastValX = 0;
float lastValY = 0;
float sin1ValX = Random.Range(0, 10);
float sin2ValX = Random.Range(0, 10);
float sin1ValY = Random.Range(0, 10);
float sin2ValY = Random.Range(0, 10);
Vector2 distanceFromStart = Vector2.zero;
while (LeanTween.isTweening(leanTweenValue.id) && rectTransform != null && elapsedTime < time + leanTweenValue.delay + 2)
{
elapsedTime += Time.deltaTime;
sin1ValX += Random.Range(-rateOfChange, rateOfChange);
sin2ValX += Random.Range(-rateOfChange, rateOfChange);
sin1ValY += Random.Range(-rateOfChange, rateOfChange);
sin2ValY += Random.Range(-rateOfChange, rateOfChange);
float newValX = (Mathf.Sin(sin1ValX * tweeningValue) + Mathf.Sin(sin2ValX * tweeningValue)) * magnitude;
float deltaX = newValX - lastValX;
lastValX = newValX;
float newValY = (Mathf.Sin(sin1ValY * tweeningValue) + Mathf.Sin(sin2ValY * tweeningValue)) * magnitude;
float deltaY = newValY - lastValY;
lastValY = newValY;
rectTransform.position += new Vector3(deltaX, deltaY);
distanceFromStart += new Vector2(deltaX, deltaY);
yield return(null);
}
if (rectTransform != null)
{
rectTransform.position -= new Vector3(distanceFromStart.x, distanceFromStart.y);
}
}
private void RefreshCombatCapability()
{
int newCombatCapability = ManageHeroesProxy.instance.CurrentFormationTeamInfo.Power;
// SortedDictionary<FormationPosition, uint> currentFormationDic = ManageHeroesProxy.instance.CurrentFormationDictionary;
// List<FormationPosition> formationPositions = currentFormationDic.GetKeys();
// int formationPositionCount = formationPositions.Count;
// for (int i = 0; i < formationPositionCount; i++)
// {
// uint roleInstanceID = currentFormationDic[formationPositions[i]];
// if (GameProxy.instance.IsPlayer(roleInstanceID))
// {
// newCombatCapability += GameProxy.instance.PlayerInfo.Power;
// }
// else
// {
// newCombatCapability += HeroProxy.instance.GetHeroInfo(roleInstanceID).Power;
// }
// }
LTDescr ltDescr = LeanTween.value(gameObject, _cachedCombatCapability, newCombatCapability, 0.8f);
ltDescr.setOnUpdate(UpdateCombatCapability);
_cachedCombatCapability = newCombatCapability;
}
// 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);
}
IEnumerator UIMoveCoroutine(LTDescr leanTweenValue, RectTransform rectTransform, Vector3 to, float time)
{
float elapsedTime = 0f;
float tweeningValue = 0;
leanTweenValue.setOnUpdate((float value) => tweeningValue = value);
Vector3 originalPosition = rectTransform.position;
bool isTweening = LeanTween.isTweening(leanTweenValue.id);
bool isFinished = leanTweenValue.isFinished;
while (LeanTween.isTweening(leanTweenValue.id) && rectTransform != null && elapsedTime < time + leanTweenValue.delay + 2)
{
elapsedTime += Time.deltaTime;
rectTransform.position = UnBoundedLerp(
originalPosition,
to,
tweeningValue);
yield return(null);
}
if (rectTransform != null)
{
rectTransform.position = to;
}
}
// Use this for initialization
void Start()
{
LTDescr test = LeanTween.value(this.gameObject, 1, 0, 25f);
test.setOnUpdate(this.OnUpdate);
}
public void DoAnim()
{
Debug.Log("DoAnim "+gameObject.name);
deamHandLTDesc = LeanTween.move(DemonHand, where2Go, timeToComplete);
//deamHandLTDesc.setDestroyOnComplete(shouldDestroyOnComplete);
deamHandLTDesc.setOnUpdate(OnUpdate);
deamHandLTDesc.setOnComplete(nextStep);
deamHandLTDesc.setEase(easyType);
deamHandLTDesc.init();
}
