private TimerEventHandler mHandler; // Must be here to prevent GC collection of delegate
public MyTimer(int intervalMS, Action callback)
{
m_interval = intervalMS;
m_callback = callback;
mHandler = new TimerEventHandler(OnTimer);
}
public Timer(TimerEventHandler method, string externalText, int period)
{
this.newThread = new Thread(this.RunTimer);
this.text = externalText;
this.period = period;
this.TimeElapsed = method;
this.timer = new int();
}
public CooldownTimer CreateTimer(float second,TimerEventHandler action)
{
//Debug.Log("CreateTimer");
CooldownTimer cooldownTimer = new CooldownTimer (second);
cooldownTimer.Tick = action;
AddTimer (cooldownTimer);
return cooldownTimer;
}
public void Start(int interval, int timeout)
{
m_res = 0;
m_count = 0;
_startCount = timeGetTime();
m_maxCount = timeout * 1000 / interval;
m_interval = interval;
int myData = 0; // dummy data
_thandler = new TimerEventHandler(tickHandler);
m_fastTimer = timeSetEvent(interval, interval, _thandler,
ref myData, 1); // type=periodic
}
public UpdateTimer(long ticks, UpdateTimer.Type type, TimerEventHandler timeEventHandler = null)
{
Debug.Assert(ticks >= 0);
_ticksElapsed = 0;
_ticksUntilFire = ticks;
_ticksInPeriod = ticks;
_type = type;
_isRunning = true;
if (timeEventHandler != null)
{
TimerFired += timeEventHandler;
}
}
/// <summary>
/// Constructor.
/// </summary>
public HighPrecisionEventTimer()
{
// Establish the timing intervals capabilities - not needed right now but nice to have.
TimeCaps timeCaps = new TimeCaps(0, 0);
// This function queries the timer device to determine its resolution.
if (timeGetDevCaps(out timeCaps, Marshal.SizeOf(timeCaps)) != 0)
{
throw new Exception("HighPrecisionEventTimer failed to aquire parameters from the OS.");
}
_minimumValue = timeCaps.Minimum;
_maximumValue = timeCaps.Maximum;
_internalAntiGCDelegateInstance = new TimerEventHandler(TickEventHandlerMethod);
}
private static extern uint timeSetEvent(int msDelay, int msResolution,
TimerEventHandler handler, ref int userCtx, int eventType);
private static extern int timeSetEvent(int delay, int resolution, TimerEventHandler handler, IntPtr user, int eventType);
private void AddTimer(CooldownType type, float second, TimerEventHandler action)
{
CooldownTimer t = TimerManager.SharedInstance.CreateTimer (second, action);
timerDict.Add (type, t);
String name = this.gameObject.name;
Type tt = this.baseSoldier.GetType ();
// if (tt == typeof(ODSoldier) ||
// tt == typeof(HMSoldier) ||
// tt == typeof(LESoldier) ||
// tt == typeof(MXSoldier)) {
// t.Start();
// }
//
// if (name=="hf1"||name=="hf2"||name=="hf3"||name=="hf1") {
//
// }
//
//
// if (this.gameObject.name == "hf2") {
// t.Start ();
// }
// if (this.gameObject.name == "hf3") {
// t.Start ();
// }
// if (this.gameObject.name == "hf1") {
// t.Start ();
// }
t.Start ();
}
public void Start()
{
if (_timerType == 0)
{
_timer0 = new System.Threading.Timer((new TimerCallback(_elapsedTimer0Handler)),
null, 0, _interval);
}
else if (_timerType == 1)
{
_timer1.Start();
}
else if (_timerType == 2)
{
_timer2.Enabled = true;
}
else if (_timerType == 3)
{
timeBeginPeriod(1);
mHandler = new TimerEventHandler(Timer3Handler);
mTimerId = timeSetEvent(_interval, 0, mHandler, IntPtr.Zero, EVENT_TYPE);
mTestStart = DateTime.Now;
mTestTick = 0;
}
}
public static extern UInt32 TimeSetEvent(UInt32 msDelay, UInt32 msResolution, TimerEventHandler handler,
ref UInt32 userCtx, UInt32 eventType);
private static extern UInt32 timeSetEvent(UInt32 delay, UInt32 resolution, TimerEventHandler handler, IntPtr user, UInt32 eventType);
private static extern uint timeSetEvent(int msDelay, int msResolution,
TimerEventHandler handler, ref int userCtx, int eventType);
protected void DispatchEvent(TimerEventHandler evt)
{
if (evt != null) evt(this);
}
private static extern int timeSetEvent(int delay, int resolution, TimerEventHandler handler, IntPtr user, int eventType);
public void Register(TimerEventHandler Tick)
{
_handler = Tick;
_timer.Tick += _timer_Tick;
}
// constructor
internal VisibleSurfacesInstance(double refreshTimer)
{
_timerDel = new TimerEventHandler(this.Timer_Tick);
SetVisibleSurfaceRefreshTimer(refreshTimer);
}
public void Start()
{
switch (_timerType)
{
case 0:
_timer0 = new System.Threading.Timer((new TimerCallback(_elapsedTimer0Handler)), null, 0, _interval);
break;
case 1:
_timer1.Start();
break;
case 3:
timeBeginPeriod(1);
mHandler = new TimerEventHandler(Timer3Handler);
mTimerId = timeSetEvent(_interval, 0, mHandler, IntPtr.Zero, EVENT_TYPE);
mTestStart = DateTime.Now;
break;
default:
throw (new NotImplementedException());
}
}
public void Unregister(TimerEventHandler handler)
{
Timer -= handler;
}
public void Register(TimerEventHandler handler)
{
Timer += handler;
}
/// <summary>
/// Starts one shot periodic timer.
/// Handler must be STORED somewhere to prevent GC collection until it's called!
/// </summary>
public static void StartOneShot(int intervalMS, TimerEventHandler handler)
{
timeSetEvent(intervalMS, 1, handler, IntPtr.Zero, TIME_ONESHOT);
}
public void Register(TimerEventHandler Tick)
{
_handler = Tick;
_timer.Elapsed += _timer_Elapsed;
}
/// <summary>
/// Initializes the timer. Place in Start() method of target class
/// </summary>
/// <param name="startTime">The time from which to count down to</param>
public void StartMethod(double startTimeIn, TimerEventHandler timerEventHandlerIn)
{
remainingTime = startTime * 1;
startTime = startTimeIn;
timerEventHandler = timerEventHandlerIn;
}
public UpdateTimer(TimeSpan period, UpdateTimer.Type type, TimerEventHandler timeEventHandler = null)
: this(period.Ticks, type, timeEventHandler)
{
}
public void Start()
{
if (id != 0) return;
if (Check() == false)
{
_rescueTimer = new Timer(Period);
_rescueTimer.Elapsed += (o, s) => TimerHandler(0, 0, IntPtr.Zero, 0, 0);
_rescueTimer.Start();
usedMMTimer = false;
}
else
{
handler = new TimerEventHandler(TimerHandler);
id = timeSetEvent(period, 1, handler, IntPtr.Zero, EVENT_TYPE);
usedMMTimer = true;
}
}
/// <summary>
/// Initializes the timer. Place in Start() method of target class
/// </summary>
/// <param name="startTime">The time from which to count down to</param>
public void StartMethod(double startTimeIn, TimerEventHandler timerEventHandlerIn)
{
remainingTime = startTime * 1;
startTime = startTimeIn;
timerEventHandler = timerEventHandlerIn;
}
