weapon_base.c

Go to the documentation of this file.

 
class AbilityRecord
{
    int m_action; 
    int m_actionType; 
    void AbilityRecord (int a, int at) { m_action = a; m_actionType = at; }
};
 
enum WeaponWithAmmoFlags
{
    NONE = 0,
    CHAMBER = 1,
    CHAMBER_RNG = 2,
    CHAMBER_RNG_SPORADIC = 4,
    QUANTITY_RNG = 8,
    AMMO_MAG_RNG = 16,
    AMMO_CHAMBER_RNG = 32,
    MAX_CAPACITY_MAG = 64,
}
 
typedef FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> WeaponTransition; 
 
class Weapon_Base extends Weapon
{
    const int SAMF_DEFAULT = WeaponWithAmmoFlags.CHAMBER | WeaponWithAmmoFlags.MAX_CAPACITY_MAG;
    const int SAMF_RNG = WeaponWithAmmoFlags.CHAMBER_RNG | WeaponWithAmmoFlags.QUANTITY_RNG;
    
    protected const float DEFAULT_DAMAGE_ON_SHOT = 0.05;
    protected ref array<ref AbilityRecord> m_abilities = new array<ref AbilityRecord>;      
    protected ref WeaponFSM m_fsm;  
    protected bool m_isJammed = false;
    protected bool m_LiftWeapon = false;
    protected bool m_BayonetAttached;
    protected bool m_ButtstockAttached;
    protected bool m_Charged = false;
    protected bool m_WeaponOpen = false;
    protected int m_BurstCount;
    protected int m_BayonetAttachmentIdx;
    protected int m_ButtstockAttachmentIdx;
    protected int m_weaponAnimState = -1; 
    protected int m_magazineSimpleSelectionIndex = -1;
    protected int m_weaponHideBarrelIdx = -1; //index in simpleHiddenSelections cfg array
    protected float m_DmgPerShot = 0; //default is set to zero, since C++ solution has been implemented. See 'damageBarrel' and 'barrelArmor' in configs.
    protected float m_WeaponLength;
    protected float m_WeaponLiftCheckVerticalOffset;
    protected float m_ShoulderDistance;
    protected vector m_LastLiftPosition;
    ref array<int> m_bulletSelectionIndex = new array<int>;
    ref array<float> m_DOFProperties;
    ref array<float> m_ChanceToJam = new array<float>;
    protected float m_ChanceToJamSync = 0;
    protected ref PropertyModifiers m_PropertyModifierObject;
    protected PhxInteractionLayers hit_mask = PhxInteractionLayers.CHARACTER | PhxInteractionLayers.BUILDING | PhxInteractionLayers.DOOR | PhxInteractionLayers.VEHICLE | PhxInteractionLayers.ROADWAY | PhxInteractionLayers.TERRAIN | PhxInteractionLayers.ITEM_SMALL | PhxInteractionLayers.ITEM_LARGE | PhxInteractionLayers.FENCE | PhxInteractionLayers.AI;
 
