DayZPlayerImplement.c

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

/*
DayZPlayerImplement
 
this file is implemenation of dayzPlayer in script
- logic of movement
- camera switching logic
 
*/
 
class DayZPlayerCommandDeathCallback : HumanCommandDeathCallback
{
    //----------------------------------
    // callbacks
 
    override void   OnSimulationEnd()
    {
        m_pPlayer.DeathDropHandEntity();
    }
 
    override bool ShouldSimulationBeDisabled()
    {
        return m_pPlayer.m_WasInVehicle == false;
    }
    
    PlayerBase m_pPlayer;
}
 
class DayZPlayerVehicleCommandDeathCallback : HumanCommandDeathCallback
{
    override void OnSimulationEnd()
    {
        m_pPlayer.PhysicsEnableGravity(true);
    }
    
    PlayerBase m_pPlayer;
}
 
class DeathEffectTimer extends Timer
{
     override void Stop()
    {
        super.Stop();
        
        PPERequesterBank.GetRequester(PPERequester_DeathDarkening).Stop();
    }
};
 
#ifdef FEATURE_NETWORK_RECONCILIATION
 
class DayZPlayerImplementOwnerState : DayZPlayerOwnerState
{
    float m_fLastHeadingDiff;
 
    protected override event void Write(PawnStateWriter ctx)
    {
        super.Write(ctx);
 
        ctx.Write(m_fLastHeadingDiff);
    }
    
    protected override event void Read(PawnStateReader ctx)
    {
        super.Read(ctx);
 
        ctx.Read(m_fLastHeadingDiff);
    }
};
 
class DayZPlayerImplementMove : DayZPlayerMove
{
    protected override event void Write(PawnMoveWriter ctx, PawnMove prev)
    {
        super.Write(ctx, prev);
 
    }
    
    protected override event void Read(PawnMoveReader ctx, PawnMove prev)
    {
        super.Read(ctx, prev);
 
    }
};
 
#endif
 
class DayZPlayerImplement extends DayZPlayer
{
    static const float DEFAULT_DYING_TIME = 2.5;      
    static const float DYING_PROGRESSION_TIME = 0.05;     
 
 
    ref HumanMovementState                    m_MovementState = new HumanMovementState();    
    protected ref DayZPlayerImplementAiming                m_AimingModel;
    protected ref DayZPlayerImplementMeleeCombat      m_MeleeCombat;
    protected ref DayZPlayerMeleeFightLogic_LightHeavy  m_MeleeFightLogic;
    protected ref DayZPlayerImplementSwimming            m_Swimming;
    protected ref DayZPlayerImplementThrowing            m_Throwing;
    protected ref DayZPlayerImplementJumpClimb          m_JumpClimb;
    protected ref DayZPlayerImplementFallDamage            m_FallDamage;
    protected ref PlayerSoundEventHandler                m_PlayerSoundEventHandler;
    protected ref ReplaceSoundEventHandler              m_ReplaceSoundEventHandler;
    protected SHumanCommandMoveSettings                m_MoveSettings;
    protected float                                     m_FallYDiff;
    protected float                                     m_SprintedTime;
    protected float                                     m_SprintedTimePerStanceMin;
    protected bool                                      m_SprintFull;
    protected bool                                      m_IsRaised;
    protected bool                                      m_ShouldReload;
    protected bool                                      m_Camera3rdPerson;
    protected bool                                      m_CameraZoomToggle;
    protected bool                                      m_bADS;
    private float                                       m_WeaponRaiseTime; 
    protected bool                                      m_WeaponRaiseCompleted;
    protected ECameraZoomType                            m_CameraEyeZoomLevel;
    protected bool                                      m_CameraIronsight; // Ironsight NOW!
    protected bool                                      m_CameraOptics; // Optics NOW!
    protected bool                                      m_CameraOpticsAimOverride; // for tracking if aim limit is currently overriden by optics
 
    protected float                                     m_DeathDarkeningCurrentTime;
    protected bool                                      m_IsTryingHoldBreath;
    protected bool                                      m_IsShootingFromCamera;
    protected bool                                      m_PlayerSelected;
    protected bool                                      m_Suicide;
    protected bool                                      m_IsUnconscious;
    protected bool                                      m_ShouldBeUnconscious;
    protected bool                                      m_IsUnconsciousFalling;
    bool                                                m_UnconsciousDebug;
    protected int                                       m_LastCommandBeforeUnconscious;
    ref WeaponDebug                                      m_WeaponDebug;
    ref DeathEffectTimer                                m_DeathEffectTimer;
    ref Timer                                          m_FightEndBlendTimer;
    protected bool                                      m_ProcessFirearmMeleeHit;
    protected bool                                      m_ContinueFirearmMelee;
    protected bool                                      m_LiftWeapon_player;
    protected float                                     m_ObstructWeapon_player;
    protected bool                                      m_ProcessLiftWeapon;
    protected bool                                      m_ProcessLiftWeaponState;
    protected float                                     m_ProcessObstructWeapon;
    protected int                                       m_LastSurfaceUnderHash;
    protected Transport                                    m_TransportCache;
    protected string                                    m_ClimbingLadderType;
    bool                                                m_isFBsymptomPlaying;
    protected bool                                      m_HandheldOpticsInUse;
    protected bool                                      m_ResetADS;
    protected bool                                      m_ProcessResetADS;
    protected int                                       m_StepCounter;
    protected int                                       m_StepCounterVegetation // TMP; optimization of vegetation, collision sound playback
    protected int                                       m_NextVoNNoiseTime;
    protected ref array<ref SyncHitInfo>              m_SyncedHitDataArray;
    protected ref array<AbstractWave>                    m_PerformedActionSounds;
    
    // aiming model helpers 
    protected bool                                      m_RaiseStarted = false;
    protected bool                                      m_AimingFinisherStarted = false;
    protected bool                                      m_IsWeapon;
    
    private float                                       m_CurrentWaterLevel;
 
    bool                                                m_WasInVehicle;
    protected bool                                      m_TriggerPullPlayerOutOfVehicleSynch;
    protected bool                                      m_PullPlayerOutOfVehicleKeepsInLocalSpace = false;
    protected int                                       m_PullPlayerOutOfVehicleState = -1;
    int                                                 m_ActionSoundCategoryHash;
    
    protected float                                     m_dT;
    protected ref DustEffectCeilingHandlerSynced      m_CeilingDustHandler;
 
    protected float m_fObstructionSmooth;
    protected float m_fObstructionSmoothVelocity[1];
    
    void    DayZPlayerImplement()
    {
        SetEventMask(EntityEvent.CONTACT);
 
        m_SprintFull = false;
        m_SprintedTime = 0;
        m_SprintedTimePerStanceMin = PlayerConstants.FULL_SPRINT_DELAY_DEFAULT;
        m_AimingModel = new DayZPlayerImplementAiming(this);
        m_MeleeCombat = new DayZPlayerImplementMeleeCombat(this);
        m_MeleeFightLogic = new DayZPlayerMeleeFightLogic_LightHeavy(this);
        m_Swimming = new DayZPlayerImplementSwimming(this);        
        m_Throwing = new DayZPlayerImplementThrowing(this);
        m_JumpClimb = new DayZPlayerImplementJumpClimb(this);
        m_FallDamage = new DayZPlayerImplementFallDamage(this);
        m_ADSAutomationTimer = new Timer();
        m_bADS = false;
        m_WeaponRaiseCompleted = false;
        SetOptics(false);
        m_IsShootingFromCamera = true;
        m_ProcessFirearmMeleeHit = false;
        m_ContinueFirearmMelee = false;
        #ifdef PLATFORM_CONSOLE
        m_Camera3rdPerson = g_Game.GetWorld().GetThirdPersonViewMode() == ThirdPersonMode.ENABLED;
        #endif
        m_LastSurfaceUnderHash = ("cp_gravel").Hash();
        m_NextVoNNoiseTime = 0;
        m_SyncedHitDataArray = new array<ref SyncHitInfo>;
        m_PerformedActionSounds = new array<AbstractWave>();
        m_CurrentWaterLevel = 0;
        m_WeaponRaiseTime = 0;
        
        m_CachedEquipmentStorage = CachedEquipmentStorage(this);
        m_CeilingDustHandler = new DustEffectCeilingHandlerSynced(this);
        
        RegisterNetSyncVariableBoolSignal("m_TriggerPullPlayerOutOfVehicleSynch");
    }
 
#ifdef FEATURE_NETWORK_RECONCILIATION
    protected override event typename GetOwnerStateType()
    {
        return DayZPlayerImplementOwnerState;
    }
    
    protected override event typename GetMoveType()
    {
        return DayZPlayerImplementMove;
    }
 
    protected override event void ObtainState(/*inout*/ PawnOwnerState pState)
    {
        super.ObtainState(pState);
 
        DayZPlayerImplementOwnerState state = DayZPlayerImplementOwnerState.Cast(pState);
 
        state.m_fLastHeadingDiff = m_fLastHeadingDiff;
    }
 
    protected override event void RewindState(PawnOwnerState pState, /*inout*/ PawnMove pMove, inout NetworkRewindType pRewindType)
    {
        super.RewindState(pState, pMove, pRewindType);
 
        DayZPlayerImplementOwnerState state = DayZPlayerImplementOwnerState.Cast(pState);
 
        if (pRewindType != NetworkRewindType.ADDITIVE)
        {
            m_fLastHeadingDiff = state.m_fLastHeadingDiff;
        }
    }
#endif
 
    DayZPlayerImplementAiming GetAimingModel()
    {
        return m_AimingModel;
    }
 
    DayZPlayerImplementMeleeCombat GetMeleeCombat()
    {
        return m_MeleeCombat;
    }
    
    DayZPlayerMeleeFightLogic_LightHeavy GetMeleeFightLogic()
    {
        return m_MeleeFightLogic;
    }
    
    DayZPlayerImplementThrowing GetThrowing()
    {
        return m_Throwing;
    }
    
    DayZPlayerImplementFallDamage GetFallDamage()
    {
        return m_FallDamage;
    }
    
    void ~DayZPlayerImplement()
    {
    }

    override bool IsEyeZoom()
    {
        return GetEyeZoomLevel() > 0;
    }
    
    override int GetEyeZoomLevel()
    {
        return m_CameraEyeZoomLevel;
    }
    
    override bool IsShootingFromCamera()
    {
        return m_IsShootingFromCamera;
    }
    
    void OverrideShootFromCamera(bool pState)
    {
        m_IsShootingFromCamera = pState;
    }
 
    bool IsInIronsights()
    {
        return m_CameraIronsight;
    }
    
    bool IsInOptics()
    {
        return m_CameraOptics;
    }
    
    override bool IsInThirdPerson()
    {
        return m_Camera3rdPerson;
    }
    
    void SetIsInThirdPerson(bool state)
    {
        m_Camera3rdPerson = state;
    }
 
    bool IsFireWeaponRaised()
    {
        GetMovementState(m_MovementState);
        if (m_MovementState)
            return m_MovementState.IsRaised();
        
        return false;
    }
 
    bool IsTryingHoldBreath()
    {
        return m_IsTryingHoldBreath;
    }
 
    bool IsSprintFull()
    {
        return m_SprintFull;
    }
 
    void ShowWeaponDebug(bool show)
    {
        if (show)
        {
            m_WeaponDebug = new WeaponDebug;
        }
        else
        {
            m_WeaponDebug = null;
        }
    }
 
    bool IsWeaponDebugEnabled()
    {
        return m_WeaponDebug != null;
    }
    
    void SetFallYDiff(float value)
    {
        m_FallYDiff = value;
    }
    
    override float GetCurrentWaterLevel()
    {
        return m_CurrentWaterLevel;
    }
    
    override void SetCurrentWaterLevel(float pWaterLevel)
    {
        m_CurrentWaterLevel = pWaterLevel;
    }
 
    void SetIronsights(bool value)
    {
        Weapon_Base weapon = Weapon_Base.Cast(GetEntityInHands());
        if (weapon)
            weapon.SetWasIronSight(m_CameraIronsight);
        
        m_CameraIronsight = value;
        
        if (value)
        {
            HumanCommandWeapons hcw = GetCommandModifier_Weapons();
            if (hcw)
                hcw.SetADS(true);
            
            HumanInputController hic = GetInputController();
            if (hic)
                hic.ResetFreeLookToggle();
        }
    }
    
    void SetOptics(bool value)
    {
        m_CameraOptics = value;
        
        if (value)
        {
            HumanCommandWeapons hcw = GetCommandModifier_Weapons();
            if (hcw)
                hcw.SetADS(!IsHandheldOpticsInUse());
            
            HumanInputController hic = GetInputController();
            if (hic)
                hic.ResetFreeLookToggle();
        }
    }
    
    void ExitSights()
    {
        ItemOptics optics = null;
        EntityAI entityInHands = GetEntityInHands();
        Weapon weapon = Weapon.Cast(entityInHands);
        if (weapon)
        {
            optics = weapon.GetAttachedOptics();
        }
        else
        {
            optics = ItemOptics.Cast(entityInHands);
        }
        
        SetIronsights(false);
        SetOptics(false);
        
        if (optics)
        {
            SwitchOptics(optics,false);
        }
        
        HumanCommandWeapons hcw = GetCommandModifier_Weapons();
        if (hcw)
        {
            hcw.SetADS(false);
        }
    }
    
    void SwitchOptics(ItemOptics optic, bool state)
    {
        if (optic && !optic.IsSightOnly())
        {
            if (state)
            {
                if (optic.HasEnergyManager())
                    optic.GetCompEM().SwitchOn();
 
                optic.EnterOptics();
                optic.OnOpticEnter();
            }
            else
            {
                optic.ExitOptics();
                optic.OnOpticExit();
                if (optic.HasEnergyManager())
                    optic.GetCompEM().SwitchOff();
            }
        }
        
        if (m_CameraOptics != state)
        {
            SetOptics(state);
        }
    }
 
    void SetClimbingLadderType(string value)
    {
        m_ClimbingLadderType = value;
    }
 
    bool CanConsumeStamina(EStaminaConsumers consumer);
    bool CanStartConsumingStamina(EStaminaConsumers consumer);
    void DepleteStaminaEx(EStaminaModifiers modifier, float dT = -1, float coef = 1.0);
    override CachedEquipmentStorage GetCachedEquipment()
    {
        return CachedEquipmentStorage.Cast(m_CachedEquipmentStorage);
    }
    
    bool IsInVehicle()
    {
        return m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_VEHICLE || (GetParent() != null && GetParent().IsInherited(Transport));
    }
    
    bool IsSwimming()
    {
        return m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_SWIM;
    }
    
    bool IsClimbingLadder()
    {
        return m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_LADDER;
    }
    
    bool PlaySoundEventType(ESoundEventType soundType, int soundEventID, int param = 0) {};
    bool PlaySoundEvent(EPlayerSoundEventID id, bool from_anim_system = false, bool is_from_server = false) {};
    bool PlaySoundEventEx(EPlayerSoundEventID id, bool from_anim_system = false, bool is_from_server = false, int param = 0) {};
    bool StopSoundEvent(EPlayerSoundEventID id, bool is_from_server = false, int param = 0) {};
 
    bool IsFBSymptomPlaying()
    {
        return m_isFBsymptomPlaying;
    }
    
    float GetDeltaT()
    {
        return m_dT;
    }
 
    //-------------------------------------------------------------
 
    int m_DeathAnimType = -2;
    float m_DeathHitDir = 0;
    bool m_DeathJuctureSent = false;
    
    Transport GetTransportCache()
    {
        return m_TransportCache;
    }
    
