protected override void OnUpdate(TimeSpan time)
{
base.OnUpdate(time);
_probingInterval.Update(time);
if (!_probingInterval.Passed)
{
return;
}
_probingInterval.Reset();
if (IsActive)
{
//detect
var robotsNearMe = GetNoticedUnits();
//do something
OnUnitsFound(robotsNearMe);
}
if (_despawnHelper == null)
{
var m = GetPropertyModifier(AggregateField.despawn_time);
var timespan = TimeSpan.FromMilliseconds((int)m.Value);
SetDespawnTime(timespan);
}
_despawnHelper.Update(time, this);
}
public override void Update(TimeSpan time)
{
base.Update(time);
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
if (ReinforceHandler._nextReinforceCounterIncrease < DateTime.Now)
{
ReinforceHandler.SetNextReinforceCounterIncreaseFromNow(REINFORCE_COUNTER_INCREASE_MINUTES);
var oldValue = ReinforceHandler.ReinforceCounter;
ReinforceHandler.IncreaseReinforceCounter();
var newValue = ReinforceHandler.ReinforceCounter;
if (oldValue != newValue)
{
WriteLog("reinforce counter increased. " + ReinforceHandler._pbsUnit.ED.Name + " " + oldValue + "->" + newValue);
}
}
}
public override void Update(TimeSpan time)
{
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
if (Interlocked.CompareExchange(ref _inProgress, 1, 0) == 1)
{
return;
}
Task.Run(() =>
{
try
{
DoReinforceEndCheck();
}
catch (Exception ex)
{
Logger.Exception(ex);
}
}).ContinueWith(t => { _inProgress = 0; });
}
public virtual void Update(FarseerPhysicsGameSettings settings)
{
double timeStep = Math.Min(ElapsedTimeMSec * 0.001, (1.0 / 30));
m_UpdateIntervalTimer.Reset();
if (settings.Pause)
{
if (settings.SingleStep)
{
settings.SingleStep = false;
}
else
{
timeStep = 0.0;
}
DrawString("****PAUSED****");
}
else
{
World.Step(timeStep);
}
if (timeStep > 0.0)
{
++StepCount;
}
}
public void Update(TimeSpan time)
{
if (Expirable)
{
if (_expired)
{
return;
}
_expiry.Update(time);
if (_expiry.Expired)
{
OnExpired();
}
}
if (!_updated)
{
return;
}
_saveTimer.Update(time);
if (!_saveTimer.Passed)
{
return;
}
_saveTimer.Reset();
_updated = false;
OnUpdated();
}
public static Action <TimeSpan> CreateUpdateProfiler(TimeSpan interval, Action <TimeSpan> action)
{
var timer = new IntervalTimer(interval);
var updates = 0;
return((e) =>
{
updates++;
timer.Update(e);
if (!timer.Passed)
{
return;
}
try
{
action(timer.Elapsed.Divide(updates));
}
finally
{
updates = 0;
timer.Reset();
}
});
}
protected override void OnUpdate(TimeSpan time)
{
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
Logger.DebugInfo($" ---------- KEZDUNK ---------- [{Owner.InfoString}]");
//itt ez az egesz arra kell, hogy amikor megindul a server akkor belemegy valami statebe
//ott hasznal zonat, aztan csak nez, hogy nincs kinn az objekt, igen, mert az is epp pakolodik ki
//
//ez ugyan csak ragtapasz.
if (Owner.Core < Owner.CoreUseHandler.CoreMinimum)
{
Owner.CoreUseHandler.ToWarmUpState();
return;
}
Owner.CoreUseHandler.ToActiveState();
}
protected override void OnUpdate(TimeSpan time)
{
base.OnUpdate(time);
_updateInterval.Update(time);
if (!_updateInterval.Passed)
{
return;
}
_updateInterval.Interval = TimeSpan.FromMilliseconds(CycleTime + FastRandom.NextInt(-2, 2));
_updateInterval.Reset();
var onlineStatus = OnlineStatus;
if (!this.IsFullyConstructed() || !onlineStatus)
{
return;
}
var zone = Zone;
if (zone == null)
{
return;
}
if (Interlocked.CompareExchange(ref _inProgress, 1, 0) == 1)
{
return;
}
Task.Run(() => { PBSActiveObjectAction(zone); }).ContinueWith(t => { Interlocked.Exchange(ref _inProgress, 0); }).LogExceptions();
}
void SetMapUpdateInterval(int t)
{
if (t < MapConst.MIN_MAP_UPDATE_DELAY)
{
t = MapConst.MIN_MAP_UPDATE_DELAY;
}
i_timer.SetInterval(t);
i_timer.Reset();
}
public void ResetLogoutTimer()
{
if (_logoutTimer == null)
{
return;
}
_logoutTimer.Reset();
SendStartLogoutPacket(_logoutTimer);
}
public void Update(TimeSpan time)
{
_productionCheckTimer.Update(time);
if (!_productionCheckTimer.Passed)
{
return;
}
_productionCheckTimer.Reset();
CheckProductions();
}
void DoRenderIfNeed()
{
if (m_ForceRender)
{
Invalidate();
m_ForceRender = false;
}
if (AltSketchPaintHandler.DoRenderIfNeed(GetComponent <Camera>(), GetComponent <Renderer>()))
{
m_RenderUpdateTimer.Reset();
}
}
public override void Update(TimeSpan time)
{
_processHostilesTimer.Update(time);
if (_processHostilesTimer.Passed)
{
_processHostilesTimer.Reset();
ProcessHostiles();
}
foreach (var activator in _moduleActivators)
{
activator.Update(time);
}
}
private async void StopTimers()
{
if (_intervalTimerList != null)
{
IntervalTimer.Cancel = true;
TimerStartTask.Wait();
await Task.Delay(5000);
_intervalTimerList.Reset();
}
button3.Enabled = true;
button5.Enabled = true;
button2.Enabled = true;
}
public override void Update(TimeSpan time)
{
MissionAdministrator.Update(time);
_transportAssignmentInterval.Update(time);
if (!_transportAssignmentInterval.Passed)
{
return;
}
_transportAssignmentInterval.Reset();
TransportAssignment.CleanUpExpiredAssignmentsAsync();
}
private void UpdatePlayerScores(TimeSpan time)
{
_updateScoreTimer.Update(time);
if (!_updateScoreTimer.Passed)
{
return;
}
_updateScoreTimer.Reset();
var playersInRange = GetPlayersInSAPRange();
CheckPlayersInRange(playersInRange);
CheckInactivePlayers(playersInRange);
}
protected override void OnUpdate(TimeSpan time)
{
base.OnUpdate(time);
_despawnHelper.Update(time, this);
_interval.Update(time);
if (!_interval.Passed)
{
return;
}
_interval.Reset();
Task.Run(() => HealWallsInRadius()).LogExceptions();
}
public void Update(TimeSpan time)
{
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
if (_module.State.Type != ModuleStateType.Idle)
{
return;
}
_module.AcceptVisitor(this);
}
public void Update(TimeSpan time)
{
_updateTimer.Update(time);
if (!_updateTimer.Passed)
{
return;
}
OnUpdate(_updateTimer.Elapsed);
foreach (var flock in _flocks)
{
flock.Update(_updateTimer.Elapsed);
}
_updateTimer.Reset();
}
public void Update(T pbsObject, TimeSpan time)
{
if (_running)
{
return;
}
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
_running = true;
Task.Run(() => _entityRepository.Update(pbsObject))
.ContinueWith(t => _running = false)
.LogExceptions();
}
public override void Update(TimeSpan time)
{
_degradeTimer.Update(time);
if (_degradeTimer.Passed)
{
_degradeTimer.Reset();
var o = new TerrainDegradeOperation(_degradeArea);
EnqueueTerraformingOperation(o);
}
DequeueTerraformingOperations();
_timer.Update(time);
if (_timer.Passed)
{
_timer.Reset();
ProcessAffectedPositions();
}
}
public void Update(TimeSpan time)
{
if (_cachedMissionTargets.Count == 0 || _enqueuedMissionEventInfos.Count == 0)
{
return;
}
_timerUpdateMissions.Update(time);
if (!_timerUpdateMissions.Passed)
{
return;
}
_timerUpdateMissions.Reset();
MissionEventInfo missionEventInfo;
while (_enqueuedMissionEventInfos.TryDequeue(out missionEventInfo))
{
foreach (var missionTarget in _cachedMissionTargets.Values)
{
if (missionTarget == null)
{
continue;
}
if (!missionTarget.HandleMissionEvent(missionEventInfo))
{
continue;
}
if (missionTarget.IsCompleted)
{
//the dequeued item finished a target
_cachedMissionTargets.Remove(missionTarget.Id);
}
//the event got used up
break;
}
}
}
private void WarmUpCycleWork(TimeSpan time)
{
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
Owner.CoreUseHandler.EnergyState = PBSEnergyState.warmup;
Owner.CoreUseHandler.LastCoreUse = 0;
if (Owner.CorePercentage > Owner.CoreUseHandler.GetKickStartCoreRatio())
{
Owner.CoreUseHandler.ToActiveState();
return;
}
OnWarmUpCycle();
}
protected override void OnUpdate(TimeSpan time)
{
base.OnUpdate(time);
if (!Enabled || IntrusionInProgress)
{
return;
}
_timerCheckIntrusionTime.Update(time);
if (!_timerCheckIntrusionTime.Passed)
{
return;
}
_timerCheckIntrusionTime.Reset();
CheckIntrusionStartTimeAsync();
}
public AutoTopOffGroup(
string name,
bool enable,
string requestBitName,
string waterLevelGroupName,
uint maximumRuntime,
uint minimumCooldown,
bool useAnalogSensors,
float analogOnSetpoint,
float analogOffSetpoint,
bool useFloatSwitches
)
{
this.name = name;
this.enable = enable;
this.requestBitName = requestBitName;
this.waterLevelGroupName = waterLevelGroupName;
this.maximumRuntime = maximumRuntime;
this.minimumCooldown = minimumCooldown;
this.useAnalogSensors = useAnalogSensors;
this.analogOnSetpoint = analogOnSetpoint;
this.analogOffSetpoint = analogOffSetpoint;
this.useFloatSwitches = useFloatSwitches;
if (enable)
{
state = AutoTopOffState.Standby;
}
else
{
state = AutoTopOffState.Off;
}
Bit.Instance.Set(this.requestBitName, false);
timer = IntervalTimer.GetTimer(name);
timer.TimerElapsedEvent += OnTimerElapsed;
timer.Reset();
failAlarmIndex = Alarm.Subscribe(string.Format("{0}, ATO, failed", name));
}
private void ActiveCycleWork(TimeSpan time)
{
_timer.Update(time);
if (!_timer.Passed)
{
return;
}
_timer.Reset();
if (Owner.Core < Owner.CoreUseHandler.CoreMinimum)
{
Owner.CoreUseHandler.ToWarmUpState();
return;
}
Owner.CoreUseHandler.EnergyState = PBSEnergyState.active;
if (Owner.IsFullyConstructed() && Owner.OnlineStatus)
{
OnActiveCycle();
}
}
public void Update(TimeSpan time)
{
_plantsTimer.Update(time);
if (!_plantsTimer.Passed)
{
return;
}
_plantsTimer.Reset();
if (Interlocked.CompareExchange(ref _isInProcess, 1, 0) == 1)
{
return;
}
Task.Run(() => ProcessPlants()).ContinueWith(t =>
{
_isInProcess = 0;
_stopSignal = false;
});
}
protected override void OnUpdate(TimeSpan time)
{
base.OnUpdate(time);
_probingInterval.Update(time);
if (!_probingInterval.Passed)
{
return;
}
_probingInterval.Reset();
if (IsActive)
{
//detect
var robotsNearMe = GetNoticedUnits();
//do something
OnUnitsFound(robotsNearMe);
}
}
private void UpdateExpiredMissions(TimeSpan time)
{
_missionExpireTimer.Update(time);
if (!_missionExpireTimer.Passed)
{
return;
}
_missionExpireTimer.Reset();
if (!_expireInProgress)
{
_expireInProgress = true;
Task.Run(() =>
{
MissionExpireCycle();
_expireInProgress = false;
}).LogExceptions();
}
}
private void UpdateExpiredBonus(TimeSpan time)
{
_missionBonusExpireTimer.Update(time);
if (!_missionBonusExpireTimer.Passed)
{
return;
}
_missionBonusExpireTimer.Reset();
if (!_bonusInProgress)
{
_bonusInProgress = true;
Task.Run(() =>
{
CheckBonusExpire();
_bonusInProgress = false;
}).LogExceptions();
}
}
