public void UnregisterTimerLater(TimedTimerEntry timer)
{
this.m_messageQueue.Enqueue(new Message(delegate
{
this.UnregisterTimer(timer);
}));
}
public IPCAccessor()
{
TaskPool = new SelfRunningTaskPool(TaskPoolInterval, "IPCAccessor Task Pool");
m_updateTimer = TaskPool.CallPeriodically(UpdateInterval, Tick);
m_readArgs = new SocketAsyncEventArgs();
m_bufferSegment = BufferManager.GetSegment(BufferSize);
}
public TimedTimerEntry CallPeriodically(int delayMillis, Action callback)
{
var timer = new TimedTimerEntry(delayMillis, callback);
AddTimer(timer);
return(timer);
}
public TimedTimerEntry CallDelayed(int delayMillis, Action callback)
{
var timer = new TimedTimerEntry(delayMillis, -1, callback);
AddTimer(timer);
return(timer);
}
public override void Initialize()
{
base.Initialize();
m_timer = AuthServer.Instance.IOTaskPool.CallPeriodically(CacheTimeout * 60 / 4, TimerTick);
m_bansTimer = AuthServer.Instance.IOTaskPool.CallPeriodically(BansRefreshTime * 1000, RefreshBans);
m_ipBans = Database.Fetch <IpBan>(IpBanRelator.FetchQuery);
m_hardwareIdBans = Database.Fetch <HardwareIdBan>(HardwareIdBanRelator.FetchQuery);
}
public virtual void RemoveTimer(TimedTimerEntry timer)
{
ExecuteInContext(() =>
{
m_timers.Remove(timer);
timer.Dispose();
});
}
public IPCRequest(IPCMessage requestMessage, Guid guid, RequestCallbackDelegate <T> callback, RequestCallbackErrorDelegate errorCallback,
RequestCallbackDefaultDelegate defaultCallback, TimedTimerEntry timeoutTimer)
{
RequestMessage = requestMessage;
Guid = guid;
Callback = callback;
ErrorCallback = errorCallback;
DefaultCallback = defaultCallback;
TimeoutTimer = timeoutTimer;
}
private void OnStarted()
{
m_checkDCtimer = CallPeriodically((int)TimeSpan.FromMinutes(5).TotalMilliseconds, CheckDC);
var handler = Started;
if (handler != null)
{
handler(this);
}
}
public void StopAutoCraft(ExchangeReplayStopReasonEnum reason = ExchangeReplayStopReasonEnum.STOPPED_REASON_USER)
{
if (m_autoCraftTimer != null)
{
m_autoCraftTimer.Stop();
m_autoCraftTimer = null;
OnAutoCraftStopped(reason);
ChangeAmount(1);
}
}
public void Regrow()
{
if (m_regrowTimer != null)
{
m_regrowTimer.Stop();
m_regrowTimer = null;
}
InteractiveObject.Map.Refresh(InteractiveObject);
InteractiveObject.SetInteractiveState(InteractiveStateEnum.STATE_NORMAL);
}
public void Open()
{
Character.SetDialoger(m_collector);
TaxCollector.OnDialogOpened(this);
InventoryHandler.SendExchangeStartedTaxCollectorShopMessage(Character.Client, TaxCollector);
//Attention, la fenêtre d'échange se fermera automatiquement dans %1 minutes.
Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 139, 5);
Timer = Character.Area.CallDelayed((5 * 60 * 1000), Close);
}
private void AutoCraft()
{
ApplyRune();
if (ItemToImprove != null && Rune != null && Amount == -1)
{
m_autoCraftTimer = Crafter.Character.Area.CallDelayed(AUTOCRAFT_INTERVAL, AutoCraft);
}
else
{
StopAutoCraft(ExchangeReplayStopReasonEnum.STOPPED_REASON_OK);
}
}
public void RegisterTimer(TimedTimerEntry timer)
{
ExecuteInContext(() =>
{
if (!timer.Enabled)
{
timer.Start();
}
m_timers.Push(timer);
});
}
public virtual void AddTimer(TimedTimerEntry timer)
{
ExecuteInContext(() =>
{
if (!timer.Enabled)
{
timer.Start();
}
m_timers.Push(timer);
});
}
public TimedTimerEntry CallPeriodically(int interval, Action action)
{
TimedTimerEntry timedTimerEntry = new TimedTimerEntry
{
Interval = interval,
Action = action
};
timedTimerEntry.Start();
this.RegisterTimerLater(timedTimerEntry);
return(timedTimerEntry);
}
public TimedTimerEntry CallPeriodically(int interval, Action action)
{
var timer = new TimedTimerEntry
{
Interval = interval,
Action = action
};
timer.Start();
RegisterTimer(timer);
return(timer);
}
public TimedTimerEntry CallDelayed(int delay, Action action)
{
TimedTimerEntry timedTimerEntry = new TimedTimerEntry
{
Interval = -1,
Delay = delay,
Action = action
};
timedTimerEntry.Start();
this.RegisterTimerLater(timedTimerEntry);
return(timedTimerEntry);
}
public TimedTimerEntry CallDelayed(int delay, Action action)
{
var timer = new TimedTimerEntry
{
Interval = -1,
Delay = delay,
Action = action
};
timer.Start();
RegisterTimer(timer);
return(timer);
}
public override void Display()
{
ContextHandler.SendGameRolePlayArenaFightPropositionMessage(Character.Client, this, DisplayTime);
ContextHandler.SendGameRolePlayArenaRegistrationStatusMessage(Character.Client, false,
PvpArenaStepEnum.ARENA_STEP_WAITING_FIGHT, PvpArenaTypeEnum.ARENA_TYPE_3VS3);
Character.ArenaPopup = this;
try
{
m_timer = Character.Area.CallDelayed(DisplayTime * 1000, Deny);
}
catch (Exception ex)
{
Deny();
}
}
public void Start()
{
if (!this.m_started)
{
this.m_started = true;
if (this.m_fighters.Count <= 0)
{
this.NotifySuccess();
}
else
{
foreach (CharacterFighter current in this.m_fighters)
{
ContextHandler.SendGameFightTurnReadyRequestMessage(current.Character.Client, this.m_fight.TimeLine.Current);
}
this.m_timer = this.m_fight.Map.Area.CallDelayed(ReadyChecker.CheckTimeout, new Action(this.TimedOut));
}
}
}
public void Start()
{
if (m_started)
{
return;
}
m_started = true;
if (m_fighters.Count <= 0)
{
m_timer = m_fight.Map.Area.CallDelayed(0, NotifySuccess);
return;
}
foreach (var fighter in m_fighters)
{
ContextHandler.SendGameFightTurnReadyRequestMessage(fighter.Character.Client, m_fight.TimeLine.Current);
}
m_timer = m_fight.Map.Area.CallDelayed(Math.Max(0, (int)(m_fight.LastSequenceEndTime - DateTime.Now).TotalMilliseconds) + CheckTimeout, TimedOut);
}
public void SetHarvested()
{
HarvestedSince = DateTime.Now;
InteractiveObject.Map.Refresh(InteractiveObject);
m_regrowTimer = InteractiveObject.Area.CallDelayed(RegrowTime, Regrow);
}
private void UpdateCallback(object state)
{
if ((this.IsDisposed || !this.IsRunning ? 0 : (Interlocked.CompareExchange(ref this.m_currentThreadId, Thread.CurrentThread.ManagedThreadId, 0) == 0 ? 1 : 0)) == 0)
{
return;
}
DateTime now = DateTime.Now;
int num1 = (int)(now - this.m_lastUpdateTime).TotalMilliseconds;
long num2 = 0L;
long num3 = 0L;
int num4 = 0;
try
{
Stopwatch stopwatch1 = Stopwatch.StartNew();
IMessage message;
while (this.m_messageQueue.TryDequeue(out message))
{
try
{
message.Execute();
}
catch (Exception ex)
{
Area.logger.Error <Area, Exception>("Exception raised when processing Message in {0} : {1}.", this, ex);
}
}
stopwatch1.Stop();
num2 = stopwatch1.ElapsedMilliseconds;
this.m_isUpdating = true;
foreach (TimedTimerEntry timedTimerEntry in Enumerable.Where <TimedTimerEntry>((IEnumerable <TimedTimerEntry>) this.m_pausedTimers, (Func <TimedTimerEntry, bool>)(timer => timer.Enabled)))
{
this.m_timers.Push(timedTimerEntry);
}
Stopwatch stopwatch2 = Stopwatch.StartNew();
TimedTimerEntry timedTimerEntry1;
while (((timedTimerEntry1 = this.m_timers.Peek()) == null ? 0 : (timedTimerEntry1.NextTick <= DateTime.Now ? 1 : 0)) != 0)
{
TimedTimerEntry timedTimerEntry2 = this.m_timers.Pop();
if (!timedTimerEntry2.Enabled)
{
if (!timedTimerEntry2.IsDisposed)
{
this.m_pausedTimers.Add(timedTimerEntry2);
}
}
else
{
try
{
timedTimerEntry2.Trigger();
if (timedTimerEntry2.Enabled)
{
this.m_timers.Push(timedTimerEntry2);
}
++num4;
}
catch (Exception ex)
{
Area.logger.Error <Area, Exception>("Exception raised when processing TimerEntry in {0} : {1}.", this, ex);
}
}
}
stopwatch2.Stop();
num3 = stopwatch2.ElapsedMilliseconds;
}
finally
{
try
{
this.m_lastUpdateTime = now;
++this.TickCount;
this.m_isUpdating = false;
TimeSpan timeSpan = DateTime.Now - now;
this.AverageUpdateTime = (float)(((double)this.AverageUpdateTime * 9.0 + timeSpan.TotalMilliseconds) / 10.0);
Interlocked.Exchange(ref this.m_currentThreadId, 0);
int millisecondsDelay = (int)((double)this.m_updateDelay - timeSpan.TotalMilliseconds);
if (millisecondsDelay < 0)
{
millisecondsDelay = 0;
Area.logger.Debug("Area '{0}' update lagged ({1}ms) (msg:{2}ms, timers:{3}ms, timerProc:{4}/{5})", (object)this, (object)(int)timeSpan.TotalMilliseconds, (object)num2, (object)num3, (object)num4, (object)this.m_timers.Count);
}
if (!this.IsRunning)
{
this.m_stoppedAsync.Set();
}
TaskFactoryExtensions.StartNewDelayed(Task.Factory, millisecondsDelay, new Action <object>(this.UpdateCallback), (object)this);
}
catch (Exception ex)
{
Area.logger.Error <Area, Exception>("Area {0}. Could not recall callback !! Exception {1}", this, ex);
}
}
}
public void UnregisterTimer(TimedTimerEntry timer)
{
this.EnsureContext();
this.m_timers.Remove(timer);
}
public void RegisterTimer(TimedTimerEntry timer)
{
this.EnsureContext();
this.m_timers.Push(timer);
}
