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 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 })); }
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 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 StateGroupThrowsIfAddStatesCalledWithNull() { var group = new StateGroup(); Assert.Throws<ArgumentNullException>(() => group.AddStates(null)); }