    override string GetDebugText()
    {
        string text = super.GetDebugText();
        text += "Parent: " + Object.GetDebugName(Object.Cast(GetParent())) + "\n";//keep
        text += "IsSimulationDisabled: " + GetIsSimulationDisabled() + "\n";//keep
        /*
        text += "DamageDestroyed: " + IsDamageDestroyed() + "\n";
        text += "DeathProcessed: " + IsDeathProcessed() + "\n";
        text += "DeathConditionMet: " + IsDeathConditionMet() + "\n";
        text += "PullOutOfVehicleState: " + m_PullPlayerOutOfVehicleState + "\n";
        text += "PullOutOfVehicleSynch: " + m_TriggerPullPlayerOutOfVehicleSynch + "\n";
        text += "Position: " + GetPosition() + "\n";*/
        return text;
    }
 
    void TriggerPullPlayerOutOfVehicle()
    {
        if (!g_Game.IsServer())
        {
            return;
        }
        
        Transport transport;
        if (!Class.CastTo(transport, GetParent()))
        {
            return;
        }
        
        int crewIdx = -1;
        for (int i = 0; i < transport.CrewSize(); ++i)
        {
            if (transport.CrewMember(i) == this)
            {
                crewIdx = i;
                break;
            }
        }
        
        if (crewIdx == -1)
        {
            return;
        }
 
        transport.CrewGetOut(crewIdx);
        TriggerPullPlayerOutOfVehicleImpl();
 
        if (crewIdx == DayZPlayerConstants.VEHICLESEAT_DRIVER)
        {
                        
#ifdef FEATURE_NETWORK_RECONCILIATION
            PlayerIdentity identity = GetIdentity();
 
            if (identity)
            {
                identity.Possess(this);
            }
#endif
        }
        
        SetSynchDirty();
    }
 
    void TriggerPullPlayerOutOfVehicleImpl()
    {
        ResetDeathCooldown();

        DisableSimulation(false);
 
        switch (GetInstanceType())
        {
            case DayZPlayerInstanceType.INSTANCETYPE_SERVER:
            case DayZPlayerInstanceType.INSTANCETYPE_CLIENT:      
            case DayZPlayerInstanceType.INSTANCETYPE_AI_SERVER:
            case DayZPlayerInstanceType.INSTANCETYPE_AI_SINGLEPLAYER:
                m_PullPlayerOutOfVehicleState = 0;
                m_TriggerPullPlayerOutOfVehicleSynch = true;
                break;
        }
    }
    
    override void OnVariablesSynchronized()
    {
        if (m_TriggerPullPlayerOutOfVehicleSynch && !g_Game.IsDedicatedServer())
        {
            TriggerPullPlayerOutOfVehicleImpl();
        }
 
        super.OnVariablesSynchronized();
    }
 
    void DeathDropHandEntity()
    {
        if (!g_Game.IsServer())
        {
            return;
        }
 
#ifdef ENABLE_LOGGING
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("DZPI::OnSimulationEnd - trying to drop item");
        }
#endif
 
        EntityAI itemInHands = GetEntityInHands();
        if (!itemInHands)
        {
            return;
        }
        
        int boneIndex = GetBoneIndexByName("RightHand_Dummy");
        
        vector m4[4];
        GetBoneTransformWS(boneIndex, m4);
        
        // TODO(kumarjac): Change to occur on the earlier event and drop with physics instead? 
        // aside from dynamic lifetime of entities being too low, physics is stable now.
        GetInventory().DropEntityWithTransform(InventoryMode.SERVER, this, itemInHands, m4);
        
