// ===================================================================================
// INTERNAL METHODS ------------------------------------------------------------------
/// <summary>
/// Removes the given tween from this Sequence,
/// and eventually kills the Sequence if all items have been removed.
/// Used by <see cref="OverwriteManager"/> to remove overwritten tweens.
/// </summary>
internal void Remove(ABSTweenComponent p_tween)
{
if (items == null)
{
return;
}
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween && item.twMember == p_tween)
{
items.RemoveAt(i);
break;
}
}
if (items.Count == 0)
{
if (isSequenced)
{
contSequence.Remove(this);
}
Kill(!isSequenced);
}
}
void InsertCallback(float p_time, TweenDelegate.TweenCallback p_callback, TweenDelegate.TweenCallbackWParms p_callbackWParms, params object[] p_callbackParms)
{
hasCallbacks = true;
HOTSeqItem newItem = new HOTSeqItem(p_time, p_callback, p_callbackWParms, p_callbackParms);
if (items == null)
{
items = new List <HOTSeqItem> {
newItem
};
}
else
{
bool placed = false;
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
if (items[i].startTime >= p_time)
{
items.Insert(i, newItem);
placed = true;
break;
}
}
if (!placed)
{
items.Add(newItem);
}
}
_isEmpty = false;
}
/// <summary>
/// Returns a list of the eventual nested <see cref="Tweener"/> objects whose target is the given one,
/// or an empty list if none was found.
/// </summary>
public List <Tweener> GetTweenersByTarget(object p_target)
{
List <Tweener> res = new List <Tweener>();
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType != SeqItemType.Tween)
{
continue;
}
Tweener tweener = item.twMember as Tweener;
if (tweener != null)
{
// Tweener
if (tweener.target == p_target)
{
res.Add(tweener);
}
}
else
{
// Sequence
res.AddRange(((Sequence)item.twMember).GetTweenersByTarget(p_target));
}
}
return(res);
}
float Prepend(IHOTweenComponent p_twMember, float p_duration)
{
if (items == null)
{
return(Insert(0, p_twMember));
}
if (p_twMember != null)
{
HOTween.RemoveFromTweens(p_twMember);
((ABSTweenComponent)p_twMember).contSequence = this;
CheckSpeedBasedTween(p_twMember);
}
HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(0, p_twMember as ABSTweenComponent) : new HOTSeqItem(0, p_duration));
float itemDur = newItem.duration;
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
items[i].startTime += itemDur;
}
items.Insert(0, newItem);
_duration += itemDur;
SetFullDuration();
_isEmpty = false;
return(_duration);
}
// ===================================================================================
// HELPERS ---------------------------------------------------------------------------
/// <summary>
/// Fills the given list with all the plugins inside this sequence tween,
/// while also looking for them recursively through inner sequences.
/// Used by <c>HOTween.GetPlugins</c>.
/// </summary>
internal override void FillPluginsList(List <ABSTweenPlugin> p_plugs)
{
if (items == null)
{
return;
}
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem itm = items[i];
if (itm.twMember == null)
{
continue;
}
Sequence sequence = itm.twMember as Sequence;
if (sequence != null)
{
sequence.FillPluginsList(p_plugs);
}
else
{
itm.twMember.FillPluginsList(p_plugs);
}
}
}
/// <summary>
/// Returns a list of the eventual existing tweens with the given Id within this Sequence,
/// nested tweens included (or an empty list if no tweens were found).
/// </summary>
internal override List <IHOTweenComponent> GetTweensByIntId(int p_intId)
{
List <IHOTweenComponent> res = new List <IHOTweenComponent>();
if (destroyed)
{
return(res);
}
if (intId == p_intId)
{
res.Add(this);
}
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween)
{
res.AddRange(item.twMember.GetTweensByIntId(p_intId));
}
}
return(res);
}
void Rewind(bool p_play)
{
if (!_enabled)
{
return;
}
if (items == null)
{
return;
}
Startup();
if (!_hasStarted)
{
OnStart();
}
_isComplete = false;
_isLoopingBack = false;
_completedLoops = 0;
_fullElapsed = _elapsed = 0;
int itemsCount = items.Count - 1;
for (int i = itemsCount; i > -1; --i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween)
{
item.twMember.Rewind();
}
}
// Manage OnUpdate and OnRewinded.
if (_fullElapsed != prevFullElapsed)
{
OnUpdate();
if (_fullElapsed == 0)
{
OnRewinded();
}
}
prevFullElapsed = _fullElapsed;
if (p_play)
{
Play();
}
else
{
Pause();
}
}
/// <summary>
/// Sets the correct values in case of Incremental loop type.
/// Also called by Tweener.ApplySequenceIncrement (used by Sequences during Incremental loops).
/// </summary>
/// <param name="p_diffIncr">
/// The difference from the previous loop increment.
/// </param>
internal override void SetIncremental(int p_diffIncr)
{
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType != SeqItemType.Tween)
{
continue;
}
item.twMember.SetIncremental(p_diffIncr);
}
}
float Insert(float p_time, IHOTweenComponent p_twMember, float p_duration)
{
if (p_twMember != null)
{
HOTween.RemoveFromTweens(p_twMember);
((ABSTweenComponent)p_twMember).contSequence = this;
CheckSpeedBasedTween(p_twMember);
}
HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(p_time, p_twMember as ABSTweenComponent) : new HOTSeqItem(p_time, p_duration));
if (items == null)
{
items = new List <HOTSeqItem>
{
newItem
};
_duration = newItem.startTime + newItem.duration;
SetFullDuration();
_isEmpty = false;
return(_duration);
}
bool placed = false;
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
if (items[i].startTime >= p_time)
{
items.Insert(i, newItem);
placed = true;
break;
}
}
if (!placed)
{
items.Add(newItem);
}
_duration = Mathf.Max(newItem.startTime + newItem.duration, _duration);
SetFullDuration();
_isEmpty = false;
return(_duration);
}
/// <summary>
/// Returns <c>true</c> if the tween with the given int id is currently involved in a running tween or sequence.
/// </summary>
/// <param name="p_id">
/// The id to check for.
/// </param>
public override bool IsTweening(int p_id)
{
if (!_enabled || items == null)
{
return(false);
}
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween && item.twMember.IsTweening(p_id))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns a list of all the targets of this Sequence, or NULL if there are none.
/// </summary>
/// <returns>A list of all the targets of this Sequence, or NULL if there are none.</returns>
public override List <object> GetTweenTargets()
{
if (items == null)
{
return(null);
}
List <object> targets = new List <object>();
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween)
{
targets.AddRange(item.twMember.GetTweenTargets());
}
}
return(targets);
}
/// <summary>
/// Returns <c>true</c> if the given target is linked to a tween of this Sequence (running or not, taking into account also nested tweens).
/// </summary>
/// <param name="p_target">
/// The target to check.
/// </param>
/// <returns>
/// A value of <c>true</c> if the given target is linked to a tween of this Sequence (running or not, taking into account also nested tweens).
/// </returns>
public override bool IsLinkedTo(object p_target)
{
if (items == null)
{
return(false);
}
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween && item.twMember.IsLinkedTo(p_target))
{
return(true);
}
}
return(false);
}
// ===================================================================================
// METHODS ---------------------------------------------------------------------------
/// <summary>
/// Kills this Sequence and cleans it.
/// </summary>
/// <param name="p_autoRemoveFromHOTween">
/// If <c>true</c> also calls <c>HOTween.Kill(this)</c> to remove it from HOTween.
/// Set internally to <c>false</c> when I already know that HOTween is going to remove it.
/// </param>
internal override void Kill(bool p_autoRemoveFromHOTween)
{
if (_destroyed)
{
return;
}
if (items != null)
{
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i)
{
HOTSeqItem item = items[i];
if (item.seqItemType == SeqItemType.Tween)
{
item.twMember.Kill(false);
}
}
items = null;
}
base.Kill(p_autoRemoveFromHOTween);
}
float Append(IHOTweenComponent p_twMember, float p_duration)
{
if (items == null)
{
return(p_twMember != null ? Insert(0, p_twMember) : Insert(0, null, p_duration));
}
if (p_twMember != null)
{
HOTween.RemoveFromTweens(p_twMember);
((ABSTweenComponent)p_twMember).contSequence = this;
CheckSpeedBasedTween(p_twMember);
}
HOTSeqItem newItem = (p_twMember != null ? new HOTSeqItem(_duration, p_twMember as ABSTweenComponent) : new HOTSeqItem(_duration, p_duration));
items.Add(newItem);
_duration += newItem.duration;
SetFullDuration();
_isEmpty = false;
return(_duration);
}
void InsertCallback(float p_time, TweenDelegate.TweenCallback p_callback, TweenDelegate.TweenCallbackWParms p_callbackWParms, params object[] p_callbackParms)
{
hasCallbacks = true;
HOTSeqItem newItem = new HOTSeqItem(p_time, p_callback, p_callbackWParms, p_callbackParms);
if (items == null) {
items = new List<HOTSeqItem> { newItem };
} else {
bool placed = false;
int itemsCount = items.Count;
for (int i = 0; i < itemsCount; ++i) {
if (items[i].startTime >= p_time) {
items.Insert(i, newItem);
placed = true;
break;
}
}
if (!placed) items.Add(newItem);
}
_isEmpty = false;
}
