WeaponFSM.c

См. документацию.

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 && candidates.Find(state) == INDEX_NOT_FOUND && 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"); }
        }
    }
};