void fsmDebugPrint (string s)
{
#ifdef FSM_DEBUG
PrintToRPT("" + s); // comment/uncomment to hide/see debug logs
#else
//Print("" + s); // comment/uncomment to hide/see debug logs
#endif
}
void fsmDebugSpam (string s)
{
#ifdef FSM_DEBUG_SPAM
PrintToRPT("" + s); // comment/uncomment to hide/see debug logs
#else
//Print("" + s); // comment/uncomment to hide/see debug logs
#endif
}
/**@class HFSMBase
* @brief base class for hierarchic finite state machine
*
* stores current state (m_State) and transition table with possible transitions from each state
* to another state via event
*
* each state can have nested state machine, thus creating hierarchy
**/
class HFSMBase<Class FSMStateBase, Class FSMEventBase, Class FSMActionBase, Class FSMGuardBase>
{
protected ref FSMStateBase m_State; /// current fsm state
protected FSMStateBase m_OwnerState; /// state that owns this fsm (or null if root)
protected ref FSMStateBase m_InitialState; /// configurable initial state of the machine
protected ref array<ref FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase>> m_Transitions = new array<ref FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase>>; /// fsm transition table
protected bool m_HasCompletions = false;
void HFSMBase (FSMStateBase ownerState = NULL)
{
m_OwnerState = ownerState;
}
/**@fn GetCurrentState
* @return returns currently active state within this machine (i.e. not hierarchic state)
**/
FSMStateBase GetCurrentState ()
{
return m_State;
}
/**@fn SetCurrentState
* @return returns currently active state within this machine (i.e. not hierarchic state)
**/
void SetCurrentState (FSMStateBase state)
{
if(m_State != state)
{
m_State = state;
}
}
/**@fn GetOwnerState
* @return returns state that is owner of this fsm submachine. returns null if this is a root machine.
**/
FSMStateBase GetOwnerState ()
{
return m_OwnerState;
}
/**@fn GetHierarchyPath
* @brief returns hierarchic state (path to root) of a state
* @param[in] state \p state the path is starting
* @param[out] path \p current hierarchic state
* @return true if current state returned in path argument, false otherwise
**/
bool GetHierarchyPath (FSMStateBase state, out array<FSMStateBase> path)
{
FSMStateBase curr = state;
while (curr)
{
path.Insert(curr);
curr = curr.GetParentState();
}
return path.Count() > 0;
}
/**@fn SetInitialState
* @param[in] initial_state \p state the machine will be entered to after ::Start()
* @param[in] initial_event \p event that will be used to start the machine
**/
void SetInitialState (FSMStateBase initial_state)
{
m_InitialState = initial_state;
}
/**@fn AddTransition
* @brief adds transition into transition table
**/
void AddTransition (FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t)
{
m_Transitions.Insert(t);
//if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[hfsm] +++ ow=" + this.GetOwnerState() + " this=" + this + " t=" + t + " state=" + t.m_srcState + "-------- event=" + t.m_event + "[G=" + t.m_guard +"]/A=" + t.m_action + " --------|> dst=" + t.m_dstState);
if (t.m_event == NULL)
{
Print("Warning (performance): FSM " + this + " has completion transition for src=" + t.m_srcState + " ---NULL----|> dst=" + t.m_dstState);
m_HasCompletions = true;
}
}
/**@fn Start
* @brief starts the state machine by entering the initial_state (using intial_event as argument to initial state's onEntry)
* @param[in] e \p optional event for starting the machind
**/
void Start (FSMEventBase initial_event = NULL, bool useExistingState = false)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] " + this.ToString() + "::Start(" + initial_event.ToString() + "), init_state=" + m_InitialState.ToString());
}
if (!useExistingState)
m_State = m_InitialState;
m_State.OnEntry(initial_event);
if (m_HasCompletions)
ProcessCompletionTransitions();
}
/**@fn IsRunning
* @brief returns true if machine is in running state
**/
bool IsRunning () { return m_State != NULL; }
/**@fn Terminate
* @brief terminates the state machine
**/
void Terminate (FSMEventBase terminal_event = NULL)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] " + this.ToString() + "::Terminate(" + terminal_event.ToString() + ")");
}
if (IsRunning())
{
m_State.OnExit(terminal_event);
m_State = NULL;
}
}
void Abort (FSMEventBase abort_event = NULL)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] " + this.ToString() + "::Abort(" + abort_event.ToString() + ")");
}
if (IsRunning())
{
m_State.OnAbort(abort_event);
m_State = NULL;
}
}
/**@fn Update
* @brief if machine running, call OnUpdate() on current state
**/
void Update (float dt)
{
if (IsRunning())
m_State.OnUpdate(dt);
}
protected ProcessEventResult ProcessAbortTransition (FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t, FSMEventBase e)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] (local abort) state=" + t.m_srcState.ToString() + "-------- ABORT event=" + e.ToString() + "[G=" + t.m_guard.ToString() +"]/A=" + t.m_action.ToString() + " --------|> dst=" + t.m_dstState.ToString());
}
m_State.OnAbort(e); // 1) call onAbort on old state
if (t.m_action)
t.m_action.Action(e); // 2) execute transition action (if any)
auto tmp = t.m_srcState.GetParentState();
if (tmp == t.m_dstState.GetParentState())
{
m_State = t.m_dstState; // 3) change state to new (or NULL)
if (t.m_dstState != NULL)
{
m_State.OnEntry(e); // 4a1) call onEntry on new state (see 4a2) )
return ProcessEventResult.FSM_OK;
}
else
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] abort & terminating fsm: state=" + t.m_srcState.ToString() + " event=" + e.ToString());
}
return ProcessEventResult.FSM_TERMINATED; // 4b) or terminate
}
}
else
{
m_State = NULL;
return ProcessEventResult.FSM_ABORTED; // 4c) or signal abort to parent (with appropriate transition)
}
}
/**@fn FindAbortDestinationState
* @brief i
* @param[in] e \p event that will be used to find suitable transition from current state
* @return FSM_OK if transition found and allowed by guard (if any)
* @return FSM_NO_TRANSITION if no unguarded transition found in submachine or local machine
* @return FSM_TERMINATED state machine has terminated
* @return FSM_ABORTED state machine has aborted
**/
FSMStateBase FindAbortDestinationState (FSMEventBase e)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
if (GetOwnerState())
fsmDebugPrint("[hfsm] SUB! " + GetOwnerState().Type().ToString() + "::FindAbortDestinationState(" + e.Type().ToString() + ")");
else
fsmDebugPrint("[hfsm] root::FindAbortDestinationState(" + e.Type().ToString() + ")");
}
// 1) look in submachine first (if any)
if (m_State && m_State.HasFSM())
{
HFSMBase<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> a = m_State.GetFSM();
FSMStateBase abort_dst = a.FindAbortDestinationState(e);
if (abort_dst)
{
return abort_dst;
}
}
// 2) local transitions
int i = FindFirstUnguardedTransition(e);
if (i == -1)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] abort event has no transition: src=" + m_State.ToString() + " e=" + e.Type().ToString());
}
return NULL;
}
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
return t.m_dstState;
}
/**@fn ProcessAbortEvent
* @brief instructs the hierarchical state machine to process the event e
* @param[in] e \p event that will be used to find suitable transition from current state
* @return FSM_OK if transition found and allowed by guard (if any)
* @return FSM_NO_TRANSITION if no unguarded transition found in submachine or local machine
* @return FSM_TERMINATED state machine has terminated
* @return FSM_ABORTED state machine has aborted
**/
FSMStateBase ProcessAbortEvent(FSMEventBase e, out ProcessEventResult result)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
if (GetOwnerState())
fsmDebugPrint("[hfsm] SUB! " + GetOwnerState().Type().ToString() + "::ProcessAbortEvent(" + e.Type().ToString() + ")");
else
fsmDebugPrint("[hfsm] root::ProcessAbortEvent(" + e.Type().ToString() + ")");
}
// 1) look in submachine first (if any)
if (m_State && m_State.HasFSM())
{
HFSMBase<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> a = m_State.GetFSM();
ProcessEventResult subfsm_res;
FSMStateBase abort_dst = a.ProcessAbortEvent(e, subfsm_res);
switch (subfsm_res)
{
case ProcessEventResult.FSM_OK:
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] event processed by sub machine=" + m_State.ToString());
}
result = subfsm_res; // 1.1) submachine accepted event
return NULL;
}
case ProcessEventResult.FSM_ABORTED:
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] aborted sub machine=" + m_State.ToString());
}
m_State.OnAbort(e); // 1.2) submachine aborted, abort submachine owner (i.e. this)
if (GetOwnerState() == abort_dst.GetParentState())
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] aborted sub machine=" + m_State.ToString() + " & abort destination reached.");
}
m_State = abort_dst;
m_State.OnEntry(e); // 1.3) submachine aborted, call onEntry on new state (cross-hierarchy transition)
result = ProcessEventResult.FSM_OK;
return NULL;
}
else
{
result = ProcessEventResult.FSM_ABORTED; // 1.4) submachine has aborted, look for destination state in parent
return NULL;
}
break;
}
case ProcessEventResult.FSM_TERMINATED:
{
break; // submachine has finished, look for local transitions from exited submachine
}
case ProcessEventResult.FSM_NO_TRANSITION:
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] aborted (but no transition) sub machine=" + m_State.ToString());
}
break; // submachine has no transition, look for transitions in local machine
}
}
}
// 2) local transitions
int i = FindFirstUnguardedTransition(e);
if (i == -1)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] abort event has no transition: src=" + m_State.ToString() + " e=" + e.Type().ToString());
}
result = ProcessEventResult.FSM_NO_TRANSITION;
return NULL;
}
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
ProcessEventResult res = ProcessAbortTransition(t, e);
result = res;
switch (res)
{
case ProcessEventResult.FSM_OK:
{
//if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[hfsm] abort event processed by machine=" + m_State.ToString());
return NULL; // machine accepted event
}
case ProcessEventResult.FSM_ABORTED:
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] aborted sub machine=" + m_State.ToString() + " will fall-through to dst=" + t.m_dstState);
}
return t.m_dstState; // store destination state for parent(s)
}
case ProcessEventResult.FSM_TERMINATED:
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] aborted & terminated sub machine=" + m_State.ToString());
}
break; // submachine has finished, look for local transitions from exited submachine
}
case ProcessEventResult.FSM_NO_TRANSITION:
{
break; // submachine has no transition, look for transitions in local machine
}
}
return NULL;
}
/**@fn ProcessEvent
* @brief instructs the hierarchical state machine to process the event e
* @param[in] e \p event that will be used to find suitable transition from current state
* @return FSM_OK if transition found and allowed by guard (if any)
* @return FSM_NO_TRANSITION if no unguarded transition found in submachine or local machine
* @return FSM_TERMINATED state machine has terminated
**/
ProcessEventResult ProcessEvent(FSMEventBase e)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
if (GetOwnerState())
fsmDebugPrint("[hfsm] SUB!::" + GetOwnerState().Type().ToString() + "::ProcessEvent(" + e.Type().ToString() + ")");
else
fsmDebugPrint("[hfsm] root::ProcessEvent(" + e.Type().ToString() + " =" + e.DumpToString());
}
// 1) completion transitions have priority (if any)
if (m_HasCompletions)
ProcessCompletionTransitions();
// 2) submachine then (if any)
if (m_State && m_State.HasFSM())
{
ProcessEventResult subfsm_res = m_State.ProcessEvent(e);
switch (subfsm_res)
{
case ProcessEventResult.FSM_OK:
{
if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[hfsm] event processed by sub machine=" + m_State.ToString());
return subfsm_res; // submachine accepted event
}
case ProcessEventResult.FSM_TERMINATED:
{
break; // submachine has finished, look for local transitions from exited submachine
}
case ProcessEventResult.FSM_NO_TRANSITION:
{
break; // submachine has no transition, look for transitions in local machine
}
}
}
// 3) local transitions
int i = FindFirstUnguardedTransition(e);
if (i == -1)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] event has no transition: src=" + m_State.ToString() + " e=" + e.Type().ToString());
}
return ProcessEventResult.FSM_NO_TRANSITION;
}
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> row = m_Transitions.Get(i);
ProcessEventResult res;
if (row.m_dstState != NULL)
{
// this is regular transition
if (row.m_srcState.GetParentState() == row.m_dstState.GetParentState())
res = LocalTransition(i, e); // transition is within this state machine
else
Error("cross-hierarchy transition or misconfigured transition detected!");
//res = HierarchicTransition(i, e); // transition has to cross hierarchy
}
else
{
// this is terminating transition
if (row.m_srcState.GetParentState() == GetOwnerState())
res = LocalTransition(i, e); // terminating transition is within this state machine
else
Error("cross-hierarchy transition or misconfigured transition detected!");
//res = HierarchicTransition(i, e); // source node crosses hierarchy (terminate lies always within this machine)
}
return res;
}
protected int FindFirstUnguardedTransition (FSMEventBase e)
{
FSMStateBase curr_state = m_State;
int count = m_Transitions.Count();
for (int i = 0; i < count; ++i)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
if ((t.m_srcState == curr_state) && (t.m_event != NULL) && (t.m_event.Type() == e.Type()))
{
//if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[hfsm] [" + i + "/" + count + "] *** matched! t=" + t + " state=" + t.m_srcState + "-------- event=" + t.m_event + "[G=" + t.m_guard +"]/A=" + t.m_action + " --------|> dst=" + t.m_dstState);
bool hasGuard = t.m_guard != NULL;
if (!hasGuard || (hasGuard && t.m_guard.GuardCondition(e))) // 1) exec guard (if any)
{
return i;
}
}
//else if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[hfsm][" + i + "/" + count + "] ... matching t=" + t + " state=" + t.m_srcState + "-------- event=" + t.m_event + "[G=" + t.m_guard +"]/A=" + t.m_action + " --------|> dst=" + t.m_dstState);
}
return -1;
}
FSMStateBase FindTransitionState(FSMStateBase s, FSMEventBase e)
{
FSMStateBase curr_state = s;
int count = m_Transitions.Count();
for (int i = 0; i < count; ++i)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
if ((t.m_srcState == curr_state) && (t.m_event != NULL) && (t.m_event.Type() == e.Type()))
{
return t.m_dstState;
}
}
return null;
}
FSMStateBase FindGuardedTransitionState(FSMStateBase s, FSMEventBase e)
{
FSMStateBase curr_state = s;
int count = m_Transitions.Count();
for (int i = 0; i < count; ++i)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
if ((t.m_srcState == curr_state) && (t.m_event != NULL) && (t.m_event.Type() == e.Type()))
{
bool hasGuard = t.m_guard != NULL;
if (!hasGuard || (hasGuard && t.m_guard.GuardCondition(e))) // 1) exec guard (if any)
{
return t.m_dstState;
}
}
}
return null;
}
protected int FindFirstCompletionTransition ()
{
if (IsRunning())
{
FSMStateBase curr_state = m_State;
int count = m_Transitions.Count();
for (int i = 0; i < count; ++i)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
//if (LogManager.IsInventoryHFSMLogEnable()) fsmDebugPrint("[hfsm] (local) matching state=" + t.m_srcState + "-------- event=" + t.m_event + "[G=" + t.m_guard +"]/A=" + t.m_action + " --------|> dst=" + t.m_dstState);
if ((t.m_srcState.Type() == curr_state.Type()) && (t.m_event == NULL))
{
bool hasGuard = t.m_guard != NULL;
if (!hasGuard || (hasGuard && t.m_guard.GuardCondition(NULL))) // 1) exec guard (if any)
{
return i;
}
}
}
}
return -1;
}
/**@fn ProcessLocalTransition
* @brief instructs the state machine to process the event locally - no hierarchy is crossed
* @param[in] t \p the transition in m_Transitions
* @param[in] e \p event that will be used to process transition from current state
* @return FSM_OK or FSM_TERMINATED
**/
protected ProcessEventResult ProcessLocalTransition (FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t, FSMEventBase e)
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] (local) state=" + t.m_srcState.ToString() + "-------- event=" + e.ToString() + "[G=" + t.m_guard.ToString() +"]/A=" + t.m_action.ToString() + " --------|> dst=" + t.m_dstState.ToString());
}
m_State.OnExit(e); // 1) call onExit on old state
if (t.m_action)
t.m_action.Action(e); // 2) execute transition action (if any)
m_State = t.m_dstState; // 3) change state to new
if (t.m_dstState != NULL)
{
m_State.OnEntry(e); // 4a) call onEntry on new state
if (GetOwnerState())
GetOwnerState().OnSubMachineChanged(t.m_srcState, t.m_dstState); // 5a) notify owner state about change in submachine
if (m_State)
m_State.OnStateChanged(t.m_srcState, t.m_dstState); // 5b) notify current state about change in machine
return ProcessEventResult.FSM_OK;
}
else
{
if (LogManager.IsInventoryHFSMLogEnable())
{
fsmDebugPrint("[hfsm] terminating fsm: state=" + t.m_srcState.ToString() + " event=" + e.ToString());
}
if (GetOwnerState())
GetOwnerState().OnSubMachineChanged(t.m_srcState, NULL); // 5) notify owner state about change in submachine
return ProcessEventResult.FSM_TERMINATED; // 4b) or terminate
}
}
/**@fn LocalProcessEvent
* @brief instructs the state machine to process the event e
* @param[in] i \p index of the transition in m_Transitions
* @param[in] e \p event that will be used to process transition from current state
* @return FSM_OK or FSM_TERMINATED
**/
protected ProcessEventResult LocalTransition (int i, FSMEventBase e)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
ProcessEventResult ret = ProcessLocalTransition(t, e);
return ret;
}
protected ProcessEventResult ProcessCompletionTransitions ()
{
int completionIdx = FindFirstCompletionTransition();
while (completionIdx != -1)
{
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> row = m_Transitions.Get(completionIdx);
ProcessEventResult res;
if (row.m_dstState != NULL)
{
// this is regular completion transition
if (row.m_srcState.GetParentState() == row.m_dstState.GetParentState())
res = LocalTransition(completionIdx, NULL); // transition is within this state machine
else
Error("cross-hierarchy transition or misconfigured transition detected!");
//res = HierarchicTransition(completionIdx, NULL); // transition has to cross hierarchy
}
else
{
// this is terminating completion transition
if (row.m_srcState.GetParentState() == GetOwnerState())
res = LocalTransition(completionIdx, NULL); // terminating transition is within this state machine
else
Error("cross-hierarchy transition or misconfigured transition detected!");
//res = HierarchicTransition(completionIdx, NULL); // source node crosses hierarchy (terminate lies always within this machine)
}
completionIdx = FindFirstCompletionTransition();
}
return ProcessEventResult.FSM_NO_TRANSITION;
}
};
/** cross-hierarchy transitions (for future use):
protected bool RemoveCommonParents (out array<WeaponStateBase> src_path, out array<WeaponStateBase> dst_path)
{
//for (int j = 0; j < src_path.Count(); ++j) fsmDebugPrint("[hfsm] curr state src_path[" + j + "] = " + src_path[j].ToString());
//for (int k = 0; k < dst_path.Count(); ++k) fsmDebugPrint("[hfsm] next state dst_path[" + k + "] = " + dst_path[k].ToString());
while ((src_path.Count() > 0) && (dst_path.Count() > 0) && (src_path.Get(src_path.Count() - 1) == dst_path.Get(dst_path.Count() - 1)))
{
src_path.Remove(src_path.Count() - 1);
dst_path.Remove(dst_path.Count() - 1);
}
//for (int je = 0; je < src_path.Count(); ++je) fsmDebugPrint("[hfsm] curr state src_path[" + je + "] = " + src_path[je].ToString());
//for (int ke = 0; ke < dst_path.Count(); ++ke) fsmDebugPrint("[hfsm] next state dst_path[" + ke + "] = " + dst_path[ke].ToString());
}
protected ProcessEventResult HierarchicTransition (int i, FSMEventBase e)
{
fsmDebugPrint("[hfsm] { " + this.ToString() + "::HierarchicTransition(" + e.Type().ToString() + ")");
FSMTransition<FSMStateBase, FSMEventBase, FSMActionBase, FSMGuardBase> t = m_Transitions.Get(i);
array<WeaponStateBase> src_path = new array<WeaponStateBase>;
array<WeaponStateBase> dst_path = new array<WeaponStateBase>;
if (GetHierarchyPath(t.m_srcState, src_path))
{
if (t.m_dstState == NULL)
{
Error("cross hierarchy terminate not yet implemented");
WeaponStateBase curr_state = GetCurrentState();
//for (int ex = 0; ex < src_path.Count(); ++ex) { fsmDebugPrint("[hfsm] exiting level=" + ex); src_path[ex].OnExit(e); }
//for (int en = dst_path.Count(); en --> 0;)
//for (int en = 0; en < dst_path.Count(); ++en) { fsmDebugPrint("[hfsm] entering level=" + en); int ii = dst_path.Count() - 1 - en; dst_path[ii].OnEntry(e); }
fsmDebugPrint("[hfsm] } " + this.ToString() + "::HierarchicTransition(" + e.Type().ToString() + ") --> terminated");
return ProcessEventResult.FSM_TERMINATED;
}
else if (GetHierarchyPath(t.m_dstState, dst_path))
{
Error("cross hierarchy event implemented, not fully debugged");
RemoveCommonParents(src_path, dst_path);
for (int ex = 0; ex < src_path.Count(); ++ex)
{
src_path[ex].OnExit(e); // 1) call OnExit on all nodes on src_path ()
}
//if (t.m_action)
// t.m_action.Action(e); // 2) execute transition action (if any)
//m_State = t.m_dstState; // 4) change state to new
//for (int en = dst_path.Count(); en --> 0;)
for (int en = 0; en < dst_path.Count(); ++en)
{
int ii = dst_path.Count() - 1 - en;
dst_path[ii].OnEntry(e); // 5) call OnEntry on all nodes on dst_path (@NOTE: reverse order)
}
fsmDebugPrint("[hfsm] } " + this.ToString() + "::HierarchicTransition(" + e.Type().ToString() + ") --> OK");
return ProcessEventResult.FSM_OK;
}
else
{
Error("unhandled case, what did you do?");
}
}
fsmDebugPrint("[hfsm] } " + this.ToString() + "::HierarchicTransition(" + e.Type().ToString() + ") --> no transition");
return ProcessEventResult.FSM_NO_TRANSITION;
}
*/