| public Update ( GameObject gameObject ) : void | ||
| gameObject | GameObject | |
| return | void | |
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);
}
