public void PlayTween(int i, System.Action onFinish)
{
if (i < 0 || i >= m_Tweens.Length)
{
return;
}
if (mTweeners == null)
{
mTweeners = new TweenerBase[TweenTypeMax + 1];
}
TweenData tween = m_Tweens[i];
int ti = (int)tween.tweenType;
TweenerBase tweener = mTweeners[ti];
if (tweener != null)
{
tweener.Stop();
}
PlayTweenData(tween);
if (onFinish != null)
{
tweener = mTweeners[ti];
if (tweener != null && tweener.Playing)
{
tweener.OnFinishEvent += onFinish;
}
else
{
try { onFinish(); } catch (System.Exception e) { Debug.LogException(e); }
}
}
}
/// <summary>
/// Adds a task to the task pool
/// </summary>
/// <param name="data"></param>
public void AddTask(TweenData data, bool notOverrideExistingTask = default(bool))
{
// Remove existing data if applicable
if (!notOverrideExistingTask)
{
RemoveExisitingData(data);
}
// Fixing duration
if (data.duration < 0.0f)
{
data.duration = 0.0f;
}
// Fixing mod
if (!data.modifyPosition && !data.modifyAngle && !data.modifyScale)
{
Debug.LogWarning("Task on: " + data.actor + " | No modification was tasked. Defaulting to modifying position.");
data.modifyPosition = true;
}
// Build task
TweenTask newTask = new TweenTask
{
tweenData = data,
elaspedTime = 0.0f,
};
taskPool.Add(newTask);
Debug.Log("New tasked added for " + data.actor);
StartTasks();
}
public bool StopTween(int i, bool reset)
{
if (mTweeners == null)
{
return(false);
}
if (i < 0 || i >= m_Tweens.Length)
{
return(false);
}
TweenData tween = m_Tweens[i];
int ti = (int)tween.tweenType;
TweenerBase tweener = mTweeners[ti];
if (tweener == null)
{
return(false);
}
tweener.Stop();
if (reset)
{
tweener.Reset();
}
return(true);
}
void Start()
{
rb = GetComponent <Rigidbody>();
GM = FindObjectOfType <GameManager>();
playerConfig = new PlayerConfig(gameObject);
tweenData = new TweenData();
playerConfig.speed = 20;
ph_Pointer = transform.Find("ph_pointer").gameObject;
body = transform.Find("body").gameObject;
ph_pointerRadius = (transform.position - ph_Pointer.transform.position).magnitude;
fireDelegate += fireFeedback;
fireDelegate += fireProjectile;
fireDelegate += () =>
{
windSource.Play();
};
fireDelegate += () =>
{
if (!GM.gameOver)
{
GM.numberTimesFired++;
}
};
}
//create 3 tweens destination while rotating and start climb until
TweenData[] InteractBarrierBaseTweens(Barrier barrier, int memberPositionInPass, out Vector3 endPosition, float goStartTime, float goEndTime, Action reachStart = null)
{
endPosition = barrier.passStartPosition;
switch (barrier)
{
case LadderWall wall:
endPosition.y = _mem.transform.localScale.y + barrier.steps[memberPositionInPass].y;
Debug.Log($"barrier step position y { barrier.steps[memberPositionInPass]} end target is {endPosition.y} and memberPositionInPass {memberPositionInPass}");
break;
default:
break;
}
TweenData goToPassStart = MemberSequenceUtils.GoToDestination(_mem.transform, barrier.passStartPosition, goStartTime);
if (reachStart != null)
{
goToPassStart.SetOnComplete(() => reachStart()); //when member reached to climb point sent another one
}
goToPassStart.join = true;
// Vector3 target = MathfUtils.Clerp( transform.rotation.eulerAngles, barrier.transform.rotation.eulerAngles * -1,1);
Quaternion targetRotation = Quaternion.LookRotation(-barrier.transform.forward, Vector3.up);
TweenData rotateToPassStart = MemberSequenceUtils.RotateTowardsDestination(_mem.transform, targetRotation.eulerAngles,
goStartTime / 2f);
rotateToPassStart.join = true;
TweenData goToPassEnd = MemberSequenceUtils.GoToDestination(_mem.transform, endPosition, goEndTime);
return(new[] { goToPassStart, rotateToPassStart, goToPassEnd });
}
protected virtual void HideTweenData(bool immediately, float delay)
{
for (int i = 0, n = tweensData.Count; i < n; i++)
{
TweenData t = tweensData[i];
if (t != null)
{
if (t.tween == null)
{
CustomDebug.LogError(gameObject.name + ": Tween on GUIControl component not set!", this);
}
else
{
if (immediately)
{
t.tween.SetBeginStateImmediately();
t.tween.enabled = false;
}
else
{
t.tween.scaleDuration = t.hideDurationScale;
t.tween.SetBeginState(t.hideDelay + Random.Range(-t.showDelayVariance * 0.5f, t.showDelayVariance * 0.5f) + delay);
}
}
}
}
}
IEnumerator <float> RunTween(TweenData data)
{
if (data.Delay > 0)
{
yield return(Timing.WaitForSeconds(data.Delay));
}
switch (data.TweenType)
{
case TweenType.Scale:
DoScaleTween(data);
break;
case TweenType.Position:
DoPositionTween(data);
break;
case TweenType.AnchoredPosition:
DoAnchoredPositionTween(data);
break;
case TweenType.Alpha:
DoAlpha(data);
break;
default:
Debug.Log("no tween type found.");
break;
}
}
public static TweenData GoToDestination(Transform sequenced, Vector3 destination, float time)
{
//destination.y = _member.transform.position.y;
TweenData goToDestination = new TweenData(TweenType.Move, sequenced, destination, time);
return(goToDestination);
}
public float PlayGroup(string group)
{
if (string.IsNullOrEmpty(group))
{
return(-1f);
}
float ret = 0f;
for (int i = 0, imax = m_Tweens.Length; i < imax; i++)
{
TweenData tween = m_Tweens[i];
if (string.IsNullOrEmpty(tween.group))
{
continue;
}
if (group != tween.group)
{
continue;
}
PlayTween(i, null);
float dur = float.MaxValue;
if (tween.loop == eLoopType.Once || tween.loop == eLoopType.Back)
{
dur = tween.duration < 0f && tween.curve != null ? tween.curve[tween.curve.length - 1].time : tween.duration;
}
if (dur > ret)
{
ret = dur;
}
}
return(ret);
}
public void PassBarrier(Barrier barrier, Action reachEnd)
{
float goStartTime = Mathf.Clamp(Vector3.Distance(_mem.transform.position, barrier.passStartPosition), 0.5f, 1f);
float goEndTime = (barrier.neededManCount + 1) / 5f;
Vector3 endPosition;
TweenData[] passTweens =
InteractBarrierBaseTweens(barrier, barrier.neededManCount - 1, out endPosition, goStartTime, goEndTime, (() => barrier.UnlockBarrier()));
//add an extra tween when passing barrier
//Debug.Log($"current end position {endPosition} ");
endPosition += -barrier.transform.forward * 2f;// * Mathf.Abs(_myGang.Head.position.z - endPosition.z) / 2f;
endPosition.y = barrier.passEndPosition.y;
TweenData goTowardGangHead = MemberSequenceUtils.GoToDestination(_mem.transform, endPosition, 0.1f);
//Debug.Log($"after end position {endPosition} ");
passTweens = passTweens.Append(goTowardGangHead).ToArray();
AnimData walkAnim = new AnimData(MemberAnimType.Locomotion, goStartTime);
AnimData passAnim = new AnimData(MemberAnimType.Climb, goEndTime);
MemberSequenceUtils.BuildTweenSequence(passTweens, (() => reachEnd()));
_mem.StartCoroutine(DoAnimSequence(walkAnim, passAnim));
}
private void init()
{
tween_data = new TweenData[transitions.Count];
for (int i = 0, n = transitions.Count; i < n; i++)
{
tween_data[i] = new TweenData(animated_object, transitions[i].Key, transitions[i].Value);
}
}
internal static TweenData Setup(double targetValue, double speed, TweenTypes type)
{
var t = new TweenData();
t.EndAmount = targetValue;
t.Speed = speed;
t.Type = type;
return(t);
}
public override void SetTweenData(TweenData tweenData)
{
base.SetTweenData(tweenData);
if (_isThisTweenDataUsage)
{
_fullRectAnimation.SetData(_tweenData);
}
}
internal static TweenData Setup(double targetValue, long time, TweenTypes type)
{
var t = new TweenData();
t.EndAmount = targetValue;
t.Duration = time;
t.Type = type;
return(t);
}
void DoPositionTween(TweenData data)
{
RectTransform rectTrans = transform.GetComponent <RectTransform>();
if (rectTrans != null)
{
Debug.LogWarning("Doing a position tween on UI...", gameObject);
}
//todo
}
public static TweenData RotateTowardsDestination(Transform sequenced, Vector3 rotation, float time)
{
/*//destination.y = _member.transform.position.y;
* Vector3 direction = destination - sequenced.position;
* direction.y = 0f;
* Quaternion toRotation = Quaternion.LookRotation(direction);*/
TweenData rotateTowardStartTween = new TweenData(TweenType.Rotate, sequenced,
rotation, time);
return(rotateTowardStartTween);
}
void DoAnchoredPositionTween(TweenData data)
{
RectTransform rectTrans = transform.GetComponent <RectTransform>();
if (rectTrans == null)
{
Debug.LogWarning("no rect transform on " + transform.name, gameObject);
return;
}
Tween.AnchoredPosition(rectTrans, data.StartPos, data.EndPos, data.Duration, 0f, data.Curve, Tween.LoopType.None, null, OnTweenFinish);
}
void DoAlpha(TweenData data)
{
CanvasGroup cg = transform.GetComponent <CanvasGroup>();
if (cg == null)
{
Debug.LogWarning("Trying to do alpha change without a canvas group", gameObject);
return;
}
Tween.CanvasGroupAlpha(cg, data.StartAlpha, data.EndAlpha, data.Duration, data.Delay, data.Curve, Tween.LoopType.None, null, OnTweenFinish);
}
protected override void Reset()
{
base.Reset();
TweenData pTweenData = new TweenData();
pTweenData.vecPosition_Start = transform.position;
pTweenData.vecPosition_Dest = transform.position;
p_listTweenData.Add(pTweenData);
}
/// <summary>
/// Tweens to the specified value.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="time">The time.</param>
/// <param name="type">The type.</param>
/// <param name="replace">if set to <c>true</c> [replace].</param>
internal void TweenTo(double target, long time, TweenTypes type, bool replace)
{
target = Math.Max(this.MinAmount, Math.Min(this.MaxAmount, target));
var t = TweenData.Setup(target, time, type);
if (replace)
{
this.Tween.Clear();
}
this.Tween.Add(t);
}
/// <summary>
/// Tweens to the specified value.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="speed">The speed.</param>
/// <param name="type">The type.</param>
/// <param name="replace">if set to <c>true</c> [replace].</param>
internal void TweenTo(double target, double speed, TweenTypes type, bool replace)
{
target = Math.Max(MinAmount, Math.Min(MaxAmount, target));
var t = TweenData.Setup(target, speed, type);
if (replace)
{
Tween.Clear();
}
Tween.Add(t);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
void RemoveExisitingData(TweenData data)
{
for (int t = 0; t < taskPool.Count; t++)
{
TweenTask task = taskPool[t];
if (data.actor == task.tweenData.actor)
{
taskPool.Remove(task);
}
}
}
private static TweenData GetTweenData(int id)
{
if (_tweenDict.TryGetValue(id, out var tweenData))
{
return(tweenData);
}
tweenData = new TweenData();
tweenData.tokenSource = new CancellationTokenSource();
tweenData.count = 0;
_tweenDict.Add(id, tweenData);
return(tweenData);
}
void Start()
{
TweenData tweenData = new TweenData()
{
autoPlay = false,
autoKill = true,
Duration = 1f,
Delay = 0f,
id = 0 + "",
endValueVector3 = new Vector3(0f, -5f, 0f)
};
Tween tweenMove = GameTools.SetAnimMoveByCurve(gameObject, easeCurve, tweenData, ActionMoveCompelete);
tweenMove.PlayForward();
}
protected override void OnTween(float fProgress_0_1)
{
float fProgress_Calculated;
TweenData sTweenData = Calculate_CurrentTweenData(fProgress_0_1, out fProgress_Calculated);
Vector3 vecPosition = _vecTweenStartPos * (1f - fProgress_Calculated) + sTweenData.vecPosition_Dest * fProgress_Calculated;
if (p_bIsLocal)
{
_pTransformTarget.localPosition = vecPosition;
}
else
{
_pTransformTarget.position = vecPosition;
}
}
public void DoAddTweenData()
{
TweenData pTweenData = new TweenData();
if (p_bIsLocal)
{
pTweenData.vecPosition_Dest = transform.localPosition;
}
else
{
pTweenData.vecPosition_Dest = transform.position;
}
pTweenData.fDurationSec = 1f;
p_listTweenData.Add(pTweenData);
}
/************************************************************************/
/* Task Builder */
/************************************************************************/
/// <summary>
/// Tweens actor position from one position to another.
/// </summary>
/// <param name="actor"></param>
/// <param name="newPos"></param>
/// <param name="easeFunc"></param>
/// <param name="duration"></param>
/// <param name="notOverrideExistingTask"></param>
public void TweenPosition(Transform newActor, Vector3 newPos, EasingFunction.Ease easeFunc, float newDuration, bool notOverrideExistingTask = default(bool))
{
// Merging parameters into TweenData set
TweenData newTweenData = new TweenData
{
actor = newActor,
modifyPosition = true,
func = easeFunc,
duration = newDuration
};
newTweenData.startPosition = newActor.position;
newTweenData.endPosition = newPos;
// Passing TweenData into main AddTask function
AddTask(newTweenData, notOverrideExistingTask);
}
public static Tween SetAnimMoveByCurve(GameObject go, AnimationCurve easeCurve, TweenData tweendata, TweenCallback OnShowFinish = null)
{
//1.删除老的所有的动画
var anims = go.GetComponents <DOTweenAnimation>();
for (int i = 0; i < anims.Length; i++)
{
GameObject.Destroy(anims[i]);
}
//2.设置不同类型动画的初始值
var anim = go.AddComponent <DOTweenAnimation>();
//3.设置类型
anim.animationType = DOTweenAnimationType.Move;
//4.设置目标
anim.target = go.transform;
//5.设置参数
anim.autoPlay = tweendata.autoPlay;
anim.autoKill = tweendata.autoKill;
anim.duration = tweendata.Duration;
anim.delay = tweendata.Delay;
anim.id = tweendata.id;
anim.endValueV3 = tweendata.endValueVector3;
//6.设置动画曲线
if (easeCurve != null)
{
anim.easeType = Ease.INTERNAL_Custom;
anim.easeCurve = easeCurve;//CreateTween里边已经设置了if (easeType == Ease.INTERNAL_Custom) tween.SetEase(easeCurve);
}
else
{
anim.easeType = Ease.Linear;
}
//7.创建动画
anim.CreateTween();
//8.设置回调
if (OnShowFinish != null)
{
anim.tween.OnComplete(OnShowFinish);
}
return(anim.tween);
}
public TweenData CollectCurrentData(int _index)
{
CollectComponents();
TweenData _tweenData = new TweenData();
if (data != null && data.Count != 0)
{
_tweenData = data[_index];
}
if (rectTransform)
{
_tweenData.position = rectTransform.anchoredPosition;
}
else
{
_tweenData.position = cTransform.localPosition;
}
_tweenData.rotation = cTransform.localEulerAngles;
_tweenData.scale = cTransform.localScale;
if (spriteRenderer)
{
_tweenData.color = spriteRenderer.color;
}
if (image)
{
_tweenData.alpha = image.color.a;
}
if (canvasGroup)
{
_tweenData.alpha = canvasGroup.alpha;
}
return(_tweenData);
}
/// <summary>
/// Tweens actor scale from one size to another.
/// </summary>
/// <param name="actor"></param>
/// <param name="newScale"></param>
/// <param name="easeFunc"></param>
/// <param name="duration"></param>
/// <param name="notOverrideExistingTask"></param>
public void TweenScale(Transform newActor, Vector3 newScale, EasingFunction.Ease easeFunc, float newDuration, bool notOverrideExistingTask = default(bool))
{
// Merging parameters into TweenData set
TweenData newTweenData = new TweenData
{
actor = newActor,
modifyScale = true,
func = easeFunc,
duration = newDuration
};
Transform startT = newActor;
Transform endT = startT;
endT.localScale = newScale;
newTweenData.startScale = newActor.localScale;
newTweenData.endScale = newScale;
// Passing TweenData into main AddTask function
AddTask(newTweenData, notOverrideExistingTask);
}
