using Thousandto.Code.Center;
using Thousandto.Core.Base;
using System;
using System.Collections.Generic;
namespace Thousandto.Code.Logic
{
//计时器事件系统
public class TimerEventSystem : BaseSystem
{
#region//常量
//每小时的秒数
public const float HOUR_SEC_COUNT = 60 * 60;
//每天的秒数
public const float DAY_SEC_COUNT = HOUR_SEC_COUNT * 24;
//每周的秒数
public const float WEEK_SEC_COUNT = DAY_SEC_COUNT * 7;
#endregion
#region//私有变量
//id计数器
private int _idCounter = 1;
//计时器列表
private List<TimerEventInfo> _timeEventList = new List<TimerEventInfo>();
//记录心跳系统是否已经接收到心跳信息
private bool _receiveHeartMsg = false;
//下一次跨天时间戳
private int _crossDayTime = -1;
#endregion
#region//初始化，反初始化
public void Initialize()
{
_receiveHeartMsg = false;
_idCounter = 1;
_crossDayTime = -1;
}
public void Uninitialize()
{
_receiveHeartMsg = false;
_idCounter = 1;
_timeEventList.Clear();
_crossDayTime = -1;
}
#endregion
#region//公有函数
/// <summary>
/// 增加倒计时事件
/// </summary>
/// <param name="countDownTime 倒计时时间，单位秒"></param>
/// <param loop="是否循环，不循环就只会执行1次，循环就会循环倒计时"></param>
/// <param callBack="时间到时的回调函数,参数为计时器id"></param>
/// <returns>返回计时器ID，如果小于0表示添加失败</returns>
public int AddCountDownEvent(float countDownTime, bool loop, object param, Action<int, double, object> callBack)
{
if (countDownTime <= 0f)
return -1;
if (callBack == null)
return -1;
return AddTimerEvent(countDownTime, 0f, TimerEventType.CountDown, loop, param, callBack);
}
/// <summary>
/// 增加小时时间戳计时器，每个小时到达指定时间时通知
/// </summary>
/// <param time="时间值，单位秒，每小时达到这个时间的时候通知，本时间必须小于1小时"></param>
/// <param loop="是否循环，不循环就只会执行1次，循环就会循环计时"></param>
/// <param callBack="时间到时的回调函数,参数为计时器id"></param>
/// <returns>返回计时器ID，如果小于0表示添加失败</returns>
public int AddTimeStampHourEvent(float time, float validTime, bool loop, object param, Action<int, double, object> callBack)
{
if (time <= 0f || time >= HOUR_SEC_COUNT)
return -1;
if (callBack == null)
return -1;
return AddTimerEvent(time, validTime, TimerEventType.TimeStampHour, loop, param, callBack);
}
/// <summary>
/// 增加天时间戳计时器，每天到达指定时间时通知
/// </summary>
/// <param time="时间值，单位秒，每天达到这个时间的时候通知，本时间必须小于1天"></param>
/// <param loop="是否循环，不循环就只会执行1次，循环就会循环计时"></param>
/// <param callBack="时间到时的回调函数,参数为计时器id"></param>
/// <returns>返回计时器ID，如果小于0表示添加失败</returns>
public int AddTimeStampDayEvent(float time, float validTime, bool loop, object param, Action<int, double, object> callBack)
{
if (time <= 0f || time >= DAY_SEC_COUNT)
return -1;
if (callBack == null)
return -1;
return AddTimerEvent(time, validTime, TimerEventType.TimeStampDay, loop, param, callBack);
}
/// <summary>
/// 增加周时间戳计时器，每周到达指定时间时通知
/// </summary>
/// <param time="时间值，单位秒，每周达到这个时间的时候通知，本时间必须小于1周"></param>
/// <param loop="是否循环，不循环就只会执行1次，循环就会循环计时"></param>
/// <param callBack="时间到时的回调函数,参数为计时器id"></param>
/// <returns>返回计时器ID，如果小于0表示添加失败</returns>
public int AddTimeStampWeekEvent(float time, float validTime, bool loop, object param, Action<int, double, object> callBack)
{
if (time <= 0f || time >= WEEK_SEC_COUNT)
{
UnityEngine.Debug.LogError("周活动时间有误：" + time + (time <= 0) + (time >= WEEK_SEC_COUNT));
return -1;
}
if (callBack == null)
{
UnityEngine.Debug.LogError("周活动callBack为空");
return -1;
}
return AddTimerEvent(time, validTime, TimerEventType.TimeStampWeek, loop, param, callBack);
}
/// <summary>
/// 删除计时器
/// </summary>
/// <param name="id 计时器id"></param>
public void RemoveTimerEvent(int id)
{
for (int i = _timeEventList.Count - 1; i >= 0; --i)
{
if (_timeEventList[i].ID == id)
{
_timeEventList.RemoveAt(i);
break;
}
}
}
#endregion
#region//私有函数
protected override bool OnUpdate(float deltaTime)
{
var curHeart = GameCenter.HeartSystem.IsReceiveHeart;
if (curHeart && !_receiveHeartMsg)
{
//判断如果第一次收到心跳消息，重新计算计时器
_receiveHeartMsg = true;
for (int i = _timeEventList.Count - 1; i >= 0; --i)
{
CalculateExecuteTime(_timeEventList[i]);
}
_timeEventList.Sort(TimerSort);
_crossDayTime = GetCrossDayTime((int)GameCenter.HeartSystem.ServerTime);
}
if (curHeart)
{
var serverTime = GameCenter.HeartSystem.ServerTime + GameCenter.HeartSystem.ServerZoneOffset;
bool reSort = false;
for (int i = _timeEventList.Count - 1; i >= 0; --i)
{
if(i >= _timeEventList.Count)
{
continue;
}
var timer = _timeEventList[i];
if (CheckTimer(timer, serverTime))
{
if (timer.Loop)
{
//循环的计时器，需要重新排序
reSort = true;
}
else
{
_timeEventList.Remove(timer);
}
}
else
{
break;
}
}
if (reSort)
{
_timeEventList.Sort(TimerSort);
}
if (GameCenter.HeartSystem.ServerTime >= _crossDayTime)
{
_crossDayTime = GetCrossDayTime((int)GameCenter.HeartSystem.ServerTime);
GameCenter.PushFixEvent(Global.LogicEventDefine.EID_EVENT_CROSSDAY);
}
}
return base.OnUpdate(deltaTime);
}
private bool CheckTimer(TimerEventInfo timer, double serverTime)
{
if (serverTime >= timer.NextExecuteTime)
{
//已经超过了执行的时间，判断是否还在有效期内
var outTime = serverTime - timer.NextExecuteTime;
if (outTime < timer.ValidTimeValue || timer.Type == TimerEventType.CountDown)
{
//还在有效期,执行事件
if (!timer.IsExecute)
{
timer.CallBack(timer.ID, timer.ValidTimeValue - outTime, timer.Param);
}
if (!timer.Loop)
{
timer.IsExecute = true;
}
}
if (timer.Loop)
{
timer.IsExecute = false;
switch (timer.Type)
{
case TimerEventType.CountDown:
//下一次处理时间
timer.NextExecuteTime = serverTime + timer.TimeValue;
break;
case TimerEventType.TimeStampHour:
{
//下一次处理时间
DateTime curDateTime = new DateTime(1970, 1, 1, 0, 0, 0);
long lTime = long.Parse(((ulong)serverTime).ToString() + "0000000");
TimeSpan toNow = new TimeSpan(lTime);
curDateTime = curDateTime.Add(toNow);
var hourStartTime = serverTime - curDateTime.Minute * 60 - curDateTime.Second;
timer.NextExecuteTime = hourStartTime + HOUR_SEC_COUNT + timer.TimeValue;
}
break;
case TimerEventType.TimeStampDay:
{
//下一次处理时间
DateTime curDateTime = new DateTime(1970, 1, 1, 0, 0, 0);
long lTime = long.Parse(((ulong)serverTime).ToString() + "0000000");
TimeSpan toNow = new TimeSpan(lTime);
curDateTime = curDateTime.Add(toNow);
var dayStartSec = serverTime - curDateTime.Hour * HOUR_SEC_COUNT - curDateTime.Minute * 60 - curDateTime.Second;
timer.NextExecuteTime = dayStartSec + DAY_SEC_COUNT + timer.TimeValue;
}
break;
case TimerEventType.TimeStampWeek:
{
//下一次处理时间
DateTime curDateTime = new DateTime(1970, 1, 1, 0, 0, 0);
long lTime = long.Parse(((ulong)serverTime).ToString() + "0000000");
TimeSpan toNow = new TimeSpan(lTime);
curDateTime = curDateTime.Add(toNow);
int dayOfWeek = (int)curDateTime.DayOfWeek;
if (dayOfWeek == 0)
{
dayOfWeek = 6;
}
else
{
dayOfWeek -= 1;
}
var weekStartSec = serverTime - dayOfWeek * DAY_SEC_COUNT - curDateTime.Hour * HOUR_SEC_COUNT - curDateTime.Minute * 60 - curDateTime.Second;
timer.NextExecuteTime = weekStartSec + WEEK_SEC_COUNT + timer.TimeValue;
}
break;
}
}
return true;
}
return false;
}
//增加计时器统一函数
private int AddTimerEvent(float time, float validTime, TimerEventType type, bool loop, object param, Action<int, double, object> callBack)
{
var timerInfo = new TimerEventInfo();
timerInfo.ID = ++_idCounter;
timerInfo.Type = type;
timerInfo.Loop = loop;
timerInfo.TimeValue = time;
timerInfo.ValidTimeValue = validTime;
timerInfo.Param = param;
timerInfo.AddedTime = GameCenter.HeartSystem.ServerTime + GameCenter.HeartSystem.ServerZoneOffset;
timerInfo.CallBack = callBack;
timerInfo.IsExecute = false;
_timeEventList.Add(timerInfo);
if (GameCenter.HeartSystem.IsReceiveHeart)
{
CalculateExecuteTime(timerInfo);
_timeEventList.Sort(TimerSort);
}
return timerInfo.ID;
}
//计算下一次执行的时间
private void CalculateExecuteTime(TimerEventInfo timerInfo)
{
var serverTime = GameCenter.HeartSystem.ServerTime + GameCenter.HeartSystem.ServerZoneOffset;
DateTime curDateTime = new DateTime(1970, 1, 1, 0, 0, 0);
long lTime = long.Parse(((ulong)serverTime).ToString() + "0000000");
TimeSpan toNow = new TimeSpan(lTime);
curDateTime = curDateTime.Add(toNow);
switch (timerInfo.Type)
{
case TimerEventType.CountDown:
timerInfo.NextExecuteTime = serverTime + timerInfo.TimeValue;
break;
case TimerEventType.TimeStampHour:
{
var hourStartTime = serverTime - curDateTime.Minute * 60 - curDateTime.Second;
timerInfo.NextExecuteTime = hourStartTime + timerInfo.TimeValue;
while ((timerInfo.NextExecuteTime + timerInfo.ValidTimeValue) < serverTime)
{
hourStartTime += HOUR_SEC_COUNT;
timerInfo.NextExecuteTime = hourStartTime + timerInfo.TimeValue;
}
}
break;
case TimerEventType.TimeStampDay:
{
var dayStartSec = serverTime - curDateTime.Hour * HOUR_SEC_COUNT - curDateTime.Minute * 60 - curDateTime.Second;
timerInfo.NextExecuteTime = dayStartSec + timerInfo.TimeValue;
while ((timerInfo.NextExecuteTime + timerInfo.ValidTimeValue) < serverTime)
{
dayStartSec += DAY_SEC_COUNT;
timerInfo.NextExecuteTime = dayStartSec + timerInfo.TimeValue;
}
}
break;
case TimerEventType.TimeStampWeek:
{
int dayOfWeek = (int)curDateTime.DayOfWeek;
if (dayOfWeek == 0)
{
dayOfWeek = 6;
}
else
{
dayOfWeek -= 1;
}
var weekStartSec = serverTime - dayOfWeek * DAY_SEC_COUNT - curDateTime.Hour * HOUR_SEC_COUNT - curDateTime.Minute * 60 - curDateTime.Second;
timerInfo.NextExecuteTime = weekStartSec + timerInfo.TimeValue;
while ((timerInfo.NextExecuteTime + timerInfo.ValidTimeValue) < serverTime)
{
//已超时，换到下一周
weekStartSec += WEEK_SEC_COUNT;
timerInfo.NextExecuteTime = weekStartSec + timerInfo.TimeValue;
}
}
break;
}
}
//排序函数
private int TimerSort(TimerEventInfo left, TimerEventInfo right)
{
//从后往前排
return right.NextExecuteTime.CompareTo(left.NextExecuteTime);
}
//获取跨天时间戳
private int GetCrossDayTime(int time)
{
var dataTime = new DateTime((long)time * 10000000L + 621356256000000000L);
return (int)((new DateTime(dataTime.Year, dataTime.Month, dataTime.Day).Ticks - 621356256000000000L) / 10000000L) + 86400;
}
#endregion
}
}