public DelayedAction(Action action, TimeSpan durationToWaitTillExecution) { _threadLock = new object(); _action = action; _waitDuration = durationToWaitTillExecution; _waitState = WaitState.Idle; }
public void Activate() { Active = true; StartingTile = GetComponent <TileOccupier>().GetOccupiedTile(); Engine.MapCursor.X = GetComponent <TileOccupier>().X; Engine.MapCursor.Y = GetComponent <TileOccupier>().Y; Engine.MapCursor.GoToTile(); Engine.MapCursor.Show(); MovePoints = 1; ActPoints = 1; KO k = GetComponent <KO>(); if (k != null) { k.Counter--; } CombatUnit c = GetComponent <CombatUnit>(); if (!c.Guest && !c.Enemy) { Engine.CameraManager.SetTargetPosition(transform.position, .5f); } WaitState = WaitState.None; Engine.AssignControl(this); }
private void ExecuteAction() { TimeSpan durationToSleep = TimeSpan.Zero; lock (_threadLock) { if (_lastPing.TimeElapsed() < _waitDuration) { durationToSleep = _waitDuration.Subtract(DateTime.Now.Subtract(_lastPing)); if (durationToSleep.TotalMilliseconds < 0) { durationToSleep = TimeSpan.Zero; } } } if (durationToSleep == TimeSpan.Zero) { try { _action(); } finally { _waitState = WaitState.Idle; } } else { System.Threading.Thread.Sleep(durationToSleep); Tools.Threads.QueueAction(ExecuteAction); } }
public virtual async Task OptimisticConcurrencyCheck() { // Simulates a state in which two read models have been loaded to memory // and each is updated independently. The read store should detect the // concurrent update, reload the read model and apply the updates once // again. // A decorated DelayingReadModelDomainEventApplier is used to introduce // a controlled delay and a set of AutoResetEvent is used to ensure // that the read store is in the desired state before continuing using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10))) { // Arrange var id = ThingyId.New; var waitState = new WaitState(); await PublishPingCommandsAsync(id, 1, cts.Token).ConfigureAwait(false); // Arrange _waitStates[id.Value] = waitState; var delayedPublishTask = Task.Run(() => PublishPingCommandsAsync(id, 1, cts.Token), cts.Token); waitState.ReadStoreReady.WaitOne(TimeSpan.FromSeconds(10)); _waitStates.Remove(id.Value); await PublishPingCommandsAsync(id, 1, cts.Token).ConfigureAwait(false); waitState.ReadStoreContinue.Set(); await delayedPublishTask.ConfigureAwait(false); // Assert var readModel = await QueryProcessor.ProcessAsync(new ThingyGetQuery(id), cts.Token).ConfigureAwait(false); readModel.PingsReceived.Should().Be(3); } }
public OutputDataPort Progress; // Value from [0,1], where 0 is at reset time, and 1 when reaching Duration private Execution CheckCompletion <TCtx>(TCtx ctx, ref WaitState state, bool ForceUpdate, Execution running) where TCtx : IGraphInstance { Execution Result = running; float duration = ctx.ReadFloat(Duration); if (state._elapsed >= duration) { state._elapsed = duration; Result = Execution.Done; } if ((ForceUpdate) || (Result == Execution.Done)) { // Write outputs ctx.Write(Elapsed, state._elapsed); ctx.Write(Progress, duration > 0f ? state._elapsed / duration : 1f); ctx.Trigger(Output); } // If we are transitionning from running -> Done, Trigger Done if ((running == Execution.Running) && (Result == Execution.Done)) { ctx.Log("NodeId.StopWatch Done Trigger"); ctx.Trigger(Done); state._elapsed = 0; } return(Result); }
protected override void GenerateMethod(Node node, StreamWriter stream, string indent) { base.GenerateMethod(node, stream, indent); WaitState waitState = node as WaitState; if (waitState == null) { return; } if (waitState.Time != null) { stream.WriteLine("{0}\t\tprotected override double GetTime(Agent pAgent)", indent); stream.WriteLine("{0}\t\t{{", indent); string retStr = RightValueCppExporter.GenerateCode(waitState.Time, stream, indent + "\t\t\t", string.Empty, string.Empty, "Time"); if (!waitState.Time.IsPublic && (waitState.Time.IsMethod || waitState.Time.Var != null && waitState.Time.Var.IsProperty)) { retStr = string.Format("Convert.ToDouble({0})", retStr); } stream.WriteLine("{0}\t\t\treturn {1};", indent, retStr); stream.WriteLine("{0}\t\t}}", indent); } }
public FSM_GameSystem(int fsmID) : base(fsmID) { //create State //Init InitState state_Init = new InitState((int)GameSystemState_ID.Init); state_Init.Initialize(this, null, () => { }); //Ready ReadyState state_Ready = new ReadyState((int)GameSystemState_ID.Ready); state_Ready.Initialize(this, null, () => { }); //SpawnNewBlock SpawnNewBlockState state_SpawnNewBlock = new SpawnNewBlockState((int)GameSystemState_ID.SpawnNewBlock); state_SpawnNewBlock.Initialize(this, null, () => { }); //Wait WaitState state_Wait = new WaitState((int)GameSystemState_ID.Wait); state_Wait.Initialize(this, null, () => { }); //JudgeEliminate JudgeEliminateState state_JudgeEliminate = new JudgeEliminateState((int)GameSystemState_ID.JudgeEliminate); state_JudgeEliminate.Initialize(this, null, () => { }); //Eliminate EliminateState state_Eliminate = new EliminateState((int)GameSystemState_ID.Eliminate); state_Eliminate.Initialize(this, null, () => { }); }
/// <summary> /// Acquires a lock. /// </summary> /// <param name="newState">state to set</param> /// <param name="force">if true, don't wait for the lock but take it. This can be a risk!</param> private void setLock(WaitState newState,bool force) { if (force) { m_state = newState; return; } while (true) { try { Monitor.Enter(m_todo); if (m_state == WaitState.NULL) { m_state = newState; return; } } finally { Monitor.Exit(m_todo); } Thread.Sleep(100); } }
void Awake() { waitState = new WaitState(this); lookForState = new LookForState(this); searchState = new SearchState(this); navMeshAgent = GetComponent <NavMeshAgent> (); }
/// <summary> /// Release the acquired lock. /// </summary> private void releaseLock() { try { Monitor.Enter(m_todo); m_state = WaitState.NULL; } finally { Monitor.Exit(m_todo); } if (m_todo.Count > 0) { AsyncEventDetail e; try { Monitor.Enter(m_todo); e = m_todo[0]; m_todo.Remove(e); } finally { Monitor.Exit(m_todo); } executeAsyncEvent(e); } }
// Start is called before the first frame update void Start() { var waitState = new WaitState(); waitState.minWait = 1; ChangeState(waitState); }
public override int Visit(WaitState waitState) { _currentContext.AssertIsValidInputPath(waitState.InputPath); _currentContext.AssertIsValidOutputPath(waitState.OutputPath); ValidateTransition(waitState.Transition); ValidateWaitFor(waitState.WaitFor); return(0); }
public void DoMove() { GetComponent <Mover>().PreparePath(TargetTile); GetComponent <Mover>().PlayForward(); WaitState = WaitState.Resolving; Engine.PathManager.ClearAll(false); Invoke("DoneMoving", GetComponent <Mover>().MoveTime()); }
public void SetCurStatu(bool isEnd, bool isWin = false) { if (item == null || item.Name == null) { return; } EnterIcon.spriteName = (isWin) ? "Ty_Legion_Shengli" : "Ty_Legion_Taotai"; EnterIcon.gameObject.CustomSetActive(isEnd); WaitState.CustomSetActive(!isEnd); }
void MemberWritten(string name = null, string value = null) { if (name != null) { m_namesStack.Push(name); } //Debug.LogWarning(name + "=" + value + "|" + m_state + ">>" + (m_memberEnum.Current != null ? m_memberEnum.Current.Name : "")); switch (m_state) { case WaitState.WaitForMembers: { m_memberEnum.MoveNext(); IGenericMemberAcessor l_enumerationMember = m_memberEnum.Current; object l_createdObject = System.Activator.CreateInstance(l_enumerationMember.Type); OnFlush = () => { l_enumerationMember.Value = l_createdObject; }; if (l_createdObject is IGenericMemberAccessorCollection) { m_memberEnum = (l_createdObject as IGenericMemberAccessorCollection).Members.GetEnumerator(); } m_memberEnum.MoveNext(); m_state = WaitState.Field; } break; case WaitState.Field: { Debug.Log("Wait for field : " + name); m_latestName = name; m_state = WaitState.Value; } break; case WaitState.Value: { if (m_latestName == m_memberEnum.Current.Name) { object o = null; m_memberEnum.Current.Value = o = Convert.ChangeType(value, m_memberEnum.Current.Type); //Debug.LogError("set value :: " + o); m_memberEnum.MoveNext(); } m_state = WaitState.Field; } break; } }
public void Save(WorldManager.SaveCallback callback = null) { Paused = true; var waitforsave = new WaitState(Game, "Saving...", () => SaveThreadRoutine()); if (callback != null) { waitforsave.OnFinished += (bool b, WaitStateException e) => callback(b, e); } GameStateManager.PushState(waitforsave); }
public void Ping() { lock (_threadLock) { _lastPing = DateTime.Now; if (_waitState == WaitState.Idle) { _waitState = WaitState.Waiting; Tools.Threads.QueueAction(ExecuteAction); } } }
//private bool requestedPause = false; /// <summary> /// Runs only once at the start of the state. /// </summary> protected override void Enter() { // Reset flow control waitState = WaitState.Waiting; // Reset flags gm.StartEnable = false; gm.StopHUDCountDown(); counting = false; //requestedPause = false; base.Enter(); }
protected override FSM BuildStateMachine() { STATE_MOVING = new FSM.State(OnMovingUpdate, OnMovingEnter) { Name = "Moving" }; STATE_TURNING = new WaitState(TurnTime, STATE_MOVING) { Name = "Turning", OnExit = OnTurningExit }; return(new FSM(STATE_MOVING)); }
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className) { base.GenerateConstructor(node, stream, indent, className); WaitState waitState = node as WaitState; if (waitState == null) { return; } stream.WriteLine("{0}\t\t\tm_ignoreTimeScale = {1};", indent, waitState.IgnoreTimeScale ? "true" : "false"); }
/// <summary> /// Resets internal state. /// </summary> public void reset() { if (m_todo != null) { m_todo.Clear(); } if (m_ovpnMParser != null) { m_ovpnMParser.reset(); } m_state = WaitState.NULL; m_releaselock = true; }
protected override void GenerateMember(Node node, StreamWriter stream, string indent) { base.GenerateMember(node, stream, indent); WaitState waitState = node as WaitState; if (waitState == null) { return; } if (waitState.Time != null) { RightValueCppExporter.GenerateClassMember(waitState.Time, stream, indent, "Time"); } }
protected override void GenerateConstructor(Node node, StreamWriter stream, string indent, string className) { base.GenerateConstructor(node, stream, indent, className); WaitState waitState = node as WaitState; if (waitState == null) { return; } if (waitState.Time != null) { RightValueCppExporter.GenerateClassConstructor(node, waitState.Time, stream, indent, "Time"); } }
protected override void Start() { base.Start(); WaitState waitState = new WaitState(this, 0.5f); GeneralMoveState moveState = new GeneralMoveState(this, startPos, endPos, 2f, LeanTweenType.easeInOutSine); Transition waitToMove = new Transition(waitState, moveState, () => waitState.isFinished); Transition moveToWait = new Transition(moveState, waitState, () => moveState.isFinished); AddState("wait", waitState); AddState("move", moveState); SetStartState(waitState); transitions.Add(waitToMove); transitions.Add(moveToWait); // Transition transition = new Transition(locateIdleState, null, () => // ); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var obj = JObject.Load(reader); var type = obj["Type"].Value <string>(); State.IBuilder <State> result = null; switch (Enum.Parse(typeof(StateType), type)) { case StateType.Choice: result = ChoiceState.GetBuilder(); break; case StateType.Fail: result = FailState.GetBuilder(); break; case StateType.Parallel: result = ParallelState.GetBuilder(); break; case StateType.Pass: result = PassState.GetBuilder(); break; case StateType.Succeed: result = SucceedState.GetBuilder(); break; case StateType.Task: result = TaskState.GetBuilder(); break; case StateType.Wait: result = WaitState.GetBuilder(); break; case StateType.Map: result = MapState.GetBuilder(); break; } serializer.Populate(obj.CreateReader(), result); return(result); }
protected override FSM BuildStateMachine() { STATE_SHOOT_ONE = new WaitState(shootingTime) { OnExit = Shoot, }; STATE_MOVING_TO = new WaitState(movingTime, STATE_SHOOT_ONE) { OnEnter = OnMovingToEnter, OnExit = OnMovingToExit }; STATE_SHOOT_ONE.NextState = STATE_MOVING_TO; return(new FSM(STATE_NO_ACTION)); }
private void Awake() { idleState = new IdleState(this); patrolState = new PatrolSate(this); chaseState = new ChaseState(this); attackState = new AttackState(this); waitState = new WaitState(this); searchState = new SearchState(this); alertState = new AlertState(this); protectState = new ProtectState(this); stunnedState = new StunnedState(this); //For color testing auxMesh = GetComponent <MeshRenderer>(); // playerDetection = GetComponent <PlayerDetection>(); attackRange = playerDetection.attackRadius; }
protected override FSM BuildStateMachine() { STATE_MOVING = new FSM.State(OnMovingUpdate) { Name = "Moving", OnExit = StopCar }; STATE_AIMING = new TimedState(3.0f, OnAimUpdate) { Name = "Aiming", OnEnter = StartAiming }; STATE_SHOOTING = new WaitState(2, STATE_MOVING) { Name = "Shooting", OnEnter = Shoot, OnExit = SelectRandomDirection }; return(new FSM(STATE_NO_ACTION)); }
// Constructor public RecruitmentPattern(Unit unit) { _unit = unit; waitBehavior = new WaitBehavior(_unit); seekBehavior = new SeekBehavior(_unit); pursuitBehavior = new PursuitBehavior(_unit); waitState = new WaitState(this, waitBehavior); followLeaderState = new FollowLeaderState(this, seekBehavior); holdPositionState = new HoldPositionState(this, waitBehavior); defendPositionState = new DefendPositionState(this, pursuitBehavior); attackEnemyState = new AttackEnemyState(this, pursuitBehavior); attackTargetState = new AttackLeaderTargetState(this, seekBehavior); workState = new WorkState(this, waitBehavior); currentState = waitState; }
public override void _Ready() { cannon = GetNode <Position2D>("Cannon"); animationPlayer = GetNode <AnimationPlayer>("AnimationPlayer"); bulletCaseParticle = GetNode <CPUParticles2D>("BulletCaseParticle"); shootSound = GetNode <AudioStreamPlayer2D>("ShootAudioPlayer"); STATE_READY = new FSM.State(WeaponReadyUpdate) { Name = "Ready" }; STATE_TIMEOUT = new WaitState(TimeoutDuration, STATE_READY) { Name = "Reloading" }; machine = new FSM(STATE_READY); }
private void cmdExport_Click(object sender, EventArgs e) { Uri collectionUri = new Uri(txtCollectionUri.Text); string teamProject = txtTeamProject.Text; SaveFileDialog dlg = new SaveFileDialog(); dlg.CheckPathExists = true; dlg.Title = "Export Area/Iteration structure"; dlg.DefaultExt = ".nodes"; dlg.Filter = "TFS Node Structure (*.nodes)|*.nodes"; if (dlg.ShowDialog(this) == DialogResult.OK) { string filename = dlg.FileName; var networkCredential = new NetworkCredential("username", "password"); var basicAuthCredential = new BasicAuthCredential(networkCredential); var tfsCredential = new TfsClientCredentials(basicAuthCredential); using(var tfs = new TfsTeamProjectCollection(collectionUri, tfsCredential)) //using (var tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(collectionUri)) using (WaitState waitState = new WaitState(this)) { tfs.Authenticate(); tfs.EnsureAuthenticated(); // get the configuration server var svr = tfs.ConfigurationServer; // get the configuration service var svc = tfs.GetService<TeamSettingsConfigurationService>(); // get the common structure service var css = tfs.GetService<ICommonStructureService4>(); // get the spotlabs project var prj = css.GetProjectFromName(txtTeamProject.Text); // get the configurations var cfg = svc.GetTeamConfigurationsForUser(new[] { prj.Uri }).Single<TeamConfiguration>(); // get the settings var opt = cfg.TeamSettings; // get the iteration schedule var schedule = css.GetIterationDates(prj.Uri); Console.WriteLine(opt.ToString()); var store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore)); var proj = store.Projects[teamProject]; using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write)) using (StreamWriter writer = new StreamWriter(fs)) { writer.WriteLine("NODES"); writer.WriteLine(String.Format("{0}, Version {1}", Application.ProductName, Application.ProductVersion)); writer.WriteLine("Copyright (C) 2010 " + Application.CompanyName); if (chkAreaStructure.Checked) { WriteNodes(proj.AreaRootNodes, writer, "A"); } if (chkIterationStructure.Checked) { WriteNodes(proj.IterationRootNodes, writer, "I"); } writer.Close(); } } MessageBox.Show("Export successful."); } }
protected bool readBytes( NetworkStream ns, MemoryStream response, String waitFor, bool machresponseend ) { bool error = false; byte[] readBytes = new byte[client.ReceiveBufferSize]; int nbytes = 0; String lastBoundary = System.String.Empty; WaitState state = new WaitState(true); Timer aTimer = new System.Threading.Timer(new TimerCallback(this.StopWaiting), state, Timeout.Infinite, Timeout.Infinite); if ( log.IsDebugEnabled ) log.Debug ( "Reading response" ); // We wait until data is available but only if Stream is open // We setup a timer that stops the loop after x seconds for ( aTimer.Change(this.timeoutResponse, Timeout.Infinite); !error && ns.CanRead && ns.CanWrite && !ns.DataAvailable && state.Status; ){Thread.Sleep(50);} state.Status = true; // If I can read from NetworkStream and there is // some data, I get it for ( aTimer.Change(this.timeoutResponse, Timeout.Infinite); !error && ns.CanRead && state.Status && (ns.DataAvailable || !(lastBoundary.Equals(waitFor)) ) ; nbytes = 0) { try { if ( ns.DataAvailable ) { #if MONO // Reinitialize buffer to make mono happy readBytes = new byte[client.ReceiveBufferSize]; #endif nbytes = ns.Read( readBytes, 0, client.ReceiveBufferSize ); } else Thread.Sleep(50); } catch ( Exception e ) { error = true; nbytes = 0; lastErrorMessage = "Read error"; if ( log.IsErrorEnabled ) log.Error ( lastErrorMessage, e ); } if ( !error && nbytes>0 ) { if ( log.IsDebugEnabled ) log.Debug ( "Read " + nbytes + " bytes" ); response.Write( readBytes, 0, nbytes ); // Only test waitfor secuence if there is no data for reading // and there are enouth data available for comparing if ( !ns.DataAvailable && response.Length>waitFor.Length ) { // The waitfor text must be the last portion of the response if ( machresponseend ) { response.Seek(response.Length - waitFor.Length, SeekOrigin.Begin); response.Read(readBytes, 0, waitFor.Length); lastBoundary = Encoding.ASCII.GetString(readBytes, 0, waitFor.Length); // The waitfor text must be in the begining of the last line of the response } else { response.Seek(0, SeekOrigin.Begin); StreamReader reader = new StreamReader(response); String line = System.String.Empty; for ( System.String tmp=reader.ReadLine(); tmp!=null ; line=tmp, tmp=reader.ReadLine() ) {} if ( line!=null && line.Length>=waitFor.Length ) lastBoundary = line.Substring(0, waitFor.Length); reader.DiscardBufferedData(); reader=null; response.Seek (0, SeekOrigin.End); } } // Reset timer aTimer.Change(this.timeoutResponse, Timeout.Infinite); state.Status = true; } } response.Flush(); if ( log.IsDebugEnabled ) log.Debug ( String.Concat("Reading response finished. Error: ", error) ); // Discard response if there has been a read error. if ( error ) response.SetLength(0); else if ( response.Length==0 ) error = true; return !error; }
/// <summary> /// Resets internal state. /// </summary> public void reset() { m_pkcs11count = 0; if(m_pkcs11details != null) m_pkcs11details.Clear(); if(m_todo != null) m_todo.Clear(); if (m_ovpnMParser != null) m_ovpnMParser.reset(); m_state = WaitState.NULL; m_releaselock = true; }
/// <summary> /// Acquires a lock. /// </summary> /// <param name="newState">state to set</param> /// <param name="force">if true, don't wait for the lock but take it. This can be a risk!</param> private void setLock(WaitState newState, bool force) { if (force) { m_state = newState; return; } while (true) { try { Monitor.Enter(m_todo); if (m_state == WaitState.NULL) { m_state = newState; return; } } finally { Monitor.Exit(m_todo); } Thread.Sleep(100); } }
/// <summary> /// Acquires a lock. Waits, until the lock is possible. /// </summary> /// <param name="newState">state to set</param> private void setLock(WaitState newState) { setLock(newState, false); }
/// <summary> /// Resets internal state. /// </summary> public void reset() { m_logs.logDebugLine(5, "resetting logic"); m_pkcs11count = 0; if (m_pkcs11details != null) m_pkcs11details.Clear(); if (m_todo != null) m_todo.Clear(); if (m_ovpnMParser != null) m_ovpnMParser.reset(); m_state = WaitState.NULL; m_releaselock = true; }
private void cmdImport_Click(object sender, EventArgs e) { Uri collectionUri = new Uri(txtCollectionUri.Text); string teamProject = txtTeamProject.Text; OpenFileDialog dlg = new OpenFileDialog(); dlg.CheckFileExists = true; dlg.Title = "Import Area/Iteration structure"; dlg.DefaultExt = ".nodes"; dlg.Filter = "TFS Node Structure (*.nodes)|*.nodes"; if (dlg.ShowDialog(this) == DialogResult.OK) { string filename = dlg.FileName; var networkCredential = new NetworkCredential("username", "password"); var basicAuthCredential = new BasicAuthCredential(networkCredential); var tfsCredential = new TfsClientCredentials(basicAuthCredential); using (var tfs = new TfsTeamProjectCollection(collectionUri, tfsCredential)) //using (var tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(collectionUri, new UICredentialsProvider())) using (WaitState waitState = new WaitState(this)) { tfs.Authenticate(); tfs.EnsureAuthenticated(); WorkItemStore store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore)); Project proj = store.Projects[teamProject]; NodeInfo rootAreaNode = null; NodeInfo rootIterationNode = null; var css = (ICommonStructureService4)tfs.GetService(typeof(ICommonStructureService4)); foreach (NodeInfo info in css.ListStructures(proj.Uri.ToString())) { if (info.StructureType == "ProjectModelHierarchy") { rootAreaNode = info; } else if (info.StructureType == "ProjectLifecycle") { rootIterationNode = info; } } using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read)) using (StreamReader reader = new StreamReader(fs)) { string nextLine = reader.ReadLine(); if (nextLine != "NODES") { MessageBox.Show("Wrong file format!"); return; } reader.ReadLine(); reader.ReadLine(); while (!reader.EndOfStream) { nextLine = reader.ReadLine(); if (nextLine.StartsWith("A") && chkAreaStructure.Checked) { CreateNode(css, nextLine.Substring(2), rootAreaNode); } else if (nextLine.StartsWith("I") && chkIterationStructure.Checked) { CreateNode(css, nextLine.Substring(2), rootIterationNode); } else { // Ignore other lines } } reader.Close(); } MessageBox.Show("Import successful."); } } }
protected Coroutine Start() { mState = WaitState.Run; return WaitHelp.Instance.StartCoroutine(this); }