/// <summary>
/// 添加一个新任务并传递一个ID,替代该ID任务
/// </summary>
/// <param name="id"></param>
/// <param name="callback"></param>
/// <param name="delayFrame"></param>
/// <param name="count"></param>
/// <returns></returns>
public bool ReplaceFrameTask(int id, Action callback, int delayFrame, int count = 1)
{
PEFrameTask newFrameTask = CreatePEFrameTask(id, callback, delayFrame, count);
return(SearchIdExistAndReplace(id, taskFrameList, newFrameTask) ||
SearchIdExistAndReplace(id, tempFrameList, newFrameTask));
}
/// <summary>
/// 更换定时任务
/// </summary>
public bool ReplaceFrameTask(int tid, Action callback, int destTime, int delay, int count = 1)
{
destTime = frameCounter + destTime;
PEFrameTask newTask = new PEFrameTask(callback, destTime, delay, count, tid);
bool isRep = false;
for (int i = 0; i < frameTasks.Count; i++)
{
if (tid == frameTasks[i].tid)
{
frameTasks[i] = newTask;
isRep = true;
break;
}
}
if (!isRep)
{
for (int i = 0; i < tempFrameTasks.Count; i++)
{
if (tid == tempFrameTasks[i].tid)
{
tempFrameTasks[i] = newTask;
isRep = true;
break;
}
}
}
return(isRep);
}
public bool ReplaceFrameTask(int tid, Action <int> callback, int delay, int count = 1)
{
PEFrameTask newTask = new PEFrameTask(tid, callback, frameCounter + delay, delay, count);
bool isRep = false;
for (int i = 0; i < taskFrameLst.Count; i++)
{
if (taskFrameLst[i].tid == tid)
{
taskFrameLst[i] = newTask;
isRep = true;
break;
}
}
if (!isRep)
{
for (int i = 0; i < tmpFrameLst.Count; i++)
{
if (tmpFrameLst[i].tid == tid)
{
tmpFrameLst[i] = newTask;
isRep = true;
break;
}
}
}
return(isRep);
}
/// <summary>
/// 替换一个已经存在的帧定时任务
/// </summary>
/// <param name="tid">任务ID</param>
/// <param name="callback">回调</param>
/// <param name="delayTime">定时间隔</param>
/// <param name="count">循环次数(0循环)</param>
/// <returns>替换结果</returns>
public bool ReplaceFrameTask(int tid, Action callback, int delayTime, int count = 1)
{
bool result = false;
PEFrameTask newTask = new PEFrameTask(tid, frameCounter + delayTime, delayTime, count, callback);
for (int i = 0; i < taskFrameList.Count; i++)
{
if (newTask.tid == taskFrameList[i].tid)
{
result = true;
taskFrameList[i] = newTask;
break;
}
}
if (!result)
{
for (int i = 0; i < tmpFrameList.Count; i++)
{
if (newTask.tid == tmpFrameList[i].tid)
{
result = true;
tmpFrameList[i] = newTask;
break;
}
}
}
return(result);
}
private void CheckFrameTask()
{
if (tmpFrameLst.Count > 0)
{
lock (lockFrame) {
//加入缓存区中的定时任务
for (int tmpIndex = 0; tmpIndex < tmpFrameLst.Count; tmpIndex++)
{
taskFrameLst.Add(tmpFrameLst[tmpIndex]);
}
tmpFrameLst.Clear();
}
}
frameCounter += 1;
//遍历检测任务是否达到条件
for (int index = 0; index < taskFrameLst.Count; index++)
{
PEFrameTask task = taskFrameLst[index];
if (frameCounter < task.destFrame)
{
continue;
}
else
{
Action <int> cb = task.callback;
try {
if (taskHandle != null)
{
taskHandle(cb, task.tid);
}
else
{
if (cb != null)
{
cb(task.tid);
}
}
} catch (Exception e) {
LogInfo(e.ToString());
}
//移除已经完成的任务
if (task.count == 1)
{
taskFrameLst.RemoveAt(index);
index--;
recTidLst.Add(task.tid);
}
else
{
if (task.count != 0)
{
task.count -= 1;
}
task.destFrame += task.delay;
}
}
}
}
private void CheckFrameTask()
{
for (int tmpIndex = 0; tmpIndex < tmpFramerLst.Count; tmpIndex++)
{
taskFramerLst.Add(tmpFramerLst[tmpIndex]);
}
tmpFramerLst.Clear();
frameCounter += 1;
for (int index = 0; index < taskFramerLst.Count; index++)
{
PEFrameTask task = taskFramerLst[index];
if (frameCounter.CompareTo(task.destFrame) < 0)
{
continue;
}
else
{
Action <int> cb = task.callback;
try {
if (taskHandle != null)
{
taskHandle(cb, task.tid);
}
else
{
if (cb != null)
{
cb(task.tid);
}
}
}
catch (Exception e) {
LogInfo(e.ToString());
}
if (task.count == 1)
{
try {
taskFramerLst.RemoveAt(index);
index--;
recTidLst.Add(task.tid);
}
catch (Exception e) {
LogInfo(e.ToString());
}
}
else
{
if (task.count != 0)
{
task.count -= 1;
}
task.destFrame = task.destFrame + task.delay;
}
}
}
}
/// <summary>
/// 添加时间任务
/// </summary>
/// <param name="callback">回调方法</param>
/// <param name="destTime">等待的时间</param>
/// <param name="delay">延迟的时间</param>
/// <param name="count"></param>
/// <param name="timeType">添加的时间类型</param>
/// <returns></returns>
public int AddFrameTask(Action callback, int destTime, int delay, int count = 1)
{
int tid = GetID();
destTime = frameCounter + destTime;
PEFrameTask frameTask = new PEFrameTask(callback, destTime, delay, count, tid);
tempFrameTasks.Add(frameTask);
idList.Add(tid);
return(tid);
}
/// <summary>
/// 添加一个帧定时任务
/// </summary>
/// <param name="callback">回调</param>
/// <param name="delayTime">定时间隔</param>
/// <param name="count">循环次数(0循环)</param>
/// <returns></returns>
public int AddFrameTask(Action callback, int delayTime, int count = 1)
{
int tid = GetTid();
tidList.Add(tid);
PEFrameTask tmpTask = new PEFrameTask(tid, frameCounter + delayTime, delayTime, count, callback);
tmpFrameList.Add(tmpTask);
return(tid);
}
private void CheckFrameTask()
{
//加入上一帧的缓存区的定时任务
for (int tmpIndex = 0; tmpIndex < tmpFrameList.Count; tmpIndex++)
{
taskFrameList.Add(tmpFrameList[tmpIndex]);
}
tmpFrameList.Clear();
frameCounter += 1;
//遍历检测定时任务是否达到条件
for (int i = 0; i < taskFrameList.Count; i++)
{
PEFrameTask task = taskFrameList[i];
if (frameCounter < task.destFrame)
{
continue;
}
else
{
Action cb = task.callback;
try
{
if (cb != null)
{
cb();
}
}
catch (Exception e)
{
Log(e.ToString());
}
//移除已经完成的定时任务
if (task.count == 1)
{
recTidList.Add(taskFrameList[i].tid);
taskFrameList.RemoveAt(i);
i--;
}
else
{
if (task.count != 0)
{
task.count--;
}
task.destFrame += task.delay;
}
}
}
}
/// <summary>
/// 给定id、PEFrameTask列表和新PEFrameTask,查询该PEFrameTask列表中PEFrameTask是否有该id,并替代
/// </summary>
/// <param name="id"></param>
/// <param name="FrameList"></param>
/// <param name="frameTask"></param>
/// <returns></returns>
private bool SearchIdExistAndReplace(int id, List <PEFrameTask> FrameList, PEFrameTask frameTask)
{
for (int i = 0; i < FrameList.Count; i++)
{
if (FrameList[i].id == id)
{
FrameList[i] = frameTask;
return(true);
}
}
return(false);
}
/// <summary>
/// 时间计时器主运行方法
/// </summary>
private void BeginFraming()
{
for (int tempIndex = 0; tempIndex < tempFrameList.Count; tempIndex++)//遍历缓存列表,并加入至操作列表
{
taskFrameList.Add(tempFrameList[tempIndex]);
}
frameCount++;
tempFrameList.Clear(); //清除缓存列表
for (int i = 0; i < taskFrameList.Count; i++) //遍历操作列表进行操作判定
{
PEFrameTask frameTask = taskFrameList[i]; //临时赋值
if (frameCount < frameTask.destFrame) //没有达到目标时间.进行下一任务判断
{
continue;
}
else//达到当前时间
{
Action callback = frameTask.callback;//方法赋值
try
{
if (callback != null) //安全判断
{
callback(); //执行方法
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
if (frameTask.count == 1)
{
taskFrameList.RemoveAt(i); //移除当前任务
i--; //转为下一任务
recycleList.Add(frameTask.id);
}
else if (frameTask.count != 0)
{
frameTask.count--;
frameTask.destFrame += frameTask.delayFrame;
}
else
{
frameTask.destFrame += frameTask.delayFrame;
}
}
}
RecycleId();
}
/// <summary>
/// 删除定时任务
/// </summary>
public bool DeleteFrameTask(int tid)
{
//是否删除任务成功
bool result = false;
for (int i = 0; i < frameTasks.Count; i++)
{
PEFrameTask frameTask = frameTasks[i];
if (frameTask.tid == tid)
{
frameTasks.RemoveAt(i);
for (int j = 0; j < idList.Count; j++)
{
if (tid == idList[j])
{
idList.RemoveAt(j);
break;
}
}
result = true;
break;
}
}
//从缓存列表里面找
if (!result)
{
for (int i = 0; i < tempFrameTasks.Count; i++)
{
PEFrameTask frameTask = tempFrameTasks[i];
if (frameTask.tid == tid)
{
tempFrameTasks.RemoveAt(i);
for (int j = 0; j < idList.Count; j++)
{
if (tid == idList[j])
{
idList.RemoveAt(j);
break;
}
}
result = true;
break;
}
}
}
return(result);
}
/// <summary>
/// 检测帧任务
/// </summary>
private void CheakFrameTask()
{
//为什么要先加入缓存列表，因为延长时间并不是当前帧执行，需要等待一帧，所以在上一帧加入缓存列表中，在下一帧再取出
for (int tempIndex = 0; tempIndex < tempFrameTasks.Count; tempIndex++)
{
frameTasks.Add(tempFrameTasks[tempIndex]);
}
tempFrameTasks.Clear();
frameCounter += 1;
for (int index = 0; index < frameTasks.Count; index++)
{
PEFrameTask frameTask = frameTasks[index];
if (frameCounter < frameTask.destFrame)
{
continue;
}
else
{
Action action = frameTask.callBack;
try
{
action?.Invoke();
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
if (frameTask.count == 1)
{
frameTasks.RemoveAt(index);
index--;
recTidList.Add(frameTask.tid);
}
else
{
if (frameTask.count != 0)
{
frameTask.count -= 1;
}
frameTask.destFrame += frameTask.delay;
}
}
}
}
public bool DeleteFrameTask(int tid)
{
bool exist = false;
for (int i = 0; i < taskFrameLst.Count; i++)
{
PEFrameTask task = taskFrameLst[i];
if (task.tid == tid)
{
taskFrameLst.RemoveAt(i);
for (int j = 0; j < tidLst.Count; j++)
{
if (tidLst[j] == tid)
{
tidLst.RemoveAt(j);
break;
}
}
exist = true;
break;
}
}
if (!exist)
{
for (int i = 0; i < tmpFrameLst.Count; i++)
{
PEFrameTask task = tmpFrameLst[i];
if (task.tid == tid)
{
tmpFrameLst.RemoveAt(i);
for (int j = 0; j < tidLst.Count; j++)
{
if (tidLst[j] == tid)
{
tidLst.RemoveAt(j);
break;
}
}
exist = true;
break;
}
}
}
return(exist);
}
private void DelFrameTask()
{
if (tmpDelFrameLst.Count > 0)
{
lock (lockFrame) {
for (int i = 0; i < tmpDelFrameLst.Count; i++)
{
bool isDel = false;
int delTid = tmpDelFrameLst[i];
for (int j = 0; j < taskFrameLst.Count; j++)
{
PEFrameTask task = taskFrameLst[j];
if (task.tid == delTid)
{
taskFrameLst.RemoveAt(j);
recTidLst.Add(delTid);
isDel = true;
LogInfo("Del taskFrameLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
break;
}
}
if (isDel)
{
continue;
}
for (int j = 0; j < tmpFrameLst.Count; j++)
{
PEFrameTask task = tmpFrameLst[j];
if (task.tid == delTid)
{
tmpFrameLst.RemoveAt(j);
recTidLst.Add(delTid);
LogInfo("Del taskFrameLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
break;
}
}
}
tmpDelFrameLst.Clear();
}
}
}
private void DelFrameTask()
{
if (tmpDelFrameLst.Count > 0)
{
lock (lockFrame)
{
for (int i = 0; i < tmpDelFrameLst.Count; i++)
{
bool isDel = false;
int delTid = tmpDelFrameLst[i];
for (int j = 0; j < taskFrameLst.Count; j++)
{
PEFrameTask task = taskFrameLst[j];
if (task.tid == delTid)
{
isDel = true;
taskFrameLst.RemoveAt(j);
recTidLst.Add(delTid);
break;
}
}
if (isDel)
{
continue;
}
for (int j = 0; j < tmpFrameLst.Count; j++)
{
PEFrameTask task = tmpFrameLst[j];
if (task.tid == delTid)
{
tmpFrameLst.RemoveAt(j);
recTidLst.Add(delTid);
break;
}
}
}
tmpDelFrameLst.Clear();
}
}
}
/// <summary>
/// 给定id和PEFrameTask列表,查询该PEFrameTask列表中PEFrameTask是否有该id,并删除
/// </summary>
/// <param name="id"></param>
/// <param name="FrameList"></param>
/// <returns></returns>
private bool SearchIdExistAndDelete(int id, List <PEFrameTask> FrameList)
{
for (int i = 0; i < FrameList.Count; i++)
{
PEFrameTask frameTask = FrameList[i];
if (frameTask.id == id)
{
FrameList.RemoveAt(i);
for (int j = 0; j < idList.Count; j++)
{
if (id == idList[j])
{
idList.RemoveAt(j);
break;;
}
}
return(true);
}
}
return(false);
}
private void DelFrameTask()
{
if (tmpDelFrameLst.Count > 0)
{
lock (lockTmpDelFrameLst) {
for (int i = 0; i < tmpDelFrameLst.Count; i++)
{
int tid = tmpDelFrameLst[i];
for (int j = 0; j < taskFrameLst.Count; j++)
{
PEFrameTask task = taskFrameLst[j];
if (task.tid == tid)
{
taskFrameLst.RemoveAt(j);
recTidLst.Add(tid);
break;
}
}
}
for (int i = 0; i < tmpDelFrameLst.Count; i++)
{
int tid = tmpDelFrameLst[i];
for (int j = 0; j < tmpFrameLst.Count; j++)
{
PEFrameTask task = tmpFrameLst[j];
if (task.tid == tid)
{
tmpFrameLst.RemoveAt(j);
recTidLst.Add(tid);
break;
}
}
}
}
}
}
void CheckFrameTask()
{
if (tmpFrames.Count > 0)
{
lock (lockFrame)
{
//加入缓存区中的定时任务
for (int i = 0; i < tmpFrames.Count; i++)
{
taskFrames.Add(tmpFrames[i]);
}
tmpFrames.Clear();
}
}
frameCounter += 1;
//遍历检测任务是否到达条件
for (int i = 0; i < taskFrames.Count; i++)
{
PEFrameTask task = taskFrames[i];
if (frameCounter < task.destFrame)
{
continue;
}
else
{
try
{
if (taskHandle != null)
{
taskHandle(task.callBack, task.tid);
}
else
{
//时间到 callBack不为空调用
task.callBack?.Invoke(task.tid);
}
}
catch (Exception e)
{
LogInfo(e.ToString());
}
if (task.count == 1)
{
taskFrames.RemoveAt(i);
i--;
recTids.Add(task.tid);
}
else
{
if (task.count != 0)
{
task.count -= 1;
}
//重新赋值时间
task.destFrame += task.delay;
}
}
}
}
/// <summary>
/// 替换帧计时器
/// </summary>
/// <param name="tid"></param>
/// <param name="callBack"></param>
/// <param name="delay"></param>
/// <param name="count"></param>
/// <param name="timeUnit"></param>
/// <returns></returns>
public bool ReplaceFrameTask(int tid, Action callBack, int delay, int count = 1)
{
PEFrameTask newTask = new PEFrameTask(tid, frameCounter + delay, callBack, delay, count);
return(ReplaceTask <PEFrameTask>(tid, taskFrames, tmpFrames, newTask));
}