    void Weapon_Base()
    {
        //m_DmgPerShot      = ConfigGetFloat("damagePerShot");
        m_BayonetAttached   = false;
        m_ButtstockAttached = false;
        m_BayonetAttachmentIdx = -1;
        m_ButtstockAttachmentIdx = -1;
        m_BurstCount = 0;
        m_DOFProperties = new array<float>;
        
        if ( ConfigIsExisting("simpleHiddenSelections") )
        {
            TStringArray selectionNames = new TStringArray;
            ConfigGetTextArray("simpleHiddenSelections",selectionNames);
            m_weaponHideBarrelIdx = selectionNames.Find("hide_barrel");
            m_magazineSimpleSelectionIndex = selectionNames.Find("magazine");
            
            int bulletIndex = selectionNames.Find("bullet");
            if ( bulletIndex != -1 )
            { 
                m_bulletSelectionIndex.Insert(bulletIndex);
            
                for (int i = 2; i < 100; i++)
                {
                    bulletIndex = selectionNames.Find(string.Format("bullet%1",i));
                    if (bulletIndex != -1)
                    {
                        m_bulletSelectionIndex.Insert(bulletIndex);
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
        
        InitWeaponLength();
        InitWeaponLiftCheckVerticalOffset();
        InitShoulderDistance();
        InitDOFProperties(m_DOFProperties);
        if (GetGame().IsServer())
        {
            InitReliability(m_ChanceToJam);
        }
        InitStateMachine();
    }
 
    void InitStateMachine() { }
    
    override void EEInit()
    {
        super.EEInit();
        
        if (GetGame().IsServer())
        {
            GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).Call( AssembleGun );
        }
    }
    
    void SetInitialState(WeaponStableState initState)
    {
        m_fsm.SetInitialState(initState);
        SetCharged(!initState.IsDischarged());
        SetWeaponOpen(!initState.IsWeaponOpen());
        SetGroundAnimFrameIndex(initState.m_animState);
    }
    
    bool IsCharged()
    {
        return m_Charged;
    }
    
    void SetCharged(bool value)
    {
        m_Charged = value;
    }   
    
    bool IsWeaponOpen()
    {
        return m_WeaponOpen;
    }
    
    void SetWeaponOpen(bool value)
    {
        m_WeaponOpen = value;
    }
 
    override protected float GetWeightSpecialized(bool forceRecalc = false)
    {
        float baseWeight = GetInventoryAndCargoWeight(forceRecalc);
        float ammoWeight;
        float ammoDamage;
        string bulletTypeName, ammoTypeName;
        
        int muzzleCount = GetMuzzleCount();
        #ifdef DEVELOPER
        if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
        {
            WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
            data1.SetCalcDetails("TWPN: " + m_ConfigWeight+"(item weight) + " + baseWeight +"(contents weight)" );
        }
        #endif
        for (int muzzleIndex = 0; muzzleIndex < muzzleCount; muzzleIndex++)
        {
            //chamber weight
            if (!IsChamberEmpty(muzzleIndex))
            {
                ammoTypeName = GetChamberAmmoTypeName(muzzleIndex);
                ammoWeight += g_Game.ConfigGetFloat(string.Format("CfgMagazines %1 weight", ammoTypeName));
                
                #ifdef DEVELOPER
                if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
                {
                    WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
                    data2.AddCalcDetails( g_Game.ConfigGetFloat("CfgMagazines " + ammoTypeName + " weight").ToString() +"(chamber weight)");
                }
                #endif
            }
            
            //correctly calculates internal magazine weight based on the ammo type of each bullet
            if (HasInternalMagazine(muzzleIndex))
            {
                #ifdef DEVELOPER
                float debugInternalMagWeight;
                #endif
                int cartridgeCount = GetInternalMagazineCartridgeCount(muzzleIndex);
                for (int cartridgeIndex = 0; cartridgeIndex < cartridgeCount; cartridgeIndex++)
                {
                    GetInternalMagazineCartridgeInfo(muzzleIndex, cartridgeIndex, ammoDamage, bulletTypeName);
                    ammoWeight += Ammunition_Base.GetAmmoWeightByBulletType(bulletTypeName);
                    #ifdef DEVELOPER
                    debugInternalMagWeight += g_Game.ConfigGetFloat("CfgMagazines " + ammoTypeName + " weight");
                    #endif
                }
                #ifdef DEVELOPER
 
                if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
                {
                    WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
                    data3.AddCalcDetails(debugInternalMagWeight.ToString()+ "(internal mag weight)");
                }
                #endif
            }
            
        }
        return ammoWeight + baseWeight + GetConfigWeightModified();
    }
    void AssembleGun();
 
    bool CanProcessAction(int action, int actionType)
    {
        return false; // @TODO
    }
    bool HasActionAbility(int action, int actionType)
    {
        int count = GetAbilityCount();
        for (int i = 0; i < count; ++i)
        {
            AbilityRecord rec = GetAbility(i);
            if (rec.m_action == action && rec.m_actionType == actionType)
                return true;
        }
        return false;
    }
    int GetAbilityCount() { return m_abilities.Count(); }
    AbilityRecord GetAbility(int index) { return m_abilities.Get(index); }
 
    bool CanProcessWeaponEvents() { return m_fsm && m_fsm.IsRunning(); }
 
    WeaponStateBase GetCurrentState() { return m_fsm.GetCurrentState(); }
 
    bool IsWaitingForActionFinish()
    {
        return CanProcessWeaponEvents() && GetCurrentState().IsWaitingForActionFinish();
    }
 
    bool IsIdle()
    {
        return CanProcessWeaponEvents() && GetCurrentState().IsIdle();
    }
 
    bool ProcessWeaponEvent(WeaponEventBase e)
    {
        SyncEventToRemote(e);
        
        // @NOTE: synchronous events not handled by fsm
        if (e.GetEventID() == WeaponEventID.SET_NEXT_MUZZLE_MODE)
        {
            SetNextMuzzleMode(GetCurrentMuzzle());
            return true;
        }
 
        if (m_fsm.ProcessEvent(e) == ProcessEventResult.FSM_OK)
            return true;
 
        //if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("FSM refused to process event (no transition): src=" + GetCurrentState().ToString() + " event=" + e.ToString()); }
        return false;
    }
    bool ProcessWeaponAbortEvent(WeaponEventBase e)
    {
        SyncEventToRemote(e);
        
        ProcessEventResult aa;
        m_fsm.ProcessAbortEvent(e, aa);
        return aa == ProcessEventResult.FSM_OK;
    }
 
    bool CanChamberBullet(int muzzleIndex, Magazine mag)
    {
        return CanChamberFromMag(muzzleIndex, mag) && (!IsChamberFull(muzzleIndex) || IsChamberFiredOut(muzzleIndex) || !IsInternalMagazineFull(muzzleIndex));
    }
 
    void SetWeaponAnimState(int state)
    {
        m_weaponAnimState = state;
        SetGroundAnimFrameIndex(state);
    }
    void ResetWeaponAnimState()
    {
        if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(this) + " resetting anim state: " + typename.EnumToString(PistolAnimState, m_weaponAnimState) + " --> " + typename.EnumToString(PistolAnimState, -1));
        m_weaponAnimState = -1;
    }
    int GetWeaponAnimState() { return m_weaponAnimState; }
 
    void EEFired(int muzzleType, int mode, string ammoType)
    {       
        if ( !GetGame().IsDedicatedServer() )
        {
            ItemBase suppressor = GetAttachedSuppressor();
            
            // Muzzle flash & overheating effects
            ItemBase.PlayFireParticles(this, muzzleType, ammoType, this, suppressor, "CfgWeapons" );
            IncreaseOverheating(this, ammoType, this, suppressor, "CfgWeapons");
            
            if (suppressor)
            {
                ItemBase.PlayFireParticles(this, muzzleType, ammoType, suppressor, NULL, "CfgVehicles" );
                suppressor.IncreaseOverheating(this, ammoType, this, suppressor, "CfgVehicles");
            }
        }
        
        //obsolete, replaced by C++ solution!
/*
        if (GetGame().IsServer())
        {
            AddHealth("","Health",-m_DmgPerShot); //damages weapon
            if (suppressor)
                suppressor.AddHealth("","Health",-m_DmgPerShot); //damages suppressor; TODO add suppressor damage coeficient/parameter (?) to suppressors/weapons (?)
        }
*/      
        //JamCheck(muzzleType);
        
        #ifdef DIAG_DEVELOPER
        MiscGameplayFunctions.UnlimitedAmmoDebugCheck(this);
        #endif
    }
    
    bool JamCheck(int muzzleIndex )
    {
        PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
        if ( player )
        {
            float rnd = player.GetRandomGeneratorSyncManager().GetRandom01(RandomGeneratorSyncUsage.RGSJam);
            //Print("Random Jam - " + rnd);
            if (rnd < GetSyncChanceToJam())
                return true;
        }
        return false;
    }
    
    void ShowBullet(int muzzleIndex)
    {
        if ( m_bulletSelectionIndex.Count() > muzzleIndex )
        {
            SetSimpleHiddenSelectionState(m_bulletSelectionIndex[muzzleIndex],1);
        }
        else
            SelectionBulletShow();
    }
    
    void HideBullet(int muzzleIndex)
    {
        if ( m_bulletSelectionIndex.Count() > muzzleIndex )
        {
            SetSimpleHiddenSelectionState(m_bulletSelectionIndex[muzzleIndex],0);
        }
        else
            SelectionBulletHide();
    }
    
    bool IsJammed() { return m_isJammed; }
    bool CanEjectBullet() {return true;}
    void SetJammed(bool value) { m_isJammed = value; }
    float GetSyncChanceToJam() { return m_ChanceToJamSync; }
    float GetChanceToJam()
    {
        int level = GetHealthLevel();
    
        if (level >= 0 && level < m_ChanceToJam.Count())
            return m_ChanceToJam[level];
        else
            return 0.0;
    }
    
    void SyncSelectionState(bool has_bullet, bool has_mag)
    {
        if (has_bullet)
        {   
            string chamberedAmmoTypeName;
            float chamberedAmmoDmg;
            
            if ( GetCartridgeInfo(0, chamberedAmmoDmg, chamberedAmmoTypeName) )
            {
                EffectBulletShow(0, chamberedAmmoDmg, chamberedAmmoTypeName);
            }
            //ShowBullet(0);
            SelectionBulletShow();
        }
        else
        {   
            //HideBullet(0);
            SelectionBulletHide();
            EffectBulletHide(0);
        }
 
        if (has_mag)
            ShowMagazine();
        else
            HideMagazine();
    }
    
    /*override void EEOnAfterLoad()
    {
        super.EEOnAfterLoad();
        
        string chamberedAmmoTypeName;
        float chamberedAmmoDmg;
 
        if ( GetCartridgeInfo(0, chamberedAmmoDmg, chamberedAmmoTypeName) )
        {
            EffectBulletShow(0, chamberedAmmoDmg, chamberedAmmoTypeName);
        }
        
    }*/
    
    void ForceSyncSelectionState()
    {
        int nMuzzles = GetMuzzleCount();
        for (int i = 0; i < nMuzzles; ++i)
        {
            if (IsChamberFull(i))
            {
                ShowBullet(i);
                float damage;
                string ammoTypeName;
                GetCartridgeInfo(i, damage, ammoTypeName);
                EffectBulletShow(i, damage, ammoTypeName);
            }
            else
            {
                HideBullet(i);
                EffectBulletHide(i);
            }
            
            Magazine mag = GetMagazine(i);
            if (mag)
                ShowMagazine();
            else
                HideMagazine();
        }
    }
 
    override bool OnStoreLoad(ParamsReadContext ctx, int version)
    {
        if ( !super.OnStoreLoad(ctx, version) )
            return false;
        
        
        if (version >= 113)
        {
            int current_muzzle = 0;
            if (!ctx.Read(current_muzzle))
            {
                Error("Weapon.OnStoreLoad " + this + " cannot read current muzzle!");
                return false;
            }
            
            if (current_muzzle >= GetMuzzleCount() || current_muzzle < 0)
                Error("Weapon.OnStoreLoad " + this + " trying to set muzzle index " + current_muzzle + " while it only has " + GetMuzzleCount() + " muzzles!");
            else
                SetCurrentMuzzle(current_muzzle);
        }       
        
        if (version >= 105)
        {
            int mode_count = 0;
            if (!ctx.Read(mode_count))
            {
                Error("Weapon.OnStoreLoad " + this + " cannot read mode count!");
                return false;
            }
                
            for (int m = 0; m < mode_count; ++m)
            {
                int mode = 0;
                if (!ctx.Read(mode))
                {
                    Error("Weapon.OnStoreLoad " + this + " cannot read mode[" + m + "]");
                    return false;
                }
                
                if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " OnStoreLoad - loaded muzzle[" + m + "].mode = " + mode); }
                SetCurrentMode(m, mode);
            }
        }
        
        if ( version >= 106 )
        {
            if ( !ctx.Read(m_isJammed) )
            {
                Error("Weapon.OnStoreLoad cannot load jamming state");
                return false;
            }
        }
 
        if (m_fsm)
        {
            if (!m_fsm.OnStoreLoad(ctx, version))
                return false;
            
            WeaponStableState wss = WeaponStableState.Cast(m_fsm.GetCurrentState());
            if (wss)
            {
                SetGroundAnimFrameIndex(wss.m_animState);
            }
            
        }
        else
        {
            int dummy = 0;
            if (!ctx.Read(dummy))
                return false;
        }
 
        return true;
    }
 