        CEApi ceApi = GetCEApi();
        if (ceApi)
        {
            int deadBodyLifetime = ceApi.GetCEGlobalInt("CleanupLifetimeDeadPlayer");
            if (deadBodyLifetime <= 0)
            {
                deadBodyLifetime = 3600;
            }
 
            itemInHands.SetLifetime(deadBodyLifetime);
        }
    }
 
    bool HandleDeath(int pCurrentCommandID)
    {
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_DEATH)
        {
            switch (m_PullPlayerOutOfVehicleState)
            {
            case -1:
                break;
            case 0:
                m_PullPlayerOutOfVehicleState = -1;
 
                PhysicsSetSolid(true);
                
                DayZPlayerVehicleCommandDeathCallback callbackVeh;
                Class.CastTo(callbackVeh, StartCommand_Death(DayZPlayerConstants.DEATH_PULL_OUT_TRANSPORT, 0, DayZPlayerVehicleCommandDeathCallback, m_PullPlayerOutOfVehicleKeepsInLocalSpace));
                Class.CastTo(callbackVeh.m_pPlayer, this);
                break;
            }   
 
            return true;
        }
        
        if (m_DeathAnimType != -2 && g_Game.GetMissionState() == g_Game.MISSION_STATE_GAME)
        {
            if (!CommitedSuicide())  
            {
                int type = m_DeathAnimType;
                if (type == DayZPlayerConstants.DEATH_DEFAULT) 
                    type = GetTypeOfDeath(pCurrentCommandID);
 
                m_WasInVehicle = false;               
                HumanCommandVehicle hcv = GetCommand_Vehicle();
                if (hcv)
                {
                    m_TransportCache = hcv.GetTransport();
                    m_WasInVehicle = !hcv.IsGettingIn() && !hcv.IsGettingOut();
                }
 
                int seatIndex = -1;
                if (m_TransportCache)
                {
                    seatIndex = m_TransportCache.CrewMemberIndex(this);
                }

                m_ShouldBeUnconscious = false;
 
                bool keepInLocalSpace = m_PullPlayerOutOfVehicleKeepsInLocalSpace;
                if (m_TransportCache)
                {
                    if (IsUnconscious() || m_WasInVehicle)
                    {
                        keepInLocalSpace = true;
                        m_TransportCache.CrewDeath(seatIndex);
                    }
                    else
                    {
                        m_TransportCache.CrewGetOut(seatIndex);
                    }
 
                    m_TransportCache.MarkCrewMemberDead(seatIndex);
                    
                    if (seatIndex == DayZPlayerConstants.VEHICLESEAT_DRIVER)
                    {
                        
#ifdef FEATURE_NETWORK_RECONCILIATION
                        PlayerIdentity identity = GetIdentity();
 
                        if (identity)
                        {
                            identity.Possess(this);
                        }
#endif
                    }
 
                    Motorbike motorbike = Motorbike.Cast(m_TransportCache);
                    if (motorbike)
                    {
                        motorbike.FallOver();
                    }
                }
                
                DisableSimulation(false);
                GetItemAccessor().HideItemInHands(false);
                m_TransportCache = null;
 
                DayZPlayerCommandDeathCallback callback;
                Class.CastTo(callback, StartCommand_Death(type, m_DeathHitDir, DayZPlayerCommandDeathCallback, keepInLocalSpace));
                Class.CastTo(callback.m_pPlayer, this);
            }
            else
            {
                PhysicsSetSimpleDeath(true);
            }
            
            // disable voice communication
            g_Game.GetWorld().SetVoiceOn(false, false);
            
            return true;
        }
 
        return false;
    }
    
    void ResetDeathStartTime()
    {
        ResetDeathCooldown();
    }
    
    int GetTypeOfDeath(int pCurrentCommandID)
    {
        switch (pCurrentCommandID)
        {
            case DayZPlayerConstants.COMMANDID_SWIM:
                return DayZPlayerConstants.DEATH_WATER;
            case DayZPlayerConstants.COMMANDID_FALL:
                return DayZPlayerConstants.DEATH_FALL;
            case DayZPlayerConstants.COMMANDID_UNCONSCIOUS:
                HumanCommandUnconscious hcu = GetCommand_Unconscious();
                if (hcu)
                {
                    if (hcu.IsOnLand())
                        return DayZPlayerConstants.DEATH_UNCON_ON_LAND;
                    if (hcu.IsInWater())
                        return DayZPlayerConstants.DEATH_UNCON_IN_WATER;
                }
 
                break;
        }
        
        return DayZPlayerConstants.DEATH_BODY;
    }
    
    void SendDeathJuncture(int pAnimTypeDeath, float pAnimHitDirDeath)
    {
        if (m_DeathJuctureSent)
            return;
        
        DayZPlayerSyncJunctures.SendDeath(this, pAnimTypeDeath, pAnimHitDirDeath);
        m_DeathJuctureSent = true;
    }
    
    override void EEKilled(Object killer)
    {
        SendDeathJuncture(-1, 0);
        
        super.EEKilled(killer);
    }
    
    void ShowDeadScreen(bool show, float duration)
    {       
        #ifndef NO_GUI
        if (show && IsPlayerSelected())
        {
            #ifdef PLATFORM_PS4
            OnlineServices.SetMultiplayState(false);
            #endif      
            
            string message = "";
            if (!g_Game.GetMission().IsPlayerRespawning())
            {
                message = "#dayz_implement_dead";
            }
 
            #ifdef PLATFORM_CONSOLE
            g_Game.GetUIManager().ScreenFadeIn(duration, message, FadeColors.DARK_RED, FadeColors.WHITE);
            #else
            g_Game.GetUIManager().ScreenFadeIn(duration, message, FadeColors.BLACK, FadeColors.WHITE);
            #endif
        }
        else
        {
            g_Game.GetUIManager().ScreenFadeOut(duration);
 
            if (duration > 0)
                g_Game.GetCallQueue(CALL_CATEGORY_GUI).CallLater(StopDeathDarkeningEffect, duration*1000, false);
            else
                g_Game.GetCallQueue(CALL_CATEGORY_GUI).Call(StopDeathDarkeningEffect);
        }
        #endif
    }
    
    override void StopDeathDarkeningEffect()
    {
        if (m_DeathEffectTimer && m_DeathEffectTimer.IsRunning())
        {
            m_DeathEffectTimer.Stop();
            m_DeathEffectTimer = null;
        }
    }
    
    void SimulateDeath(bool state)
    {
        if (g_Game.GetMissionState() != DayZGame.MISSION_STATE_GAME)
            return;
        
        LockControls(state);
        
        if (state)
        {
            float duration = DEFAULT_DYING_TIME;
            if (m_KilledByHeadshot)
            {
                duration = 0;
            }
            
            if (duration > DYING_PROGRESSION_TIME && !m_IsUnconscious)
            {
                if (!m_DeathEffectTimer)
                    m_DeathEffectTimer = new DeathEffectTimer();
                
                Param2<float,float> par = new Param2<float,float>(duration, DYING_PROGRESSION_TIME);
                m_DeathEffectTimer.Run(DYING_PROGRESSION_TIME, this, "SetDeathDarknessLevel", par, true);
            }
            
            ShowDeadScreen(state, duration);
            
            g_Game.GetSoundScene().SetSoundVolume(0,0);
            g_Game.GetSoundScene().SetSpeechExVolume(0,0);
            g_Game.GetSoundScene().SetMusicVolume(0,0);
            g_Game.GetSoundScene().SetVOIPVolume(0,0);
            g_Game.GetSoundScene().SetRadioVolume(0,0);
        }
        else
        {
            StopDeathDarkeningEffect();
            ShowDeadScreen(state, 0);
        }
    }
    
    void LockControls(bool state)
    {
        if (state == true)
        {
            g_Game.GetInput().ChangeGameFocus(1, INPUT_DEVICE_MOUSE);
            g_Game.GetInput().ChangeGameFocus(1, INPUT_DEVICE_KEYBOARD);
            g_Game.GetInput().ChangeGameFocus(1, INPUT_DEVICE_GAMEPAD);
            
            if (g_Game.GetUIManager())    
            {
                g_Game.GetUIManager().ShowUICursor(true);
                if (g_Game.GetUIManager().IsDialogVisible())
                    g_Game.GetUIManager().CloseDialog();
            }
        }
        else
        {
            g_Game.GetInput().ChangeGameFocus(-1, INPUT_DEVICE_MOUSE);
            g_Game.GetInput().ChangeGameFocus(-1, INPUT_DEVICE_KEYBOARD);
            g_Game.GetInput().ChangeGameFocus(-1, INPUT_DEVICE_GAMEPAD);
            
            if (g_Game.GetUIManager())
            {
                if (g_Game.GetUIManager().GetMenu())
                {
                    g_Game.GetUIManager().ShowUICursor(true);
                }
                else
                {
                    g_Game.GetUIManager().ShowUICursor(false);
                }
            }
        }
    }
    
    void SetDeathDarknessLevel(float duration, float tick_time);
    
    void CompleteWeaponRaise()
    {
        m_WeaponRaiseTime = 0;
        m_WeaponRaiseCompleted = true;
        HumanInputController hic = GetInputController();
        if (hic)
            hic.ResetFreeLookToggle();
    }
    
    void ResetWeaponRaiseProgress()
    {
        m_WeaponRaiseTime = 0;
        m_WeaponRaiseCompleted = false;
    }
    
    bool IsWeaponRaiseCompleted()
    {
        return m_WeaponRaiseCompleted;
    }
    
    DayZPlayerInventory GetDayZPlayerInventory()
    {
        DayZPlayerInventory inv = DayZPlayerInventory.Cast(GetInventory());
        return inv;
    }
 
    override void OnInputForRemote(ParamsReadContext ctx)
    {
        int userDataType = 0;
        if (!ctx.Read(userDataType))
        {
            Error("DayZPlayer: OnInputForRemote - cannot read input type");
            return;
        }
        
        switch (userDataType)
        {
            case INPUT_UDT_WEAPON_REMOTE_EVENT:
                GetDayZPlayerInventory().OnEventForRemoteWeapon(ctx);
                break;
            case INPUT_UDT_HAND_REMOTE_EVENT:
                GetDayZPlayerInventory().OnHandEventForRemote(ctx);
                break;
            case INPUT_UDT_INVENTORY:
                GetDayZPlayerInventory().OnInputUserDataForRemote(ctx);
                break;
            default:
                Error("OnInputForRemote - unknown userDataType=" + userDataType);
                break;
        }
    }
 
    override void OnInputFromServer (ParamsReadContext ctx)
    {
        int userDataType = 0;
        if (!ctx.Read(userDataType))
        {
            Error("DayZPlayer: OnInputFromServer - cannot read input type");
            return;
        }
 
        switch (userDataType)
        {
            case INPUT_UDT_INVENTORY:
                GetDayZPlayerInventory().OnServerInventoryCommand(ctx);
                break;
            default:
                Error("OnInputFromServer - unknown userDataType=" + userDataType);
                break;
        }
    }
    void RequestSoundEvent(EPlayerSoundEventID id, bool from_server_and_client = false);
    void RequestSoundEventEx(EPlayerSoundEventID id, bool from_server_and_client = false, int param = 0);
    void RequestSoundEventStop(EPlayerSoundEventID id, bool from_server_and_client = false, int param = EPlayerSoundEventParam.STOP_PLAYBACK);
    protected void SendSoundEvent(EPlayerSoundEventID id);
    protected void SendSoundEventEx(EPlayerSoundEventID id, int param = 0);
    
    override void OnItemInHandsChanged()
    {
        OnItemInHandsChangedEx();
    }
    
    override void OnItemInHandsChangedEx(bool pInstant = false, bool pChangeAnimationInstance = true)
    {
        //Print("inv: DayZPlayerImplement::OnItemInHandsChanged: "/* + GetEntityInHands()*/);
        StopWeaponEvent();
        GetItemAccessor().OnItemInHandsChanged(pInstant, pChangeAnimationInstance);
        
        if (!IsAlive())
        {
            //Print("inv: DayZPlayerImplement::OnItemInHandsChanged - human not alive! calling ResetWeaponInHands");
            GetItemAccessor().ResetWeaponInHands();
        }
        
        HumanInventoryWithFSM.Cast(GetHumanInventory()).CheckFSMState();
    }
 
    WeaponManager GetWeaponManager() { return null; }
 
    //-------------------------------------------------------------
    void HandleWeapons(float pDt, Entity pInHands, HumanInputController pInputs, out bool pExitIronSights)
    {
        HumanCommandWeapons      hcw = GetCommandModifier_Weapons();
        GetDayZPlayerInventory().HandleWeaponEvents(pDt, pExitIronSights);
 
        Weapon_Base weapon;
        Class.CastTo(weapon, pInHands);
        ItemOptics optic = weapon.GetAttachedOptics();
        
        CheckLiftWeapon();
        ProcessLiftWeapon();
        
        GetMovementState(m_MovementState);
        
        // obstruction
        bool    wantedLift          = m_LiftWeapon_player;
        bool    currentLift         = hcw.IsWeaponLifted();
        if (wantedLift != currentLift) 
        {
            hcw.LiftWeapon(wantedLift);
            // Reset the velocity, cause at this point we might need to start moving in the opposite direction rather rapidly,
            // to prevent the obstruction from smashing the player's head while lifting
            m_fObstructionSmoothVelocity[0] = 0;
        }       
        
        float   wantedObstruction   = m_ObstructWeapon_player;
        float   currentObstruction  = hcw.GetWeaponObstruction();
        if (wantedObstruction != currentObstruction)
        {
            // The following times are times chosen by observation; the following values produced
            // consistent and relatively nicely looking results and were OK'd by the animators.
            const float outTime    = 0.150;   // duration when smoothing hi -> lo
            const float inTime     = 0.010;   // duration when smoothing lo -> hi
            const float inTimeLift = 0.100;   // duration when smoothing in during lift
            
            float smoothTime;
            if (wantedLift) // When lifting always transition rather quickly
            {
                wantedObstruction = 0.0;
                smoothTime = inTimeLift;
            }
            else // Otherwise we can take our time based on the delta
            {
                float t = Math.Clamp(Math.AbsFloat(wantedObstruction-currentObstruction), 0, 1);
                smoothTime = Math.Lerp(outTime, inTime, t);
            }
            
            // Do the interpolation and clamp to wanted value if the change is below certain threshold, to prevent uneccessary interpolation
            m_fObstructionSmooth = Math.SmoothCD(m_fObstructionSmooth, wantedObstruction, m_fObstructionSmoothVelocity, smoothTime, 6.0, pDt);
            if (Math.AbsFloat(m_fObstructionSmooth-wantedObstruction) < 0.0001) 
            { 
                m_fObstructionSmooth = wantedObstruction;
            }
            
            #ifdef DIAG_DEVELOPER
            if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_DISABLE_OBSTRUCTION_INTERPOLATION))
                m_fObstructionSmooth = wantedObstruction;
            #endif
                
            hcw.ObstructWeapon(m_fObstructionSmooth);
            
            #ifndef SERVER
            #ifdef DIAG_DEVELOPER
            PluginDiagMenuClient.GetWeaponLiftDiag().Data().SetInterpolation( inTime, inTimeLift, outTime, smoothTime, m_fObstructionSmooth, currentObstruction, wantedObstruction );
            #endif
            #endif
        }
        // !obstruction
        
        // hold breath
        if (pInputs.IsHoldBreath() && m_MovementState.IsRaised() && (IsInIronsights() || IsInOptics()))
        {
            m_IsTryingHoldBreath = true;
        }
        else
        {
            m_IsTryingHoldBreath = false;
        }
        
        if (pInputs.IsFireModeChange())
        {
            GetWeaponManager().SetNextMuzzleMode();
        }
        if (pInputs.IsZeroingUp())
        {
            if (optic && (optic.IsInOptics() || optic.IsUsingWeaponIronsightsOverride()))
            {
                optic.StepZeroingUp();
            }
            else
            {
                weapon.StepZeroingUpAllMuzzles();
            }
        }
        if (pInputs.IsZeroingDown())
        {
            if (optic && (optic.IsInOptics() || optic.IsUsingWeaponIronsightsOverride()))
            {
                optic.StepZeroingDown();
            }
            else
            {
                weapon.StepZeroingDownAllMuzzles();
            }
        }
        
        if (!m_LiftWeapon_player && (m_CameraIronsight || !weapon.CanEnterIronsights() || m_CameraOptics/*m_ForceHandleOptics*/))     // HACK straight to optics, if ironsights not allowed
        {
            if (optic)
                HandleOptic(optic, false, pInputs, pExitIronSights);
        }
        
        if (!m_MovementState.IsRaised())
        {
            m_IsFireWeaponRaised = false; //legacy reasons
            if (weapon && weapon.IsInOptics())
            {
                weapon.ExitOptics();
            }
            
            ResetWeaponRaiseProgress();
 
            return; // if not raised => return
        }
        else
        {
            m_IsFireWeaponRaised = true; //legacy reasons
            if (!IsWeaponRaiseCompleted())
            {
                m_WeaponRaiseTime += pDt;
            }
            
            if (m_WeaponRaiseTime >= PlayerConstants.WEAPON_RAISE_BLEND_DELAY)
            {
                CompleteWeaponRaise();
            }
        }
        
        if (GetWeaponManager().CanFire(weapon))
        {
            bool autofire = weapon.GetCurrentModeAutoFire(weapon.GetCurrentMuzzle()) && weapon.IsChamberEjectable(weapon.GetCurrentMuzzle());
            int burst = weapon.GetCurrentModeBurstSize(weapon.GetCurrentMuzzle());
            int burst_count = weapon.GetBurstCount();
            if (!autofire && (burst < 2 || burst_count < 1))
            {
                if (pInputs.IsAttackButtonDown() && GetInputInterface().SyncedValue("UAWeaponMeleeAttack") == 0 && GetInputInterface().SyncedValue("UAHeavyMeleeAttack") == 0)
                {
                    GetWeaponManager().Fire(weapon);
                }
            }
            else if (autofire || burst > 1)
            {
#ifdef DIAG_DEVELOPER
                int burst_option = GetWeaponManager().GetBurstOption();
                if (burst_option == 0)
                {
#endif
                    if (pInputs.IsAttackButton() && GetInputInterface().SyncedValue("UAWeaponMeleeAttack") == 0 && GetInputInterface().SyncedValue("UAHeavyMeleeAttack") == 0)
                    {
                        if (autofire || burst_count < burst)
                        {
                            GetWeaponManager().Fire(weapon);
                        }
                    }
                    else
                    {
                        weapon.ResetBurstCount();   
                    }
#ifdef DIAG_DEVELOPER
                }
                else if (burst_option == 1)
                {
                    if (burst > 1 && burst_count == burst)
                    {
                        weapon.ResetBurstCount();   
                    }
                    else if (burst > 1 && burst_count < burst)
                    {
                        GetWeaponManager().Fire(weapon);    
                    }
                    else
                    {
                        //Autofire
                        if (pInputs.IsAttackButton())
                        {
                            GetWeaponManager().Fire(weapon);    
                        }                       
                    }   
                }
#endif
            }
        }
 
        #ifdef PLATFORM_CONSOLE
        if (g_Game.GetInput().LocalRelease("UAFire", false) || m_ShouldReload)
        {
            if (!weapon.IsWaitingForActionFinish() && !IsFighting())
            {
                int muzzle_index = weapon.GetCurrentMuzzle();
            
                if (weapon.IsChamberFiredOut(muzzle_index))
                {
                    if (weapon.CanProcessWeaponEvents())
                    {
                        if (GetWeaponManager().CanEjectBullet(weapon))
                        {
                            GetWeaponManager().EjectBullet();
                            pExitIronSights = true;
                            m_ShouldReload = false;
                        }
                    }
                }
            }
            else
            {
                m_ShouldReload = true;
            }
        }
        #endif
    }
    
    void HandleOptic(notnull ItemOptics optic, bool inHands, HumanInputController pInputs, out bool pExitOptics)
    {
        UAInterface input = GetInputInterface();
        if (!input)
        {
            return;
        }
 
        Weapon_Base weapon;
        int FOVcount;
        bool controllerPressIn;
        bool controllerPressOut;
        
        if (input.SyncedPress_ID(UAZoomInOptics))
        {
            weapon = Weapon_Base.Cast(optic.GetHierarchyParent());
            FOVcount = optic.GetStepFOVCount();
            controllerPressIn = input.SyncedPress_ID(UAZoomInOpticsControllerHelper);
        
            if (weapon && m_CameraIronsight && !m_CameraOptics)
            {
                SetIronsights(false);
                SwitchOptics(optic,true);
                optic.SetStepFOVIndex(0);
            }
            else if (m_CameraOptics)
            {
                if (controllerPressIn) //controller
                {
                    if (!optic.StepFOVUp())
                    {
                        if (FOVcount > 0)
                        {
                            optic.SetStepFOVIndex(0); //loop to minimum magnification
                        }
                        
                        if (weapon && weapon.CanEnterIronsights()) //loop into ironsights
                        {
                            SwitchOptics(optic,false);
                            SetIronsights(true);
                        }
                    }
                }
                else //m&k
                {
                    optic.StepFOVUp();
                }
            }
        }
        
        if (input.SyncedPress_ID(UAZoomOutOptics))
        {
            weapon = Weapon_Base.Cast(optic.GetHierarchyParent());
            FOVcount = optic.GetStepFOVCount();
            controllerPressOut = input.SyncedPress_ID(UAZoomOutOpticsControllerHelper);
            if (m_CameraOptics)
            {
                if (!optic.StepFOVDown())
                {
                    if (controllerPressOut)
                    {
                        if (FOVcount > 0 && (!weapon || !weapon.CanEnterIronsights()))
                        {
                            optic.SetStepFOVIndex(FOVcount - 1); //loop to maximum magnification
                        }
                    }
                    
                    if (weapon && weapon.CanEnterIronsights())
                    {
                        SwitchOptics(optic,false);
                        SetIronsights(true);
                    }
                }
            }
            else if (controllerPressOut && weapon && m_CameraIronsight)
            {
                SwitchOptics(optic,true);
                if (FOVcount > 0)
                {
                    optic.SetStepFOVIndex(FOVcount - 1); //loop to maximum magnification
                }
            }
        }
    }
 
    //-------------------------------------------------------------
 
    bool m_DamageHitFullbody = false;
    int m_DamageHitAnimType = -1.0;
    float m_DamageHitDir = 0.0;
    float m_DamageHealth = 0.0;
    
    const float HIT_INTERVAL_MIN = 0.3;         // Minimum time in seconds before a COMMANDID_HIT to COMMANDID_HIT transition is allowed
    float m_HitElapsedTime = HIT_INTERVAL_MIN;
 
    bool IsInFullbodyDamageAnimation()
    {
        return (m_DamageHitFullbody && m_DamageHitAnimType != -1) || GetCommand_Damage() != null;
    }

    void EvaluateDamageHit(int pCurrentCommandID)
    {
        m_DamageHitAnimType = -1;
 
        if (!m_SyncedHitDataArray || m_SyncedHitDataArray.Count() == 0)
        {
            return;
        }
        
        //evaluate all hit data
        SyncHitInfo data;
        SyncHitInfo greatest_hit;
        int nSyncedHitDataArray = m_SyncedHitDataArray.Count();
        for (int i = 0; i < nSyncedHitDataArray; ++i)
        {
            data = m_SyncedHitDataArray[i];
            m_DamageHitDir = data.m_HitDir;
            
            //client-side effects
            #ifndef SERVER
            if (IsAlive() && !IsUnconscious() && data.m_HasSource && g_Game.GetMission().GetHud() && g_Game.GetPlayer() == this) //only for controlled players
            {
                m_DamageHealth = data.m_HealthDamage;
                #ifndef NO_GUI
                if (m_DamageHealth > 0.0)
                {
                    float rel = m_DamageHealth / (GetMaxHealth("","Health") * PlayerConstants.HEAVY_HIT_THRESHOLD);
                    g_Game.GetMission().GetHud().SpawnHitDirEffect(this,m_DamageHitDir,rel);
                }
                #endif
            }
            #endif
            
            if (!greatest_hit)
            {
                greatest_hit = data;
            }
            //else if (data.m_HealthDamage > greatest_hit.m_HealthDamage || (data.m_Fullbody && !greatest_hit.m_Fullbody)) //TODO - revisit cumulative calculation for animation evaluation purposes (stagger on shotgun to the chest)
            else if (data.m_Fullbody) //temporary solution; last fullbody hit is used for animation purposes, some light hit otherwise
            {
                greatest_hit = data;
            }
        }
        
        m_SyncedHitDataArray.Clear();
        m_DamageHealth = 0.0;

        if (m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE || m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE || IsUnconscious())
        {
            return;
        }
        
        //general effects
        m_DamageHitFullbody = greatest_hit.m_Fullbody;
        m_DamageHitAnimType = greatest_hit.m_AnimType;
        m_DamageHitDir = greatest_hit.m_HitDir;
    }
 
    bool HandleDamageHit(int pCurrentCommandID)
    {
        // Update elapsed time since hit first
        if ( pCurrentCommandID == DayZPlayerConstants.COMMANDID_DAMAGE )
        {
            // Throttle heavy hit command up to a fixed rate
            if ( m_HitElapsedTime < HIT_INTERVAL_MIN )
            {
                m_HitElapsedTime += m_dT;
                ResetDamageHitState(false);
                return false;
            }
        }
        
        // If transportcache is not null, player is unconscious inside of a car and should not head into a damage command
        if (m_DamageHitAnimType != -1 && m_TransportCache == null && !CommitedSuicide())
        {
            HumanCommandVehicle vehCommand = GetCommand_Vehicle();       
            if (m_DamageHitFullbody && (!vehCommand || vehCommand.IsGettingIn() || vehCommand.IsGettingOut()))
            {
                StartCommand_Damage(m_DamageHitAnimType, m_DamageHitDir);
                ResetDamageHitState(true);
                return true;
            }
            else
            {
                AddCommandModifier_Damage(m_DamageHitAnimType, m_DamageHitDir);
                ResetDamageHitState(false);
                return false;
            }
        }
        
        return pCurrentCommandID == DayZPlayerConstants.COMMANDID_DAMAGE;
    }
    
    void ResetDamageHitState(bool resetTimer)
    {
        m_DamageHitAnimType = -1;
        m_DamageHitFullbody = false;
        
        if (resetTimer)
        {
            m_HitElapsedTime = 0;
        }
    }

    bool EvaluateDeathAnimation(int pDamageType, EntityAI pSource, string pAmmoType, out int pAnimType, out float pAnimHitDir)
    {
        bool doPhxImpulse = g_Game.ConfigGetInt("cfgAmmo " + pAmmoType + " doPhxImpulse") > 0;
 
        pAnimType = DayZPlayerConstants.DEATH_DEFAULT;       
        if (doPhxImpulse)
            pAnimType = DayZPlayerConstants.DEATH_FAST;

        vector targetDirection = GetDirection();
        vector toSourceDirection = (pSource.GetPosition() - GetPosition());
 
        targetDirection[1] = 0;
        toSourceDirection[1] = 0;
 
        targetDirection.Normalize();
        toSourceDirection.Normalize();
 
        float cosFi = vector.Dot(targetDirection, toSourceDirection);
        vector cross = targetDirection * toSourceDirection;
 
        pAnimHitDir = Math.Acos(cosFi) * Math.RAD2DEG;
        if (cross[1] < 0)
            pAnimHitDir = -pAnimHitDir;
        
        return true;
    }

    bool EvaluateDamageHitAnimation(TotalDamageResult pDamageResult, int pDamageType, EntityAI pSource, string pComponent, string pAmmoType, vector pModelPos, out int pAnimType, out float pAnimHitDir, out bool pAnimHitFullbody)
    {
        int invertHitDir = 0; //Used to flip the heavy hit animation direction
        
        pAnimType = 0;
        pAnimHitFullbody = false; // additive anm
        GetMovementState(m_MovementState);
 
        switch (pDamageType)
        {
            case DamageType.CLOSE_COMBAT:
                if (pSource.IsInherited(DayZInfected))
                    break;
 
                pAnimType = g_Game.ConfigGetInt("cfgAmmo " + pAmmoType + " hitAnimation");
                invertHitDir = g_Game.ConfigGetInt("cfgAmmo " + pAmmoType + " invertHitDir");
                if (!IsUnconscious() && pAnimType == 1 && !m_MeleeFightLogic.IsInBlock())
                    pAnimHitFullbody = true;
                break;
 
            case DamageType.FIRE_ARM:
                int impactBehaviour = 0;
 
                if (!IsUnconscious() && GetHealth("", "Shock") > 25)
                {
                    if (pComponent == "Torso" || pComponent == "Head")
                    {
                        impactBehaviour = g_Game.ConfigGetInt("cfgAmmo " + pAmmoType + " impactBehaviour");
                        float fireDamage = pDamageResult.GetHighestDamage("Health");
                        float shockDamage = pDamageResult.GetHighestDamage("Shock");
                        if ((fireDamage > 80.0 || shockDamage > 40.0) && impactBehaviour == 1)
                            pAnimHitFullbody = true;
                    }
                }
 
                break;
 
            case DamageType.EXPLOSION:
                break;
 
            case DamageType.CUSTOM:
                pAnimType = g_Game.ConfigGetInt("cfgAmmo " + pAmmoType + " hitAnimation");
                if (pAnimType == 1)
                    pAnimHitFullbody = true;
                else if (pAmmoType != "HeatDamage" || IsSwimming() || IsInVehicle())
                    return false; 
 
                break;
        }

        vector targetDirection = GetDirection();
        vector toSourceDirection = (pSource.GetPosition() - GetPosition());
 
        targetDirection[1] = 0;
        toSourceDirection[1] = 0;
 
        targetDirection.Normalize();
        toSourceDirection.Normalize();
 
        float cosFi = vector.Dot(targetDirection, toSourceDirection);
        vector cross = targetDirection * toSourceDirection;
 
        pAnimHitDir = Math.Acos(cosFi) * Math.RAD2DEG;
        
        // We will invert direction of the hit
        if (invertHitDir > 0)
            pAnimHitDir -= 180;
        
        if (cross[1] < 0)
            pAnimHitDir = -pAnimHitDir;
        
        return true;
    }

    override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
    {
        super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
        
        m_TransportHitRegistered = false;
        
        if (!IsAlive())
        {
            int animTypeDeath;
            float animHitDirDeath;
            if (EvaluateDeathAnimation(damageType, source, ammo, animTypeDeath, animHitDirDeath))
            {
                SendDeathJuncture(animTypeDeath, animHitDirDeath);
            }           
            
            if (!m_DeathSyncSent) //checked until the death is evaluated by 'OnCommandHandlerTick' higher up the road
            {
                Man killer = source.GetHierarchyRootPlayer();
                
                if (!m_KillerData) //only one player is considered killer in the event of crossfire
                {
                    m_KillerData = new KillerData();
                    m_KillerData.m_Killer = killer;
                    m_KillerData.m_MurderWeapon = source;
                }
                
                if (killer && killer.IsPlayer())
                {
                    // was player killed by headshot?
                    if (dmgZone == "Brain")
                    {
                        m_KilledByHeadshot = true;
                        if (m_KillerData.m_Killer == killer)
                            m_KillerData.m_KillerHiTheBrain = true;
                    }
                }
            }
        }
        else
        {
            int animType;
            float animHitDir;
            bool animHitFullbody;
            if (EvaluateDamageHitAnimation(damageResult, damageType, source, dmgZone, ammo, modelPos, animType, animHitDir, animHitFullbody))
                DayZPlayerSyncJunctures.SendDamageHitEx(this, animType, animHitDir, animHitFullbody, damageResult, damageType, source, dmgZone, ammo, modelPos);
            else
            {
                bool skipSoundRequest = false;
                if (damageType == DamageType.CUSTOM && GetCommand_Fall())
                    skipSoundRequest = GetFallDamage().GetLandType() < HumanCommandFall.LANDTYPE_MEDIUM;
 
                if (!skipSoundRequest)
                    RequestSoundEvent(EPlayerSoundEventID.TAKING_DMG_LIGHT);
            }
        }
 
        // interupt melee for non-blocked hit or heavy hit
        if (animHitFullbody)
        {
            HumanCommandMelee2 hcm = GetCommand_Melee2();
            if (hcm)
                hcm.Cancel();
        }
    }
 
    //-------------------------------------------------------------
    float   m_fLastHeadingDiff = 0;

    override bool   HeadingModel(float pDt, SDayZPlayerHeadingModel pModel)
    {
        if (!IsAlive())
        {
            return false;
        }
        
        GetMovementState(m_MovementState);
        
        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_LADDER)
        {
            m_fLastHeadingDiff = 0;
            return false;
        }
        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_VEHICLE)
        {
            HumanCommandVehicle hmv = GetCommand_Vehicle();
            if (hmv.IsGettingOut() || hmv.IsGettingIn())
            {
                return DayZPlayerImplementHeading.NoHeading(pDt, pModel, m_fLastHeadingDiff);
            }
            
            m_fLastHeadingDiff = 0;
            return false;
        }
        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_UNCONSCIOUS)
        {
            HumanCommandUnconscious  hcu = GetCommand_Unconscious();
            if (!hcu.IsWakingUp())
            {
                m_fLastHeadingDiff = 0;
                //pModel.m_iCamMode = DayZPlayerConstants.CAMERAMODE_HEAD;
                return false;
            }
        }
        
        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_CLIMB)
        {
            m_fLastHeadingDiff = 0;
            return false;
        }
        
