weaponfsm.c

Go to the documentation of this file.

 
class WeaponFSM extends HFSMBase<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase>
{
 private static const int MAX_SYNCHRONIZE_ATTEMPTS = 12;
 private static const int MIN_SYNCHRONIZE_INTERVAL = 3000; // ms
 private static const int RESET_SYNCHRONIZE_THRESHOLD = 3600000; // ms
 private int m_SynchronizeAttempts;
 private int m_LastSynchronizeTime;
 
 protected int m_NextStateId = 0; 
 protected ref array<WeaponStateBase> m_UniqueStates = new array<WeaponStateBase>; 
 
 protected void SetInternalID(WeaponStateBase state)
 {
 if (state && state.GetInternalStateID() == -1)
 {
 state.SetInternalStateID(m_NextStateId);
 
 //if (LogManager.IsWeaponLogEnable()) { wpnDebugSpam("[wpnfsm] " + Object.GetDebugName(m_weapon) + " unique state=" + state + " has id=" + m_NextStateId); }
 m_UniqueStates.Insert(state);
 ++m_NextStateId;
 }
 }
 
 override void AddTransition(FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> t)
 {
 super.AddTransition(t);
 
 SetInternalID(t.m_srcState);
 SetInternalID(t.m_dstState);
 }
 
 override protected ProcessEventResult ProcessLocalTransition(FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> t, WeaponEventBase 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());
 
 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
 
