public int AddTimeTask(Action <int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
if (timeUnit != PETimeUnit.Millisecond)
{
switch (timeUnit)
{
case PETimeUnit.Second:
delay = delay * 1000;
break;
case PETimeUnit.Minute:
delay = delay * 1000 * 60;
break;
case PETimeUnit.Hour:
delay = delay * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delay = delay * 1000 * 60 * 60 * 24;
break;
default:
LogInfo("Add Task TimeUnit Type Error...");
break;
}
}
int tid = GetTid();;
nowTime = GetUTCMilliseconds();
lock (lockTime) {
tmpTimeLst.Add(new PETimeTask(tid, callback, nowTime + delay, delay, count));
}
return(tid);
}
/// <summary>
/// 替换一个已经存在的时间定时任务
/// </summary>
/// <param name="tid">任务ID</param>
/// <param name="callback">回调</param>
/// <param name="delayTime">延时时间</param>
/// <param name="unit">时间单位(默认毫秒)</param>
/// <param name="count">循环次数(0循环)</param>
/// <returns>替换结果</returns>
public bool ReplaceTimeTask(int tid, Action callback, float delayTime, PETimeUnit unit = PETimeUnit.Millsecond, int count = 1)
{
bool result = false;
//时间换算为毫秒
if (unit != PETimeUnit.Millsecond)
{
switch (unit)
{
case PETimeUnit.Second:
delayTime = delayTime * 1000;
break;
case PETimeUnit.Minute:
delayTime = delayTime * 1000 * 60;
break;
case PETimeUnit.Hour:
delayTime = delayTime * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delayTime = delayTime * 1000 * 60 * 60 * 24;
break;
default:
break;
}
}
// Time.realtimeSinceStartup 从游戏启动到现在为止的时间
nowTime = GetUTCMilliseconds() + delayTime;
PETimeTask newTask = new PETimeTask(tid, nowTime, delayTime, count, callback);
for (int i = 0; i < taskTimeList.Count; i++)
{
if (newTask.tid == taskTimeList[i].tid)
{
result = true;
taskTimeList[i] = newTask;
break;
}
}
if (!result)
{
for (int i = 0; i < tmpTimeList.Count; i++)
{
if (newTask.tid == tmpTimeList[i].tid)
{
result = true;
tmpTimeList[i] = newTask;
break;
}
}
}
return(result);
}
/// <summary>
/// 添加一个新任务并传递一个ID,替代该ID任务
/// </summary>
/// <param name="id"></param>
/// <param name="callback"></param>
/// <param name="delayTime"></param>
/// <param name="timeUnit"></param>
/// <param name="count"></param>
/// <returns></returns>
public bool ReplaceTimeTask(int id, Action callback, float delayTime, PETimeUnit timeUnit = PETimeUnit.Millisecond,
int count = 1)
{
PETimeTask newTimeTask = CreatePETimeTask(id, callback, delayTime, timeUnit, count);
return(SearchIdExistAndReplace(id, taskTimeList, newTimeTask) ||
SearchIdExistAndReplace(id, tempTimeList, newTimeTask));
}
/// <summary>
/// <para>添加任务至缓存列表</para>
/// <para>callback:需要执行的方法</para>
/// <para>delayTime:延迟时间</para>
/// <para>PETimeUnit:时间单位(毫秒,秒,分,小时,天)</para>
/// <para>count:循环次数(0时无限循环)</para>
/// </summary>
/// <param name="callback"></param>
/// <param name="delayTime"></param>
/// <param name="timeUnit"></param>
/// <param name="count"></param>
/// <returns></returns>
public int AddTimeTask(Action callback, float delayTime, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
int id = GetId(); //获取ID
tempTimeList.Add(CreatePETimeTask(id, callback, delayTime, timeUnit, count)); //添加到任务列表
idList.Add(id); //添加到id列表
return(id); //返回该id值
}
/// <summary>
/// 替换任务
/// </summary>
/// <param name="tid"></param>
/// <returns></returns>
public bool ReplaceTimeTask(int tid, Action <int> callback, float delay, PETimeUnit PETimeUnit = PETimeUnit.Millisecond, int count = 1)
{
if (PETimeUnit != PETimeUnit.Millisecond)
{
switch (PETimeUnit)
{
case PETimeUnit.Second:
delay = delay * 1000;
break;
case PETimeUnit.Minute:
delay = delay * 1000 * 60;
break;
case PETimeUnit.Hour:
delay = delay * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delay = delay * 1000 * 60 * 60 * 24;
break;
default:
LogInfo("Add Task PETimeUnit Type Error...");
break;
}
}
nowTime = GetUTCMilliseconds();
TimeTask newTask = new TimeTask(tid, callback, nowTime + delay, delay, count);
bool isRep = false; // 是否替换成功
// 尝试在任务列表里寻找替换
for (int i = 0; i < taskTimeLst.Count; i++)
{
if (taskTimeLst[i].tid == tid)
{
taskTimeLst[i] = newTask;
isRep = true;
break;
}
}
// 任务列表里没有，尝试去缓存找
if (!isRep)
{
for (int i = 0; i < tmpTimeLst.Count; i++)
{
if (tmpTimeLst[i].tid == tid)
{
tmpTimeLst[i] = newTask;
isRep = true;
break;
}
}
}
return(isRep);
}
public bool ResetTimeTaskDesttime(int tid, float delay, PETimeUnit timeUnit = PETimeUnit.Millisecond)
{
if (timeUnit != PETimeUnit.Millisecond)
{
switch (timeUnit)
{
case PETimeUnit.Second:
delay = delay * 1000;
break;
case PETimeUnit.Minute:
delay = delay * 1000 * 60;
break;
case PETimeUnit.Hour:
delay = delay * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delay = delay * 1000 * 60 * 60 * 24;
break;
default:
LogInfo("Replace Task TimeUnit Type Error...");
break;
}
}
nowTime = GetUTCMilliseconds();
var newdestTime = nowTime + delay;
bool reset = false;
for (int i = 0; i < taskTimeLst.Count; i++)
{
if (taskTimeLst[i].tid == tid)
{
taskTimeLst[i].destTime = newdestTime > taskTimeLst[i].destTime ? newdestTime : taskTimeLst[i].destTime;
reset = true;
break;
}
}
if (!reset)
{
for (int i = 0; i < tmpTimeLst.Count; i++)
{
if (tmpTimeLst[i].tid == tid)
{
tmpTimeLst[i].destTime = newdestTime > tmpTimeLst[i].destTime ? newdestTime : tmpTimeLst[i].destTime;
reset = true;
break;
}
}
}
return(reset);
}
public bool ReplaceTimeTask(int tid, Action <int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
if (timeUnit != PETimeUnit.Millisecond)
{
switch (timeUnit)
{
case PETimeUnit.Second:
delay = delay * 1000;
break;
case PETimeUnit.Minute:
delay = delay * 1000 * 60;
break;
case PETimeUnit.Hour:
delay = delay * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delay = delay * 1000 * 60 * 60 * 24;
break;
default:
LogInfo("replace task timeunit type error...");
break;
}
}
nowTime = GetUTCMilliseconds();
PETimeTask newTask = new PETimeTask(tid, callback, nowTime + delay, delay, count);
bool isRep = false;
for (int i = 0; i < taskTimerLst.Count; i++)
{
if (taskTimerLst[i].tid == tid)
{
taskTimerLst[i] = newTask;
isRep = true;
break;
}
}
if (!isRep)
{
for (int i = 0; i < tmpTimerLst.Count; i++)
{
if (tmpTimerLst[i].tid == tid)
{
tmpTimerLst[i] = newTask;
isRep = true;
break;
}
}
}
return(isRep);
}
/// <summary>
/// 添加一个时间定时任务
/// </summary>
/// <param name="callback">回调</param>
/// <param name="delayTime">延时时间</param>
/// <param name="unit">时间单位(默认毫秒)</param>
/// <param name="count">执行次数(0循环)</param>
/// <returns>任务ID</returns>
public int AddTimeTask(Action callback, float delayTime, PETimeUnit unit = PETimeUnit.Millsecond, int count = 1)
{
//时间换算为毫秒
if (unit != PETimeUnit.Millsecond)
{
switch (unit)
{
case PETimeUnit.Second:
delayTime = delayTime * 1000;
break;
case PETimeUnit.Minute:
delayTime = delayTime * 1000 * 60;
break;
case PETimeUnit.Hour:
delayTime = delayTime * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delayTime = delayTime * 1000 * 60 * 60 * 24;
break;
default:
break;
}
}
int tid = GetTid();
tidList.Add(tid);
// Time.realtimeSinceStartup 从游戏启动到现在为止的时间
nowTime = GetUTCMilliseconds() + delayTime;
PETimeTask tmpTask = new PETimeTask(tid, nowTime, delayTime, count, callback);
tmpTimeList.Add(tmpTask);
return(tid);
}
/// <summary>
/// <para>根据ID创建一个新PETimeTask</para>
/// <para>callback:需要执行的方法</para>
/// <para>delayTime:延迟时间</para>
/// <para>PETimeUnit:时间单位(毫秒,秒,分,小时,天)</para>
/// <para>count:循环次数(0时无限循环)</para>
/// </summary>
/// <param name="id"></param>
/// <param name="callback"></param>
/// <param name="delayTime"></param>
/// <param name="timeUnit"></param>
/// <param name="count"></param>
/// <returns></returns>
private PETimeTask CreatePETimeTask(int id, Action callback, float delayTime, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
switch (timeUnit)//根据PETimeUnit类型赋值
{
case PETimeUnit.Millisecond:
break;
case PETimeUnit.Second:
delayTime *= 1000;
break;
case PETimeUnit.Minute:
delayTime *= 1000 * 60;
break;
case PETimeUnit.Hour:
delayTime *= 1000 * 60 * 60;
break;
case PETimeUnit.Day:
delayTime *= 1000 * 60 * 60 * 24;
break;
default:
Debug.Log("没有当前的计时单位");
break;;
}
float destTime = Time.realtimeSinceStartup * 1000 + delayTime; //由于默认为毫秒,因此×1000
PETimeTask timeTask = new PETimeTask //新任务赋值
{
destTime = destTime,
callback = callback,
delayTime = delayTime,
count = count,
id = id
};
return(timeTask);
}
/// <summary>
/// 添加时间回调事件
/// </summary>
/// <param name="destTime">Destination time.</param>
/// <param name="callback">Callback.</param>
/// <param name="count">count = 0表示一直循环.</param>
public int AddTimeTake(double destTime, double delayTime, Action callback = null, PETimeUnit unit = PETimeUnit.Millisecond, int count = 1)
{
double time = 0;
switch (unit)
{
case PETimeUnit.Millisecond:
time = destTime;
break;
case PETimeUnit.Second:
time = destTime * 1000;
break;
case PETimeUnit.Minute:
time = destTime * 1000 * 60;
break;
case PETimeUnit.Hour:
time = destTime * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
time = destTime * 1000 * 60 * 60 * 24;
break;
default:
Debug.Log("Unit Error...");
break;
}
double dest = Time.realtimeSinceStartup * 1000 + time;
int tid = GetTid();
PETimeTake take = new PETimeTake
{
tid = tid,
destTime = dest,
delayTime = delayTime,
callback = callback,
count = count,
};
cacheTimeTakes.Add(take);
return(tid);
}
/// <summary>
/// <para>根据ID创建一个新PETimeTask</para>
/// <para>callback:需要执行的方法</para>
/// <para>delayTime:延迟时间</para>
/// <para>PETimeUnit:时间单位(毫秒,秒,分,小时,天)</para>
/// <para>count:循环次数(0时无限循环)</para>
/// </summary>
/// <param name="id"></param>
/// <param name="callback"></param>
/// <param name="delayTime"></param>
/// <param name="timeUnit"></param>
/// <param name="count"></param>
/// <param name="updateModel"></param>
/// <returns></returns>
private PETimeTask CreatePETimeTask(int id, Action callback, float delayTime, PETimeUnit timeUnit = PETimeUnit.Second, int count = 1)
{
return(CreatePETimeTask(id, callback, null, delayTime, timeUnit, count));
}
/// <summary>
/// <para>根据ID创建一个新PETimeTask</para>
/// <para>callback:需要执行的方法</para>
/// <para>delayTime:延迟时间</para>
/// <para>PETimeUnit:时间单位(毫秒,秒,分,小时,天)</para>
/// <para>count:循环次数(0时无限循环)</para>
/// </summary>
/// <param name="id"></param>
/// <param name="callback"></param>
/// <param name="delayTime"></param>
/// <param name="timeUnit"></param>
/// <param name="count"></param>
/// <param name="updateModel"></param>
/// <returns></returns>
private PETimeTask CreatePETimeTask(int id, Action callback, Action <double> updateCallBack, float delayTime, PETimeUnit timeUnit = PETimeUnit.Second, int count = 1)
{
switch (timeUnit)//根据PETimeUnit类型赋值
{
case PETimeUnit.Second:
break;
case PETimeUnit.Minute:
delayTime *= 60;
break;
case PETimeUnit.Hour:
delayTime *= 60 * 60;
break;
case PETimeUnit.Day:
delayTime *= 60 * 60 * 24;
break;
default:
Debug.Log("没有当前的计时单位");
break;;
}
double destTime = GetTime() + delayTime; //由于默认为毫秒,因此×1000
PETimeTask timeTask = new PETimeTask //新任务赋值
{
destTime = destTime,
callback = callback,
delayTime = delayTime,
count = count,
id = id,
updateModel = true,
updateCallback = updateCallBack
};
return(timeTask);
}
public int AddTimeTask(Action <int> cb, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int replay = 1)
{
return(pt.AddTimeTask(cb, delay, timeUnit, replay));
}
/// <summary>
/// 替换一个已经存在的时间定时任务
/// </summary>
/// <param name="tid">任务ID</param>
/// <param name="callback">回调</param>
/// <param name="delayTime">延时时间</param>
/// <param name="unit">时间单位(默认毫秒)</param>
/// <param name="count">循环次数(0循环)</param>
/// <returns>替换结果</returns>
public bool ReplaceTimeTask(int tid, Action callback, float delayTime, PETimeUnit unit = PETimeUnit.Millsecond, int count = 1)
{
return(timer.ReplaceTimeTask(tid, callback, delayTime, unit, count));
}
/// <summary>
/// 添加一个时间定时任务
/// </summary>
/// <param name="callback">回调</param>
/// <param name="delayTime">延时时间</param>
/// <param name="unit">时间单位(默认毫秒)</param>
/// <param name="count">执行次数(0循环)</param>
/// <returns>任务ID</returns>
public int AddTimeTask(Action callback, float delayTime, PETimeUnit unit = PETimeUnit.Millsecond, int count = 1)
{
return(timer.AddTimeTask(callback, delayTime, unit, count));
}
/// <summary>
/// 替换时间回调事件
/// </summary>
public bool ReplaceTimeTake(int tid, double destTime, double delayTime, Action callback = null, PETimeUnit unit = PETimeUnit.Millisecond, int count = 1)
{
bool isReplace = false;
double time = 0;
switch (unit)
{
case PETimeUnit.Millisecond:
time = destTime;
break;
case PETimeUnit.Second:
time = destTime * 1000;
break;
case PETimeUnit.Minute:
time = destTime * 1000 * 60;
break;
case PETimeUnit.Hour:
time = destTime * 1000 * 60 * 60;
break;
case PETimeUnit.Day:
time = destTime * 1000 * 60 * 60 * 24;
break;
default:
Debug.Log("Unit Error...");
break;
}
double dest = Time.realtimeSinceStartup * 1000 + time;
PETimeTake take = new PETimeTake
{
tid = tid,
destTime = dest,
delayTime = delayTime,
callback = callback,
count = count,
};
for (int i = 0; i < timeTakes.Count; i++)
{
if (timeTakes[i].tid == tid)
{
timeTakes[i] = take;
isReplace = true;
}
}
return(isReplace);
}
public int AddTimeTask(Action <int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int loopTime = 1)
{
return(peTimer.AddTimeTask(callback, delay, timeUnit, loopTime));
}
public int AddTimeTask(Action callback, float delay, int count = 1, PETimeUnit timeUnit = PETimeUnit.Millisecond)
{
return(pt.AddTimeTask(callback, delay, count, timeUnit));
}
public bool ReplaceTimeTask(int tid, Action callback, float delay, int count = 1, PETimeUnit timeUnit = PETimeUnit.Millisecond)
{
return(pt.ReplaceTimeTask(tid, callback, delay, count, timeUnit));
}
public int AddTimeTask(Action <int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
return(pt.AddTimeTask(callback, delay, timeUnit, count));
}
public void AddTimeTask(Action <int> cb, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
{
pt.AddTimeTask(cb, delay, timeUnit, count);
}