    void SaveCurrentFSMState(ParamsWriteContext ctx)
    {
        if (m_fsm && m_fsm.IsRunning())
        {
            if (m_fsm.SaveCurrentFSMState(ctx))
            {
                if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " state saved."); }
            }
            else
                Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " state NOT saved.");
        }
        else
            Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon.SaveCurrentFSMState: trying to save weapon without FSM (or uninitialized weapon) this=" + this + " type=" + GetType());
    }
 
    bool LoadCurrentFSMState(ParamsReadContext ctx, int version)
    {
        if (m_fsm)
        {
            if (m_fsm.LoadCurrentFSMState(ctx, version))
            {
                WeaponStableState state = WeaponStableState.Cast(GetCurrentState());
                if (state)
                {
                    SyncSelectionState(state.HasBullet(), state.HasMagazine());
                    state.SyncAnimState();
                    if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " stable state loaded and synced."); }
                    return true;
                }
                else
                {
                    if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " unstable/error state loaded."); }
                    return false;
                }
            }
            else
            {
                Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " did not load.");
                return false;
            }
        }
        else
        {
            Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon.LoadCurrentFSMState: trying to load weapon without FSM (or uninitialized weapon) this=" + this + " type=" + GetType());
            return false;
        }
    }
 
    override void AfterStoreLoad()
    {
        if (m_fsm)
        {
            int mi = GetCurrentMuzzle();
            Magazine mag = GetMagazine(mi);
            bool has_mag = mag != null;
            bool has_bullet = !IsChamberEmpty(mi);
            SyncSelectionState(has_bullet, has_mag);
        }
    }
 
    override void OnStoreSave(ParamsWriteContext ctx)
    {
        super.OnStoreSave(ctx);
        
        // current muzzle added in version 113
        int current_muzzle = GetCurrentMuzzle();
        ctx.Write(current_muzzle);
        
        // fire mode added in version 105
        int mode_count = GetMuzzleCount();
        ctx.Write(mode_count);
        for (int m = 0; m < mode_count; ++m)
            ctx.Write(GetCurrentMode(m));
        
        ctx.Write(m_isJammed);
 
        if (m_fsm)
            m_fsm.OnStoreSave(ctx);
        else
        {
            int dummy = 0;
            ctx.Write(dummy);
        }
    }
 
    int GetInternalStateID()
    {
        if (m_fsm)
            return m_fsm.GetInternalStateID();
        return 0;
    }
    
    int GetCurrentStableStateID()
    {
        if (m_fsm)
        {
            return m_fsm.GetCurrentStableStateID();
        }
        return 0;
    }
 
    void RandomizeFSMState()
    {
        if (m_fsm)
        {
            int mi = GetCurrentMuzzle();
            Magazine mag = GetMagazine(mi);
            bool has_mag = mag != null;
            bool has_bullet = !IsChamberEmpty(mi);
            bool has_jam = IsJammed();
            array<MuzzleState> muzzleStates = GetMuzzleStates();
            m_fsm.RandomizeFSMStateEx(muzzleStates, has_mag, has_jam);
            ForceSyncSelectionState();
        }
    }
 
    protected array<MuzzleState> GetMuzzleStates()
    {
        array<MuzzleState> muzzleStates = new array<MuzzleState>;
        
        int nMuzzles = GetMuzzleCount();
        for (int i = 0; i < nMuzzles; ++i)
        {
            MuzzleState state = MuzzleState.U;
            if (IsChamberFiredOut(i))
                state = MuzzleState.F;
            else if (IsChamberFull(i))
                state = MuzzleState.L;
            else if (IsChamberEmpty(i))
                state = MuzzleState.E;
            else
                ErrorEx(string.Format("Unable to identify chamber state of muzzle %1", i));
            
            muzzleStates.Insert(state);
        }
        
        return muzzleStates;
    }
    
 
    static Weapon_Base CreateWeaponWithAmmo( string weaponType, string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER )
    {   
        Weapon_Base wpn = Weapon_Base.Cast(GetGame().CreateObjectEx( weaponType, vector.Zero, ECE_PLACE_ON_SURFACE ));
    
        if ( !wpn )
        {
            ErrorEx(string.Format("%1 does not exist or is not a weapon.", weaponType));
            return null;
        }
    
        wpn.SpawnAmmo(magazineType, flags);     
        return wpn;
    }
    
    bool SpawnAmmo( string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER )
    {
        // Attempt internal mag
        if ( HasInternalMagazine(-1) && FillInnerMagazine(magazineType, flags) )
            return true;
        
        // Attempt mag attachment
        if ( GetMagazineTypeCount(0) > 0 && SpawnAttachedMagazine(magazineType, flags) )
            return true;
        
        // Attempt chamber
        if ( FillChamber(magazineType, flags) )
            return true;
        
        return false;
    }
    
    Magazine SpawnAttachedMagazine( string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER )
    {
        // Check if the gun has any magazines registered in config
        if ( GetMagazineTypeCount(0) == 0 )
        {
            ErrorEx(string.Format("No 'magazines' config entry for %1.", this));
            return null;
        }
        
        // Randomize when no specific one is given
        if ( magazineType == "" )
        {
            if ( flags & WeaponWithAmmoFlags.MAX_CAPACITY_MAG)
                magazineType = GetMaxMagazineTypeName(0);
            else
                magazineType = GetRandomMagazineTypeName(0);
        }
        
        EntityAI magAI = GetInventory().CreateAttachment(magazineType);
        if (!magAI)
        {
            ErrorEx(string.Format("Failed to create and attach %1 to %2", GetDebugName(magAI), this));
            return null;
        }
        
        Magazine mag;
        if (!CastTo(mag, magAI))
        {
            ErrorEx(string.Format("Expected magazine, created: %1", GetDebugName(magAI)));
            return null;
        }
        
        // Decide random quantity when enabled
        if (flags & WeaponWithAmmoFlags.QUANTITY_RNG)
            mag.ServerSetAmmoCount(Math.RandomIntInclusive(0, mag.GetAmmoMax()));
        
        // Fill chamber when flagged
        bool chamberRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
        bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER) || chamberRng;     
        if (chamber || chamberRng)
        {
            FillChamber(magazineType, flags);
        }
 
        // FSM cares about magazine state
        RandomizeFSMState();
        Synchronize();
 
        return mag;
    }
 
    bool FillInnerMagazine( string ammoType = "", int flags = WeaponWithAmmoFlags.CHAMBER )
    {
        // Don't try to fill it when there are none
        if (!HasInternalMagazine(-1))
            return false;
    
        // Make sure the given ammoType is actually useable
        if (ammoType != "")
        {
            if (!AmmoTypesAPI.MagazineTypeToAmmoType(ammoType, ammoType))
                return false;
        }
        
        
        bool didSomething = false;      
        int muzzCount = GetMuzzleCount();
        
        bool ammoRng = ammoType == "";
        bool ammoFullRng = ammoRng && (flags & WeaponWithAmmoFlags.AMMO_MAG_RNG);
        
        // No full RNG flag, so pick one random and use only this one
        if (ammoRng && !ammoFullRng)
            ammoType = GetRandomChamberableAmmoTypeName(0);
        
        // Fill the internal magazine
        for (int i = 0; i < muzzCount; ++i)
        {
            int ammoCount = GetInternalMagazineMaxCartridgeCount(i);
            
            // Decide random quantity when enabled
            if ( flags & WeaponWithAmmoFlags.QUANTITY_RNG )
                ammoCount = Math.RandomIntInclusive(0, ammoCount);
            
            // Only do the things when there is actually ammo to fill
            if (ammoCount > 0)
            {
                // Push in the cartridges
                for (int j = 0; j < ammoCount; ++j)
                {
                    // Full random, decide a new one for every cartridge
                    if ( ammoFullRng )
                        ammoType = GetRandomChamberableAmmoTypeName(i);
                    
                    PushCartridgeToInternalMagazine(i, 0, ammoType);
                    didSomething = true;
                }
            }
        }
        
        // Call the chamber method if asked for
        bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER) || (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
        if (chamber && FillChamber(ammoType, flags))
        {
            didSomething = true;
        }
        
        // Does not need any FSM fixing, FSM does not care about inner magazines
        
        return didSomething;
    }
    
    bool FillChamber( string ammoType = "", int flags = WeaponWithAmmoFlags.CHAMBER )
    {
        // Quickly check if there are any chambers we can fill
        int muzzCount = GetMuzzleCount();
        bool anyEmpty = false;
        
        for (int m = 0; m < muzzCount; ++m)
        {
            if (IsChamberEmpty(m))
            {
                anyEmpty = true;
                break;
            }
        }
 
        if (!anyEmpty)
            return false;
        
        // Make sure the given ammoType is actually useable
        if (ammoType != "")
            if (!AmmoTypesAPI.MagazineTypeToAmmoType(ammoType, ammoType))
                return false;
        
        // Just so we don't '&' wastefully in a loop
        bool didSomething = false;      
        bool chamberFullRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG_SPORADIC);
        bool chamberRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
        bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER);
        
        if (chamber || chamberRng || chamberFullRng)
        {
            int amountToChamber = muzzCount;
            
            // No need to do this for full rng, as that will roll for every muzzle
            if (chamberRng)
                amountToChamber = Math.RandomIntInclusive(0, muzzCount);
            
            bool chamberAmmoRng = (ammoType == "");
            bool chamberAmmoFullRng = chamberAmmoRng && (flags & WeaponWithAmmoFlags.AMMO_CHAMBER_RNG);
            
            // No full RNG flag, so pick one random and use only this one
            if (chamberAmmoRng && !chamberAmmoFullRng)
                ammoType = GetRandomChamberableAmmoTypeName(0);
            
            for (int i = 0; i < muzzCount; ++i)
            {
                // Skip when there's already something in the chamber
                if (!IsChamberEmpty(i))
                    continue;
                
                // Roll the rng when enabled
                if (chamberFullRng)
                    chamber = Math.RandomIntInclusive(0, 1);
                
                // We chambering
                if (chamber)
                {
                    // Full random, decide a new one for every muzzle
                    if ( chamberAmmoFullRng )
                        ammoType = GetRandomChamberableAmmoTypeName(i);
                    
                    // Push it
                    PushCartridgeToChamber(i, 0, ammoType);
                    didSomething = true;
                    
                    // Stop chambering when we hit the desired amount
                    --amountToChamber;              
                    if (amountToChamber <= 0)
                        break;
                }
            }
        }
        
        // Only fix the FSM and Synchronize when absolutely needed
        if (!didSomething)
            return false;
        
        // FSM cares about chamber state
        RandomizeFSMState();        
        Synchronize();
        
        return true;
    }
    
    
    
    
    override int GetSlotsCountCorrect()
    {
        int ac = GetInventory().AttachmentCount();
        int sc = GetInventory().GetAttachmentSlotsCount() + GetMuzzleCount();
        if (ac > sc) sc = ac; // fix of some weapons which has 1 attachments but 0 slots...
        return sc;
    };
 
    PropertyModifiers GetPropertyModifierObject() 
    {
        if (!m_PropertyModifierObject)
        {
            m_PropertyModifierObject = new PropertyModifiers(this);
        }
        return m_PropertyModifierObject;
    }
    
    void OnFire(int muzzle_index)
    {
/*
        array<Man> players();
        GetGame().GetPlayers(players);
        
        Man root = GetHierarchyRootPlayer();
        
        if (!root)
        {
            return;
        }
        
        vector safePosition = root.GetPosition() + (root.GetDirection() * "0 1 0" * 3.0);
        
        Man other = null;
        foreach (auto player : players)
        {
            if (player != GetHierarchyRootPlayer())
            {
                player.SetPosition(safePosition);
            }
        }
*/
 
        m_BurstCount++;
    }
    
    void OnFireModeChange(int fireMode)
    {
        if ( !GetGame().IsDedicatedServer() )
        {
            EffectSound eff;
            
            if ( fireMode == 0 )
                eff = SEffectManager.PlaySound("Fire_Mode_Switch_Marked_Click_SoundSet", GetPosition());
            else
                eff = SEffectManager.PlaySound("Fire_Mode_Switch_Simple_Click_SoundSet", GetPosition());
            
            eff.SetAutodestroy(true);
        }
        
        ResetBurstCount();
    }
    
    void ValidateAndRepair()
    {
        if ( m_fsm )
            m_fsm.ValidateAndRepair();
    }
    
    override void OnInventoryEnter(Man player)
    {
        m_PropertyModifierObject = null;
 
        ValidateAndRepair();
        
        super.OnInventoryEnter(player);
    }
    
    override void OnInventoryExit(Man player)
    {
        m_PropertyModifierObject = null;
        super.OnInventoryExit(player);
    }
 
    override void EEItemAttached(EntityAI item, string slot_name)
    {
        super.EEItemAttached(item, slot_name);
 
        GetPropertyModifierObject().UpdateModifiers();
    }
 
    override void EEItemDetached(EntityAI item, string slot_name)
    {
        super.EEItemDetached(item, slot_name);
 
        GetPropertyModifierObject().UpdateModifiers();
    }
    
    override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
    {
        super.EEItemLocationChanged(oldLoc, newLoc);
 
        if (newLoc.GetType() == InventoryLocationType.HANDS)
        {
            PlayerBase player;
            if (newLoc.GetParent() && PlayerBase.CastTo(player, newLoc.GetParent()))
            { 
                HumanCommandMove cm = player.GetCommand_Move();
                if (cm)
                {
                    cm.SetMeleeBlock(false);
                }
            }
        }
    }
    
    override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
    {
        super.OnItemLocationChanged(old_owner,new_owner);
        
        // "resets" optics memory on optics
        PlayerBase player;
        if (PlayerBase.CastTo(player,old_owner))
        { 
            player.SetReturnToOptics(false);
            
            //optics item state reset
            ItemOptics optics;
            if (Class.CastTo(optics,GetAttachedOptics()))
            {
                player.SwitchOptics(optics,false);
            }
        }
 
        HideWeaponBarrel(false);
    }
    
    override bool CanReleaseAttachment(EntityAI attachment)
    {
        if ( !super.CanReleaseAttachment( attachment ) )
            return false;
        Magazine mag = Magazine.Cast(attachment);
        if (mag)
        {
            PlayerBase player = PlayerBase.Cast( GetHierarchyRootPlayer() );
            if ( player )
            {
                if ( player.GetItemInHands() == this )
                    return true;
            }
            return false;
        }
 
        return true;
    }
    
    override bool CanRemoveFromHands(EntityAI parent)
    {
        if (IsIdle())
        {
            return true;
        }
        if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " not in stable state=" + GetCurrentState().Type()); }
        return false; // do not allow removal of weapon while weapon is busy
    }
 
    bool IsRemoteWeapon()
    {
        InventoryLocation il = new InventoryLocation;
        if (GetInventory().GetCurrentInventoryLocation(il))
        {
            EntityAI parent = il.GetParent();
            DayZPlayer dayzp = DayZPlayer.Cast(parent);
            if (il.GetType() == InventoryLocationType.HANDS && dayzp)
            {
                bool remote = dayzp.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE;
                return remote;
            }
        }
        return true;
    }
 
    void SyncEventToRemote(WeaponEventBase e)
    {
        DayZPlayer p = DayZPlayer.Cast(GetHierarchyParent());
        if (p && p.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            ScriptRemoteInputUserData ctx = new ScriptRemoteInputUserData();
 
            ctx.Write(INPUT_UDT_WEAPON_REMOTE_EVENT);
            e.WriteToContext(ctx);
 
            if (LogManager.IsWeaponLogEnable())
                wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " send 2 remote: sending e=" + e + " id=" + e.GetEventID() + " p=" + e.m_player + "  m=" + e.m_magazine);
 
            p.StoreInputForRemotes(ctx);
        }
    }
 
    
    RecoilBase SpawnRecoilObject()
    {
        return new DefaultRecoil(this);
    }
 
    int GetWeaponSpecificCommand(int weaponAction, int subCommand)
    {
        return subCommand;
    }
 
    bool CanFire()
    {
        if (!IsChamberEmpty(GetCurrentMuzzle()) && !IsChamberFiredOut(GetCurrentMuzzle()) && !IsJammed() && !m_LiftWeapon && !IsDamageDestroyed())
            return true;
        return false;
    }
            
    bool CanEnterIronsights()
    {
        ItemOptics optic = GetAttachedOptics();
        if (!optic)
            return true;
        
        return optic.HasWeaponIronsightsOverride();
    }
    
    bool InitDOFProperties(out array<float> temp_array)
    {
        if (GetGame().ConfigIsExisting("cfgWeapons " + GetType() + " PPDOFProperties"))
        {
            GetGame().ConfigGetFloatArray("cfgWeapons " + GetType() + " PPDOFProperties", temp_array);
            return true;
        }
        return false;
    }
    
    bool InitReliability(out array<float> reliability_array)
    {
        if (GetGame().ConfigIsExisting("cfgWeapons " + GetType() + " Reliability ChanceToJam"))
        {
            GetGame().ConfigGetFloatArray("cfgWeapons " + GetType() + " Reliability ChanceToJam", reliability_array);
            return true;
        }
        return false;
    }
    
    bool InitWeaponLength()
    {
        if (ConfigIsExisting("WeaponLength"))
        {
            m_WeaponLength = ConfigGetFloat("WeaponLength");
            return true;
        }
        m_WeaponLength = 0.8; //default value if not set in config; should not be zero
        return false;
    }
    
    bool InitWeaponLiftCheckVerticalOffset()
    {
        if (ConfigIsExisting("WeaponLiftCheckVerticalOffset"))
        {
            m_WeaponLiftCheckVerticalOffset = ConfigGetFloat("WeaponLiftCheckVerticalOffset");
            return true;
        }
        m_WeaponLiftCheckVerticalOffset = 0.0; //no offset by default
        return false;
    }
    
    protected bool InitShoulderDistance()
    {
        if (ConfigIsExisting("ShoulderDistance"))
        {
            m_ShoulderDistance = ConfigGetFloat("ShoulderDistance");
            return true;
        }
        
        m_ShoulderDistance = 0;
        return false;
    }   
    
    ref array<float> GetWeaponDOF()
    {
        return m_DOFProperties;
    }
    
    // lifting weapon on obstcles
    bool LiftWeaponCheck(PlayerBase player)
    {
        int idx;
        float distance;
        float hit_fraction; //junk
        vector start, end;
        vector direction;
        vector usti_hlavne_position;
        vector trigger_axis_position;
        vector hit_pos, hit_normal; //junk
        Object obj;
        ItemBase attachment;
        HumanMovementState movementState = new HumanMovementState();
        
        bool wasLift = m_LiftWeapon;
        vector lastLiftPosition = m_LastLiftPosition;
        
        m_LiftWeapon = false;
        // not a gun, no weap.raise for now
        if ( HasSelection("Usti hlavne") )
            return false;
        
        if (!player)
        {
            Print("Error: No weapon owner, returning");
            return false;
        }
        
        // weapon not raised
        player.GetMovementState(movementState);
        if (!movementState.IsRaised())
            return false;
        
        // suppress raising of weapon during melee attack preventing state inconsistency
        if (movementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MELEE || movementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MELEE2)
        {
            return false;
        }
        
        usti_hlavne_position = GetSelectionPositionLS( "Usti hlavne" );     // Usti hlavne
        trigger_axis_position = GetSelectionPositionLS("trigger_axis");
        
        // If possible use aiming angles instead as these will work consistently
        // and independently of any cameras, etc. 
        HumanCommandWeapons hcw = player.GetCommandModifier_Weapons();
        if (hcw)
        {
            vector yawPitchRoll = Vector(
                hcw.GetBaseAimingAngleLR() + player.GetOrientation()[0],
                hcw.GetBaseAimingAngleUD(),
                0.0);
            direction = yawPitchRoll.AnglesToVector();
        }
        else // Fallback to previously implemented logic
        {
            // freelook raycast
            if (player.GetInputController().CameraIsFreeLook())
            {
                if (player.m_DirectionToCursor != vector.Zero)
                {
                    direction = player.m_DirectionToCursor;
                }
                // if player raises weapon in freelook
                else
                {
                    direction = MiscGameplayFunctions.GetHeadingVector(player);
                }
            }
            else
            {
                direction = GetGame().GetCurrentCameraDirection(); // exception for freelook. Much better this way!
            }
        }
        
        idx = player.GetBoneIndexByName("Neck"); //RightHandIndex1
        if ( idx == -1 )
            { start = player.GetPosition()[1] + 1.5; }
        else
            { start = player.GetBonePositionWS(idx); }
        
        
        // Updated weapon lift detection code prototype
        {
            // 0: construct stable trasformation matrix that
            // approximately aligns with the weapon transform
            // without actually using the weapon as reference
            // (as the weapon can be moved unpredictably by anims)
            vector resTM[4];
            resTM[0] = Vector(direction[0], 0, direction[2]).Normalized();
            resTM[0] = vector.RotateAroundZeroDeg(resTM[0], vector.Up, 90);
            resTM[2] = direction;
            resTM[1] = resTM[2] * resTM[0]; 
            resTM[3] = start;
            
            // Approximate the roll of leaning
            HumanMovementState hms = new HumanMovementState();
            player.GetMovementState(hms);
            float leanAngle = hms.m_fLeaning * 35;
            vector rotTM[3];
            Math3D.YawPitchRollMatrix( Vector(0, 0, leanAngle), rotTM );
            Math3D.MatrixMultiply3(resTM, rotTM, resTM);
            
            // Draw relative TM diagnostic
            #ifdef DIAG_DEVELOPER
            if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
            {
                Shape.CreateArrow(resTM[3], resTM[3] + resTM[0], 0.05, COLOR_RED, ShapeFlags.ONCE);
                Shape.CreateArrow(resTM[3], resTM[3] + resTM[1], 0.05, COLOR_GREEN, ShapeFlags.ONCE);
                Shape.CreateArrow(resTM[3], resTM[3] + resTM[2], 0.05, COLOR_BLUE, ShapeFlags.ONCE);
            }
            #endif
            
            // 1: pick from predefined offset relative to
            // the previously constructed transform 
            float udAngle = Math.Asin(direction[1]) * Math.RAD2DEG;
            
            // offsets are [right, up, forward]
            // values are based on what felt right after iterating
            vector offsets[] = 
            { 
                "0.11 0.17 0.0",  // offset while aiming down
                "0.12 0.05 0.0", // offset while aiming forward
                "0.112 0.03 0.0" // offset while aiming up
            };
            const int lastIndex = 2; // length of offsets - 1
            
            // <0,1> range of aiming
            float a = Math.Clamp(Math.InverseLerp(DayZPlayerCamera1stPerson.CONST_UD_MIN, DayZPlayerCamera1stPerson.CONST_UD_MAX, udAngle), 0, 0.9999);
            int lo = a * lastIndex;
            int hi = Math.Clamp(lo+1, 0, lastIndex);
            
            // remap to current lo-hi range
            float t = Math.Clamp(a * lastIndex - lo, 0, 1);
            vector offset = vector.Lerp(offsets[lo], offsets[hi], t);
            
            // offsets are [right, up forward]
            // additional offsets added to previous offsets per stance
            vector stanceOffsets[] = 
            {
                "0 -0.015 0",   // erect
                "0 0.03 0", // crouch
                "0 -0.04 0",// prone
            };
            
            // 2. pick from predefined offsets based on stance,
            // allows to even further approximate the alignment
            int stanceOffsetIndex = hms.m_iStanceIdx;
            if (stanceOffsetIndex >= DayZPlayerConstants.STANCEIDX_PRONE)
                stanceOffsetIndex -= DayZPlayerConstants.STANCEIDX_RAISED;
            
            stanceOffsetIndex -= DayZPlayerConstants.STANCEIDX_ERECT;
            offset += stanceOffsets[stanceOffsetIndex];
            
            // if any additional height offset is defined, apply it
            if (m_WeaponLiftCheckVerticalOffset != 0)
            {
                offset[1] = offset[1] + m_WeaponLiftCheckVerticalOffset;
            }
            
            // 3. use the offset as the start position.
            // it will not be perfect, but it should reflect
            // the actual weapon transform more accurately
            start = offset.Multiply4(resTM);
        }
        
        /*usti_hlavne_position = ModelToWorld(usti_hlavne_position);
        distance = vector.Distance(start,usti_hlavne_position);*/
        distance = m_WeaponLength + GetEffectiveAttachmentLength();
        
        vector weaponStart = start + (m_ShoulderDistance * direction);
        vector weaponEnd = weaponStart + (distance * direction);
        
        // Draw diagnostics: Script -> Weapon -> Weapon Lift
        #ifdef DIAG_DEVELOPER
        if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
        {
            vector diagNoAttachEnd = weaponStart + (m_WeaponLength * direction);
            int diagPtsShpFlgs = ShapeFlags.ONCE | ShapeFlags.NOOUTLINE;
            float diagPtsRadius = 0.025;
            Shape.CreateSphere(COLOR_GREEN, diagPtsShpFlgs, weaponStart, diagPtsRadius);
            Shape.CreateSphere(COLOR_YELLOW, diagPtsShpFlgs, diagNoAttachEnd, diagPtsRadius);
            Shape.CreateSphere(COLOR_BLUE, diagPtsShpFlgs, weaponEnd, diagPtsRadius);
        }
        #endif
        
        // For the physical cast, extend the distance by x%
        // to allow for smoother transition handling in some cases
        end = weaponEnd + ((0.1 * distance) * direction);
        
        // Prepare raycast params and perform the cast in fire geo
        RaycastRVParams rayParm = new RaycastRVParams(start, end, player, 0.04);
        rayParm.flags = CollisionFlags.ALLOBJECTS;
        rayParm.type = ObjIntersect.Fire;
        
        DbgUI.BeginCleanupScope();
        array<ref RaycastRVResult> results = {};
        if (!DayZPhysics.RaycastRVProxy(rayParm, results) || results.Count() == 0)
        {
            hit_pos = vector.Zero;
            hit_fraction = 0;
        }
        else
        {
            RaycastRVResult res = results[0];
            
            #ifdef DIAG_DEVELOPER   // isect diag
            if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG) == 2)
            {
                DbgUI.Begin("Weapon Lift Diag");
                {
                    if (res.surface)
                    {
                        DbgUI.Text("Intersection data:");
                        DbgUI.Text("  Name: " + res.surface.GetName());
                        DbgUI.Text("  EntryName: " + res.surface.GetEntryName());
                        DbgUI.Text("  SurfaceType: " + res.surface.GetSurfaceType());
                        
                        DbgUI.Text("  IsPassThrough: " + res.surface.IsPassthrough());
                        DbgUI.Text("  IsSolid: " + res.surface.IsSolid());
                    }
                    else
                    {
                        DbgUI.Text("Intersection with no surface");
                    }
                }
                DbgUI.End();
            }
            #endif  // !isect diag
            
            if (LiftWeaponRaycastResultCheck(res))
            {
                hit_pos = res.pos;
                float len0 = (hit_pos - start).Length();
                float len1 = (end - start).Length();
                if (len0 <= 0 || len1 <= 0)
                {
                    hit_fraction = 1;
                }
                else
                {
                    hit_fraction = len0 / len1;
                }
            }
            else
            {
                hit_pos = vector.Zero;
                hit_fraction = 0;
            }
        }
        
        DbgUI.EndCleanupScope();
        
        // Draw diagnostics: Script -> Weapon -> Weapon Lift
        #ifdef DIAG_DEVELOPER
        if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
        {
            const vector epsilon = "0 0.0002 0"; // to overcome excessive z-fighting for diag
            if (lastLiftPosition!=vector.Zero)
            {
                Shape.CreateArrow(start-epsilon, lastLiftPosition-epsilon, 0.05, COLOR_YELLOW, ShapeFlags.ONCE);
            }
            
            Shape.CreateArrow(start, weaponEnd, 0.05, COLOR_WHITE, ShapeFlags.ONCE | ShapeFlags.NOZBUFFER );
            
            if (hit_fraction != 0)
            {
                Shape.CreateArrow(start+epsilon, hit_pos+epsilon, 0.05, COLOR_RED, ShapeFlags.ONCE);
            }
        }
        #endif
        
        // Start by assuming that we want to retain state
        bool wantsLift = wasLift;
        
        // Sq. distance of weapon movement required to trigger lift (in)
        const float inThreshold = 0.002;
        // Sq. distance of weapon movement required to trigger lift (out)
        const float outThreshold = 0.003;
        const float noIsctOutThreshold = 0.01;
        
        // Min angle in degrees change from last lift to stop lifting
        // Base threshold of 0.75 degrees + 0.6 degrees per meter of weapon length
        float angleThreshold = 0.75 + Math.Clamp( m_WeaponLength * 0.6, 0, 1.5 );
        
        // Update state when a hit is registered
        if (hit_fraction != 0)
        {
            vector v1 = hit_pos - weaponEnd;
            vector v2 = hit_pos - end;
            float d = vector.Dot(v1, v2);
            // But leave some threshold where previous state is kept
            // to prevent excessive switches from occuring
            if (!wasLift && d > inThreshold)
            {
                wantsLift = true;
            }
            else if (wasLift && d < -outThreshold)
            {
                wantsLift = false;
            }
            
            m_LastLiftPosition = hit_pos;
        }
        else
        {
            // With no hit and no previous lift
            if (lastLiftPosition == vector.Zero)
            {
                wantsLift = false;
                m_LastLiftPosition = vector.Zero;
            }
            // See if previous hit wasn't very close to our current position,
            // in which case simply don't lift the weapon
            else
            {
                vector v3 = (lastLiftPosition - start).Normalized();
                vector v4 = (end-start).Normalized();
                float d2 = vector.Dot(v3, v4);
                // no isect, angle delta check
                if (Math.Acos(d2) > (angleThreshold * Math.DEG2RAD)) // if relative angle is > x degree, stop lifting
                {
                    wantsLift = false;
                    m_LastLiftPosition = vector.Zero;
                }
                // no isect, distance check
                else
                {
                    float d3 = vector.Dot( lastLiftPosition - weaponEnd, (start-end).Normalized() );
                    if (d3 < -noIsctOutThreshold)
                    {
                        wantsLift = false;
                        m_LastLiftPosition = vector.Zero;
                    }
                }
            }
        }
        
        // lift is desired
        if (wantsLift)
        {
            //Print(distance);
            m_LiftWeapon = true;
            return true;
        }
        return false;
    }
    
    bool LiftWeaponRaycastResultCheck(notnull RaycastRVResult res)
    {
        return res.surface.IsSolid();
    }
    
    float GetEffectiveAttachmentLength()
    {
        ItemBase attachment;
        if (HasBayonetAttached())
        {
            int bayonetIndex = GetBayonetAttachmentIdx();
            attachment = ItemBase.Cast(GetInventory().FindAttachment(bayonetIndex));
        }
        else
        {
            attachment = GetAttachedSuppressor();
        }
        
        if (attachment)
        {
            return Math.Max(attachment.m_ItemModelLength + attachment.m_ItemAttachOffset, 0);
        }
        else
        {
            return 0;
        }
    }
    
    void SetSyncJammingChance( float jamming_chance )
    {
        m_ChanceToJamSync = jamming_chance;
    }
    
    bool EjectCartridge(int muzzleIndex, out float ammoDamage, out string ammoTypeName)
    {
        if (IsChamberEjectable(muzzleIndex))
        {
            if (PopCartridgeFromChamber(muzzleIndex, ammoDamage, ammoTypeName))
                return true;
        }
        else if (GetInternalMagazineCartridgeCount(muzzleIndex) > 0)
        {
            if (PopCartridgeFromInternalMagazine(muzzleIndex, ammoDamage, ammoTypeName))
                return true;
        }
        return false;
    }
    
    bool CopyWeaponStateFrom(notnull Weapon_Base src)
    {
        float damage = 0.0;
        string type;
 
        for (int mi = 0; mi < src.GetMuzzleCount(); ++mi)
        {
            if (!src.IsChamberEmpty(mi))
            {
                if (src.GetCartridgeInfo(mi, damage, type))
                {
                    PushCartridgeToChamber(mi, damage, type);
                }
            }
            
            for (int ci = 0; ci < src.GetInternalMagazineCartridgeCount(mi); ++ci)
            {
                if (src.GetInternalMagazineCartridgeInfo(mi, ci, damage, type))
                {
                    PushCartridgeToInternalMagazine(mi, damage, type);
                }
            }
        }
        
        int dummy_version = int.MAX;
        PlayerBase parentPlayer = PlayerBase.Cast(src.GetHierarchyRootPlayer());
        if (!parentPlayer)
            dummy_version -= 1;
        ScriptReadWriteContext ctx = new ScriptReadWriteContext;
        src.OnStoreSave(ctx.GetWriteContext());
        OnStoreLoad(ctx.GetReadContext(), dummy_version);
        return true;
    }
    
    override void SetBayonetAttached(bool pState, int slot_idx = -1)
    {
        m_BayonetAttached = pState;
        m_BayonetAttachmentIdx = slot_idx;
    }
    
    override bool HasBayonetAttached()
    {
        return m_BayonetAttached;
    }
    
    override int GetBayonetAttachmentIdx()
    {
        return m_BayonetAttachmentIdx;
    }
    
    override void SetButtstockAttached(bool pState, int slot_idx = -1)
    {
        m_ButtstockAttached = pState;
        m_ButtstockAttachmentIdx = slot_idx;
    }
 
    override bool HasButtstockAttached()
    {
        return m_ButtstockAttached;
    }
    
    override int GetButtstockAttachmentIdx()
    {
        return m_ButtstockAttachmentIdx;
    }
    
    void HideWeaponBarrel(bool state)
    {
        if ( !GetGame().IsDedicatedServer() )//hidden for client only
        {
            ItemOptics optics = GetAttachedOptics();
            if ( optics && !optics.AllowsDOF() && m_weaponHideBarrelIdx != -1 )
            {
                SetSimpleHiddenSelectionState(m_weaponHideBarrelIdx,!state);
            }
        }
    }
    
    void ShowMagazine()
    {
        if (m_magazineSimpleSelectionIndex > -1)
            SetSimpleHiddenSelectionState(m_magazineSimpleSelectionIndex,1);
        else
            SelectionMagazineShow();
    }
    
    void HideMagazine()
    {
        if (m_magazineSimpleSelectionIndex > -1)
            SetSimpleHiddenSelectionState(m_magazineSimpleSelectionIndex,0);
        else
            SelectionMagazineHide();
    }
    
    override EntityAI ProcessMeleeItemDamage(int mode = 0)
    {
        EntityAI attachment;
        
        switch (mode)
        {
            case 0:
                super.ProcessMeleeItemDamage();
            break;
            
            case 1:
                attachment = GetInventory().FindAttachment(m_ButtstockAttachmentIdx);
            break;
            
            case 2:
                attachment = GetInventory().FindAttachment(m_BayonetAttachmentIdx);
            break;
            
            default:
                super.ProcessMeleeItemDamage();
            break;
        }
        
        if (attachment)
        {
            attachment.ProcessMeleeItemDamage();
            return attachment;
        }
        
        return this;
    }
    
    bool IsShowingChamberedBullet()
    {
        return true;
    }
    
    int GetBurstCount()
    {
        return m_BurstCount;
    }
    
    void ResetBurstCount()
    {
        m_BurstCount = 0;
    }
 
    override void SetActions()
    {
        super.SetActions();
        AddAction(FirearmActionUnjam);
        AddAction(FirearmActionAttachMagazine);
        AddAction(FirearmActionLoadBullet);
        AddAction(FirearmActionMechanicManipulate);
        AddAction(ActionTurnOnWeaponFlashlight);
        AddAction(ActionTurnOffWeaponFlashlight);
 
        AddAction(FirearmActionAttachMagazineQuick); // Easy reload
        AddAction(FirearmActionLoadBulletQuick); // Easy reload
    }
    
    override bool CanBeUsedForSuicide()
    {
        if (!ConfigGetBool("isSuicideWeapon"))
            return false;
        
        return super.CanBeUsedForSuicide();
    }
    
    //Debug menu Spawn Ground Special
    override void OnDebugSpawn()
    {
        SpawnAmmo("", SAMF_DEFAULT);
    }
};