void RunStackAction(StackAction action, List <T> stack, Action onComplete) { if (stack.Count == 0) { ListPool <T> .Release(stack); onComplete.Invoke(); return; } var applicationState = stack.Last(); stack.RemoveAt(stack.Count - 1); var changeEvent = StackChangeEvent <T> .GetPooled(action, applicationState); var changeStateRequest = new ProgressListenerRequest(); changeStateRequest.OnProgressChange += () => InvokeProgressChange(changeStateRequest.Progress, changeEvent); changeStateRequest.OnComplete += () => { RunStackAction(action, stack, onComplete); StackChangeEvent <T> .Release(changeEvent); }; GetStateFromEnum(applicationState).ChangeState(changeEvent, changeStateRequest); }
public static StackChangeEvent <TEnum> GetPooled(StackAction action, TEnum state) { var e = s_EventsPool.Get(); e.Action = action; e.State = state; return(e); }
public static StackChangeEvent <T> GetPooled(StackAction action, IReadOnlyList <T> oldStackValue, IReadOnlyList <T> newStackValue) { var e = s_EventsPool.Get(); e.Action = action; e.OldStackValue = oldStackValue; e.NewStackValue = newStackValue; return(e); }
public override void OnEnter(StackAction stackAction) { if (stackAction == StackAction.Push) { gameObject.SetActive(true); } else { canvasGroup.interactable = true; background.color = GameSettings.instance.enabledUIColor; } }
public override void OnExit(StackAction stackAction) { if (stackAction == StackAction.Pop) { gameObject.SetActive(false); } else { canvasGroup.interactable = false; background.color = GameSettings.instance.disabledUIColor; } }
/// <summary> /// Change the current state of the state manager. Add it to the state stack. /// Will trigger state changing events and transitions. /// Any additional state changes that happened in the meantime will be queued and executed after the current change finishes. /// </summary> public void ChangeState(TState state, object param, StackAction stackAction) { // Already in this state, do nothing. // Only if change is the same. if (CurrentState.CompareTo(state) == 0 && Equals(CurrentStateParam, param)) { return; } // Sanity check. if (m_StackedStates.Count > 7 && stackAction == StackAction.Push) { UnityEngine.Debug.LogWarning($"You're stacking too many states down. Are you sure? Stacked state: {state}."); } // TODO: Validate State Event. Give chance users to reject the next state. if (m_ChangingStates) { m_PendingStateChanges.Enqueue(new StateEventArgs <TState>(default(TState), null, state, param, stackAction, this)); return; } else { m_ChangingStates = true; } TState prevState = CurrentState; object prevStateParam = CurrentStateParam; // Can access while inside event handler. CurrentEventArgs = new StateEventArgs <TState>(prevState, prevStateParam, state, param, stackAction, this); // HACK: User may start and finish transition while on this call. Prevent him from finishing the transition, I'll do it here after that. m_ExecutingTransitionEffect = true; TransitionStarts?.Invoke(CurrentEventArgs); m_TransitionStartsSubscribers[state]?.Invoke(); m_ExecutingTransitionEffect = false; if (CurrentEventArgs.TransitionsPending.Count == 0) { OnTransitionFinished(); } }
void PushAction(int id, StackAction type, float t = 0.0f, string text = "", int param = 0) { if (!UnitActKey.Contains(id)) { UnitActKey.Add(id); } if (!UnitActionStack.ContainsKey(id)) { UnitActionStack.Add(id, new ActionConfig()); UnitActionStack[id].id = id; } ActionItem it = new ActionItem(); it.text = text; it.pause_time = t; it.type = type;//say = 1 pause = 2 skill = 3;crouch = 4, block=5 it.param = param; UnitActionStack[id].action.Add(it); }
protected StackQueueEventArgs(StackAction order, object obj) { this.Order = order; this.time = DateTime.Now.ToBinary(); this.Object = obj; }
/// <summary> /// 作为子状态机使用时需要实现此方法 /// </summary> public virtual void OnExit(StackAction stackAction) { }
/// <summary> /// 作为子状态机使用时需要实现此方法 /// </summary> public virtual void OnEnter(StackAction stackAction) { }
public override void OnExit(StackAction stackAction) { _onExit?.Invoke(stackAction); }
public override void OnEnter(StackAction stackAction) { _onEnter?.Invoke(stackAction); }
public abstract void OnExit(StackAction stackAction);
public abstract void OnEnter(StackAction stackAction);
protected StackQueueEventArgs(bool Empty) { this.Order = StackAction.None; this.Object = null; this.time = DateTime.Now.ToBinary(); }
public StackQueueEventArgs(StackAction order) : this(order, null) { }
public ParseItem(StackAction stackAction, string value = null) { StackAction = stackAction; Value = value; }
public StackRequest(StackAction action, int sceneID = 0) { Action = action; SceneID = sceneID; }
public void TypeStack(string type, int index, StackAction action) { string innerMessage = $"{action}: \"{type}\", Index: {index}"; WriteEntry("TYPE STACK", innerMessage); }