public void RemovedFromScheduler()
{
groupTag = null;
job = null;
jobRepeat = null;
noMoreTasks = false;
iterativeMode = false;
node = null;
for (LinkedListNode <SingleTask> task = tasks.First;
task != null;
task = task.Next)
{
task.Value.RemovedFromScheduler();
}
for (LinkedListNode <SingleTask> taskNode = tasks.First; taskNode != null; taskNode = taskNode.Next)
{
ReturnNode(taskNode);
}
tasks.Clear();
SuperInvokePoolHolder.PoolManager.ReturnInstance <Sequence>(this);
}
/// <summary>
/// Resumes every job tagged with 'tag(s)'.
/// </summary>
/// <param name="tag">The tag(s) of the jobs to be resumed.</param>
public static void Resume(params string[] tags)
{
for (int i = 0; i < tags.Length; i++)
{
ScheduleBridge.Resume(SuperInvokeTag.GetInstance(tags[i]));
}
}
private static IJobRepeat ActualRunRepeat(Action method, string tag, RepeatSettings repeatSettings)
{
CheckMethod(method);
CheckDelay(repeatSettings.delay);
JobRepeat jobRepeat = null;
if (repeatSettings.repeats == INFINITY || repeatSettings.repeats > 0) //if repeats == 0 it does nothing
{
jobRepeat = new JobRepeat()
{
TotalRepeatsNumber = repeatSettings.repeats
};
Sequence sequence = Sequence.MakeInstance();
sequence.SetGroupTag(SuperInvokeTag.GetInstance(tag));
sequence.AddSingleTask(SingleTask.MakeInstance(method, 0, tag));
sequence.SetIterativeMode(repeatSettings);
sequence.SetJob(jobRepeat);
ScheduleBridge.Schedule(sequence);
}
return(jobRepeat);
}
internal static void Kill(SuperInvokeTag tag)
{
if (!managerWasDestroyed && tag != null)
{
GrabManager();
superInvokeManager.Kill(tag);
}
}
/// <summary>
/// Kills every job except those tagged with 'tag(s)'.
/// </summary>
/// <param name="tags">The tag(s) of the jobs that must remain alive.</param>
public static void KillAllExcept(params string[] tags)
{
List <SuperInvokeTag> tagList = new List <SuperInvokeTag>();
foreach (var tag in tags)
{
tagList.Add(SuperInvokeTag.GetInstance(tag));
}
ScheduleBridge.KillAllExcept(tagList.ToArray());
}
public void RemovedFromScheduler()
{
groupTag = null;
job = null;
noMoreTasks = false;
method = null;
SuperInvokePoolSettings.PoolManager.ReturnInstance <SingleTask>(this);
}
public static SingleTask MakeInstance(Action method, float delayTime, string groupTag)
{
SingleTask singleTask = SuperInvokePoolSettings.PoolManager.GetInstance <SingleTask>();
singleTask.SetTask(method, delayTime);
if (groupTag != null)
{
singleTask.groupTag = SuperInvokeTag.GetInstance(groupTag);
}
return(singleTask);
}
/// <summary>
/// reset
/// </summary>
public void Reset()
{
delayTime = 0;
startEvent = null;
intervalEvent = null;
endEvent = null;
userData = null;
tag = null;
intervalTime = 0;
repeatCount = 1;
currentIndex = 0;
loopingDuration = 0;
loopTimerHandler = null;
frameDelayTimerHandler = null;
delayFrame = 0;
}
internal void Resume(SuperInvokeTag superInvokeTag)
{
//resume paused nodes
LinkedListNode <ISuperInvokeRunnable> pausedNode = pauseQueue.First;
while (pausedNode != null)
{
if (pausedNode.Value.HasThisTag(superInvokeTag))
{
LinkedListNode <ISuperInvokeRunnable> nodeToResume = pausedNode;
pausedNode = pausedNode.Next;
pauseQueue.Remove(nodeToResume);
scheduleQueue.AddLast(nodeToResume);
nodeToResume.Value.Resume(SystemTime.Current);
}
else
{
pausedNode = pausedNode.Next;
}
}
//resume node in execution
if (inExecution)
{
for (LinkedListNode <ISuperInvokeRunnable> executionNode = executionQueue.First;
executionNode != null;
executionNode = executionNode.Next)
{
if (executionNode.Value.HasThisTag(superInvokeTag) && executionNode.Value.GetJobState() == JobState.Paused)
{
pauseAfterExecutionBag.Remove(executionNode.Value);
executionNode.Value.Resume(SystemTime.Current);
}
}
}
}
internal void Pause(SuperInvokeTag superInvokeTag)
{
//pause scheduled node
LinkedListNode <ISuperInvokeRunnable> scheduleNode = scheduleQueue.First;
while (scheduleNode != null)
{
if (scheduleNode.Value.HasThisTag(superInvokeTag))
{
LinkedListNode <ISuperInvokeRunnable> nodeToPause = scheduleNode;
scheduleNode = scheduleNode.Next;
scheduleQueue.Remove(nodeToPause);
pauseQueue.AddLast(nodeToPause);
nodeToPause.Value.Pause(SystemTime.Current);
}
else
{
scheduleNode = scheduleNode.Next;
}
}
//pause node in execution
if (inExecution)
{
for (LinkedListNode <ISuperInvokeRunnable> executionNode = executionQueue.First;
executionNode != null;
executionNode = executionNode.Next)
{
if (executionNode.Value.HasThisTag(superInvokeTag) && executionNode.Value.GetJobState() == JobState.Scheduled)
{
pauseAfterExecutionBag.Add(executionNode.Value);
executionNode.Value.Pause(SystemTime.Current);
}
}
}
}
public bool HasThisTag(SuperInvokeTag tag)
{
return(tag.Equals(groupTag) || tag.Equals(job.Tag));
}
public void SetGroupTag(SuperInvokeTag tag)
{
groupTag = tag;
}
internal static void Pause(SuperInvokeTag tag)
{
GrabManager();
superInvokeManager.Pause(tag);
}
internal static void Resume(SuperInvokeTag tag)
{
GrabManager();
superInvokeManager.Resume(tag);
}
/// <summary>
/// Returns a unique string tag any time it is called.
/// Every string tag returned starts with the upper-case sigma symbol 'Σ'.
/// </summary>
public static string CreateTag()
{
return(SuperInvokeTag.CreateStringTag());
}
internal void Kill(SuperInvokeTag superInvokeTag)
{
ActualKillTasks(runnable => runnable.HasThisTag(superInvokeTag));
}
/// <summary>
/// 启动定时器
/// </summary>
/// <returns></returns>
public IGameTimer Send()
{
if (null == tag)
{
tag = SuperInvoke.CreateTag();
}
if (null != startEvent)
{
startEvent(userData);
}
if (loopingDuration > 0)
{
var timerManager = App.Make <ITimerManager>();
if (null != timerManager)
{
loopTimerHandler = timerManager.Make(() =>
{
if (null != loopEvent)
{
loopEvent(userData);
}
}).Loop(loopingDuration);
// 执行延迟结束事件
SuperInvoke.Run(loopingDuration, tag, internalEndEvent);
}
return(this);
}
if (repeatCount == 1) // 单次事件
{
if (delayFrame == 0) // 时间延迟
{
SuperInvoke.Run(delayTime, tag, internalEndEvent);
}
else
{
// 帧数延迟
frameDelayTimerHandler = App.Make <ITimerManager>().Make(() =>
{
if (null != endEvent)
{
endEvent(userData);
}
}).DelayFrame(delayFrame);
}
}
else
{
// 多次事件
SuperInvoke.RunRepeat(delayTime, intervalTime, repeatCount, tag, () =>
{
intervalEvent(currentIndex, userData);
currentIndex++;
});
if (null != endEvent)
{
SuperInvoke.Run(delayTime + repeatCount * intervalTime, tag, internalEndEvent);
}
}
return(this);
}
