public void CompositeStateTest() { var sm = new StateMachine(); var s0 = CreateState("0"); var s0States = new StateCollection(); s0.ParallelSubStates.Add(s0States); sm.States.Add(s0); var s00 = CreateState("00"); s0States.Add(s00); var s01 = CreateState("01"); s0States.Add(s01); var t0 = new Transition { SourceState = s0, TargetState = s0, }; t0.Action += (s, e) => _events = _events + "A0"; sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); t0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0E00U00U0U00U0X00X0A0E0E00U00U0U00U0", _events); }
/// <summary> /// Updates the GameObject state. /// </summary> /// <param name="gameTime"></param> internal virtual void Update(GameTime gameTime) { if (_isKilled) { return; } this.GameTime = new GameTimeWrapper(gameTime); StateMachine?.Update(); ForEachBehavior(b => b.Update()); this.Renderer?.Update(); if (_isKilled) { DoKill(true); } }
private void Update() { _stateMachine?.Update(); #if DEBUGGER if (_stateMachine != null) { Debugger.Default.Display("Current State", _stateMachine.CurrentState.ToString()); } Debugger.Default.Display("Active Users", _context.Db.CountActive()); if (_context != null && _context.Company != null) { var company = _context.Company; Debugger.Default.Display("Company/Balance", company.Balance); Debugger.Default.Display("Company/Balance/+ $1000", () => company.Balance += 1000); Debugger.Default.Display("Company/Balance/- $1000", () => company.Balance -= 1000); Debugger.Default.Display("Company/Level", company.Level); Debugger.Default.Display("Company/Expenses", company.Expenses); Debugger.Default.Display("Company/ExpensesTimer/Duration", company.ExpensesTimer.Duration); Debugger.Default.Display("Company/ExpensesTimer/TimeRemaining", company.ExpensesTimer.TimeRemaining); Debugger.Default.Display("Company/Specials", company.Specials); foreach (var param in company.Params) { Debugger.Default.Display($"Company/Params/{param.Key}", param.Value); } Debugger.Default.Display($"Company/Flags", string.Join(", ", company.Flags)); var contract = company.ActiveContract; if (contract != null) { Debugger.Default.Display("Contract/Name", contract.Info.Name); Debugger.Default.Display("Contract/Reward", contract.Info.Reward); Debugger.Default.Display("Contract/Difficulty", contract.Info.TotalDifficulty); Debugger.Default.Display("Contract/TimeRemaining", contract.WorkVotingState.TimeRemaining); } } #endif }
/// <summary> /// Update this instance. /// </summary> void Update() { stateMachine.Update(); if (Input.GetKeyDown(KeyCode.S)) { stateMachine.ChangeState("Break"); } if (Input.GetKeyDown(KeyCode.Space)) { if (running) { stateMachine.ChangeState(stateMachineWalkHash); } else { stateMachine.ChangeState(stateMachineRunHash); } running = !running; } }
void FixedUpdate() { fixedUpdateCount++; StateMachine.Update(); if (StateMachine.State == StSwing) { if (positionChanged) { // Set the transform to the new position GetComponent <Transform>().position = newPosition; } // Update the line render endpoints at the end of each step LineRender.GetComponent <LineRenderer>().SetPositions(lineRenderEndpoints); Debug.Log("Swing force: " + SwingForce + " " + "MoveForce: " + MoveForce); rb.AddForce(SwingForce); } rb.AddForce(Vector2.right * MoveForce); var clampedVelocity = new Vector2(Mathf.Clamp(rb.velocity[0], -MaxRunSpeed, MaxRunSpeed), rb.velocity[1]); rb.velocity = clampedVelocity; }
protected override void Update() { if (GameManager.GM.CurrentSate == GameManager.GameState.Playing) { base.Update(); _isGrounded = (Physics2D.Linecast(GroundCheckOrigin.position, GroundCheckMid.position, GroundLayerMask)); attackTimer += Time.deltaTime; if (aggroLeashTimer < aggroLeashDuration) { aggro = true; aggroLeashTimer += Time.deltaTime; } else { SetAggro(false); } //keep this last in the update stateMachine.Update(); } }
// Update is called once per frame void Update() { stateMachine.Update(); if (TimerUtil.Timer <= 0) { stateMachine.SetCurrentState(EnumState.FailGame); } if (Input.GetKeyDown(KeyCode.Space) && stateMachine.CurrentState != EnumState.Idle) { if (stateMachine.CurrentState != EnumState.PauseGame) { stateMachine.SetCurrentState(EnumState.PauseGame); Cursor.lockState = CursorLockMode.None; } else { stateMachine.SetCurrentState(EnumState.StartGame); Cursor.lockState = CursorLockMode.Locked; } } }
public void Update() { hitWall = Physics2D.Raycast(this.transform.position, this.transform.right * direction, detectWall - deltaSize, wallLayer); Debug.DrawRay(this.transform.position, this.transform.right * direction * (detectWall - deltaSize), Color.red); if (hitWall) { Rotate(); } hitPlayer = Physics2D.Raycast(this.transform.position, this.transform.right * direction, detectPlayer - deltaSize, playerLayer); Debug.DrawRay(this.transform.position, this.transform.right * direction * (detectPlayer - deltaSize), Color.blue); if (hitPlayer && !isChasing) { isChasing = true; isIdling = false; } if (Input.GetKeyDown(KeyCode.V)) { Rotate(); } stateMachine.Update(); }
private void SetupMain() { float time = 0; sm .State("idle") .Reset() .OnEntry(() => time = Time.time) .Condition(() => Time.time - time >= 3, "patrol") .State("patrol") .OnEntry(() => { // find the nearest patrol check point subsm.Reset("decide"); _patrolIndex = PatrolCheckPoints.FindMinIndex(p => Vector3.Distance(p, transform.position)); _moveTo = _patrolIndex != -1 ? PatrolCheckPoints[_patrolIndex] : transform.position; }) .OnState(() => subsm.Update()) .State("attack") .State("retreat") .State("heal") ; }
public void TestSmallTransitionLoop() { var runs = 0; var machine = new StateMachine(); var state1 = new ActionState { Enter = () => runs++ }; var state2 = new ActionState { Enter = () => runs++ }; machine.AddTransition(DefaultState.Enter, state1); machine.AddTransition(state1, state2); machine.AddTransition(state2, state1); machine.Update(0); Assert.AreEqual(2, runs, double.Epsilon); }
// Update is called once per frame void Update() { if (isPlaying(anim, "Attack1")) { isAttack = true; if (weaponHitbox != null) { weaponHitbox.SetActive(true); } } else { isAttack = false; attackCounter = 0; if (weaponHitbox != null) { weaponHitbox.SetActive(false); } } //if (isDead) //stateMachine.ChangeState(new StateMove(this.gameObject)); //else if (!isDead) { stateMachine.ChangeState(input.CheckInputNotMove()); } if (!isDead) { stateMachine.Update(); } if (myStats.health <= 0 && !isDead) { isDead = true; Die(); } }
// Update is called once per frame void Update() { FindClosestPlayer(); //For multiplayer will have to check for closets player stateMachine.Update(); if (CanMove) Move(); Vector3 headDirection = Firing.GetHeadDirection(); Vector3 pos = transform.position; if (!CheckShot(pos, headDirection * MaxVisionDistance, 0, MaxVisionDistance)) { Firing.SetIsShooting(false); Vector3 playerPos = TargetedPlayer.transform.position; Vector3 direction = playerPos - pos; //if can see player with direct line bool canSeePlayer = Physics.Raycast(pos, direction, out RaycastHit objectHit, MaxVisionDistance) && objectHit.collider.CompareTag("Player"); if (canSeePlayer) { //move head towards player Firing.RotateHead(playerPos); } else { if(FindShot(direction)) Firing.RotateHead(ShootDirection); } } else { Firing.SetIsShooting(true); } }
// Update is called once per frame void Update() { sm.Update(); if (lastPos != Vector3.zero) { var distance = Vector3.Distance(lastPos, transform.position); //Debug.Log(distance); var _forwardAngle = Mathf.Min(distance * 300, 30); var newRot = Quaternion.AngleAxis(_forwardAngle, Vector3.right); transform.rotation = Quaternion.RotateTowards(transform.rotation, newRot, 2); } lastPos = transform.position; //if (subsm.Current.Name == "moveTo") //{ // Debug.Log("moveTO " + _forwardAngle); // if (_forwardAngle <= 20) // { // _forwardAngle = Mathf.Min(_forwardAngle + 10 * Time.deltaTime, 20); // var newRot = Quaternion.AngleAxis(_forwardAngle, Vector3.right); // transform.rotation = Quaternion.RotateTowards(transform.rotation, newRot, 2); // } //} //else //{ // if (_forwardAngle > 0) // { // _forwardAngle = Mathf.Max(_forwardAngle - 10*Time.deltaTime, 0); // var newRot = Quaternion.AngleAxis(_forwardAngle, Vector3.right); // transform.rotation = Quaternion.RotateTowards(transform.rotation, newRot, 2); // } //} }
protected override void OnUpdate() { base.OnUpdate(); m_systems.Execute(); m_systems.Cleanup(); SystemStateTransitionEvent e = null; if (m_procedureStateMachine != null) { e = EventRoute.TakeEvent <SystemStateTransitionEvent>(); } m_procedureStateMachine?.Update(); EventRoute.ClearOutOfDateEvents(); if (e != null) { m_procedureStateMachine.FireEvent(e.transition, e.eventArg); } }
void Update() { if (PauseGame.IsPaused() || GameManager.CurrentState is CinematicState) { return; } Move(); movementMachine.Update(); movementMachine.GetState <PlayerDashState>().Cooldowns(); CheckIfInBounds(); if (Time.time - lastDamagedTime >= RegenTime && !(movementMachine.CurrentState is PlayerDeathState) && CurrentHP < MaxHP) { lifeTickTimer += Time.deltaTime; if (lifeTickTimer >= LifeTick) { CurrentHP++; lifeTickTimer -= LifeTick; } } }
public override void UpdateTurn() { base.UpdateTurn(); m_stateMachine.Update(); if (m_stateMachine.CurrentStateID == EState.WAITING && Controller.ViewIsDone.IsTriggered) { m_stateMachine.ChangeState(EState.IDLE); } if (m_stateMachine.CurrentStateID == EState.IDLE) { if (m_path.Count > Brain.Data.Range && Move(m_path)) { m_stateMachine.ChangeState(EState.MOVEMENT); } else { m_stateMachine.ChangeState(EState.MOVEMENT_DONE); } } else if (m_stateMachine.CurrentStateID == EState.MOVEMENT_DONE) { m_attackBuffer.Clear(); if (m_path.Count <= Brain.Data.Range && Attack(m_attackBuffer)) { m_stateMachine.ChangeState(EState.ATTACKING); } else { m_stateMachine.ChangeState(EState.ATTACKING_DONE); } } else if (m_stateMachine.CurrentStateID == EState.ATTACKING_DONE) { Controller.IsFinishTurn = true; } }
void Update() { if (Input.GetKeyDown(KeyCode.B)) { Toggle(); } fsm.Update(); //if dest state exists if (destinationState != null) { //and we aren't switching if (fsm.currentStateStr != "Switching") { //and our current state isn't our destination if (fsm.currentStateStr != destinationState) { fsm.ChangeState("Switching"); } destinationState = null; } } }
public override void Update() { base.Update(); anim.speed = animSpeed; currentBaseState = anim.GetCurrentAnimatorStateInfo(0); stateMachine.Update(); staminaConsumeUpdate += Time.deltaTime; // If not in idle state and moving, drain stamina, else restore stamina if needed if (staminaConsumeUpdate >= staminaConsumeUpdateRate) { if (stateMachine.CurrentState != HumanMayorRest.Instance && biped.Speed >= 0.1f) { ModStamina(-staminaConsumeRate); } else { ModStamina(staminaRestoreRate); } staminaConsumeUpdate = 0f; } }
void Update() { state_machine.Update(); }
void Update() { _state.Update(); }
// Update is called once per frame void Update() { if (mDead) { return; } mStateMachine.Update(); //character movement { //left if (Input.GetKey(KeyCode.LeftArrow)) { mHorizontal = -1; } else if (Input.GetKey(KeyCode.RightArrow))//right { mHorizontal = 1; } else//not moving left or right { mHorizontal = 0; } //up if (Input.GetKey(KeyCode.UpArrow)) { mVertical = 1; } else if (Input.GetKey(KeyCode.DownArrow))//down { mVertical = -1; } else//not moving up or down { mVertical = 0; } } //check for attack if (mBeamCounter > 0.0f && (mBeamCounter >= mBeamThreshold || (PLAYER_STATES)mStateMachine.GetStateNumber() == PLAYER_STATES.BEAM_ATTACK) && Input.GetKey(KeyCode.Space)) { mStateMachine.ChangeState((int)PLAYER_STATES.BEAM_ATTACK); //mAnimator.SetInteger("state", (int)PLAYER_STATES.BEAM_ATTACK); playBeam(); } else if (mChangeTimer <= 0.0f && Input.GetKey(KeyCode.X)) { mChangeTimer = mChangeDelay; mAnikiState = mAnikiState == ANIKI_STATES.FRONTAL ? ANIKI_STATES.SANDWICH : ANIKI_STATES.FRONTAL; mMarkerOne.Toggle(); mMarkerTwo.Toggle(); mAnikiOne.Toggle(); mAnikiTwo.Toggle(); } else if (Input.GetKey(KeyCode.C)) { mStateMachine.ChangeState((int)PLAYER_STATES.CHARGE); //mAnimator.SetInteger("state", (int)PLAYER_STATES.CHARGE); } else if (Input.GetKey(KeyCode.Z)) { mStateMachine.ChangeState((int)PLAYER_STATES.ATTACK); //mAnimator.SetInteger("state", (int)PLAYER_STATES.ATTACK); if (!mSoundDelay) { playShoot(); } } else { if (mHorizontal == 0 && mVertical == 0) { mStateMachine.ChangeState((int)PLAYER_STATES.IDLE); //mAnimator.SetInteger("state", (int)PLAYER_STATES.IDLE); } else { mStateMachine.ChangeState((int)PLAYER_STATES.MOVE); //mAnimator.SetInteger("state", (int)PLAYER_STATES.MOVE); } } switch ((PLAYER_STATES)(mStateMachine.GetStateNumber())) { case PLAYER_STATES.BEAM_ATTACK: if (mAnikiOne.mHp != 0 || mAnikiTwo.mHp != 0) { mBeamCounter -= mBeamDepletionRate * Time.deltaTime; if (mBeamCounter < 0.0f) { mBeamCounter = 0.0f; } } break; case PLAYER_STATES.CHARGE: mBeamCounter += mBeamChargeRate * Time.deltaTime; if (mBeamCounter > mBeamMax) { mBeamCounter = mBeamMax; } break; default: break; } mChangeTimer -= Time.deltaTime; if (mChangeTimer <= 0.0f) { mChangeTimer = 0.0f; } }
public void TestWithFinalState() { var sm = new StateMachine(); var s0 = CreateState("0"); var s0States = new StateCollection(); s0.ParallelSubStates.Add(s0States); sm.States.Add(s0); var s1 = CreateState("1"); sm.States.Add(s1); var s00 = CreateState("00"); s0States.Add(s00); var s01 = CreateState("01"); s0States.Add(s01); var s02 = CreateState("02"); s0States.Add(s02); // Set final state s0States.FinalState = s02; var t0 = new Transition { SourceState = s0, TargetState = s1, FireAlways = true, }; t0.Action += (s, e) => _events = _events + "A0"; var t0001 = new Transition { SourceState = s00, TargetState = s01, }; t0001.Action += (s, e) => _events = _events + "A0001"; var t0102 = new Transition { SourceState = s01, TargetState = s02, }; t0102.Action += (s, e) => _events = _events + "A0102"; sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); t0001.Fire(); sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); t0102.Fire(); sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0E00U00U0U00U0X00A0001E01U01U0U01U0X01A0102E02U02U0X02X0A0E1U1", _events); }
void Update() { _stateMachine.Update(); }
protected virtual void Update() { _stateMachine.Update(Time.deltaTime); UpdateDirection(); }
private void Update() { MovementMachine.Update(); }
public void IgnoredHistory() { var sm = new StateMachine(); var s0 = CreateState("0"); sm.States.Add(s0); var s1 = CreateState("1"); var s1States = new StateCollection(); s1States.SaveHistory = true; s1.ParallelSubStates.Add(s1States); sm.States.Add(s1); var s10 = CreateState("10"); s1States.Add(s10); var s11 = CreateState("11"); s1States.Add(s11); var s12 = CreateState("12"); s1States.Add(s12); s1States.InitialState = s11; var t0 = new Transition { SourceState = s0, TargetState = s12, }; t0.Action += (s, e) => _events = _events + "A0"; var t1211 = new Transition { SourceState = s12, TargetState = s11, }; t1211.Action += (s, e) => _events = _events + "A1211"; var t1 = new Transition { SourceState = s1, TargetState = s0, }; t1.Action += (s, e) => _events = _events + "A1"; var t010 = new Transition { SourceState = s0, TargetState = s10, }; t010.Action += (s, e) => _events = _events + "A010"; sm.Update(TimeSpan.FromSeconds(1)); t0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); t1211.Fire(); sm.Update(TimeSpan.FromSeconds(1)); t1.Fire(); sm.Update(TimeSpan.FromSeconds(1)); t010.Fire(); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0U0X0A0E1E12U12U1X12A1211E11U11U1X11X1A1E0U0X0A010E1E10U10U1", _events); }
public void SimpleStateMachine() { var sm = new StateMachine(); sm.States.Add(CreateState("0")); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0U0", _events); }
public void TestFireAlways() { var sm = new StateMachine(); var s0 = CreateState("0"); sm.States.Add(s0); var s1 = CreateState("1"); sm.States.Add(s1); var t0 = new Transition { SourceState = s0, TargetState = s1, FireAlways = true, }; t0.Action += (s, e) => _events = _events + "A0"; var t1 = new Transition { SourceState = s1, TargetState = s0, FireAlways = true, }; t1.Action += (s, e) => _events = _events + "A1"; sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0U0X0A0E1U1X1A1E0U0", _events); }
public void TestNoFinalState() { var sm = new StateMachine(); var s0 = CreateState("0"); var s0States = new StateCollection(); s0.ParallelSubStates.Add(s0States); sm.States.Add(s0); var s1 = CreateState("1"); sm.States.Add(s1); var s00 = CreateState("00"); s0States.Add(s00); var s01 = CreateState("01"); s0States.Add(s01); var s02 = CreateState("02"); s0States.Add(s02); Assert.AreEqual(null, s0States.FinalState); var t0 = new Transition { SourceState = s0, TargetState = s1, FireAlways = true, }; t0.Action += (s, e) => _events = _events + "A0"; sm.Update(TimeSpan.FromSeconds(1)); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0E00U00U0X00X0A0E1U1", _events); }
public void TwoParallelTransitionsManualFire() { var sm = new StateMachine(); var s0 = CreateState("0"); sm.States.Add(s0); var s1 = CreateState("1"); sm.States.Add(s1); var t0 = new Transition { SourceState = s0, TargetState = s1, Guard = () => false, }; t0.Action += (s, e) => _events = _events + "A0"; var t1 = new Transition { SourceState = s0, TargetState = s1, }; t1.Action += (s, e) => _events = _events + "A1"; sm.Update(TimeSpan.FromSeconds(1)); t1.Fire(); t0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0U0X0A1E1U1", _events); }
public void TwoCompositeStates() { var sm = new StateMachine(); var s0 = CreateState("0"); var s0States = new StateCollection(); s0.ParallelSubStates.Add(s0States); sm.States.Add(s0); var s1 = CreateState("1"); var s1States = new StateCollection(); s1.ParallelSubStates.Add(s1States); sm.States.Add(s1); var s00 = CreateState("00"); s0States.Add(s00); var s01 = CreateState("01"); s0States.Add(s01); var s10 = CreateState("10"); s1States.Add(s10); var s11 = CreateState("11"); s1States.Add(s11); var t0001 = new Transition { SourceState = s00, TargetState = s01, }; t0001.Action += (s, e) => _events = _events + "A0001"; var t0111 = new Transition { SourceState = s01, TargetState = s11, }; t0111.Action += (s, e) => _events = _events + "A0111"; var t101 = new Transition { SourceState = s1, TargetState = s10, }; t101.Action += (s, e) => _events = _events + "A101"; sm.Update(TimeSpan.FromSeconds(1)); t0001.Fire(); sm.Update(TimeSpan.FromSeconds(1)); t0111.Fire(); sm.Update(TimeSpan.FromSeconds(1)); t101.Fire(null, null); sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0E00U00U0X00A0001E01U01U0X01X0A0111E1E11U11U1X11X1A101E1E10U10U1", _events); }
// Update is called once per frame override public void Update() { base.Update(); fsm.Update(); }
protected void Update() { stateMachine.Update(); }
private void Update() { sm.Update(); }
public void EmptyStateMachine() { var sm = new StateMachine(); sm.Update(TimeSpan.FromSeconds(1)); }
//this must be implemented public override void Update() { thirst += 1; stateMachine.Update(); }
private void Update() { stateMachine.Update(); }
// Request actions to the FSM and perform them private void Update() { Action actions = stateMachine.Update(); actions?.Invoke(); }
override public void Update() { base.Update(); fsm.Update(); stabCooldownTimer -= Time.deltaTime; }
public void TestParallelStates2() { var sm = new StateMachine(); var s0 = CreateState("0"); sm.States.Add(s0); var s0A = new StateCollection(); s0.ParallelSubStates.Add(s0A); var s0B = new StateCollection(); s0.ParallelSubStates.Add(s0B); var s0C = new StateCollection(); s0.ParallelSubStates.Add(s0C); var s1 = CreateState("1"); sm.States.Add(s1); var sa0 = CreateState("a0"); s0A.Add(sa0); var sa1 = CreateState("a1"); s0A.Add(sa1); var sb0 = CreateState("b0"); s0B.Add(sb0); var sb1 = CreateState("b1"); s0B.Add(sb1); var sb2 = CreateState("b2"); s0B.Add(sb2); var sc0 = CreateState("c0"); s0C.Add(sc0); var sc1 = CreateState("c1"); s0C.Add(sc1); s0C.InitialState = sc1; // Set final state s0A.FinalState = sa1; s0B.FinalState = sb2; s0C.FinalState = null; var t0 = new Transition { SourceState = s0, TargetState = s1, FireAlways = true, }; t0.Action += (s, e) => _events = _events + "A0"; var ta0a1 = new Transition { SourceState = sa0, TargetState = sa1, FireAlways = true, }; ta0a1.Action += (s, e) => _events = _events + "Aa0a1"; var tb0b1 = new Transition { SourceState = sb0, TargetState = sb1, FireAlways = true, }; tb0b1.Action += (s, e) => _events = _events + "Ab0b1"; var tb1b2 = new Transition { SourceState = sb1, TargetState = sb2, FireAlways = true, }; tb1b2.Action += (s, e) => _events = _events + "Ab1b2"; var tc0c1 = new Transition { SourceState = sc0, TargetState = sc1, FireAlways = true, }; tc0c1.Action += (s, e) => _events = _events + "Ac0c1"; var tc1c0 = new Transition { SourceState = sc1, TargetState = sc0, }; tc1c0.Action += (s, e) => _events = _events + "Ac1c0"; tc1c0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); tc1c0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); tc1c0.Fire(); sm.Update(TimeSpan.FromSeconds(1)); tc1c0.Fire(); // tc1c0 fires --> t0 must not fire. sm.Update(TimeSpan.FromSeconds(1)); Assert.AreEqual("E0Ea0Eb0Ec1Ua0Ub0Uc1U0Xa0Aa0a1Ea1Xb0Ab0b1Eb1Xc1Ac1c0Ec0Ua1Ub1Uc0U0Xb1Ab1b2Eb2Xc0Ac0c1Ec1Ua1Ub2Uc1U0Xc1Ac1c0Ec0Ua1Ub2Uc0U0", _events); }