#ifdef DEVELOPER
        int actMenuValue = DiagMenu.GetEngineValue(DayZPlayerConstants.DEBUG_TURNSLIDE);
        if (actMenuValue != 0)
        {
            return DayZPlayerImplementHeading.ClampHeading(pDt, pModel, m_fLastHeadingDiff);
        }
#endif
        
        if (m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
        {
            m_fLastHeadingDiff = 0;
            return false;
        }

        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MOVE)
        {
            HumanCommandMove hcm = GetCommand_Move();
            if (hcm.IsStandingFromBack())
            {
                m_fLastHeadingDiff = 0;
                return false;
            }
        }
        
        HumanItemAccessor hia = GetItemAccessor();
        HumanItemBehaviorCfg hibcfg = hia.GetItemInHandsBehaviourCfg();
        if (hibcfg && hibcfg.m_StanceRotation[m_MovementState.m_iStanceIdx] == DayZPlayerConstants.ROTATION_DISABLE)
        {
            return DayZPlayerImplementHeading.NoHeading(pDt, pModel, m_fLastHeadingDiff);
        }
        if (IsUnconscious() || (GetCommand_Move() && GetCommand_Move().IsLeavingUncon()))
        {
            return DayZPlayerImplementHeading.NoHeading(pDt, pModel, m_fLastHeadingDiff);
        }
 
        return DayZPlayerImplementHeading.RotateOrient(pDt, pModel, m_fLastHeadingDiff);    
    }
 
 
    //-------------------------------------------------------------
    override bool   AimingModel(float pDt, SDayZPlayerAimingModel pModel)
    {
        GetMovementState(m_MovementState);
        if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MELEE2)
        {
            HumanCommandMelee2 hcm = GetCommand_Melee2();
            if (hcm.IsFinisher())
            {
                if (!m_AimingFinisherStarted)
                {
                    m_AimingModel.OnFinisherBegin(pModel.m_fCurrentAimY);
                    m_AimingFinisherStarted = true;
                }
                m_AimingModel.ProcessStealthFilters(pDt, pModel);
            }
            
            return true;
        }
 
        if (m_MovementState.IsRaised())
        {
            if (!m_RaiseStarted)
            {
                m_AimingModel.OnRaiseBegin(this);
                m_RaiseStarted = true;
            }
            m_AimingModel.ProcessAimFilters(pDt, pModel, m_MovementState.m_iStanceIdx);
            
            return true;
        }
 
        m_RaiseStarted = false;
        m_AimingFinisherStarted = false;
 
        return true;
    }
 
    //-------------------------------------------------------------
    
    bool ProcessJumpOrClimb(float pDt, int pCurrentCommandID)
    {
        HumanInputController hic = GetInputController();
        if (!hic || !hic.IsJumpClimb())
        {
            return false;
        }
        
        m_JumpClimb.JumpOrClimb();
    
        if (!m_JumpClimb.WasSuccessful())
        {
            return false;
        }
        
        return true;
    }
    
    bool CanJump()
    {
        if (IsFBSymptomPlaying() || IsRestrained() || IsUnconscious() || IsInFBEmoteState())
            return false;
        
        if (m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE || m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
            return false;
        
        if (IsRaised() && GetInputInterface().SyncedPress("UAGetOverControllerHelper")) //no raised jump on cotroller
        {
            return false;
        }
        
        HumanItemBehaviorCfg hibcfg = GetItemAccessor().GetItemInHandsBehaviourCfg();
        if (!hibcfg.m_bJumpAllowed)
            return false;
        
        if (!DayZPlayerUtils.PlayerCanChangeStance(this, DayZPlayerConstants.STANCEIDX_ERECT) || !DayZPlayerUtils.PlayerCanChangeStance(this, DayZPlayerConstants.STANCEIDX_RAISEDERECT))
            return false;
        
        HumanCommandMove hcm = GetCommand_Move();
        if (hcm)
        {
            if (hcm.IsChangingStance())
                return false;
        }
        
        HumanCommandSwim hcs = GetCommand_Swim();
        if (hcs)
        {
            return false;
        }
        
        return true;
    }
 
    bool CanClimb(int climbType, SHumanCommandClimbResult climbRes)
    {
        if (IsFBSymptomPlaying() || IsRestrained() || IsUnconscious() || IsInFBEmoteState() || GetCommand_Action() || GetCommandModifier_Action())
            return false;
        
        if (m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE || m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
            return false;
        
        if (IsRaised() && GetInputInterface().SyncedPress("UAGetOverControllerHelper")) //no raised climb on cotroller
        {
            return false;
        }
        
        HumanItemBehaviorCfg hibcfg = GetItemAccessor().GetItemInHandsBehaviourCfg();
        if (!hibcfg.m_bJumpAllowed)
            return false;
        
        if (climbRes)
        {
            EntityAI entity;
            if (Class.CastTo(entity,climbRes.m_GrabPointParent) && entity.IsHologram())
                return false;
            if (Class.CastTo(entity,climbRes.m_ClimbStandPointParent) && entity.IsHologram())
                return false;
            if (Class.CastTo(entity,climbRes.m_ClimbOverStandPointParent) && entity.IsHologram())
                return false;
        }
 
        return true;
    }
    
 
    void OnJumpStart()
    {
    }
    
    void OnJumpEnd(int pLandType = 0)
    {
    }
    
    void StopHandEvent()
    {
        GetDayZPlayerInventory().CancelHandEvent();
    }
    
    void StopWeaponEvent()
    {
        GetDayZPlayerInventory().CancelWeaponEvent();
    }
    
    void AbortWeaponEvent()
    {
        GetDayZPlayerInventory().AbortWeaponEvent();
    }
 
    // Please on't depend on this, we will eventually hopefully remove this
    void SyncDeferredEventToRemotes()
    {
        GetDayZPlayerInventory().SyncDeferredEventToRemotes();
    }
 
    //-------------------------------------------------------------
    void HandleADS()
    {
        if (!IsAlive())
        {
            if (m_CameraIronsight || m_CameraOptics)
            {
                ExitSights();
            }
            return;
        }
        
        bool bADSToggle = false;
        bool exitSights = false;
        HumanInputController hic = GetInputController();
        HumanItemAccessor  hia = GetItemAccessor();
        HumanCommandWeapons  hcw = GetCommandModifier_Weapons();
        PlayerBase playerPB = PlayerBase.Cast(this);
        GetMovementState(m_MovementState);
        
        if (playerPB.IsRolling())
        {
            exitSights = true;
        }
        
        bool isItemInHandsWeapon = hia.IsItemInHandsWeapon();
        if (m_ResetADS || (!isItemInHandsWeapon && hic.WeaponADS()))
        {
            hic.ResetADS();
            m_ResetADS = false;
        }
        
        if (!m_MovementState.IsRaised() || m_LiftWeapon_player)
        {
            ResetWeaponRaiseProgress();
            exitSights = true;
        }
        else
        {
            bool isWeaponADS = hic.WeaponADS();
            if (m_bADS != isWeaponADS)
            {
                m_bADS = isWeaponADS;
                bADSToggle = true;
            }
            
            if (m_bADS && !m_CameraIronsight && !m_CameraOptics)
            {
                if (!IsWeaponRaiseCompleted())
                {
                    bADSToggle = false;
                    exitSights = true;
                }
                else
                {
                    bADSToggle = true;
                }
            }
        }
    
        if (bADSToggle && !GetCommand_Melee2() && !GetThrowing().IsThrowingModeEnabled())
        {
            if (hia.IsItemInHandsWeapon() && playerPB.GetWeaponManager() && !playerPB.GetWeaponManager().IsRunning())
            {
                Weapon_Base weapon = Weapon_Base.Cast(GetEntityInHands());
                ItemOptics optic = weapon.GetAttachedOptics();
                bool switchToADS = false;
                bool canUseIronsights = weapon.CanEnterIronsights();
                bool canUseOptics = optic != NULL;
                
                if (canUseIronsights || canUseOptics)
                    switchToADS = m_bADS;
                
                // go to ironsights - disable ironsights when
                if (!m_MovementState.IsRaised() || m_MovementState.m_iMovement == DayZPlayerConstants.MOVEMENTIDX_SPRINT)
                {
                    switchToADS = false;
                }
                
                // fixes camera switching during item transitions
                if (IsLiftWeapon() || IsWeaponObstructionBlockingADS() || !IsRaised() || GetDayZPlayerInventory().IsProcessing() || !IsWeaponRaiseCompleted() || IsFighting())
                {
                    exitSights = true;
                }
                else if (switchToADS) // enter ironsights or optics
                {
                    // filter by usability
                    if (weapon.GetWasIronSight() && !canUseIronsights)
                    {
                        weapon.SetWasIronSight(false);
                    }
                    else if (!weapon.GetWasIronSight() && !canUseOptics)
                    {
                        weapon.SetWasIronSight(true);
                    }
                    
                    if (weapon.GetWasIronSight())
                    {
                        SwitchOptics(optic,false);
                        SetIronsights(true);
                    }
                    else if (!weapon.GetWasIronSight() || (!canUseIronsights && canUseOptics))
                    {
                        SetIronsights(false);
                        SwitchOptics(optic,true);
                    }
                    else
                    {
                        exitSights = true;
                    }
                    
                    if (hcw && (m_CameraOptics/* || m_CameraIronsight*/))
                    {
                        hcw.SetADS(true);
                    }
                }
                else
                {
                    exitSights = true;
                }
            }
        }
        
        // leave ironsight and/ or optics
        if (exitSights && !IsHandheldOpticsInUse() && (m_CameraIronsight || m_CameraOptics) || GetCommand_Melee2())
        {
            ExitSights();
        }
    }
    
    void HandleView()
    {
        if (!IsAlive())
        {
            if (m_CameraIronsight || m_CameraOptics)
            {
                ExitSights();
            }
            return;
        }
        
        HumanInputController hic = GetInputController();
    
        bool camChange = hic.CameraViewChanged();
        int thirdPersonViewMode = g_Game.GetWorld().GetThirdPersonViewMode();
        
        if (IsRaised())
        {
            if (m_IsWeapon)
            {
                camChange = false;
            }
        }
        
        if (thirdPersonViewMode == ThirdPersonMode.DISABLED)
        {
            m_Camera3rdPerson = false;
        }
        else if (camChange)
        {
            m_Camera3rdPerson = !m_Camera3rdPerson;
        }
        
        // exits optics completely, comment to return to ADS
        if ((m_LiftWeapon_player || IsWeaponObstructionBlockingADS()) && (m_CameraOptics || m_CameraIronsight))
            ExitSights();
        
        if (IsPlayerInStance(DayZPlayerConstants.STANCEMASK_RAISEDPRONE) && (m_CameraOptics || m_CameraIronsight))
        {
            SetVerticalMinimumAimLimit(DayZPlayerCameraIronsights.CONST_UD_MIN_BACK);
            m_CameraOpticsAimOverride = true;
        }
        else if (m_CameraOpticsAimOverride)
        {
            SetVerticalMinimumAimLimit(DayZPlayerCameraIronsights.CONST_UD_MIN);
            m_CameraOpticsAimOverride = false;
        }
        
        if (hic.IsZoomToggle() && !m_MovementState.IsRaised())        
        {
            m_CameraEyeZoomLevel = ECameraZoomType.NORMAL;
            if ((IsClimbingLadder() && Math.AbsInt(m_MovementState.m_iMovement) == 2) || (IsSwimming() && m_MovementState.m_iMovement == 3))
            {
                m_CameraEyeZoomLevel = ECameraZoomType.SHALLOW;
            }
            else if (!IsClimbingLadder() && !IsSwimming() && !IsInVehicle())
            {
                float pSpeed;
                vector pLocalDirection;
                hic.GetMovement(pSpeed ,pLocalDirection);
                
                if (m_MovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_ERECT && pSpeed == 3)
                {
                    m_CameraEyeZoomLevel = ECameraZoomType.SHALLOW;
                }
            }
        }
        else
        {
            m_CameraEyeZoomLevel = ECameraZoomType.NONE;
        }
        
        if (m_MovementState.IsRaisedInProne())
        {
            float headingAngle = MiscGameplayFunctions.GetHeadingAngle(this);
            float headingAngleDiffBlock = Math.AbsFloat(m_LastHeadingAngleBlock - headingAngle);
            float headingAngleDiffBlock2 = Math.AbsFloat(m_LastHeadingAngleBlock2 - headingAngle);
            float headingAngleDiff = 0.0;
            
            if (m_LastHeadingAngle * headingAngle < 0.0)
            {
                headingAngleDiff = Math.AbsFloat(m_LastHeadingAngle + headingAngle);
            }
            else
            {
                headingAngleDiff = Math.AbsFloat(m_LastHeadingAngle - headingAngle);
            }
            
            if (headingAngleDiff > 0.2)
            {
                int time = g_Game.GetTime();
                
                float timefilterconstant = 400 - (headingAngleDiff * 100);
                
                if (headingAngleDiffBlock > 0.8 && time - m_LastBackSoundTime > timefilterconstant)
                {
                    float volume = headingAngleDiff / 0.5;
                    if (volume > 1)
                    {
                        volume = 1;
                    }
                    if (volume < 0.25)
                    {
                        volume = 0.25;
                    }
 
                    m_SoundOffset = headingAngleDiff / 2;
                    if (m_SoundOffset > 0.25)
                    {
                        m_SoundOffset = 0.25;
                    }
 
                    string soundSetName = "Cloth_Body_longmove_TShirt_Soundset";
                    
                    string bodyClothName = "";
                    EntityAI attachment = GetInventory().FindAttachment(InventorySlots.BODY);
                    if (attachment)
                    {
                        bodyClothName = attachment.GetAttachmentSoundType();
                    }
 
                    if (bodyClothName != "")
                    {
                        string path = "CfgSoundTables CfgAttachmentSoundTables Cloth_Body_Longmove_LookupTable";
                        int soundCount = g_Game.ConfigGetChildrenCount(path);
 
                        for (int i = 0; i < soundCount; i++)
                        {
                            string name = "";
                            g_Game.ConfigGetChildName(path, i, name);
                            
                            if (name == bodyClothName)
                            {
                                TStringArray stringArray = new TStringArray();
                                g_Game.ConfigGetTextArray(path + " " + name + " soundSets", stringArray);
                                soundSetName = stringArray.Get(0);
 
                                delete stringArray;
                            }
                        }
                    }
 
                    SoundParams soundParams = new SoundParams(soundSetName);
                    SoundObjectBuilder soundObjectBuilder = new SoundObjectBuilder(soundParams);
                    
                    if (soundObjectBuilder != NULL)
                    {
                        SoundObject soundObject = soundObjectBuilder.BuildSoundObject();
                        
                        if (soundObject != NULL)
                        {
                            soundObject.SetPosition(GetPosition());
 
                            AbstractWave wave = g_Game.GetSoundScene().Play3D(soundObject, soundObjectBuilder);
                            wave.SetStartOffset(m_SoundOffset);
                            wave.SetVolumeRelative(volume);
 
                            m_LastBackSoundTime = g_Game.GetTime();
                            m_LastHeadingAngleBlock = headingAngle;
                        }
                    }
                }
 
                if (headingAngleDiffBlock2 > 1.5 && time - m_LastBackSoundTime2 > (timefilterconstant * 2))
                {
                    float volume2 = headingAngleDiff * 2;
                    if (volume2 > 1)
                    {
                        volume2 = 1;
                    }
 
                    m_SoundOffset = headingAngleDiff / 1.8;
                    if (m_SoundOffset < 0.1)
                    {
                        m_SoundOffset = 0.1;
                    }
                    if (m_SoundOffset > 0.3)
                    {
                        m_SoundOffset = 0.3;
                    }
 
                    string soundSetName2 = "walkProne_noHS_asphalt_ext_Char_SoundSet";
                    string surfaceType = GetSurfaceType();
 
                    if (surfaceType != "")
                    {
                        string movementSurfaceType = "walkProne_" + surfaceType;
                        
                        string path2 = "CfgSoundTables CfgStepSoundTables walkProne_noHS_Char_LookupTable";
                        int soundCount2 = g_Game.ConfigGetChildrenCount(path2);
 
                        for (int i2 = 0; i2 < soundCount2; i2++)
                        {
                            string name2 = "";
                            g_Game.ConfigGetChildName(path2, i2, name2);
                            
                            if (name2 == movementSurfaceType)
                            {
                                TStringArray stringArray2 = new TStringArray();
                                g_Game.ConfigGetTextArray(path2 + " " + name2 + " soundSets", stringArray2);
                                soundSetName2 = stringArray2.Get(0);
 
                                delete stringArray2;
                            }
                        }
                    }
 
                    SoundParams soundParams2 = new SoundParams(soundSetName2);
                    SoundObjectBuilder soundObjectBuilder2 = new SoundObjectBuilder(soundParams2);
                    
                    if (soundObjectBuilder2 != NULL)
                    {
                        SoundObject soundObject2 = soundObjectBuilder2.BuildSoundObject();
                        
                        if (soundObject2 != NULL)
                        {
                            soundObject2.SetPosition(GetPosition());
 
                            AbstractWave wave2 = g_Game.GetSoundScene().Play3D(soundObject2, soundObjectBuilder2);
                            wave2.SetStartOffset(m_SoundOffset);
                            wave2.SetVolumeRelative(volume2);            
 
                            m_LastBackSoundTime2 = g_Game.GetTime();
                            m_LastHeadingAngleBlock2 = headingAngle;
                        }
                    }
                }
 
                m_LastHeadingAngle = headingAngle;
            }
        }
    }
 
    float m_LastHeadingAngleBlock;
    float m_LastHeadingAngleBlock2;
    float m_LastHeadingAngle;
    int m_LastBackSoundTime;
    int m_LastBackSoundTime2;
    float m_SoundOffset;
 
 
    //-------------------------------------------------------------
    // these functions are for modded overide in script command mods 
 
    bool    ModCommandHandlerBefore(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
    {
        return false;
    }
 
    bool    ModCommandHandlerInside(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
    {
        return false;
    }
    
    bool    ModCommandHandlerAfter(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
    {
        return false;
    }
 
    //-------------------------------------------------------------
 
    
    override void CommandHandler(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
    {
        m_dT = pDt;
 
        vector playerPosition = PhysicsGetPositionWS();
        
        GetDayZPlayerInventory().HandleInventory(pDt);
        GetHumanInventory().Update(pDt);
        
        if (ModCommandHandlerBefore(pDt, pCurrentCommandID, pCurrentCommandFinished))
        {
            return;
        }
 
        HumanCommandVehicle hcv;
 
        HumanInputController hic = GetInputController();
        EntityAI entityInHands = GetEntityInHands();
        GetMovementState(m_MovementState);
        
        bool isRaisedNow = m_MovementState.IsRaised();
        bool isWeapon       = entityInHands && entityInHands.IsInherited(Weapon);
        
        bool updateAimingMdfr = false;
        if (isWeapon != m_IsWeapon)
        {
            m_IsWeapon = isWeapon;
            updateAimingMdfr = true;
        }
 
        if (isRaisedNow != m_IsRaised)
        {
            updateAimingMdfr = true;
            m_IsRaised = m_MovementState.IsRaised();
        }
        
        if (updateAimingMdfr)
        {
            if (isRaisedNow && isWeapon)
                GetUApi().ActivateModificator("aiming");
            else
                GetUApi().DeactivateModificator("aiming");
        }
        
        // handle ADS ironsights/optics transition logic
        HandleADS();
        
        // handle weapons
        if (hic)
        {
            ItemOptics opticInHands = ItemOptics.Cast(entityInHands);
            if (isWeapon && (!m_ProcessFirearmMeleeHit || !m_ContinueFirearmMelee))
            {
                m_ProcessFirearmMeleeHit = false;
                bool exitIronSights = false;
                HandleWeapons(pDt, entityInHands, hic, exitIronSights);
            }
            else if (IsHandheldOpticsInUse() && m_CameraOptics && opticInHands)
            {
                bool exitOptic = false;
                HandleOptic(opticInHands, true, hic, exitOptic);
            }
        }
        
        HandleView();
        
        if (m_MovementState.m_iMovement != m_MovementState.m_LocalMovement)
        {
            OnMovementChanged();
            m_MovementState.m_LocalMovement = m_MovementState.m_iMovement;
        }
        
        if (HandleDeath(pCurrentCommandID))
        {
            return;
        }
        
        if ( pCurrentCommandID == DayZPlayerConstants.COMMANDID_VEHICLE )
        {
            HumanCommandVehicle cmdVehicle = GetCommand_Vehicle();
            if ( cmdVehicle && cmdVehicle.IsGettingOut() )
            {
                vector waterLevel;
                if ( m_Swimming.CheckSwimmingStart( waterLevel ) )
                {
                    // not all the events may have been called as getting out could have occurred while under water
                    cmdVehicle.ProcessLeaveEvents();
 
                    StartCommand_Swim();
                    return;
                }
            }
        }
        
        if (pCurrentCommandFinished)
        {
            if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_UNCONSCIOUS)
            {
                if ((m_LastCommandBeforeUnconscious == DayZPlayerConstants.COMMANDID_VEHICLE) && (m_TransportCache != null))
                {
                    int crew_index = m_TransportCache.CrewMemberIndex(this);
                    int seat = m_TransportCache.GetSeatAnimationType(crew_index);
                    StartCommand_Vehicle(m_TransportCache, crew_index, seat, true);
                    m_TransportCache = null;
                    return;
                }
            }
 
            // start moving
 
            // start falling ? (could happen after climbing)
            if (PhysicsIsFalling(true))
            {
                StartCommand_Fall(0);
                SetFallYDiff(playerPosition[1]);
                return;
            }

            if (m_Swimming.m_bWasSwimming)
            {
                StartCommand_Swim();
                return;
            }
 
            StartCommand_Move();
            
            if (entityInHands)
                ForceStandUpForHeavyItems(entityInHands);
            
            return;
        }
    
 
        //--------------------------------------------
 
        if (ModCommandHandlerInside(pDt, pCurrentCommandID, pCurrentCommandFinished))
        {
            return;
        }
        
 
        //--------------------------------------------
        // vehicle handling
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_VEHICLE)
        {
            hcv = GetCommand_Vehicle();
            if (hcv.WasGearChange())
            {
                GearChangeActionCallback cb = GearChangeActionCallback.Cast(AddCommandModifier_Action(DayZPlayerConstants.CMD_ACTIONMOD_SHIFTGEAR, GearChangeActionCallback));
                cb.SetVehicleCommand(hcv);
            }
            
            Transport transport;
            int seatPos;
 
            transport = hcv.GetTransport();
            seatPos = hcv.GetVehicleSeat();
            if (IsAlive() && IsAuthority() && transport && transport.CrewShouldEject(seatPos))
            {
                // TODO(kumarjac):  Temporary code until we have a ragdoll command to activate instead
                //                  Due to lack of time, we opted to re-use unconsciousness here instead
                ModifiersManager mdfMan;
                GetGame().GetMission().MissionScript.CallFunction(this, "GetModifiersManager", mdfMan, null);
                mdfMan.ActivateModifier(eModifiers.MDF_UNCONSCIOUSNESS);
            }
            
            return;
        }
        
        //--------------------------------------------
        HumanCommandMove hcm = GetCommand_Move();
        if (hcm && m_MovementState.m_iMovement == DayZPlayerConstants.MOVEMENTIDX_SPRINT && hcm.GetCurrentMovementSpeed() > 2.99)
        {
            m_SprintedTime += pDt;
            if (m_SprintedTime > m_SprintedTimePerStanceMin)
            {
                m_SprintFull = true;
                m_SprintedTimePerStanceMin = PlayerConstants.FULL_SPRINT_DELAY_DEFAULT;
            }
            else
                m_SprintFull = false;
        }
        else
        {
            m_SprintedTime = 0.0;
            m_SprintFull = false;
        }
 
        //--------------------------------------------
        // swimming handling
        if (m_Swimming.HandleSwimming(pCurrentCommandID, hcm, m_MovementState))
        {
            if (ProcessJumpOrClimb(pDt, pCurrentCommandID))
            {
                return;
            }
            
            m_JumpClimb.CheckAndFinishJump();
            return;         
        }
        
        //--------------------------------------------
        // ladder handling
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_LADDER)
        {
            OnLadder(pDt, m_MovementState);
            return;
        }
 
        //--------------------------------------------
        // climb handling
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_CLIMB)
        {
            return;
        }
 
        //--------------------------------------------
        // fall handling
 
        if (IsAlreadyInFallingCommand(pCurrentCommandID))
        {
            if (IsLanded(pCurrentCommandID))
            {
                DayZPlayerType type = GetDayZPlayerType();
                NoiseParams npar;
 
                FallDamageData fallDamageData = new FallDamageData();
                fallDamageData.m_Height = m_FallYDiff - playerPosition[1];
 
                // land
                if (fallDamageData.m_Height < 0.5)
                {
                    fallDamageData.m_LandType = HumanCommandFall.LANDTYPE_NONE; 
                    OnLand(pCurrentCommandID, fallDamageData);
                    npar = type.GetNoiseParamsLandLight();
                    AddNoise(npar);
                }
                else if (fallDamageData.m_Height < 3.0)
                {
                    if (m_MovementState.IsInProne() || m_MovementState.IsInRaisedProne())
                        fallDamageData.m_LandType = HumanCommandFall.LANDTYPE_NONE;
                    else
                        fallDamageData.m_LandType = HumanCommandFall.LANDTYPE_LIGHT;
                    
                    OnLand(pCurrentCommandID, fallDamageData);
                    npar = type.GetNoiseParamsLandLight();
                    AddNoise(npar);
                }
                else if (fallDamageData.m_Height < 5.0)
                {
                    fallDamageData.m_LandType = HumanCommandFall.LANDTYPE_MEDIUM;
                    OnLand(pCurrentCommandID, fallDamageData);
                    npar = type.GetNoiseParamsLandHeavy();
                    AddNoise(npar);
                }
                else
                {
                    fallDamageData.m_LandType = HumanCommandFall.LANDTYPE_HEAVY;
                    OnLand(pCurrentCommandID, fallDamageData);
                    npar = type.GetNoiseParamsLandHeavy();
                    AddNoise(npar);
                }
                
                if (fallDamageData.m_Height >= DayZPlayerImplementFallDamage.HEALTH_HEIGHT_LOW && GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
                {
                    OnPlayerRecievedHit();
                }
 
                m_FallDamage.HandleFallDamage(fallDamageData);
                m_JumpClimb.CheckAndFinishJump(fallDamageData.m_LandType);
            }

            if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_FALL)
            {
                return;
            }
        }
        else if (PhysicsIsFalling(false)) 
        {
            // Not in a falling command but the controller is falling, start default fall
            StartCommand_Fall(0);
            SetFallYDiff(playerPosition[1]);
            return;
        }
 
        //--------------------------------------------
        // handle jumping
 
#ifndef NO_GUI
#ifdef DEVELOPER
 
        if (DiagMenu.GetEngineValue(DayZPlayerConstants.DEBUG_ENABLEJUMP))
        {
            SHumanCommandClimbSettings hcls = GetDayZPlayerType().CommandClimbSettingsW();
            
            if (m_MovementState.m_iMovement != DayZPlayerConstants.MOVEMENTIDX_IDLE)
                hcls.m_fFwMaxDistance = 3;
            else
                hcls.m_fFwMaxDistance = 1.2;
 
            SHumanCommandClimbResult    ret;

            HumanCommandClimb.DoClimbTest(this, ret, 0x3);
        }
 
#endif
#endif 
 
        // start jump 
        if (ProcessJumpOrClimb(pDt, pCurrentCommandID))
        {
            return;
        }
 
        HumanCommandAdditives ad = GetCommandModifier_Additives();
    
        bool force = false;
#ifndef NO_GUI
#ifdef DEVELOPER
        force = DiagMenu.GetEngineValue(DayZPlayerConstants.DEBUG_ENABLETALKING);
#endif
#endif 
        float amplitude = IsPlayerSpeaking();
        
        if (amplitude > 0.1 || force)
        {   
            if (ad)
                ad.SetTalking(true);
            
            // add noises on server
            if (g_Game.IsServer())
            {
                int now = g_Game.GetTime();
                if (now >= m_NextVoNNoiseTime)
                {
                    m_NextVoNNoiseTime = now + 1000;
                    
                    int voiceLevel = g_Game.GetVoiceLevel(this);
                    DayZPlayerType pt = GetDayZPlayerType();
                    
                    // add noise every second while talking 
                    NoiseParams vonpar;
                    switch (voiceLevel)
                    {
                        case VoiceLevelWhisper:
                            vonpar = pt.GetNoiseParamsWhisper();
                        break;
                        case VoiceLevelTalk:
                            vonpar = pt.GetNoiseParamsTalk();
                        break;
                        case VoiceLevelShout:
                            vonpar = pt.GetNoiseParamsShout();
                        break; 
                    }
                    AddNoise(vonpar);
                }
            }
        }
        else
        {
            if (ad)
                ad.SetTalking(false);
        }
        
        //--------------------------------------------
        // anything whats handled by InputController

 
        if (hic)
        {
            HumanCommandWeapons hcw = GetCommandModifier_Weapons();
            m_Throwing.HandleThrowing(hic, hcw, entityInHands, pDt);
            
            if (m_MeleeFightLogic.CanFight())
            {
                if (m_MeleeFightLogic.HandleFightLogic(pCurrentCommandID, hic, entityInHands, m_MovementState, m_ContinueFirearmMelee))
                {
                    m_ProcessFirearmMeleeHit = isWeapon && (hic.IsMeleeWeaponAttack() || m_ProcessFirearmMeleeHit) || m_ContinueFirearmMelee;
                    return;
                }
            }
        }
 

        if (ModCommandHandlerAfter(pDt, pCurrentCommandID, pCurrentCommandFinished))
        {
            return;
        }
    }
    
    void HideClothing(ItemOptics optic, bool state) {}
 
    //-------------------------------------------------------------
 
    float   m_TestDamageCounter  = -1;   
    float   m_DebugDirectionVal  = -180;
    bool    m_DebugTypeVal            = false;
 
    int         m_DebugWeaponChangeStage = 0;
    string  m_DebugWeaponChangeItem;
    int         m_DebugWeaponChangeShowSlot;

    void  CommandHandlerDebug(float pDt, int pCurrentCommandID, bool pCurrentCommandFinished)
    {
        if (GetPluginManager())
        {
            PluginDayzPlayerDebug playerDebug = PluginDayzPlayerDebug.Cast(GetPluginManager().GetPluginByType(PluginDayzPlayerDebug));
            if (playerDebug)
            {
                playerDebug.CommandHandler();

                if (m_DebugWeaponChangeStage == 0)
                {
 
                    // debug weapon change
                    int         hideSlot;
 
                    if (playerDebug.IsWeaponChange(m_DebugWeaponChangeItem, hideSlot, m_DebugWeaponChangeShowSlot))
                    {
                        //Print("Change Weapon started: " + m_DebugWeaponChangeItem + "," + hideSlot.ToString() + "," + m_DebugWeaponChangeShowSlot.ToString());
 
                        HumanCommandWeapons  w = GetCommandModifier_Weapons();
                        w.StartAction(WeaponActions.HIDE, hideSlot);
 
                        m_DebugWeaponChangeStage = 1;
                    }
                }
                else if (m_DebugWeaponChangeStage == 1)
                {
                    // wait for weapon hide to meet event 
                    HumanCommandWeapons  w2 = GetCommandModifier_Weapons();
                    if (w2 && w2.GetRunningAction() == WeaponActions.HIDE)
                    {
                        if (w2.IsEvent() == WeaponEvents.CHANGE_HIDE)
                        {
                            //Print("Change Weapon - hidden: ");

                            PlayerBase player = PlayerBase.Cast(this);
                            EntityAI item_in_hands = player.GetEntityInHands();
                            if (item_in_hands != NULL && player.CanDropEntity(item_in_hands) && g_Game.GetPlayer().GetHumanInventory().CanRemoveEntityInHands())
                            {
                                player.PredictiveDropEntity(item_in_hands);
                            }
 
                            if (m_DebugWeaponChangeItem != "")
                            {
                                InventoryLocation dst = new InventoryLocation;
                                dst.SetHands(this, NULL);
                                EntityAI item = SpawnEntity(m_DebugWeaponChangeItem, dst,ECE_IN_INVENTORY,RF_DEFAULT);
                            }

                            w2.StartAction(WeaponActions.SHOW, 3);
 
                            m_DebugWeaponChangeStage = 2;
                        }
                    }
                }
                else if (m_DebugWeaponChangeStage == 2)
                {
                    HumanCommandWeapons  w3 = GetCommandModifier_Weapons();
                    if (w3 && w3.IsActionFinished())
                    {
                        m_DebugWeaponChangeStage = 0;
                    }
                }
            }
        }
    

        if (m_TestDamageCounter >= 0)
        {
            if (m_TestDamageCounter > 3)
            {
                m_DebugDirectionVal = m_DebugDirectionVal + 90;
                m_TestDamageCounter = 0;
 
                if (m_DebugDirectionVal > 90)
                {
                    m_DebugDirectionVal = -180;
                    m_DebugTypeVal        = !m_DebugTypeVal;
                }
 
                if (m_DebugTypeVal)
                {
                    AddCommandModifier_Damage(0, m_DebugDirectionVal); // starts light
                }
                else
                {
                    StartCommand_Damage(0, m_DebugDirectionVal); // starts heavy (full body)
                }
                // 0.. types
                // from: -180 back, -90 left, 0 front, 90 right, 180 back 
                //AddCommandModifier_Damage(0, directionVal); // starts light
                //StartCommand_Damage(0, 0); // starts heavy (full body)
            }
 
            m_TestDamageCounter += pDt;
        }
 
 
#ifndef NO_GUI
#ifdef DEVELOPER
 
        // injury / exhaustion
        {
            HumanCommandAdditives ad = GetCommandModifier_Additives();

            float v = DiagMenu.GetEngineRangeValue(DayZPlayerConstants.DEBUG_SHOWINJURY);
            if (v > 0)
            {
                ad.SetInjured(v, true);
            }

            v = DiagMenu.GetEngineRangeValue(DayZPlayerConstants.DEBUG_SHOWEXHAUSTION);
            if (v > 0)
            {
                ad.SetExhaustion(v, true);
            }
        }
#endif
#endif 
 
    }
 
 
 
    //-------------------------------------------------------------
    override int    CameraHandler(int pCameraMode)
    {
        if (!m_LiftWeapon_player && !IsWeaponObstructionBlockingADS())
        {
            ItemOptics optics = null;
            EntityAI entityInHands = GetEntityInHands();
            Weapon weapon = Weapon.Cast(entityInHands);
            if (weapon)
                optics = weapon.GetAttachedOptics();
            else if (entityInHands)
                Class.CastTo(optics,entityInHands);
            
            if (m_CameraOptics && optics)
            {
                return DayZPlayerCameras.DAYZCAMERA_OPTICS;
            }
            else if (m_CameraIronsight && weapon)
            {
                return DayZPlayerCameras.DAYZCAMERA_IRONSIGHTS;
            }
        }   
        
        // If the logic above doesn't reach optics nor ironsights camera,
        // yet weapon is still raised and ads is wanted, enforce 1pv camera
        // as this will reduce erratic behaviour of camera switching in 3pv
        HumanInputController hic = GetInputController();
        if (m_Camera3rdPerson && m_IsWeapon && m_IsRaised && hic && hic.WeaponADS())
        {
            return DayZPlayerCameras.DAYZCAMERA_1ST;
        }
        
        //uncon
        if ( GetCurrentCommandID() == DayZPlayerConstants.COMMANDID_UNCONSCIOUS )
        {
#ifdef USER_kumarjac
            HumanCommandUnconscious hcu = GetCommand_Unconscious();
            if (hcu && hcu.IsRagdoll() && m_Camera3rdPerson)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_ERC;
            }
#endif
            
            return DayZPlayerCameras.DAYZCAMERA_1ST_UNCONSCIOUS;
        }
        
        // Vehicle
        HumanCommandVehicle vehicleCommand = GetCommand_Vehicle();
        int thirdPersonViewMode = g_Game.GetWorld().GetThirdPersonViewMode();
        if (vehicleCommand)
        {
            if (thirdPersonViewMode >= ThirdPersonMode.ENABLED)
            {
                if (!m_Camera3rdPerson)
                {
                    return DayZPlayerCameras.DAYZCAMERA_1ST_VEHICLE;
                }
                else
                {
                    Transport transport = vehicleCommand.GetTransport();
                    if (transport && GetParent())
                    {
                        return transport.Get3rdPersonCameraType();
                    }
                }
            }
            else
            {
                return DayZPlayerCameras.DAYZCAMERA_1ST_VEHICLE;
            }
        }
        
        // Character
        if (thirdPersonViewMode == ThirdPersonMode.DISABLED || thirdPersonViewMode == ThirdPersonMode.VEHICLES_ONLY)
            m_Camera3rdPerson = false;
        
        if (!m_Camera3rdPerson)
        {
            return DayZPlayerCameras.DAYZCAMERA_1ST;
        }
        else
        {           
            GetMovementState(m_MovementState);
            


 
            if (m_MovementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_CLIMB)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_CLIMB;
            }
 
            if (m_JumpClimb.m_bIsJumpInProgress)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_JUMP;
            }
            
            int targetStanceIndex = m_MovementState.m_iStanceIdx;
            
            HumanCommandMove commandMove = GetCommand_Move();
            if (commandMove && commandMove.IsChangingStance() && m_MovementState.IsRaised())
            {
                targetStanceIndex = m_MovementState.m_iStanceIdx - DayZPlayerConstants.STANCEIDX_RAISED;
            }
            
            //      
            // normal movement cameras          
            if (targetStanceIndex == DayZPlayerConstants.STANCEIDX_CROUCH)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_CRO;
            }
            else if (targetStanceIndex == DayZPlayerConstants.STANCEIDX_RAISEDCROUCH)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_CRO_RAISED;
            }
            else if (targetStanceIndex == DayZPlayerConstants.STANCEIDX_PRONE)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_PRO;
            }
            else if (targetStanceIndex == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_PRO_RAISED;
            }
 
            if (targetStanceIndex == DayZPlayerConstants.STANCEIDX_RAISEDERECT)
            {
                if (m_IsWeapon) 
                {
                    return DayZPlayerCameras.DAYZCAMERA_3RD_ERC_RAISED;
                }
                else
                {
                    return DayZPlayerCameras.DAYZCAMERA_3RD_ERC_RAISED_MELEE;
                }
            }
            else if (targetStanceIndex == DayZPlayerConstants.MOVEMENTIDX_SPRINT)
            {
                return DayZPlayerCameras.DAYZCAMERA_3RD_ERC_SPR;
            }
 
            // DayZPlayerConstants.STANCEIDX_ERECT
            return DayZPlayerCameras.DAYZCAMERA_3RD_ERC;
        }
        
        return DayZPlayerCameras.DAYZCAMERA_1ST;
    }
    
    void OnMovementChanged()//(int state_old, int state_new)
    {
        if (m_MovementState.m_LocalMovement ==  DayZPlayerConstants.MOVEMENTIDX_SPRINT)
        {
            OnSprintEnd();
        }
        
        if (m_MovementState.m_iMovement == DayZPlayerConstants.MOVEMENTIDX_SPRINT) 
        {
            OnSprintStart();   
        }
    }
    
    void OnSprintStart()
    {
        if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
        {
            GetUApi().GetInputByID(UALeanLeft).Lock();
            GetUApi().GetInputByID(UALeanRight).Lock();
        }
    }
    
    void OnSprintEnd()
    {
        if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
        {
            #ifdef PLATFORM_CONSOLE
            if (GetUApi().GetInputByID(UAVoiceModifierHelper).LocalValue() == 0)
            #endif
            {
                GetUApi().GetInputByID(UALeanLeft).Unlock();
                GetUApi().GetInputByID(UALeanRight).Unlock();
            }
        }
    }
    //-------------------------------------------------------------
 
    void OnInputUserDataReceived(ParamsReadContext ctx)
    {
        int userDataTypeParam = 0;
        if (!ctx.Read(userDataTypeParam))
        {
            Error("DayZPlayerImplement: cannot read input type");
            return;
        }
 
        OnInputUserDataProcess(userDataTypeParam, ctx);
    }
 
    bool OnInputUserDataProcess(int userDataType, ParamsReadContext ctx)
    {
        m_MeleeCombat.SetTargetObject(null);
        m_MeleeCombat.SetHitPos(vector.Zero);
        m_MeleeCombat.SetHitZoneIdx(-1);
        m_MeleeCombat.SetFinisherType(-1);
 
        if (userDataType == INPUT_UDT_MELEE_TARGET)
        {
            EntityAI target = null;
            if (ctx.Read(target))
            {
                m_MeleeCombat.SetTargetObject(target);
            }
 
            vector hitPos = vector.Zero;
            if (ctx.Read(hitPos))
            {
                m_MeleeCombat.SetHitPos(hitPos);
            }
 
            int hitZoneIdx = -1;
            if (ctx.Read(hitZoneIdx))
            {
                m_MeleeCombat.SetHitZoneIdx(hitZoneIdx);
            }
 
            int finisherType = -1;
            if (ctx.Read(finisherType))
            {
                if (finisherType != -1 && target)
                {
                    bool isWithinRange = vector.Distance(GetPosition(), target.GetPosition()) <= PlayerConstants.MAX_FINISHER_RANGE;
                    if (!target.IsAlive() || !target.CanBeBackstabbed() || !isWithinRange)
                    {
                        finisherType = -1;
                    }
                }
                m_MeleeCombat.SetFinisherType(finisherType);
            }
            
            return true;
        }
 
        return false;
    }
 
    //-------------------------------------------------------------
    void OnSyncJuncture(int pJunctureID, ParamsReadContext pCtx)
    {
        switch (pJunctureID)
        {
            case DayZPlayerSyncJunctures.SJ_DEATH:
                if (m_DeathAnimType == -2)
                    DayZPlayerSyncJunctures.ReadDeathParams(pCtx, m_DeathAnimType, m_DeathHitDir);
                break;
                
            case DayZPlayerSyncJunctures.SJ_DAMAGE_HIT:
                SyncHitInfo data = new SyncHitInfo;
                if (DayZPlayerSyncJunctures.ReadDamageHitParamsEx(pCtx, data) && data != null)
                {
                    m_SyncedHitDataArray.Insert(data);
                }
                break;
        }
    }
 
    AnimBootsType GetBootsType()
    {
        EntityAI boots = GetInventory().FindAttachment(InventorySlots.FEET);
        if (boots)
        {
            switch (boots.GetAttachmentSoundType())
            {
                case "Sneakers":
                    return AnimBootsType.Sneakers;
                case "Boots":
                    return AnimBootsType.Boots;
            }
        }
 
        return AnimBootsType.None;
    }
    
    //Get top body clothes
    AnimUpperBodyType GetBodyAttachmentType()
    {
        EntityAI attachment = GetInventory().FindAttachment(InventorySlots.BODY);
        if (attachment)
        {
            switch (attachment.GetAttachmentSoundType())
            {
                case "NylonJacket":
                    return AnimUpperBodyType.NylonJacket;
                case "TShirt":
                    return AnimUpperBodyType.TShirt;
                case "WoolShirt":
                    return AnimUpperBodyType.WoolShirt;
                case "HeavyJacket":
                    return AnimUpperBodyType.HeavyJacket; 
                case "LeatherJacket":
                    return AnimUpperBodyType.LeatherJacket;
                case "Coat":
                    return AnimUpperBodyType.Coat;
                case "ChemlonDress":
                    return AnimUpperBodyType.ChemlonDress;
                case "Ghillie":
                    return AnimUpperBodyType.Ghillie;
                case "Chainmail":
                    return AnimUpperBodyType.Chainmail;
            }
        }
        
        return AnimUpperBodyType.None;
    }
    
    AnimBackType GetBackAttachmentType()
    {
        EntityAI back = GetInventory().FindAttachment(InventorySlots.BACK);
        if (back)
        {
            switch (back.GetAttachmentSoundType())
            {
                case "Small":
                    return AnimBackType.Small;
                case "Military":
                    return AnimBackType.Military;
                case "Outdoor":
                    return AnimBackType.Outdoor;
                case "Ghillie":
                    return AnimBackType.Ghillie; 
            }
        }
        
        return AnimBackType.None;
    }
    
    //Get weapon on back
    AnimRangedWeaponType GetShoulderAttachmentType()
    {
        EntityAI shoulderAttachment = GetInventory().FindAttachment(InventorySlots.SHOULDER);
        EntityAI meleeAttachment = GetInventory().FindAttachment(InventorySlots.MELEE);
        
        AnimRangedWeaponType shoulderAttType = AnimRangedWeaponType.None;
        AnimRangedWeaponType meleeAttType = AnimRangedWeaponType.None;
        
        if (shoulderAttachment)
        {
            switch (shoulderAttachment.GetAttachmentSoundType())
            {
                case "Shotgun":
                {
                    shoulderAttType = AnimRangedWeaponType.Shotgun;
                    break;
                }   
                case "Rifle":
                {
                    shoulderAttType = AnimRangedWeaponType.Rifle;
                    break;
                }
            }
        }
        if (meleeAttachment)
        {
            switch (meleeAttachment.GetAttachmentSoundType())
            {
                case "Shotgun":
                {
                    meleeAttType = AnimRangedWeaponType.Shotgun;
                    break;
                }
                case "Rifle":
                {
                    meleeAttType = AnimRangedWeaponType.Rifle;
                    break;
                }
            }
        }
        
        if (shoulderAttType == AnimRangedWeaponType.Shotgun || meleeAttType == AnimRangedWeaponType.Shotgun)
            return AnimRangedWeaponType.Shotgun;
        
        if (shoulderAttType == AnimRangedWeaponType.Rifle || meleeAttType == AnimRangedWeaponType.Rifle)
            return AnimRangedWeaponType.Rifle;
 
        return AnimRangedWeaponType.None;
    }
 
    //-------------------------------------------------------------
 
    AbstractWave PlaySound(SoundObject so, SoundObjectBuilder sob)
    {
        if (so == null)
            return null;
 
        so.SetPosition(GetPosition());
        AbstractWave wave = g_Game.GetSoundScene().Play3D(so, sob);
        return wave;
    }
 
    void AddNoise(NoiseParams noisePar, float noiseMultiplier = 1.0)
    {
        if (noisePar != null)
            g_Game.GetNoiseSystem().AddNoise(this, noisePar, noiseMultiplier);
    }
 
    //-------------------------------------------------------------
 
    void OnStepEvent(string pEventType, string pUserString, int pUserInt)
    {
        vector orientation;
        vector position = GetPosition();
        DayZPlayerType playerType = GetDayZPlayerType();
        HumanMovementState    state = new HumanMovementState();
        GetMovementState(state);
        
        SurfaceInfo surfaceInfo;
        if (pUserInt < 100)
        {
            string boneName = "";
            if (pUserInt % 2 == 1)
            {
                boneName = "leftfoot";
                surfaceInfo = g_Game.GetSurfaceInfoUnderObjectByBone(this, SurfaceAnimationBone.LeftBackLimb);
                if (!surfaceInfo)
                {
                    surfaceInfo = g_Game.GetSurfaceInfoUnderObjectByBone(this, SurfaceAnimationBone.RightBackLimb);
                    boneName = "rightfoot";
                }
            }
            else
            {
                boneName = "rightfoot";
                surfaceInfo = g_Game.GetSurfaceInfoUnderObjectByBone(this, SurfaceAnimationBone.RightBackLimb);
                if (!surfaceInfo)
                {
                    surfaceInfo = g_Game.GetSurfaceInfoUnderObjectByBone(this, SurfaceAnimationBone.LeftBackLimb);
                    boneName = "leftfoot";
                }
            }
            
            if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER || !GetGame().IsMultiplayer())
            {
                //synced dusty ceiling effect
                if (surfaceInfo)
                {
                    HandleCeilingDustStepEffect(surfaceInfo, boneName);
                }
            }
            
            #ifdef DIAG_DEVELOPER
            if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
            {
                if (DiagMenu.GetBool(DiagMenuIDs.MISC_PLAYER_SURFACE_DEBUG))
                {
                    string surfaceType = "NULL";
                    if (surfaceInfo)
                        surfaceType = surfaceInfo.GetSurfaceType();
                    
                    CharacterStepsDebug.SetStepData(boneName, surfaceType);
                }
            }
            #endif
        }
        
        #ifndef SERVER
        #ifndef NO_GUI
        DayZPlayerTypeStepSoundLookupTable table = playerType.GetStepSoundLookupTable();
        SoundObjectBuilder soundBuilder = NULL;
        if (pUserInt < 100)
        {
            if (surfaceInfo)
            {
                m_LastSurfaceUnderHash = surfaceInfo.GetSurfaceType().Hash();
                
                if (state.m_iMovement == DayZPlayerConstants.MOVEMENTIDX_SPRINT)
                {
                    orientation = -GetDirection();//Using direction to compute forward dot product of surface in the direction oposite player
                
                    vector surfaceNormal = g_Game.SurfaceGetNormal(position[0], position[2]);
                    float dotWithForward = vector.Dot(surfaceNormal, orientation);
                
                    float pitch = Math.Atan2(-dotWithForward, surfaceNormal[1]) * Math.RAD2DEG;
                
                    //VectorToYaw using first and second float insted of first and third then why it is need adjustment
                    orientation[1] = orientation[2]; 
                    orientation[2] = 0;
                
                    float yaw = orientation.VectorToYaw();
                
                    orientation[0] = -yaw + 90; 
                    orientation[1] = pitch;
 
 
                    int stepParticleID = surfaceInfo.GetStepParticleId();
                    if (stepParticleID > 0)
                    {
                        ParticleSource source = ParticleManager.GetInstance().PlayInWorldEx(stepParticleID, null, position);
                        //Direction align with surface in the opposite direction to the player
                        source.SetOrientation(orientation);
                    }
                }
                
                soundBuilder = table.GetSoundBuilder(pUserInt, state.m_iMovement, m_LastSurfaceUnderHash, GetBootsType());
            }
        }
        else
        {
            surfaceInfo = g_Game.GetSurfaceInfoUnderObject(this);
            if (surfaceInfo)
                m_LastSurfaceUnderHash = surfaceInfo.GetSurfaceType().Hash();
            
            soundBuilder = table.GetSoundBuilder(pUserInt, state.m_iMovement, m_LastSurfaceUnderHash, GetBootsType());
        }
 
        if (soundBuilder != null && g_Game.GetPlayer())
        {
            m_StepCounterVegetation++;
 
            if (m_StepCounterVegetation >= 3)
            {
                m_StepCounterVegetation = 0;
                g_Game.ProfilerStart("Player_Vegetation_Sounds");
 
                orientation = vector.Zero;
                vector edgeLength = Vector(0.75, 2.5, 0.75);
                array<Object> excludedObjects = new array<Object>();
                excludedObjects.Insert(this);
                array<Object> collidedObjects = new array<Object>();
                
                if (g_Game.IsBoxCollidingGeometry(position, orientation, edgeLength, ObjIntersectView, ObjIntersectNone, excludedObjects, collidedObjects))
                {
                    foreach (Object obj : collidedObjects)
                    {
                        WoodBase colPlant;
                        if (Class.CastTo(colPlant, obj))
                        {
                            if (colPlant.HasPlayerCollisionParticle() && state.m_iMovement > DayZPlayerConstants.MOVEMENTIDX_WALK)
                                MiscEffects.PlayVegetationCollideParticles(colPlant, this);
                            
                            if (colPlant.HasPlayerCollisionSound())
                            {
                                SoundObject vegSoundObject;
                                 
                                StaticObjectType plantType = StaticObjectType.Cast(colPlant.GetEntityType());
 
                                //custom lookup first
                                SoundObjectBuilder vegSoundObjectBuilder = plantType.GetVegetationSoundBuilderFromEventID(pUserInt);
                                if (vegSoundObjectBuilder)
                                {
                                    vegSoundObject = vegSoundObjectBuilder.BuildSoundObject();
                                }
                                else //then generic
                                {
                                    array<ref VegetationSound> vegSoundArray = playerType.GetVegetationSounds();
                                    foreach (VegetationSound vegetationSound: vegSoundArray)
                                    {
                                        if (vegetationSound.GetAnimEventIds().Find(pUserInt) >= 0)
                                        {
                                            vegSoundObjectBuilder = vegetationSound.GetSoundObjectBuilder();
                                            vegSoundObject = vegSoundObjectBuilder.BuildSoundObject();
                                            break;
                                        }
                                    }
                                }
                                
                                if (vegSoundObject != null)
                                {
                                    AttenuateSoundIfNecessary(vegSoundObject);
                                    PlaySound(vegSoundObject, vegSoundObjectBuilder);
                                }
                                
                                break;
                            }
                        }
                    }
                }
 
                g_Game.ProfilerStop("Player_Vegetation_Sounds");
            }
                
            SoundObject soundObject = soundBuilder.BuildSoundObject();
            if (soundObject != null)
            {
                AttenuateSoundIfNecessary(soundObject);
                PlaySound(soundObject, soundBuilder);
            }
            
        }
        #endif
        #endif
        
        if (g_Game.IsServer())
        {
            m_StepCounter++;//move outside of server condition if needed on client as well
 
            float noiseMultiplier = 0;          
            
            NoiseParams noiseParams;
            if (state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_ERECT || state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDERECT)
                noiseParams = playerType.GetNoiseParamsStand();
            else if (state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_CROUCH || state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDCROUCH)
                noiseParams = playerType.GetNoiseParamsCrouch();
            else if (state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE || state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
                noiseParams = playerType.GetNoiseParamsProne();
            else
            {
                Debug.Log(string.Format("Wrong stance, id: %1 using backup with stand stance (id: 0)", state.m_iStanceIdx));
                noiseParams = playerType.GetNoiseParamsStand();
            }
            
            noiseMultiplier = NoiseAIEvaluate.GetNoiseMultiplier(this);
                                    
            AddNoise(noiseParams, noiseMultiplier);
            
            if ((m_StepCounter % PlayerConstants.CHECK_EVERY_N_STEP) == 0)
            {
                ProcessFeetDamageServer(pUserInt);
                m_StepCounter = 0;
            }
        }
    }
 
    void OnSoundEvent(string pEventType, string pUserString, int pUserInt)
    {
        int eventReplaceID = 0;
        
        if (pEventType == "Sound")
        {
            if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE)
            {
                eventReplaceID = m_ReplaceSoundEventHandler.GetSoundEventID(pUserInt, ESoundEventType.SOUND_COMMON);
                if (eventReplaceID > 0 && PlaySoundEventType(ESoundEventType.SOUND_COMMON, eventReplaceID))
                    return; //return only when 'PlaySoundEventType' successful
            }
            
            ProcessSoundEvent(pEventType, pUserString, pUserInt);
        }
        else if (pEventType == "SoundWeapon")
        {
            if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE)
            {
                eventReplaceID = m_ReplaceSoundEventHandler.GetSoundEventID(pUserInt, ESoundEventType.SOUND_WEAPON);
                if (eventReplaceID > 0 && PlaySoundEventType(ESoundEventType.SOUND_WEAPON, eventReplaceID))
                    return; //return only when 'PlaySoundEventType' successful
            }
            
            ProcessWeaponEvent(pEventType, pUserString, pUserInt);
        }
        else if (pEventType == "SoundAttachment")
        {
            ProcessAttachmentEvent(pEventType, pUserString, pUserInt);
        }
        else if (pEventType == "SoundVoice")
        {
            if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE)
            {
                if (m_ReplaceSoundEventHandler)
                eventReplaceID = m_ReplaceSoundEventHandler.GetSoundEventID(pUserInt, ESoundEventType.SOUND_VOICE); //check if some animation override registered
                
                if (eventReplaceID > 0 && PlaySoundEventType(ESoundEventType.SOUND_VOICE, eventReplaceID))
                {
                    return; //return only when 'PlaySoundEventType' successful
                }
                else
                {
                    //made this a secondary override, since there is some weirdness in sharing sound event IDs between unrelated animations (eating X forcefeeding etc.) and redundant translations (888 -> 888)
                    int eventID = m_PlayerSoundEventHandler.ConvertAnimIDtoEventID(pUserInt);
                    if (eventID > 0)
                    {
                        PlaySoundEvent(eventID);
                        return;
                    }
                }
            }
            
            ProcessVoiceEvent(pEventType, pUserString, pUserInt);
        }
        else
        {
            Debug.Log("OnSoundEvent: Unknown sound event \"" + pEventType + "\"");
        }
    }
    
    void OnParticleEvent(string pEventType, string pUserString, int pUserInt)
    {
        
    }
 
    
    void ProcessWeaponEvent(string pEventType, string pUserString, int pUserInt)
    {
        DayZPlayerType type = GetDayZPlayerType();
        AnimSoundEvent soundEvent = null;
 
        float quantity = 0;
        
        EntityAI entityInHands = GetEntityInHands();
        if (entityInHands && entityInHands.IsInherited(ItemBase))
        {
            ItemBase item;
            Class.CastTo(item, entityInHands);
            if (item.HasQuantity())
                quantity = (float)item.GetQuantity() / (item.GetQuantityMax() - item.GetQuantityMin());
            InventoryItemType invItemType = item.GetInventoryItemType();
            soundEvent = invItemType.GetSoundEvent(pUserInt);
        }
 
        if (soundEvent == null)
        {
            quantity = 0;
            soundEvent = type.GetSoundWeaponEvent(pUserInt);
        }
 
        if (soundEvent != null)
        {
            if (!g_Game.IsHeadlessOrDedicatedServer())
            {
                SoundObjectBuilder builder = soundEvent.GetSoundBuilderEx(m_ActionSoundCategoryHash);
                if (builder)
                {
                    builder.AddVariable("quantity", quantity);
                    builder.AddVariable("interior", IsSoundInsideBuilding());
                    
                    SoundObject soundObject = builder.BuildSoundObject();
                    if (soundObject != NULL)
                    {
                        AttenuateSoundIfNecessary(soundObject);
                        AbstractWave sound = PlaySound(soundObject, builder);
                        
                        if (pUserString == "StopOnAnimEnd")
                            m_PerformedActionSounds.Insert(sound);
                    }
                }
                else
                {
                    //TODO:Userful error message
                }
            }
            
            if (g_Game.IsServer())
            {
                AddNoise(soundEvent.m_NoiseParams);
            }
        }
    }
 
    void ProcessAttachmentEvent(string pEventType, string pUserString, int pUserInt)
    {
#ifndef NO_GUI
        DayZPlayerType type = GetDayZPlayerType();
        DayZPlayerTypeAttachmentSoundLookupTable table = type.GetAttachmentSoundLookupTable();
            
        array<string> attachments = new array<string>();
        pUserString.Split(",", attachments);
        for (int i = 0; i < attachments.Count(); i++)
        {
            int attachmentHash = -1;
            if (attachments[i] == "shoulder")
                attachmentHash = GetShoulderAttachmentType();
            else if (attachments[i] == "body")
                attachmentHash = GetBodyAttachmentType();
            else if (attachments[i] == "back")
                attachmentHash = GetBackAttachmentType();
            
            SoundObjectBuilder soundBuilder = table.GetSoundBuilder(pUserInt, attachments[i], attachmentHash);
            
            if (soundBuilder != NULL)
            {
                SoundObject soundObject = soundBuilder.BuildSoundObject();
                if (soundObject != NULL)
                {
                    AttenuateSoundIfNecessary(soundObject);
                    PlaySound(soundObject, soundBuilder);
                }
            }
        }
#endif
    }
 
    void SetVariablesLadderSoundObjectBuilder(SoundObjectBuilder soundObjectBuilder)
    {
        if (m_ClimbingLadderType == "wood")
        {
            soundObjectBuilder.AddVariable("laddertype", 1);
        }
        else
        {
            soundObjectBuilder.AddVariable("laddertype", 0);
        }
        
        AnimBootsType pBoots = GetBootsType();
        
        if (pBoots == AnimBootsType.None)
        {
            soundObjectBuilder.AddVariable("bare", 1);
            soundObjectBuilder.AddVariable("sneakers", 0);
            soundObjectBuilder.AddVariable("boots", 0);
        }
        else if (pBoots == AnimBootsType.Sneakers)
        {
            soundObjectBuilder.AddVariable("bare", 0);
            soundObjectBuilder.AddVariable("sneakers", 1);
            soundObjectBuilder.AddVariable("boots", 0);
        }
        else if (pBoots == AnimBootsType.Boots)
        {
            soundObjectBuilder.AddVariable("bare", 0);
            soundObjectBuilder.AddVariable("sneakers", 0);
            soundObjectBuilder.AddVariable("boots", 1);
        }
    }
 
    void ProcessSoundEvent(string pEventType, string pUserString, int pUserInt)
    {
        DayZPlayerType type = GetDayZPlayerType();
        DayZPlayerTypeAnimTable table = type.GetSoundTable();
        AnimSoundEvent soundEvent;
        if (table)
        {
            soundEvent = table.GetSoundEvent(pUserInt);
        }
        
        if (soundEvent != NULL)
        {
            if (!g_Game.IsHeadlessOrDedicatedServer())
            {
                SoundObjectBuilder objectBuilder = soundEvent.GetSoundBuilder();
                if (GetCommand_Ladder())
                {
                    SetVariablesLadderSoundObjectBuilder(objectBuilder);
                }
                objectBuilder.AddEnvSoundVariables(GetPosition());
 
                SoundObject soundObject = objectBuilder.BuildSoundObject();
                if (soundObject != NULL)
                {
                    AttenuateSoundIfNecessary(soundObject);
                    AbstractWave sound = PlaySound(soundObject, objectBuilder);
                    
                    if (pUserString == "StopOnAnimEnd")
                        m_PerformedActionSounds.Insert(sound);
                }
            }
            
            if (g_Game.IsServer())
            {
                if (soundEvent.m_NoiseParams != NULL)
                    g_Game.GetNoiseSystem().AddNoise(this, soundEvent.m_NoiseParams);
            }
        }
    }
    
    
 
    AbstractWave ProcessVoiceEvent(string pEventType, string pUserString, int pUserInt)
    {
        #ifdef SERVER//none of this code needs to run on server, ifdef put here rather than before the method call to maintain mod compatibility
        return null;
        #endif
        DayZPlayerType type = GetDayZPlayerType();
        DayZPlayerTypeVoiceSoundLookupTable table = type.GetVoiceSoundLookupTable();
        if (!table)
            return null;
        AbstractWave wave;
        GameInventory inventory = GetInventory();
        EntityAI mask = inventory.FindAttachment(InventorySlots.MASK);
        EntityAI head_gear = inventory.FindAttachment(InventorySlots.HEADGEAR);
        
        string category;
        if (mask || head_gear)
        {
            string category_mask;
            string category_headgear;
            
            int priority_mask;
            int priority_headgear;
            
            if (mask)
            {
                category_mask = mask.ConfigGetString("soundVoiceType");
                priority_mask = mask.ConfigGetInt("soundVoicePriority");
            }
            if (head_gear)
            {
                category_headgear = head_gear.ConfigGetString("soundVoiceType");
                priority_headgear = head_gear.ConfigGetInt("soundVoicePriority");
            }
            
            if (priority_headgear >= priority_mask && category_headgear != "")
            {
                category = category_headgear;
            }
            else
            {
                category = category_mask;
            }
        }
 
        if (category == "")
        {
            category = "none";
        }
        
        SoundObjectBuilder soundBuilder = table.GetSoundBuilder(pUserInt, category.Hash());
        
        if (soundBuilder)
        {
            PlayerBase player = PlayerBase.Cast(this);
            //this code block looks super shady, but it's the only way the sounds play correctly, god knows what's going on on c++ side
            int maleVoiceType = 0;
            int femaleVoiceType = 0;
            if (player.IsMale())
            {
                maleVoiceType = player.GetVoiceType();
            }
            else
            {
                femaleVoiceType = player.GetVoiceType();
            }
 
            soundBuilder.AddVariable("male", maleVoiceType);
            soundBuilder.AddVariable("female", femaleVoiceType);
            
            // end of weirdness
            SoundObject soundObject = soundBuilder.BuildSoundObject();
            if (soundObject != NULL)
            {
                AttenuateSoundIfNecessary(soundObject);
                wave = PlaySound(soundObject, soundBuilder);
            }
 
        }
        
        return wave;
    }
    
    void ProcessFeetDamageServer(int pUserInt);
    
    protected void HandleCeilingDustStepEffect(SurfaceInfo surfaceInfo, string boneName)
    {
        //player variant, synced
        m_CeilingDustHandler.OnStepUpdate(surfaceInfo, boneName);
    }
 
    //-------------------------------------------------------------
 
    bool CheckForTakeItem(EntityAI item)
    {
        bool restrained = IsRestrained(); // IsRestrained()
        bool unconscious = IsUnconscious(); // IsRestrained()
 
        ItemBase ib = ItemBase.Cast(item);
        if (ib && (PlayerBase.DEBUG_INVENTORY_ACCESS || !IsAlive() || restrained || unconscious || ib.CanBeMovedOverride()))
            return true;
        return false;
    }
    
    bool CheckForDropItem(EntityAI item)
    {
        /*
        bool restrained = IsRestrained(); // IsRestrained()
        bool unconscious = IsUnconscious(); // IsRestrained()
        
        ItemBase ib = ItemBase.Cast(item);
        if (!IsAlive() || restrained || unconscious || ib.CanBeMovedOverride())
            return true;
        return false;
        */
        return CheckForTakeItem(item); //the two functions are currently identical
    }
    
    //-------------------------------------------------------------
    bool CheckForRespawn(EntityAI item)
    {
        PlayerBase player = PlayerBase.Cast(this);
        if (!player)
            return true;
        
        if (!IsAlive() || player.IsUnconscious())
            return true;
        return false;
    }
 
