private void LeaveChildren(StateEventArg arg)
{
foreach (var region in regions)
{
region.Value.Leave(arg);
}
}
private void EnterChildren(StateEventArg arg)
{
foreach (var region in regions)
{
region.Value.Enter(arg);
}
}
public void Enter(StateEventArg arg)
{
Assert.IsNotNull(initial);
ChangeActive(initial, initial, null);
rootActive.EnterFromParent(arg);
}
public void Leave(StateEventArg arg)
{
Assert.IsNotNull(rootActive);
rootActive.LeaveFromParent(arg);
ChangeActiveImpl(null, null, null);
}
private void ChangeActive(Vertex v, Vertex rootState, StateEventArg arg)
{
if (v is State)
{
ChangeActiveImpl(v as State, rootState as State, arg);
}
}
private void RemoveSreen( object sender, StateEventArg arg)
{
if ((GameState)arg.currentState == GameState.Playing)
{
isLoading = false;
}
}
protected override void LeaveProcedure(StateEventArg arg)
{
ProcedureStateMachine?.Destroy();
m_systems.TearDown();
EventRoute.Dispose();
m_contexts.game.DestroyAllEntities();
m_contexts.Reset();
Object.Destroy(m_rootNode.gameObject);
#if (!ENTITAS_DISABLE_VISUAL_DEBUGGING && UNITY_EDITOR)
Object.Destroy(m_systems.gameObject);
var contextObserverBehaviours = Object.FindObjectsOfType <Entitas.VisualDebugging.Unity.ContextObserverBehaviour>();
var allContexts = m_contexts.allContexts;
foreach (var ob in contextObserverBehaviours)
{
if (System.Array.IndexOf(allContexts, ob.contextObserver.context) != -1)
{
Object.Destroy(ob.gameObject);
}
}
#endif
m_blackboard = null;
m_procedureStateMachine = null;
m_systems = null;
m_contexts = null;
m_rootNode = null;
m_eventRoute = null;
m_schedulable = null;
}
protected override void EnterProcedure(StateEventArg arg)
{
m_contexts = new Contexts();
m_eventRoute = new EntitasEventRoute(m_contexts);
m_rootNode = new GameObject(GetRootNodeName()).transform;
RootNodeService.RootNode = m_rootNode;
m_blackboard = new Blackboard();
m_procedureStateMachine = CreateStateMachine();
m_schedulable = new Schedulable();
m_systems = new Feature("Systems");
EntitasSystemEnvironment parameters = new EntitasSystemEnvironment(m_contexts.game, EventRoute, Blackboard, ProcedureStateMachine, m_schedulable);
CreateSystems(m_systems, parameters);
m_systems.Initialize();
if (ProcedureStateMachine != null)
{
ProcedureStateMachine.EnterStateEvent += OnEnterState;
RequireStateTransitionDelay("__Start");
}
}
protected void RequireStateTransitionDelay(string transition, StateEventArg arg = null)
{
EventRoute.SendEvent(EventSendType.OneTime, new SystemStateTransitionEvent()
{
transition = transition,
eventArg = arg
});
}
internal override bool HandleEvent(string transitionName, StateEventArg arg)
{
foreach (var region in regions)
{
if (region.Value.HandleEvent(transitionName, arg))
{
return(true);
}
}
return(false);
}
internal override void EnterFromChild(Region r, StateEventArg arg)
{
base.EnterFromChild(r, arg);
foreach (var region in regions)
{
if (region.Value != r)
{
region.Value.Enter(arg);
}
}
}
public void LeaveChild(State child, Region lca, StateEventArg arg)
{
Assert.IsNotNull(child);
Assert.AreEqual(child.Container, this);
if (this != lca)
{
if (State != null)
{
State.LeaveFromChild(lca, arg);
}
}
}
public void EnterChild(State child, StateEventArg arg)
{
Assert.IsNotNull(child);
Assert.AreEqual(child.Container, this);
if (rootActive != child)
{
if (State != null)
{
State.EnterFromChild(this, arg);
ChangeActiveImpl(child, child, null);
}
}
}
private void OnLeaveProcedure(StateEventArg arg)
{
if (Running)
{
if (suspendable && !m_paused && arg is ProcedurePauseEvent)
{
m_paused = true;
PauseProcedure(arg as ProcedurePauseEvent);
}
else
{
Running = false;
LeaveProcedure(arg);
}
}
}
protected override void EnterProcedure(StateEventArg arg)
{
m_blackboard = new Blackboard();
m_procedureStateMachine = CreateStateMachine();
m_systems = new Feature("Systems");
CreateSystems(m_systems);
m_systems.Initialize();
if (m_procedureStateMachine != null)
{
m_procedureStateMachine.EnterStateEvent += OnEnterState;
m_procedureStateMachine.Start();
}
}
private void ChangeActiveImpl(State state, State rootState, StateEventArg arg)
{
if (active != null)
{
StateMachine.OnLeaveState(active.Name);
}
active = state;
rootActive = rootState;
StateMachine.OnEnterState(rootActive != null ? rootActive.Name : "", arg);
//Debug.Log(string.Format("Region {0} Active: {1}", Name, rootActive != null ? rootActive.Name : "null"));
if (rootActive is FinalState)
{
IsFinal = true;
FinalEvent?.Invoke();
}
}
public void FireEvent(string transitionName, StateEventArg arg = null)
{
if (transitionName == "__Start")
{
Start();
}
else
{
foreach (var region in regions)
{
if (region.Value.HandleEvent(transitionName, arg))
{
break;
}
}
}
}
protected override void LeaveProcedure(StateEventArg arg)
{
m_procedureStateMachine?.Destroy();
m_systems.TearDown();
EventRoute.Dispose();
#if (!ENTITAS_DISABLE_VISUAL_DEBUGGING && UNITY_EDITOR)
Object.Destroy(m_systems.gameObject);
#endif
m_blackboard = null;
m_procedureStateMachine = null;
m_systems = null;
m_contexts = null;
m_rootNode = null;
m_eventRoute = null;
}
protected override void OnEnter(StateEventArg arg)
{
base.OnEnter(arg);
if (!Running)
{
if (suspendable && m_paused)
{
ResumeProcedure(arg);
}
else
{
EnterProcedure(arg);
}
m_paused = false;
Running = true;
}
}
protected override void EnterProcedure(StateEventArg userData)
{
m_contexts = new Contexts();
m_eventRoute = new EntitasEventRoute(m_contexts);
m_rootNode = new GameObject(GetRootNodeName()).transform;
RootNodeService.RootNode = m_rootNode;
m_procedureStateMachine = CreateStateMachine();
foreach (var v in Region.Subvertices)
{
EntitasSubProcedure p = v as EntitasSubProcedure;
if (p == null)
{
continue;
}
p.InitialSubProcedure(m_contexts, m_rootNode, EventRoute);
}
}
public bool HandleEvent(string transitionName, StateEventArg arg)
{
TransitionList list;
Transition t;
if (!transitions.TryGetValue(transitionName, out list))
{
if (rootActive != null && rootActive.HandleEvent(transitionName, arg))
{
return(true);
}
return(false);
}
else
{
if (!list.TryGetValue(active, out t))
{
return(false);
}
}
if (t.RootSource != rootActive)
{
return(false);
}
if (t.Guard != null && !t.Guard())
{
return(true);
}
Assert.AreEqual(this, StateMachine.LCA(t.Source, t.Target));
rootActive.LeaveImmediate(this, arg);
t.Effect?.Invoke();
ChangeActive(t.Target, t.RootTarget, arg);
((State)t.Target).EnterImmediate(arg);
return(true);
}
protected virtual void LeaveProcedure(StateEventArg arg)
{
}
protected virtual void OnEnterState(string state, StateEventArg arg)
{
EventRoute.SendEvent(EventSendType.OneFrame, new SystemSwitchStateEvent {
state = state, arg = arg
});
}
private void OnGameHandlerChangeState(object sender, StateEventArg arg)
{
GameState newState = (GameState)arg.currentState;
if (newState == GameState.Playing)
{
this.spriteRenderer.enabled = true;
ChangeCurrentState(CatState.Starting);
}
else if (newState == GameState.Transit)
{
ChangeCurrentState(CatState.Pause);
}
else if (newState == GameState.GameLost)
{
ChangeCurrentState(CatState.Dead);
}
}
internal override void EnterImmediate(StateEventArg arg)
{
base.EnterImmediate(arg);
EnterChildren(arg);
}
protected void OnChangeState(StateEventArg arg){
if (RaiseChangeState != null) {
RaiseChangeState(this, arg);
}
}
internal override void EnterFromParent(StateEventArg arg)
{
base.EnterFromParent(arg);
EnterChildren(arg);
}
internal void OnEnterState(string state, StateEventArg arg)
{
EnterStateEvent?.Invoke(state, arg);
}
protected virtual void EnterProcedure(StateEventArg arg)
{
}
internal override void LeaveFromParent(StateEventArg arg)
{
LeaveChildren(arg);
base.LeaveFromParent(arg);
}
protected void RequireSwitchState(string transition, StateEventArg arg = null)
{
SystemEnvironment.StateMachine.FireEvent(transition, arg);
}
internal override void LeaveImmediate(Region lca, StateEventArg arg)
{
LeaveChildren(arg);
base.LeaveImmediate(lca, arg);
}
public virtual void Enter(StateEventArg arg)
{
}
