/// <summary> /// /// </summary> /// <returns>Returns true if the current processing stage should break</returns> private bool CheckForNewActionToInit() { if (this._pendingAction == null) { IPipelineAction actionToBegin = null; // Don't hold the lock any longer than necessary. lock (this._queueLock) { if (this._actionQueue.Count == 0) { this.Stop(); return true; } actionToBegin = this._actionQueue.Dequeue(); } if (actionToBegin.RequiresExplicitVTState) { // Support VT on/off toggling. The cached scope will not be null when rolling over from a previous action. // In that case, if multiple actions were queued up and both want VT disabled, don't bother turning it back on in between. if (this._cachedVTRunScope != null) { // The next action wants a different VTState, so we need to dispose of the current one if (this._cachedVTRunScope.DesiredState != actionToBegin.DesiredVTRunState) { this._cachedVTRunScope.Dispose(); this._cachedVTRunScope = null; } } // If we get here and the sached VT scope is null, it means we need to initialize it if (this._cachedVTRunScope == null) { this._cachedVTRunScope = VTRunScope.Enter(actionToBegin.DesiredVTRunState); } } actionToBegin.Init(); this._pendingActionNeedsBegun = true; // If we get this far without any exceptions, then store the action as the pending action. // If any exceptions happen before this, we want to make sure we are not stuck in some state where we are waiting // on a bugged action to finish this._pendingAction = actionToBegin; // Don't Begin invoke on the same cycle as init return true; } // We didn't do anything return false; }
private bool CheckForActionToBegin() { if (this._pendingAction != null && this._pendingActionNeedsBegun) { if (this._pendingAction.RequireIdleToPerform && REPlugin.Instance.MonitorManager.CharacterState.Busy.WaitOne(0)) { // Can't begin invoke yet because this action wants us to wait until we are idle to invoke return true; } if (!_pendingAction.Ready()) { // The action has said that for some reason it is not ready to be performed yet. return true; } try { // First begin invoke the action this._pendingAction.Perform(); this._backgroundDispatcher.EnqueueAction(this._pendingAction.WaitForOutcome); return true; } catch { // If we hit an exception, we don't want to leave VT in an undesired state. That could lead to a bot getting killed or something if (this._cachedVTRunScope != null) { this._cachedVTRunScope.Dispose(); this._cachedVTRunScope = null; } // If any exceptions, need to reset our state. this._pendingAction = null; this._backgroundAction = null; throw; } finally { this._pendingActionNeedsBegun = false; } } // We didn't do anything return false; }
private void DisposeOfVTScopeIfEmptyQueue(bool forceDispose) { if (this._cachedVTRunScope != null) { if (forceDispose || this.QueueCount == 0) { this._cachedVTRunScope.Dispose(); this._cachedVTRunScope = null; } } }