#ifdef DEVELOPER
 
    // -------------------------------------------------------------------------
    override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
    {
        super.OnRPC(sender, rpc_type, ctx);
 
        if (rpc_type == ERPCs.RPC_DAYZPLAYER_DEBUGSERVERWALK)
        {
            Print("ERPCs.RPC_DAYZPLAYER_DEBUGSERVERWALK");
 
            Param1<bool> rp = new Param1<bool>(false);
            ctx.Read(rp);
 
            GetInputController().OverrideMovementSpeed(rp.param1, 1);
            GetInputController().OverrideAimChangeX(rp.param1, 0.01);
 
        }
    }
 
#endif
 
    bool IsLanded(int pCurrentCommandID)
    {
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_FALL)
        {
            HumanCommandFall fall = GetCommand_Fall();
 
            if (fall)
            {
                return fall.PhysicsLanded();
            }
        }
        
        return false;
    }
 
    bool OnLand(int pCurrentCommandID, FallDamageData fallDamageData)
    {
        if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_FALL)
        {
            HumanCommandFall fall = GetCommand_Fall();
 
            if (fall)
            {
                fall.Land(fallDamageData.m_LandType);
                return true;
            }
        }
 
        return false;
    }
 
    bool IsAlreadyInFallingCommand(int pCurrentCommandID)
    {
        return pCurrentCommandID == DayZPlayerConstants.COMMANDID_FALL;
    }
    
    void OverrideSlidePoseAngle(float value)
    {
        if (!m_MoveSettings)
            m_MoveSettings = GetDayZPlayerType().CommandMoveSettingsW();
        if (m_MoveSettings.m_fSlidingPoseAngle != value)
        {
            m_MoveSettings.m_fSlidingPoseAngle = value;
            StartCommand_Move(); //nescessary, re-initializes with adjusted values
        }
    }
    
    float GetSlidePoseAngle()
    {
        return GetDayZPlayerType().CommandMoveSettingsW().m_fSlidingPoseAngle;
    }
    
    void CheckAnimationOverrides()
    {
    }
    
    bool IsPlayerSelected()
    {
        return m_PlayerSelected;
    }
    
    bool IsRestrained();
    
    bool IsInFBEmoteState();
    
    void SetSuicide(bool state)
    {
        m_Suicide = state;
    }
    
    bool CommitedSuicide()
    {
        return m_Suicide;
    }
    
    void OnLadder(float delta_time, HumanMovementState pState);
    
    //-------------------------------------------------------------
    
    override protected void EOnContact(IEntity other, Contact extra)
    {
        if (!IsAlive())
            return;
        
        if (GetParent() == other)
            return;
 
        Transport transport = Transport.Cast(other);
        if (transport)
        {
            if (g_Game.IsServer())
            {
                RegisterTransportHit(transport);
            }
        }
    }
    
    protected void AttenuateSoundIfNecessary(SoundObject soundObject)
    {
        if (g_Game.GetPlayer() != NULL && (IsSoundInsideBuilding() != g_Game.GetPlayer().IsSoundInsideBuilding() || IsCameraInsideVehicle() != g_Game.GetPlayer().IsCameraInsideVehicle()))
        {
            soundObject.SetKind(WaveKind.WAVEATTALWAYS);
        }
        else
        {
            soundObject.SetKind(WaveKind.WAVEEFFECTEX);
        }
    }
    
    void CheckLiftWeapon();
    void ProcessLiftWeapon();
    
    void SetHandheldOpticsInUse(bool state)
    {
        m_HandheldOpticsInUse = state;
    }
    
    bool IsHandheldOpticsInUse()
    {
        return m_HandheldOpticsInUse;
    }
    
    bool IsLiftWeapon();
    float GetWeaponObstruction();
    bool IsWeaponObstructionBlockingADS();
    
    bool IsRaised()
    {
        return m_IsRaised;
    }
 
    bool IsFighting();
    
    // Will return true when the item is not heavy as well
    bool CanPickupHeavyItem(notnull EntityAI item)
    {
        return !item.IsHeavyBehaviour() || (item.IsHeavyBehaviour() && DayZPlayerUtils.PlayerCanChangeStance(this, DayZPlayerConstants.STANCEIDX_ERECT));
    }
    
    bool CanPickupHeavyItemSwap(notnull EntityAI item1, notnull EntityAI item2)
    {
        return CanPickupHeavyItem(item1) && CanPickupHeavyItem(item2);
    }
    
    protected override array<InventoryItem> OnDrawOptics2D()
    {
        array<InventoryItem> optics;
        
        // Find preferred optics, i.e. active on in hands (if any are held) or the ones attached to weapon (if any is held)
        ItemOptics preferredOptics;
        {
            HumanInventory inventory = GetHumanInventory();
            EntityAI itemInHands = inventory.GetEntityInHands();
            
            ItemOptics opticsInHands = ItemOptics.Cast(itemInHands);
            if (opticsInHands)
            {
                preferredOptics = opticsInHands;
            }
            else
            {
                Weapon_Base weaponInHands = Weapon_Base.Cast(itemInHands);
                if (weaponInHands)
                {
                    preferredOptics = weaponInHands.GetAttachedOptics();
                }
            }
        }
        
        // Draw selected optics when the player is viewing through them
        if (preferredOptics && preferredOptics.IsInOptics() && preferredOptics.IsUsingOptics2DModel())
        {
            optics = {}; // only allocate the array when necessary
            optics.Insert(preferredOptics);
        }
        
        // Draw equipped NVGs
        CachedEquipmentStorageQuery query = new CachedEquipmentStorageQuery();
 
        query.m_Category      = ECachedEquipmentItemCategory.NVG;
        query.m_Placement        = ECachedEquipmentPlacement.ATTACHMENT;
        query.m_ParentPlacement = {InventorySlots.HEADGEAR, InventorySlots.EYEWEAR};
 
        array<Entity> nvgs = GetCachedEquipment().GetEntitiesByCategory(query);
 
        EntityAI nvAttachment;
        foreach (Entity nvg : nvgs)
        {
            nvAttachment = EntityAI.Cast(nvg);
            break;
        }
 
        if (nvAttachment)
        {
            bool blockedByOptics = preferredOptics && preferredOptics.IsInOptics() && !preferredOptics.IsUsingOptics2DModel();
            if ((!blockedByOptics || preferredOptics.IsUsableWithNV()) && PlayerBase.Cast(this).IsNVGWorking())
            {
                NVGoggles goggles = NVGoggles.Cast(nvAttachment);
                if (goggles)
                {
                    if (!optics) 
                        optics = {};
                    
                    optics.Insert(goggles);
                }
            }
        }
        
        return optics;
    }
 