 ValidateAndRepair();
 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
 ValidateAndRepair();
 return ProcessEventResult.FSM_TERMINATED; // 4b) or terminate
 }
 }
 
 override protected ProcessEventResult ProcessAbortTransition(FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> t, WeaponEventBase 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());
 
 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) )
 ValidateAndRepair();
 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;
 ValidateAndRepair();
 return ProcessEventResult.FSM_ABORTED; // 4c) or signal abort to parent (with appropriate transition)
 }
 }
 
 override WeaponStateBase ProcessAbortEvent (WeaponEventBase 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<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> a = m_State.GetFSM();
 ProcessEventResult subfsm_res;
 WeaponStateBase 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
 ValidateAndRepair();
 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;
 ValidateAndRepair();
 return NULL;
 }
 else
 {
 result = ProcessEventResult.FSM_ABORTED; // 1.4) submachine has aborted, look for destination state in parent
 ValidateAndRepair();
 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;
 ValidateAndRepair();
 return NULL;
 }
 
 m_State.OnAbort(e);
 
 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;
 ValidateAndRepair();
 return NULL;
 }
 
 FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> 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());
 ValidateAndRepair();
 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);
 
 ValidateAndRepair();
 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;
 } 
 
 override ProcessEventResult ProcessEvent (WeaponEventBase 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;
 }
 
 m_State.OnExit(e);
 
 // 3.5) find correct transition after handled exit
 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<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> 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;
 }
 
 WeaponStateBase FindStateForInternalID(int id)
 {
 int state_count = m_UniqueStates.Count();
 for (int idx = 0; idx < state_count; ++idx)
 {
 int state_id = m_UniqueStates.Get(idx).GetInternalStateID();
 if (state_id == id)
 return m_UniqueStates.Get(idx);
 }
 return null;
 }
 
 WeaponStableState FindStableStateForID(int id)
 {
 if (id == 0)
 return null;
 
 int count = m_Transitions.Count();
 for (int i = 0; i < count; ++i)
 {
 WeaponTransition trans = m_Transitions.Get(i);
 WeaponStableState state = WeaponStableState.Cast(trans.m_srcState);
 if (state && id == state.GetCurrentStateID())
 return state;
 }
 return null;
 }
 
 protected bool LoadAndSetCurrentFSMState(ParamsReadContext ctx, int version)
 {
 int curr_state_id = -1;
 if (!ctx.Read(curr_state_id))
 {
 Error("[wpnfsm] LoadCurrentFSMState - cannot read current state");
 return false;
 }
 
 WeaponStateBase state = FindStateForInternalID(curr_state_id);
 if (state)
 {
 Terminate();
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] synced current state=" + state + " id=" + curr_state_id); } 
 m_State = state; 
 Start(null, true);
 return true;
 }
 else
 Error("[wpnfsm] LoadCurrentFSMState - cannot find state for id=" + curr_state_id);
 return false;
 
 }
 
 bool LoadCurrentFSMState(ParamsReadContext ctx, int version)
 {
 if (LoadAndSetCurrentFSMState(ctx, version))
 {
 bool res = m_State.LoadCurrentFSMState(ctx, version);
 if (LogManager.IsWeaponLogEnable()) { wpnDebugSpam("[wpnfsm] LoadCurrentFSMState - loaded current state=" + GetCurrentState()); }
 return res;
 }
 return false;
 }
 
 bool LoadCurrentUnstableFSMState(ParamsWriteContext ctx, int version)
 {
 if (LoadAndSetCurrentFSMState(ctx, version))
 {
 // read all substates
 int state_count = m_UniqueStates.Count();
 for (int idx = 0; idx < state_count; ++idx)
 {
 if (LogManager.IsWeaponLogEnable()) { wpnDebugSpam("[wpnfsm] LoadCurrentUnstableFSMState " + idx + "/" + state_count + " id=" + m_UniqueStates.Get(idx).GetInternalStateID() + " state=" + m_UniqueStates.Get(idx)); }
 if (!m_UniqueStates.Get(idx).LoadCurrentFSMState(ctx, version))
 Error("[wpnfsm] LoadCurrentUnstableFSMState - cannot load unique state " + idx + "/" + state_count + " with id=" + m_UniqueStates.Get(idx).GetInternalStateID() + " state=" + m_UniqueStates.Get(idx));
 }
 return true;
 }
 return false;
 }
 
 bool SaveCurrentFSMState(ParamsWriteContext ctx)
 {
 WeaponStateBase state = GetCurrentState();
 int curr_state_id = state.GetInternalStateID();
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] SaveCurrentFSMState - saving current state=" + GetCurrentState() + " id=" + curr_state_id); }
 
 if (!ctx.Write(curr_state_id))
 {
 Error("[wpnfsm] SaveCurrentFSMState - cannot save curr_state_id=" + curr_state_id);
 return false;
 }
 
 // write only current state
 if (!state.SaveCurrentFSMState(ctx))
 {
 Error("[wpnfsm] SaveCurrentFSMState - cannot save currrent state=" +state);
 return false;
 }
 return true;
 }
 
 bool SaveCurrentUnstableFSMState(ParamsWriteContext ctx)
 {
 WeaponStateBase state = GetCurrentState();
 int curr_state_id = state.GetInternalStateID();
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] SaveCurrentUnstableFSMState - saving current state=" + GetCurrentState() + " id=" + curr_state_id); }
 
 if (!ctx.Write(curr_state_id))
 {
 Error("[wpnfsm] SaveCurrentFSMState - cannot save curr_state_id=" + curr_state_id);
 return false;
 }
 
 // write all substates
 int state_count = m_UniqueStates.Count();
 for (int idx = 0; idx < state_count; ++idx)
 {
 int state_id = m_UniqueStates.Get(idx).GetInternalStateID();
 if (state_id != -1)
 {
 if (LogManager.IsWeaponLogEnable()) { wpnDebugSpam("[wpnfsm] SaveCurrentUnstableFSMState " + idx + "/" + state_count + " id=" + state_id + " name=" + m_UniqueStates.Get(idx)); }
 if (!m_UniqueStates.Get(idx).SaveCurrentFSMState(ctx))
 Error("SaveCurrentUnstableFSMState - cannot save unique state=" + m_UniqueStates.Get(idx) + " idx=" + idx + "/" + state_count + " with id=" + state_id);
 }
 else
 Error("[wpnfsm] SaveCurrentUnstableFSMState state=" + m_UniqueStates.Get(idx) + " with unassigned ID!");
 }
 return true;
 }
 
 void ValidateAndRepair()
 {
 Internal_ValidateAndRepair();
 }
 
 protected bool Internal_ValidateAndRepair()
 {
 bool repaired = false;
 
 // Only repair stable states
 WeaponStableState state = WeaponStableState.Cast(m_State); 
 if (state && state.IsRepairEnabled())
 { 
 Weapon_Base weapon = state.m_weapon;
 if (weapon)
 { 
 repaired |= ValidateAndRepairHelper(weapon,
 "MagazineRepair",
 state.HasMagazine(), ( weapon.GetMagazine(0) != null ),
 new WeaponEventAttachMagazine, new WeaponEventDetachMagazine,
 state);
 
 repaired |= ValidateAndRepairHelper(weapon,
 "JammedRepair",
 state.IsJammed(), weapon.IsJammed(),
 new WeaponEventTriggerToJam, new WeaponEventUnjam,
 state);
 
 if (weapon.IsJammed())
 return repaired;
 
 int nMuzzles = weapon.GetMuzzleCount();
 switch (nMuzzles)
 {
 case 1:
 {
 repaired |= ValidateAndRepairHelper(weapon,
 "ChamberFiredRepair",
 state.IsChamberFiredOut(0), weapon.IsChamberFiredOut(0),
 new WeaponEventTrigger, new WeaponEventMechanism,
 state);
 
 repaired |= ValidateAndRepairHelper(weapon,
 "ChamberRepair",
 state.IsChamberFull(0), weapon.IsChamberFullEx(0),
 new WeaponEventLoad1Bullet, new WeaponEventMechanism,
 state);
 
 break;
 }
 default:
 { 
 for (int i = 0; i < nMuzzles; ++i)
 {
 repaired |= ValidateAndRepairHelper(weapon,
 "ChamberFiredRepair",
 state.IsChamberFiredOut(i), weapon.IsChamberFiredOut(i),
 null, null, // A bit brute forced, not really any clean way to transition
 state);
 
 repaired |= ValidateAndRepairHelper(weapon,
 "ChamberRepair",
 state.IsChamberFull(i), weapon.IsChamberFull(i),
 null, null, // A bit brute forced, not really any clean way to transition
 state);
 }
 
 break;
 }
 }
 }
 }
 
 return repaired;
 }
 
 protected bool ValidateAndRepairHelper(Weapon_Base weapon, string name, bool stateCondition, bool gunCondition, WeaponEventBase e1, WeaponEventBase e2, out WeaponStableState state)
 {
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + weapon.GetDebugName(weapon) + " ValidateAndRepair - " + name + " - " + m_State + " - state: " + stateCondition + " & weapon: " + gunCondition); }
 
 if (stateCondition != gunCondition)
 {
 WeaponStableState repairedState;
 
 // Seeing this message is not TOO bad, it just means this system is working
 // It is simply being listed in the logs to identify how much the FSM state and weapon state still desyncs
 // Which can be because of a myriad of causes, such as incorrectly set up transitions
 // Or simply certain timings of certain actions or interrupts lined up perfectly, which can have repro rates such as 1/300
 Error(string.Format("[wpnfsm] ValidateAndRepair Attempting to repair: %1 - %2 - %3 - state: %4 != weapon: %5",
 weapon.GetDebugName(weapon), name, m_State, stateCondition, gunCondition));
 
 if (e1 && e2)
 repairedState = ValidateAndRepairStateFinder(gunCondition, e1, e2, state);
 
 if (repairedState)
 {
 Terminate();
 m_State = repairedState;
 Start(null, true);
 state = repairedState;
 weapon.SyncSelectionState(state.HasBullet(), state.HasMagazine());
 repairedState.SyncAnimState();
 
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + weapon.GetDebugName(weapon) + " ValidateAndRepair - " + name + " - Result - " + m_State); }
 return true;
 }
 else
 {
 // Last ditch effort
 if (m_SynchronizeAttempts < MAX_SYNCHRONIZE_ATTEMPTS)
 {
 int currentTime = g_Game.GetTime();
 int timeDiff = currentTime - m_LastSynchronizeTime;
 
 // Careful with calling synchronize
 if (timeDiff > MIN_SYNCHRONIZE_INTERVAL)
 {
 // If a lot of time passed since last attempt
 // There is a possibility the weapon was fixed for a period
 if (timeDiff > RESET_SYNCHRONIZE_THRESHOLD)
 m_SynchronizeAttempts = 0;
 
 // Only call this on server or in SP
 // Synchronize will ask the server for its FSM state anyways
 if (g_Game.IsServer())
 weapon.RandomizeFSMState();
 
 weapon.Synchronize();
 
 ++m_SynchronizeAttempts;
 m_LastSynchronizeTime = currentTime;
 }
 }
 else
 {
 OnFailThresholdBreached(weapon, name, stateCondition, gunCondition);
 }
 }
 }
 
 return false;
 }
 
 protected void OnFailThresholdBreached(Weapon weapon, string name, bool stateCondition, bool gunCondition)
 {
 // Now seeing THIS one, after the one above, THIS one CAN be bad
 // As the state was identified as being desynced with the actual weapon state
 // But the system was unable to fix it, so the weapon is now working improperly or not at all
 // There is even the possibility that this weapon is now permanently broken
 Error(string.Format("[wpnfsm] %1 ValidateAndRepair THRESHOLD BREACH - %2 - %3 - state: %4 != weapon: %5",
 weapon.GetDebugName(weapon), name, m_State, stateCondition, gunCondition));
 
 // At this point might even consider just deleting the weapon :c
 }
 
 protected WeaponStableState ValidateAndRepairStateFinder(bool condition, WeaponEventBase e1, WeaponEventBase e2, WeaponStableState state)
 {
 WeaponStateBase interState;
 if (condition)
 interState = FindTransitionState(state, e1);
 else
 interState = FindTransitionState(state, e2);
 
 WeaponEventBase e = new WeaponEventHumanCommandActionFinished;
 return WeaponStableState.Cast(FindGuardedTransitionState(interState, e));
 }
 
 bool OnStoreLoad(ParamsReadContext ctx, int version)
 {
 int id = 0;
 ctx.Read(id);
 WeaponStableState state = FindStableStateForID(id);
 if (state)
 {
 Terminate();
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] OnStoreLoad - loading current state=" + state + " id=" + id); } 
 m_State = state;
 Start(null, true);
 }
 else
 {
 Print("[wpnfsm] Warning! OnStoreLoad - cannot load curent weapon state, id=" + id);
 }
 
 return true;
 }
 
 int GetCurrentStableStateID()
 {
 // 1) if current state is stable state then return ID directly
 WeaponStableState state = WeaponStableState.Cast(GetCurrentState());
 if (state)
 return state.GetCurrentStateID();
 
 // 2) otherwise find closest stable state (by looking on abort event)
 WeaponStateBase abort_dst = FindAbortDestinationState(new WeaponEventHumanCommandActionAborted(null));
 WeaponStableState closest_stable_state = WeaponStableState.Cast(abort_dst);
 
 if (closest_stable_state)
 {
 Print("[wpnfsm] Save occured in fsm transition! current state=" + GetCurrentState() + " closes stable state=" + closest_stable_state + " id=" + closest_stable_state.GetCurrentStateID());
 return closest_stable_state.GetCurrentStateID();
 } 
 
 Print("[wpnfsm] Warning! Save occured in fsm transition! GetCurrentStateID - cannot find closest weapon stable state.");
 return 0;
 }
 
 int GetInternalStateID()
 {
 WeaponStateBase curr = GetCurrentState();
 int id = 0;
 if (curr)
 id = curr.GetInternalStateID();
 return id;
 }
 
 void OnStoreSave(ParamsWriteContext ctx)
 {
 int id = GetCurrentStableStateID();
 if (LogManager.IsWeaponLogEnable()) { wpnDebugSpamALot("[wpnfsm] OnStoreSave - saving current state=" + GetCurrentState() + " id=" + id); }
 ctx.Write(id);
 }
 
 void RandomizeFSMState(bool hasBullet, bool hasMagazine, bool isJammed)
 {
 array<MuzzleState> muzzleStates;
 if (hasBullet)
 muzzleStates = { MuzzleState.L };
 else
 muzzleStates = { MuzzleState.E };
 
 RandomizeFSMStateEx(muzzleStates, hasMagazine, isJammed);
 }
 
 void RandomizeFSMStateEx(array<MuzzleState> muzzleStates, bool hasMagazine, bool isJammed)
 {
 array<WeaponStableState> candidates = new array<WeaponStableState>;
 int tc = m_Transitions.Count();
 foreach (WeaponTransition trans : m_Transitions)
 {
 WeaponStableState state = WeaponStableState.Cast(trans.m_srcState);
 if (state && state.HasMagazine() == hasMagazine && state.IsJammed() == isJammed)
 {
 if (state.IsSingleState())
 {
 // There is only one, insert it and stop
 candidates.Insert(state);
 break;
 }
 
 int nMuzzles = muzzleStates.Count();
 int nMuzzlesState = state.GetMuzzleStateCount();
 if (nMuzzles != nMuzzlesState)
 {
 ErrorEx(string.Format("Number of muzzles on the weapon (%1) does not correspond with what state has configured (%2).", nMuzzles, nMuzzlesState));
 continue;
 }
 
 bool equal = true;
 for (int i = 0; i < nMuzzles; ++i)
 {
 if (muzzleStates[i] != state.GetMuzzleState(i))
 {
 equal = false;
 break;
 }
 }
 
 if (equal)
 candidates.Insert(state);
 }
 }
 
 int cc = candidates.Count();
 if (cc)
 {
 int randomIndex = Math.RandomInt(0, cc);
 WeaponStableState selected = candidates.Get(randomIndex);
 Terminate();
 m_State = selected;
 if (!Internal_ValidateAndRepair())
 Start(null, true);
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] RandomizeFSMState - randomized current state=" + m_State + " id=" + selected.GetCurrentStateID()); }
 selected.SyncAnimState();
 }
 else
 {
 if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] RandomizeFSMState - warning - cannot randomize, no states available"); }
 }
 }
};