public override void OnInspectorGUI()
{
TweenBase item = (TweenBase)target;
if (item.WarnCurveLooping(item))
{
EditorGUILayout.HelpBox("Curve is set to clamp, but tween is set to looping.", MessageType.Warning);
}
if (item.WarningRendererVisibilityCheck(item))
{
EditorGUILayout.HelpBox("Auto Paused : Check PAUSE OFFSCREEN setting", MessageType.Warning);
}
if (Application.isPlaying)
{
if (GUILayout.Button("Play"))
{
item.ResetToStart();
item.PlayFromCurrentState();
}
}
//DoDrawDefaultInspector(this.serializedObject);
base.OnInspectorGUI();
}
public override void InitComponent()
{
base.InitComponent();
Transform node = transform.Find("Evo");
node.SafeSetActive(true);
m_nameText = node.GetComponent <Text>("name_txt");
m_currentLevel = node.GetComponent <Text>("left_txt");
m_nextLimitLevel = node.GetComponent <Text>("right_txt");
TweenBase[] ts = node.GetComponentsInChildren <TweenBase>(true);
if (ts != null)
{
float time = 0f;
foreach (var t in ts)
{
if (t.loopType == LoopType.Yoyo)
{
continue;
}
if (t.duration + t.delayStart > time)
{
time = t.duration + t.delayStart;
m_t = t;
}
}
if (m_t)
{
m_t.onComplete.AddListener((forward) => { canClick = true; });
}
}
}
void Start()
{
initialRotationValue = model.transform.rotation; // save the initial rotation
model.angularDrag = angularDrag;
tweenShake = GetComponent <TweenShake>();
audioSource = GetComponent <AudioSource>();
}
private IEnumerator KickSequenceCoroutine(GameObject target, TweenActionSettings settings)
{
yield return(KickTween.RunLeft(target, 100f).WaitForFinish());
yield return(KickTween.RunRight(target, 100f).WaitForFinish());
TweenBase tween = KickTween.RunUp(target, 100f);
while (tween.IsRunning())
{
yield return(null);
}
tween = KickTween.RunDown(target, 100f);
yield return(new WaitForSeconds(0.01f));
Object.DestroyImmediate(tween);
if (tween.IsFinished())
{
yield return(KickTween.RunDown(target, 100f).WaitForFinish());
}
KickTween.RunDirection(target, 100f, new Vector2(2f, 1.5f));
}
public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
{
TweenBase target = property.serializedObject.targetObject as TweenBase;
Object interpolator = target.interpolator;
if (!interpolator)
{
rect.xMax -= rect.height + 4;
}
EditorGUI.BeginChangeCheck();
interpolator = EditorGUI.ObjectField(rect, "interpolator", interpolator, typeof(TweenInterpolator), true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Set Interpolator");
target.interpolator = interpolator as TweenInterpolator;
EditorUtility.SetDirty(target);
}
if (!interpolator)
{
rect.xMin = rect.xMax + 4;
rect.width = rect.height;
if (GUI.Button(rect, addButton, GUIStyle.none))
{
Undo.AddComponent <TweenInterpolator>(target.gameObject);
}
}
}
public override void InitComponent()
{
base.InitComponent();
Transform node = transform.Find("strength");
m_nameText = node.GetComponent <Text>("name_txt");
m_levelText = node.transform.GetComponent <Text>("txt_level_01");
m_expText = node.transform.GetComponent <Text>("level_bar_text");
Transform process = node.transform.Find("progressbar");
m_expBars = Util.GetExpBars(process);
TweenBase[] ts = process.GetComponents <TweenBase>();
if (ts != null)
{
float time = 0;
foreach (var item in ts)
{
if (item.loopType == LoopType.Yoyo)
{
continue;
}
if (item.duration + item.delayStart > time)
{
m_maxTimeTween = item;
time = item.duration + item.delayStart;
}
}
if (m_maxTimeTween)
{
m_maxTimeTween.onComplete.AddListener(OnBaseTweenComplete);
}
}
}
public static TweenBase IncrementTarget(TweenBase target, bool reverse)
{
var tweensOnObject = target.GetComponents <TweenBase>();
int thisIndex = Array.IndexOf(tweensOnObject, target);
if (thisIndex == -1)
{
Debug.LogError("Wha??? isn't on selF???");
return(target);
}
if (thisIndex == tweensOnObject.Length - 1 && reverse == false)
{
return(target);
}
if (thisIndex == 0 && reverse)
{
return(target);
}
int returnIndex = thisIndex + (reverse ? -1 : 1);
return(tweensOnObject[returnIndex]);
}
public void PlayReverse()
{
if (forceFromRotation)
{
if (space == Space.Self)
{
_tween = Tween.LocalRotation(target, toRotation, fromRotation, duration, delay, easing,
loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
else
{
_tween = Tween.Rotation(target, toRotation, fromRotation, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
}
else
{
if (space == Space.Self)
{
_tween = Tween.LocalRotation(target, fromRotation, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
else
{
_tween = Tween.Rotation(target, fromRotation, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
}
}
void Move(Vector2 origin, Vector2 destination, Tween.LoopType loopType = Tween.LoopType.None)
{
float distance = Vector3.Distance(origin, destination);
float time = distance / speed;
currentTween = Tween.Position(transform, origin, destination, time, 0.0f, Tween.EaseInOutStrong, loopType);
direction = (destination - (Vector2)transform.position).normalized;
}
protected override void OnOpen()
{
ignoreStack = true;
base.OnOpen();
MultiLangrage();
m_redEntry.BindNode(GetComponent <Transform>("left"));
m_blueEntry.BindNode(GetComponent <Transform>("right"));
m_timer = GetComponent <Text>("ranking/time");
m_tween = GetComponent <TweenAlpha>("ranking/vs");
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
t1?.Cancel();
Vector3 startPosition = this.transform.position;
Vector3 targetPosition = this.transform.position + new Vector3(0, 1.5f, 0f);
t1 = Tween.Position(this.transform, targetPosition, 10f, 0.5f);
}
}
private void stopBlink()
{
if (_tween == null)
{
return;
}
Tween.normal.kill(_tween.index);
_tween = null;
}
public virtual void Show(bool show)
{
if (canvas != null)
{
canvas.interactable = show;
canvas.blocksRaycasts = show;
if (canvas.alpha.Equals(0.0f) && !show && !overrideAlphaCheck)
{
return;
}
if (!canvas.alpha.Equals(0.0f) && show && !overrideAlphaCheck)
{
return;
}
}
float to = show ? 1 : 0;
float from = !show ? 1 : 0;
if (overrideAlphaCheck)
{
from = canvas.alpha;
}
string func = show ? "HandleTransitionInComplete" : "HandleTransitionOutComplete";
float fadeTime = show ? fadeTimeIn : fadeTimeOut;
if (currentTween != null)
{
currentTween.Stop();
}
currentTween = Tween.Value
(
from,
to,
(Action <float>)(x =>
{
OnUpdate((float)x);
}),
fadeTime, 0, null, Tween.LoopType.None, null,
() =>
{
if (show)
{
HandleTransitionInComplete();
}
else
{
HandleTransitionOutComplete();
}
}
);
}
private void InitComponent()
{
SetDamageParentVisible();
if (!rectTransform)
{
rectTransform = transform as RectTransform;
}
if (!m_tween)
{
m_tween = GetComponent <TweenBase>();
}
}
public virtual void EnabledTextBox(bool tween = true)
{
gameObject.SetActive(true);
if (tween)
{
cTween = Tween.LocalScale(GetComponent <RectTransform>(), Vector2.zero, Vector2.one, 0.5f, 0f, Tween.EaseInOut);
}
else
{
transform.localScale = Vector3.one;
}
}
private void Drop()
{
dropTween = Tween.Position(
target: transform,
endValue: Vector3.Scale(transform.position, new Vector3(1, 0, 1)) + Vector3.up * (transform.position.y - 1f),
duration: dropping ? Constants.transitionTime * 0.25f : Constants.transitionTime * 0.25f * 1.04577f,
delay: 0f,
easeCurve: dropping ? Tween.EaseLinear : Tween.EaseIn,
completeCallback: Detect
);
dropping = true;
}
public void PlayReverse()
{
Vector3 startPos = Vector3.zero;
if (forceFromPosition)
{
if (space == Space.Self)
{
startPos = addMove ? target.localPosition : Vector3.zero;
_tween = Tween.LocalPosition(target, toPosition - startPos, fromPosition - startPos, duration, delay,
easing,
loopType,
delegate { startReverseCallback?.Invoke(); }, delegate { completeReverseCallback?.Invoke(); });
}
else
{
startPos = addMove ? target.position : Vector3.zero;
_tween = Tween.Position(target, toPosition - startPos, fromPosition - startPos, duration, delay, easing,
loopType,
delegate { startReverseCallback?.Invoke(); }, delegate { completeReverseCallback?.Invoke(); });
}
}
else
{
if (space == Space.Self)
{
var newFromPos = fromPosition;
if (addMove)
{
startPos = toPosition;
newFromPos = target.localPosition;
}
_tween = Tween.LocalPosition(target, newFromPos - startPos, duration, delay, easing, loopType,
delegate { startReverseCallback?.Invoke(); }, delegate { completeReverseCallback?.Invoke(); });
}
else
{
var newFromPos = fromPosition;
if (addMove)
{
startPos = toPosition;
newFromPos = target.position;
}
_tween = Tween.Position(target, newFromPos - startPos, duration, delay, easing, loopType,
delegate { startReverseCallback?.Invoke(); }, delegate { completeReverseCallback?.Invoke(); });
}
}
}
public void PlayReverse()
{
if (forceFrom)
{
_tween = Tween.CanvasGroupAlpha(target, toAlpha, fromAlpha, duration, delay, easing,
loopType, delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
else
{
_tween = Tween.CanvasGroupAlpha(target, fromAlpha, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
}
private void showBlink()
{
if (_tween != null)
{
return;
}
_tween = Tween.normal.createTween(1f, 0.2f, 1000, v =>
{
_color.a = v;
_loadingImage.color = _color;
}, null, EaseType.InQuad).setRecycle(true);
}
public void PlayReverse()
{
if (forceFromColor)
{
_tween = Tween.ShaderColor(rend.material, colorName, toColor, fromColor, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
else
{
_tween = Tween.ShaderColor(rend.material, colorName, fromColor, duration, delay, easing, loopType,
delegate { startCallback?.Invoke(); }, delegate { completeCallback?.Invoke(); });
}
}
/// <summary>
/// 添加缓动动画
/// </summary>
/// <param name="go"></param>
/// <param name="tween"></param>
public void AddTween(GameObject go, TweenBase tween)
{
List <TweenBase> tweenList;
int hash = go.GetHashCode();
if (!_tweenMap.TryGetValue(hash, out tweenList))
{
tweenList = new List <TweenBase>();
_tweenMap.Add(hash, tweenList);
_curTweenGoList.Add(hash);
_curTweenGoCount++;
}
tweenList.Add(tween);
}
public TweenBase GetLongestTween()
{
TweenBase tempTween = new TweenBase();
for (int i = 0; i < tweenSequence.Length; i++)
{
if (tweenSequence[i].duration > tempTween.duration)
{
tempTween = tweenSequence[i];
}
}
return(tempTween);
}
private void ColorPressed()
{
if (!applyColor)
{
return;
}
if (colorRendererTarget != null)
{
_colorTween = Tween.Color(colorRendererTarget, pressedColor, colorDuration, 0, null, Tween.LoopType.None, null, null, false);
}
if (colorImageTarget != null)
{
_colorTween = Tween.Color(colorImageTarget, pressedColor, colorDuration, 0, null, Tween.LoopType.None, null, null, false);
}
}
protected override void Awake()
{
base.Awake();
menuController = GetComponentInParent <MenuController>();
canvasGroup = GetComponent <CanvasGroup>();
tween = GetComponent <TweenBase>();
rectTransform = GetComponent <RectTransform>();
layoutElement = GetComponent <LayoutElement>();
widgets = new List <WidgetBase>(GetComponentsInChildren <WidgetBase>())
.Where(widget => widget.GetComponentInParent <MenuScreen>() == this)
.ToList();
}
public virtual void DisableTextbox(bool tween = true)
{
var rt = GetComponent <RectTransform>();
if (rt != null)
{
if (tween)
{
cTween = Tween.LocalScale(rt, Vector2.one, Vector2.zero, 0.5f, 0f, Tween.EaseInOut, Tween.LoopType.None, null, () => { gameObject.SetActive(false); });
}
else
{
gameObject.SetActive(false);
}
}
}
void StartRoomHighlight(Room _room)
{
switch (_room)
{
case Room.MEETING:
if (meetingTween == null || meetingTween.Status != Tween.TweenStatus.Running)
{
meetingTween = Tween.Value(0f, 1f, UpdateMeetingAlpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
case Room.PRESENTATION:
if (presentationTween == null || presentationTween.Status != Tween.TweenStatus.Running)
{
presentationTween = Tween.Value(0f, 1f, UpdatePresentationAlpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
case Room.RELAX:
if (idleTween == null || idleTween.Status != Tween.TweenStatus.Running)
{
idleTween = Tween.Value(0f, 1f, UpdateIdleAlpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
case Room.TASK_1:
if (task1Tween == null || task1Tween.Status != Tween.TweenStatus.Running)
{
task1Tween = Tween.Value(0f, 1f, UpdateTask1Alpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
case Room.TASK_2:
if (task2Tween == null || task2Tween.Status != Tween.TweenStatus.Running)
{
task2Tween = Tween.Value(0f, 1f, UpdateTask2Alpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
case Room.TASK_3:
if (task3Tween == null || task3Tween.Status != Tween.TweenStatus.Running)
{
task3Tween = Tween.Value(0f, 1f, UpdateTask3Alpha, 0.75f, 0f, Tween.EaseInOut, Tween.LoopType.PingPong);
}
break;
}
}
public void Play(object target)
{
Configure(target);
TweenBase tb = _tween as TweenBase;
Tween t = _tween as Tween;
if (null != t)
{
t.Easer = Easer;
}
if (null != tb)
{
tb.Play(target);
}
}
public override void InitComponent()
{
base.InitComponent();
m_tween = gameObject.GetComponent <TweenBase>();
if (m_tween)
{
m_tween.onComplete.AddListener(OnTweenComplete);
}
Transform t = transform.Find("avatars");
m_avatatParent = t.gameObject;
m_bossItems = new BossNoticeItem[t.childCount];
for (int i = 0; i < m_bossItems.Length; i++)
{
m_bossItems[i] = new BossNoticeItem(t.GetChild(i));
}
}
private void Initelize()
{
if (isInited)
{
return;
}
isInited = true;
icon = transform.GetComponent <Image>("icon");
duration = transform.GetComponent <Image>("duration");
desc = transform.GetComponent <Text>("des");
overrideNum = transform.GetComponent <Text>("count");
destoryTween = transform.GetComponent <TweenBase>();
activeTween = transform.GetComponent <TweenBase>("icon/Image");
desc?.SafeSetActive(false);
icon?.GetComponent <Button>()?.onClick.AddListener(() => onClick?.Invoke(buff));
}
private void ColorSelected()
{
if (!applyColor)
{
return;
}
if (colorRendererTarget != null)
{
if (colorRendererTarget.material.HasProperty("_Color"))
{
_colorTween = Tween.Color(colorRendererTarget, selectedColor, colorDuration, 0, null, Tween.LoopType.None, null, null, false);
}
}
if (colorImageTarget != null)
{
_colorTween = Tween.Color(colorImageTarget, selectedColor, colorDuration, 0, null, Tween.LoopType.None, null, null, false);
}
}
void Start()
{
shake = TweenShake.Obtain()
.SetStartValue( Camera.position )
.SetDuration( 1f )
.SetShakeMagnitude( 0.25f )
.SetShakeSpeed( 13f )
.SetTimeScaleIndependent( true )
.OnExecute( ( result ) => { Camera.position = new Vector3( result.x, result.y, Camera.position.z ); } );
fallTween = this.TweenPosition()
.SetStartValue( transform.position + Vector3.up * 5f )
.SetEasing( TweenEasingFunctions.EaseInExpo )
.SetDuration( 1f )
.SetDelay( 0.25f )
.SetTimeScaleIndependent( true )
.OnCompleted( ( sender ) => { shake.Play(); } )
.Play();
}
private void onTweenComplete(TweenBase sender)
{
Debug.Log("finish");
}
public override void Configure(object target)
{
//Tween.Delay = Delay;
//Tween.Duration = Duration;
bool goingX = false;
bool goingY = false;
if (null != WidthTo || null != WidthBy)
goingX = true;
//throw new Exception("XTo nor XBy value not defined");
if (null != HeightTo || null != HeightBy)
goingY = true;
//throw new Exception("YTo nor YBy value not defined");
if (!goingX && !goingY)
{
Debug.LogWarning("Not Width nor Height resize");
return;
}
Parallel parallel = new Parallel();
if (goingX)
{
float widthStart = (float)(WidthFrom ?? StartWidthValueReaderFunc(target));
_tx = new Tween
{
Name = "ResizeX",
Property = "Width",
Duration = Duration,
Easer = Easer,
StartValue = widthStart,
EndValue = WidthTo ?? widthStart + WidthBy
};
parallel.Add(_tx);
}
if (goingY)
{
float heightStart = (float)(HeightFrom ?? StartHeightValueReaderFunc(target));
_ty = new Tween
{
Name = "ResizeY",
Property = "Height",
Duration = Duration,
Easer = Easer,
StartValue = heightStart,
EndValue = HeightTo ?? heightStart + HeightBy
};
parallel.Add(_ty);
}
Tween = parallel;
//Debug.Log("_tx.StartValue " + _tx.StartValue);
//Debug.Log("_tx.EndValue " + _tx.EndValue);
//Debug.Log("_ty.StartValue " + _ty.StartValue);
//Debug.Log("_ty.EndValue " + _ty.EndValue);
}