#ifdef DIAG_DEVELOPER
    Weapon_Base SpawnWeaponInHands(string type)
    {
        return Weapon_Base.Cast(GetHumanInventory().CreateInHands(type));
    }
#endif
    
    //Obsolete stuff below this point//
    
    static const int                                    DEAD_SCREEN_DELAY = 1000; 
    protected bool                                      m_CameraEyeZoom; //DEPRECATED
    ref Timer                                          m_ADSAutomationTimer; //DEPRECATED
    protected bool                                      m_ADSTimerLaunched; //DEPRECATED
    protected bool                                      m_ProcessWeaponRaiseCompleted; //DEPRECATED
    protected bool                                      m_IsFireWeaponRaised; //DEPRECATED, value still set for legacy reasons
    protected bool                                      m_WasIronSight;   // moved from player to weapon
    void SetReturnToOptics(bool state); //DEPRECATED
    void RunADSTimer(); //DEPRECATED
    void StopADSTimer(); //DEPRECATED
    void SendCompleteWeaponRaiseJuncture(); //DEPRECATED
    void DepleteStamina(EStaminaModifiers modifier, float dT = -1) {};
 
    [Obsolete("1.30: uses CGame GetSurfaceInfo* methods instead")]
    string GetSurfaceType(SurfaceAnimationBone limbType)
    {
        string surfaceType;
        int liquidType;
 
        g_Game.SurfaceUnderObjectByBoneCorrectedLiquid(this, limbType, surfaceType, liquidType);
        
        return surfaceType;
    }
}