public void EventInExitHandlerPropagatedCorrectly()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var evt = new Event("Event");
state1.TransitionOn(evt).To(state2);
var ex = new Exception("Foo");
var group = new StateGroup <State>("Group")
.WithExit(i => { throw ex; });
state1.AddToGroup(group);
var e = Assert.Throws <TransitionFailedException>(() => evt.Fire());
Assert.AreEqual(state1, e.FaultInfo.From);
Assert.AreEqual(state2, e.FaultInfo.To);
Assert.AreEqual(evt, e.FaultInfo.Event);
Assert.AreEqual(ex, e.FaultInfo.Exception);
Assert.AreEqual(sm, e.FaultInfo.StateMachine);
Assert.AreEqual(FaultedComponent.GroupExitHandler, e.FaultInfo.FaultedComponent);
Assert.AreEqual(group, e.FaultInfo.Group);
}
public override object VisitGroup(PParser.GroupContext context)
{
StateGroup group = (StateGroup)nodesToDeclarations.Get(context);
group.OwningMachine = CurrentMachine;
using (currentScope.NewContext(group.Scope))
{
foreach (PParser.GroupItemContext groupItemContext in context.groupItem())
{
switch (Visit(groupItemContext))
{
case StateGroup subGroup:
group.AddGroup(subGroup);
break;
case State state:
group.AddState(state);
break;
default:
throw Handler.InternalError(groupItemContext,
new ArgumentOutOfRangeException(nameof(context)));
}
}
}
return(group);
}
public static StateGroup GetCurrentStates(EntityManager entityManager, Allocator allocator)
{
var buffer = entityManager.GetBuffer <State>(CurrentStatesEntity);
var states = new StateGroup(ref buffer, allocator);
return(states);
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
var isAuthorized = false;
if (httpContext != null)
{
if (httpContext.Session != null)
{
if (httpContext.Session["user_id"] != null && httpContext.Session["user_account"] != null)
{
isAuthorized = true;
}
else
{
if (httpContext.Request.Cookies.AllKeys.Contains("Cookie"))
{
var _cookie = httpContext.Request.Cookies["Cookie"];
if (_cookie != null)
{
if (DateTime.Parse(_cookie["ex"]) > DateTime.Now && int.Parse(_cookie["userid"]) > 0)
{
StateGroup.CreateSession(httpContext, _cookie["account"], int.Parse(_cookie["userid"]), _cookie["username"]);
isAuthorized = true;
}
}
}
}
}
}
return(isAuthorized);// base.AuthorizeCore(httpContext);
}
public static void StateGroups()
{
var stateMachine = new StateMachine();
var initial = stateMachine.CreateInitialState("Initial");
var evt = new Event("evt");
///////////////////////
var stateA = stateMachine.CreateState("State A");
var stateB = stateMachine.CreateState("State B");
// You can create state groups, and add states to them
var statesAAndB = new StateGroup("States A and B")
.WithEntry(info => Console.WriteLine($"Entering group from {info.From} to {info.To} on {info.Event}"))
.WithExit(info => Console.WriteLine($"Exiting group from {info.From} to {info.To} on {info.Event}"));
statesAAndB.AddStates(stateA, stateB);
// You can also add states to groups
stateA.AddToGroup(statesAAndB);
///////////////////////
initial.TransitionOn(evt).To(stateA);
stateA.TransitionOn(evt).To(stateB);
stateB.TransitionOn(evt).To(initial);
evt.Fire();
evt.Fire();
evt.Fire();
}
private void CreateStateGroup(Key key)
{
StateGroup stateGroup = new StateGroup();
stateGroup.Load(key, this);
this.m_StateGroups.Add(stateGroup);
}
public void AddGroup(StateGroup group)
{
Debug.Assert(group.ParentStateContainer == null);
group.ParentStateContainer = this;
group.OwningMachine = this;
groups.Add(group.Name, group);
}
public void IndicatesWhetherInState()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var state3 = sm.CreateState("State 3");
var evt = sm.CreateEvent("Event");
var group1 = new StateGroup("Group 1");
var group2 = new StateGroup("Group 2");
state1.AddToGroup(group1);
state2.AddToGroup(group2);
state3.AddToGroup(group2);
state1.TransitionOn(evt).To(state2);
state2.TransitionOn(evt).To(state3);
Assert.True(group1.IsCurrent);
Assert.False(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
}
public void Load(Key key, StateMachine machine)
{
string svalue = key.GetVariable(0).SValue;
State stateByName = machine.GetStateByName(svalue);
if (stateByName != null)
{
this.m_FromStates.Add(stateByName);
}
else
{
StateGroup statesGroupByName = machine.GetStatesGroupByName(svalue);
if (statesGroupByName == null)
{
DebugUtils.Assert("[StateTransition::Load] Can't find from state!", true, DebugUtils.AssertType.Info);
return;
}
List <State> states = statesGroupByName.GetStates();
for (int i = 0; i < states.Count; i++)
{
this.m_FromStates.Add(states[i]);
}
}
this.m_ToState = machine.GetStateByName(key.GetVariable(1).SValue);
for (int j = 0; j < key.GetKeysCount(); j++)
{
Key key2 = key.GetKey(j);
if (key2.GetName() == "Cnd")
{
this.m_ConditionMethods.Add(key2.GetVariable(0).SValue);
}
}
}
static GraphicsDevice()
{
OpenTK.Toolkit.Init(new OpenTK.ToolkitOptions()
{
Backend = OpenTK.PlatformBackend.Default
});
GraphicsContextFlags flags = GraphicsContextFlags.Default;
#if !DEBUG
flags |= GraphicsContextFlags.NoError; //Disable error checking
#else
flags |= GraphicsContextFlags.Debug;
#endif
Window = new GameWindow(1024, 1024, GraphicsMode.Default, "Game Window", OpenTK.GameWindowFlags.Default, OpenTK.DisplayDevice.Default, 0, 0, flags | GraphicsContextFlags.ForwardCompatible);
Window.Resize += Window_Resize;
Window.Load += Game_Load;
Window.RenderFrame += InitRender;
Window.UpdateFrame += Game_UpdateFrame;
GameLoop = new StateGroup();
Cleanup = new WeakAction();
DeletionQueue = new ConcurrentQueue <Tuple <int, GLObjectType> >();
curProg = null;
}
public State GetTargetGoalState(ref StateGroup targetStates, ref StackData stackData)
{
foreach (var targetState in targetStates)
{
var foodState = new State
{
Target = stackData.AgentEntity,
Trait = typeof(ItemContainerTrait),
ValueTrait = typeof(FoodTrait),
};
//只针对自身食物类物品需求的goal state
if (!targetState.BelongTo(foodState))
{
continue;
}
//如果targetState有指明物品名，则直接寻找其是否为cooker的产物
//这是因为在指定物品名的情况下，有可能会省略ValueTrait
if (!IsItemInRecipes(targetState.ValueString, ref stackData))
{
continue;
}
return(targetState);
}
return(default);
public void IndicatesWhetherInState()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var state3 = sm.CreateState("State 3");
var evt = new Event("Event");
var group1 = new StateGroup <State>("Group 1");
var group2 = new StateGroup <State>("Group 2");
state1.AddToGroup(group1);
state2.AddToGroup(group2);
state3.AddToGroup(group2);
state1.TransitionOn(evt).To(state2);
state2.TransitionOn(evt).To(state3);
Assert.True(group1.IsCurrent);
Assert.False(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
}
public StateGroup GetSettings(ref State targetState, ref StackData stackData, Allocator allocator)
{
var settings = new StateGroup(1, allocator);
if (!targetState.ValueString.Equals(new NativeString64()))
{
//如果指定了物品名，那么只有一种setting，也就是targetState本身
settings.Add(targetState);
}
else if (targetState.ValueString.Equals(new NativeString64()) &&
targetState.ValueTrait != null)
{
//如果targetState是类别范围，需要对每种符合范围的物品做setting
//todo 此处应查询define获得所有符合范围的物品名，示例里暂时从工具方法获取
var itemNames =
Utils.GetItemNamesOfSpecificTrait(targetState.ValueTrait,
Allocator.Temp);
for (var i = 0; i < itemNames.Length; i++)
{
var state = targetState;
state.ValueString = itemNames[i];
settings.Add(state);
}
itemNames.Dispose();
}
return(settings);
}
// 当存在existState时,是否允许添加newState
protected bool allowAddStateByGroup(Type newState, Type existState)
{
// 任意一个状态没有所属组,则不在同一组
if (!mStateGroupList.TryGetValue(newState, out List <Type> newGroup) ||
!mStateGroupList.TryGetValue(existState, out List <Type> existGroup))
{
return(true);
}
// 有一个状态不属于任何状态组时两个状态是可以共存的
if (newGroup == null || existGroup == null)
{
return(true);
}
int count0 = newGroup.Count;
int count1 = existGroup.Count;
for (int i = 0; i < count0; ++i)
{
StateGroup group = mGroupStateList[newGroup[i]];
for (int j = 0; j < count1; ++j)
{
// 属于同一状态组,并且该状态组中的所有状态都不能共存,而且不允许添加跟当前状态互斥的状态,则不允许添加该状态
if (newGroup[i] != existGroup[j])
{
continue;
}
// 状态可共存
if (group.mMutex == GROUP_MUTEX.COEXIST)
{
;
}
// 只与主状态互斥
else if (group.mMutex == GROUP_MUTEX.MUETX_WITH_MAIN)
{
// 有主状态时不可添加其他状态
if (group.mMainState == existState)
{
return(false);
}
}
// 只与主状态互斥,任何状态都可以添加
else if (group.mMutex == GROUP_MUTEX.MUETX_WITH_MAIN)
{
return(true);
}
// 不可添加新状态
else if (group.mMutex == GROUP_MUTEX.NO_NEW)
{
return(false);
}
// 添加新状态时移除所有旧状态
else if (group.mMutex == GROUP_MUTEX.REMOVE_OTHERS)
{
;
}
}
}
return(true);
}
public override object VisitGroup(PParser.GroupContext context)
{
string symbolName = context.name.GetText();
StateGroup group = CurrentScope.Put(symbolName, context);
nodesToDeclarations.Put(context, group);
return(VisitChildrenWithNewScope(group, context));
}
/// <summary>
/// 条件：世界里要有对应物品
/// </summary>
/// <param name="targetState"></param>
/// <param name="setting"></param>
/// <param name="stackData"></param>
/// <param name="preconditions"></param>
public void GetPreconditions([ReadOnly] ref State targetState, ref State setting,
[ReadOnly] ref StackData stackData, ref StateGroup preconditions)
{
var state = setting;
state.Target = Entity.Null;
preconditions.Add(state);
}
void DelState(StateGroup state)
{
if (state == null)
{
return;
}
mRemoveList.Add(state);
}
public StateGroup Put(string name, PParser.GroupContext tree)
{
StateGroup group = new StateGroup(name, tree);
CheckConflicts(group, Namespace(stateGroups));
stateGroups.Add(name, group);
return(group);
}
// 当存在existState时,是否允许添加newState
protected bool allowAddStateByGroup(PlayerState newState, PlayerState existState)
{
// 任意一个状态没有所属组,则不在同一组
if (!mStateGroupList.ContainsKey(newState.GetType()) ||
!mStateGroupList.ContainsKey(existState.GetType()))
{
return(true);
}
List <Type> newGroup = mStateGroupList[newState.GetType()];
List <Type> existGroup = mStateGroupList[existState.GetType()];
// 有一个状态不属于任何状态组时两个状态是可以共存的
if (newGroup == null || existGroup == null)
{
return(true);
}
int count0 = newGroup.Count;
int count1 = existGroup.Count;
for (int i = 0; i < count0; ++i)
{
for (int j = 0; j < count1; ++j)
{
// 属于同一状态组,并且该状态组中的所有状态都不能共存,而且不允许添加跟当前状态互斥的状态,则不允许添加该状态
if (newGroup[i] != existGroup[j])
{
continue;
}
StateGroup group = mGroupStateList[newGroup[i]];
GROUP_MUTEX_OPERATION operate = group.mCoexist;
// 状态可共存
if (operate == GROUP_MUTEX_OPERATION.GMO_COEXIST)
{
;
}
// 只与主状态互斥
else if (operate == GROUP_MUTEX_OPERATION.GMO_MUETX_WITH_MAIN)
{
// 有主状态时不可添加其他状态
if (group.mMainState == existState.GetType())
{
return(false);
}
}
// 不可添加新状态
else if (operate == GROUP_MUTEX_OPERATION.GMO_NO_NEW)
{
return(false);
}
// 添加新状态时移除所有旧状态
else if (operate == GROUP_MUTEX_OPERATION.GMO_REMOVE_OTHERS)
{
;
}
}
}
return(true);
}
public ActionResult <string> StateWithMostCities()
{
var result = _allCities.GroupBy(city => city.State).Select(StateGroup => new {
StateName = StateGroup.Key,
CountCities = StateGroup.Count()
}).OrderByDescending(x => x.CountCities).First();
return(result.StateName);
}
public void GetPreconditions(ref State targetState, ref State setting,
ref StackData stackData, ref StateGroup preconditions)
{
//我自己需要有指定的物品
var state = setting;
state.Target = stackData.AgentEntity;
preconditions.Add(state);
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var smallscreen = "0";
if (returnUrl == "wince")
{
smallscreen = "1";
}
// 这不会计入到为执行帐户锁定而统计的登录失败次数中
// 若要在多次输入错误密码的情况下触发帐户锁定，请更改为 shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
IuserinfoService us = ServiceFactory.userinfoservice;
userinfo ui = us.GetEntityById(userinfo => userinfo.Account == model.Email);
if (ui == null)
{
ModelState.AddModelError("", "无效的登录尝试。");
return(View(model));
}
else
{
StateGroup.CreateSession(this.HttpContext, model.Email, ui.ID, ui.FullName);
//Session["user_account"] = model.Email;
//Session["user_id"] = ui.ID;
//Session["user_name"] = ui.FullName;
log4net.LogManager.GetLogger(ui.ID.ToString()).Info(string.Format("{0} login at {1}!", ui.FullName, DateTime.Now.ToString()));
StateGroup.CreateCookie(this.HttpContext, model.Email, ui.ID, ui.FullName);
if (smallscreen == "1")
{
return(RedirectToLocal("/wms_scanhome"));
}
else
{
return(RedirectToLocal(returnUrl));
}
}
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "无效的登录尝试。");
return(View(model));
}
}
public void DelState(int id)
{
StateGroup state = null;
if (!mStates.TryGetValue(id, out state))
{
return;
}
mRemoveList.Add(state);
}
public void AddStateAddsState()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group = new StateGroup("group");
group.AddState(state);
Assert.That(group.States, Is.EquivalentTo(new[] { state }));
}
public void AddStateAddsState()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group = new StateGroup("group");
group.AddState(state);
Assert.That(group.States, Is.EquivalentTo(new[] { state }));
}
public void StateCanBeAddedToMultipleGroupsAtOnce()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group1 = new StateGroup("group1");
var group2 = new StateGroup("group2");
state.AddToGroups(group1, group2);
Assert.That(state.Groups, Is.EquivalentTo(new[] { group1, group2 }));
}
public void SetCurrentStates(ref StateGroup currentStates, EntityManager entityManager)
{
if (CurrentStates == null)
{
CurrentStates = new List <StateView>(currentStates.Length());
}
foreach (var currentState in currentStates)
{
CurrentStates.Add(new StateView(entityManager, currentState));
}
}
public void AddStatesAddsStates()
{
var sm = new StateMachine("sm");
var state1 = sm.CreateInitialState("state1");
var state2 = sm.CreateState("state2");
var group = new StateGroup("group");
group.AddStates(state1, state2);
Assert.That(group.States, Is.EquivalentTo(new[] { state1, state2 }));
}
public void StateIsNotAddedToGroupMultipleTimes()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group = new StateGroup("group");
state.AddToGroup(group);
state.AddToGroup(group);
Assert.That(state.Groups, Is.EquivalentTo(new[] { group }));
}
public void AddStatesAddsStates()
{
var sm = new StateMachine("sm");
var state1 = sm.CreateInitialState("state1");
var state2 = sm.CreateState("state2");
var group = new StateGroup("group");
group.AddStates(state1, state2);
Assert.That(group.States, Is.EquivalentTo(new[] { state1, state2 }));
}
private excel_state_group CheckMutex(excel_state_group excel, int srcUID)
{
if (excel == null)
{
return(null);
}
excel_state_group mutexExcel = null;
for (int i = 0; i < mStateList.Count; ++i)
{
StateGroup s = mStateList[i];
// 如果互斥检查范围是全部，则检查全部状态是否呼出
// 如果互斥检查范围是同一来源，则只检查同一来源的状态是否互斥
if (excel.mutexScope == (int)StateMutexScope.All ||
(excel.mutexScope == (int)StateMutexScope.SameSrc && srcUID == s.mSrcUID))
{
int mutexID = excel.mutexID;
// 同ID或同互斥组的状态都算互斥;
if ((mutexID > 0 && mutexID == s.mExcel.mutexID) ||
(mutexID == 0 && excel.id == s.mExcel.id))
{
mutexExcel = s.mExcel;
break;
}
}
}
if (mutexExcel != null)
{
if (excel.mutexPriority > mutexExcel.mutexPriority)
{
// 优先级高，直接删除并替换原来的状态;
DelState(mutexExcel.id);
}
else if (excel.mutexPriority == mutexExcel.mutexPriority)
{
// 同优先级，状态叠加升级一层（如果没有填升级ID则直接替换掉原来的状态）
int nextID = mutexExcel.mutexNextID;
if (nextID > 0)
{
excel = excel_state_group.Find(nextID);
}
DelState(mutexExcel.id);
}
else if (excel.mutexPriority < mutexExcel.mutexPriority)
{
// 低优先级，添加失败;
excel = null;
}
}
return(excel);
}
public ActionResult LogOut()
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
log4net.LogManager.GetLogger(Session["user_id"].ToString()).Info(string.Format("{0} log out at {1}", Session["user_name"].ToString(), DateTime.Now.ToString()));
//Session["user_account"] = null;
//Session["user_id"] = null;
//Session["user_name"] = null;
StateGroup.ClearState(this.HttpContext);
return(RedirectToAction("Index", "Home"));
}
public State GetTargetGoalState(ref StateGroup targetStates, ref StackData stackData)
{
//针对“目标获得物品”的state
var stateFilter = new State
{
Trait = typeof(ItemContainerTrait),
};
var agent = stackData.AgentEntity;
//额外：target不能为自身
return(targetStates.GetState(state => state.Target != agent && state.BelongTo(stateFilter)));
}
public void DoesNotFireHandlersWhenTransitioningBetweenTwoStatesInGroup()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var evt = new Event("Event");
bool fired = false;
var group = new StateGroup<State>("Group")
.WithEntry(i => fired = true)
.WithExit(i => fired = true);
state1.AddToGroup(group);
state2.AddToGroup(group);
state1.TransitionOn(evt).To(state2);
evt.Fire();
Assert.False(fired);
}
public void FiresEntryHandlerWithCorrectArgumentsWhenEntered()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var evt = sm.CreateEvent("Event");
StateHandlerInfo<State> info = null;
var group = new StateGroup("Group")
.WithEntry(i => info = i);
state2.AddToGroup(group);
state1.TransitionOn(evt).To(state2);
evt.Fire();
Assert.NotNull(info);
Assert.AreEqual(state1, info.From);
Assert.AreEqual(state2, info.To);
Assert.AreEqual(evt, info.Event);
}
public void IsCurrentIncludesChildStateMachines()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var subSm = state1.CreateChildStateMachine();
var state11 = subSm.CreateInitialState("State 1.1");
var state12 = subSm.CreateState("State 1.2");
var group = new StateGroup("Group");
state1.AddToGroup(group);
var evt = sm.CreateEvent("Event");
state11.TransitionOn(evt).To(state12);
Assert.True(group.IsCurrent);
evt.Fire();
Assert.True(group.IsCurrent);
}
public void EventInEntryHandlerPropagatedCorrectly()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var evt = new Event("Event");
state1.TransitionOn(evt).To(state2);
var ex = new Exception("Foo");
var group = new StateGroup<State>("Group")
.WithEntry(i => { throw ex; });
state2.AddToGroup(group);
var e = Assert.Throws<TransitionFailedException>(() => evt.Fire());
Assert.AreEqual(state1, e.FaultInfo.From);
Assert.AreEqual(state2, e.FaultInfo.To);
Assert.AreEqual(evt, e.FaultInfo.Event);
Assert.AreEqual(ex, e.FaultInfo.Exception);
Assert.AreEqual(sm, e.FaultInfo.StateMachine);
Assert.AreEqual(FaultedComponent.GroupEntryHandler, e.FaultInfo.FaultedComponent);
Assert.AreEqual(group, e.FaultInfo.Group);
}
public void IndicatesNameCorrectly()
{
var group = new StateGroup<State>("State Group");
Assert.AreEqual("State Group", group.Name);
}
public void StateListsStateGroupsCorrectly()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var group1 = new StateGroup<State>("Group 1");
var group2 = new StateGroup<State>("Group 2");
state1.AddToGroup(group1);
state1.AddToGroup(group2);
Assert.That(state1.Groups, Is.EquivalentTo(new[] { group1, group2 }));
Assert.That(((IState)state1).Groups, Is.EquivalentTo(new[] { group1, group2 }));
}
public void StateIsNotAddedToGroupMultipleTimes()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group = new StateGroup("group");
state.AddToGroup(group);
state.AddToGroup(group);
Assert.That(state.Groups, Is.EquivalentTo(new[] { group }));
}
public void StateGroupListsStatesCorerctly()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var group = new StateGroup<State>("Group");
state1.AddToGroup(group);
state2.AddToGroup(group);
Assert.That(group.States, Is.EqualTo(new[] { state1, state2 }));
Assert.That(((IStateGroup)group).States, Is.EqualTo(new[] { state1, state2 }));
}
public void StateCanBeAddedToMultipleGroupsAtOnce()
{
var sm = new StateMachine("sm");
var state = sm.CreateInitialState("state");
var group1 = new StateGroup("group1");
var group2 = new StateGroup("group2");
state.AddToGroups(group1, group2);
Assert.That(state.Groups, Is.EquivalentTo(new[] { group1, group2 }));
}
public void StateGroupThrowsIfAddStatesCalledWithNull()
{
var group = new StateGroup();
Assert.Throws<ArgumentNullException>(() => group.AddStates(null));
}
public static void StateGroups()
{
var stateMachine = new StateMachine();
var initial = stateMachine.CreateInitialState("Initial");
var evt = new Event("evt");
///////////////////////
var stateA = stateMachine.CreateState("State A");
var stateB = stateMachine.CreateState("State B");
// You can create state groups, and add states to them
var statesAAndB = new StateGroup("States A and B")
.WithEntry(info => Console.WriteLine($"Entering group from {info.From} to {info.To} on {info.Event}"))
.WithExit(info => Console.WriteLine($"Exiting group from {info.From} to {info.To} on {info.Event}"));
statesAAndB.AddStates(stateA, stateB);
// You can also add states to groups
stateA.AddToGroup(statesAAndB);
///////////////////////
initial.TransitionOn(evt).To(stateA);
stateA.TransitionOn(evt).To(stateB);
stateB.TransitionOn(evt).To(initial);
evt.Fire();
evt.Fire();
evt.Fire();
}
