dayzplayerimplement.c

Go to the documentation of this file.

/*
DayZPlayerImplement
 
this file is implemenation of dayzPlayer in script
- logic of movement
- camera switching logic
 
*/
 
class DayZPlayerCommandDeathCallback : HumanCommandDeathCallback
{
 //----------------------------------
 // callbacks
 
 override void OnSimulationEnd()
 {
 if (LogManager.IsSyncLogEnable()) syncDebugPrint("DZPI::OnSimulationEnd - trying to drop item");
 
 if (GetGame().IsServer())
 {
 EntityAI itemInHands = m_pPlayer.GetHumanInventory().GetEntityInHands();
 if (itemInHands)
 {
 int boneIndex = m_pPlayer.GetBoneIndexByName("RightHand_Dummy");
 
 vector m4[4];
 m_pPlayer.GetBoneTransformWS(boneIndex, m4);
 
 m_pPlayer.GetInventory().DropEntityWithTransform(InventoryMode.SERVER, m_pPlayer, itemInHands, m4);
 
 if (GetCEApi())
 {
 int deadBodyLifetime = GetCEApi().GetCEGlobalInt("CleanupLifetimeDeadPlayer");
 if (deadBodyLifetime <= 0)
 {
 deadBodyLifetime = 3600;
 }
 itemInHands.SetLifetime(deadBodyLifetime);
 }
 } 
 }
 }
 
 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();
 }
};
 
class DayZPlayerImplement extends DayZPlayer
{
 static const int DEAD_SCREEN_DELAY = 1000; 
 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 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_WasIronsight; // was previously ironsights. Only used on weapons
 protected bool m_CameraIronsight; // Ironsight NOW!
 protected bool m_CameraOptics; // Optics NOW!
 
 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 bool m_ProcessLiftWeapon;
 protected bool m_ProcessLiftWeaponState;
 protected int m_LastSurfaceUnderHash;
 protected Transport m_TransportCache;
 protected string m_ClimbingLadderType;
 bool m_isFBsymptomPlaying;
 protected bool m_HandheldOpticsInUse;
 protected bool m_ResetADS;
 protected int m_StepCounter;
 protected int m_NextVoNNoiseTime;
 protected ref array<ref SyncHitInfo> m_SyncedHitDataArray;
 
 // 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;
 
 void DayZPlayerImplement()
 {
 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;
 m_WasIronsight = true; //initially uses ironsights by default
 #ifdef PLATFORM_CONSOLE
 m_Camera3rdPerson = !GetGame().GetWorld().Is3rdPersonDisabled();
 #endif
 m_LastSurfaceUnderHash = ("cp_gravel").Hash();
 m_NextVoNNoiseTime = 0;
 m_SyncedHitDataArray = new array<ref SyncHitInfo>;
 m_CurrentWaterLevel = 0;
 m_WeaponRaiseTime = 0;
 
 RegisterNetSyncVariableBoolSignal("m_TriggerPullPlayerOutOfVehicleSynch");
 }
 
 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(GetHumanInventory().GetEntityInHands());
 if (weapon)
 {
 m_WasIronsight = m_CameraIronsight;
 }
 
 m_CameraIronsight = value;
 
 if (value)
 {
 HumanCommandWeapons hcw = GetCommandModifier_Weapons();
 if (hcw)
 {
 hcw.SetADS(true);
 }
 }
 }
 
 void SetOptics(bool value)
 {
 m_CameraOptics = value;
 
 if (value)
 {
 HumanCommandWeapons hcw = GetCommandModifier_Weapons();
 if (hcw)
 {
 hcw.SetADS(!IsHandheldOpticsInUse());
 }
 }
 }
 
 void ExitSights()
 {
 ItemOptics optics = null;
 EntityAI entityInHands = GetHumanInventory().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)
 {
 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 DepleteStamina(EStaminaModifiers modifier, float dT = -1) {};
 
 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 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 IsFBSymptomPlaying()
 {
 return m_isFBsymptomPlaying;
 }
 
 float GetDeltaT()
 {
 return m_dT;
 }
 
 //-------------------------------------------------------------
 
 int m_DeathAnimType = -2;
 float m_DeathHitDir = 0;
 bool m_DeathJuctureSent = false;
 
 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 (!GetGame().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();
 
 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 && !GetGame().IsDedicatedServer())
 {
 TriggerPullPlayerOutOfVehicleImpl();
 }
 
 super.OnVariablesSynchronized();
 }
 
 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();
 }
 
 bool keepInLocalSpace = false;
 if (IsUnconscious() || m_WasInVehicle)
 {
 if (m_TransportCache)
 {
 m_TransportCache.CrewDeath(m_TransportCache.CrewMemberIndex(this));
 m_TransportCache.MarkCrewMemberDead(m_TransportCache.CrewMemberIndex(this));
 }
 }
 else
 {
 if (m_TransportCache)
 {
 m_TransportCache.CrewGetOut(m_TransportCache.CrewMemberIndex(this));
 m_TransportCache.MarkCrewMemberDead(m_TransportCache.CrewMemberIndex(this));
 }
 
 keepInLocalSpace = m_PullPlayerOutOfVehicleKeepsInLocalSpace;
 }
 
 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
 {
 PhysicsSetRagdoll(true);
 }
 
 // disable voice communication
 GetGame().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 (!GetGame().GetMission().IsPlayerRespawning())
 {
 message = "#dayz_implement_dead";
 }
 
 #ifdef PLATFORM_CONSOLE
 GetGame().GetUIManager().ScreenFadeIn(duration, message, FadeColors.DARK_RED, FadeColors.WHITE);
 #else
 GetGame().GetUIManager().ScreenFadeIn(duration, message, FadeColors.BLACK, FadeColors.WHITE);
 #endif
 }
 else
 {
 GetGame().GetUIManager().ScreenFadeOut(duration);
 
 if (duration > 0)
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).CallLater(StopDeathDarkeningEffect, duration*1000, false);
 else
 GetGame().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);
 
 GetGame().GetSoundScene().SetSoundVolume(0,0);
 GetGame().GetSoundScene().SetSpeechExVolume(0,0);
 GetGame().GetSoundScene().SetMusicVolume(0,0);
 GetGame().GetSoundScene().SetVOIPVolume(0,0);
 GetGame().GetSoundScene().SetRadioVolume(0,0);
 }
 else
 {
 StopDeathDarkeningEffect();
 ShowDeadScreen(state, 0);
 }
 }
 
 void LockControls(bool state)
 {
 if (state == true)
 {
 GetGame().GetInput().ChangeGameFocus(1, INPUT_DEVICE_MOUSE);
 GetGame().GetInput().ChangeGameFocus(1, INPUT_DEVICE_KEYBOARD);
 GetGame().GetInput().ChangeGameFocus(1, INPUT_DEVICE_GAMEPAD);
 
 if (GetGame().GetUIManager()) 
 {
 GetGame().GetUIManager().ShowUICursor(true);
 if (GetGame().GetUIManager().IsDialogVisible())
 GetGame().GetUIManager().CloseDialog();
 }
 }
 else
 {
 GetGame().GetInput().ChangeGameFocus(-1, INPUT_DEVICE_MOUSE);
 GetGame().GetInput().ChangeGameFocus(-1, INPUT_DEVICE_KEYBOARD);
 GetGame().GetInput().ChangeGameFocus(-1, INPUT_DEVICE_GAMEPAD);
 
 if (GetGame().GetUIManager())
 {
 if (GetGame().GetUIManager().GetMenu())
 {
 GetGame().GetUIManager().ShowUICursor(true);
 }
 else
 {
 GetGame().GetUIManager().ShowUICursor(false);
 }
 }
 }
 }
 
 void SetDeathDarknessLevel(float duration, float tick_time);
 
 void SendCompleteWeaponRaiseJuncture();
 
 void CompleteWeaponRaise()
 {
 m_WeaponRaiseTime = 0;
 m_WeaponRaiseCompleted = true;
 }
 
 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);
 protected void SendSoundEvent(EPlayerSoundEventID id);
 protected void SendSoundEventEx(EPlayerSoundEventID id, int param = 0);
 
 override void OnItemInHandsChanged()
 {
 //Print("inv: DayZPlayerImplement::OnItemInHandsChanged: "/* + GetHumanInventory().GetEntityInHands()*/);
 StopWeaponEvent();
 GetItemAccessor().OnItemInHandsChanged();
 
 if (!IsAlive())
 {
 //Print("inv: DayZPlayerImplement::OnItemInHandsChanged - human not alive! calling ResetWeaponInHands");
 GetItemAccessor().ResetWeaponInHands();
 }
 }
 
 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);
 
 // 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 (GetGame().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);
 pInputs.ResetFreeLookToggle();
 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);
 pInputs.ResetFreeLookToggle();
 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;
 for (int i = 0; i < m_SyncedHitDataArray.Count(); i++)
 {
 data = m_SyncedHitDataArray[i];
 m_DamageHitDir = data.m_HitDir;
 
 //client-side effects
 #ifndef SERVER
 if (IsAlive() && !IsUnconscious() && data.m_HasSource && GetGame().GetMission().GetHud() && GetGame().GetPlayer() == this) //only for controlled players
 {
 m_DamageHealth = data.m_HealthDamage;
 if (m_DamageHealth > 0.0)
 {
 float rel = m_DamageHealth / (GetMaxHealth("","Health") * PlayerConstants.HEAVY_HIT_THRESHOLD);
 GetGame().GetMission().GetHud().SpawnHitDirEffect(this,m_DamageHitDir,rel);
 }
 }
 #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)
 {
 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 = GetGame().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 DT_CLOSE_COMBAT:
 if (pSource.IsInherited(DayZInfected))
 break;
 
 pAnimType = GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " hitAnimation");
 invertHitDir = GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " invertHitDir");
 if (!IsUnconscious() && pAnimType == 1 && !m_MeleeFightLogic.IsInBlock())
 pAnimHitFullbody = true;
 break;
 
 case DT_FIRE_ARM:
 int impactBehaviour = 0;
 
 if (!IsUnconscious() && GetHealth("", "Shock") > 25)
 {
 if (pComponent == "Torso" || pComponent == "Head")
 {
 impactBehaviour = GetGame().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 DT_EXPLOSION:
 break;
 
 case DT_CUSTOM:
 pAnimType = GetGame().ConfigGetInt("cfgAmmo " + pAmmoType + " hitAnimation");
 if (pAnimType == 1)
 pAnimHitFullbody = true;
 else
 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 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;
 }
 
 return true;
 }
 
 bool CanClimb(int climbType, SHumanCommandClimbResult climbRes)
 {
 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 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();
 }
 
 //-------------------------------------------------------------
 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;
 }
 
 if (m_ResetADS || !hia.IsItemInHandsWeapon())
 {
 hic.ResetADS();
 m_ResetADS = false;
 }
 
 if (!m_MovementState.IsRaised() || m_LiftWeapon_player)
 {
 ResetWeaponRaiseProgress();
 exitSights = true;
 }
 else
 {
 if (m_bADS != hic.WeaponADS())
 {
 m_bADS = hic.WeaponADS();
 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.GetItemInHands() && playerPB.GetItemInHands().IsWeapon() && playerPB.GetWeaponManager() && !playerPB.GetWeaponManager().IsRunning())
 {
 Weapon_Base weapon = Weapon_Base.Cast(GetHumanInventory().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() || !IsRaised() || GetDayZPlayerInventory().IsProcessing() || !IsWeaponRaiseCompleted() || IsFighting())
 {
 exitSights = true;
 }
 else if (switchToADS) // enter ironsights or optics
 {
 // filter by usability
 if (m_WasIronsight && !canUseIronsights)
 {
 m_WasIronsight = false;
 }
 else if (!m_WasIronsight && !canUseOptics)
 {
 m_WasIronsight = true;
 }
 
 if (m_WasIronsight)
 {
 hic.ResetFreeLookToggle();
 SwitchOptics(optic,false);
 SetIronsights(true);
 }
 else if (!m_WasIronsight || (!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();
 
 if (IsRaised())
 {
 if (m_IsWeapon)
 {
 camChange = false;
 }
 }
 
 if (GetGame().GetWorld().Is3rdPersonDisabled())
 {
 m_Camera3rdPerson = false;
 }
 else if (camChange)
 {
 m_Camera3rdPerson = !m_Camera3rdPerson;
 }
 
 // exits optics completely, comment to return to ADS
 if (m_LiftWeapon_player && (m_CameraOptics || m_CameraIronsight))
 ExitSights();
 
 if (IsPlayerInStance(DayZPlayerConstants.STANCEMASK_RAISEDPRONE) && (m_CameraOptics || m_CameraIronsight))
 GetDayZPlayerType().SetVerticalMinimumAimLimit(DayZPlayerCameraIronsights.CONST_UD_MIN_BACK);
 else
 GetDayZPlayerType().SetVerticalMinimumAimLimit(DayZPlayerCameraIronsights.CONST_UD_MIN);
 
 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 = GetGame().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 = GetGame().ConfigGetChildrenCount(path);
 
 for (int i = 0; i < soundCount; i++)
 {
 string name = "";
 GetGame().ConfigGetChildName(path, i, name);
 
 if (name == bodyClothName)
 {
 TStringArray stringArray = new TStringArray();
 GetGame().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 = GetGame().GetSoundScene().Play3D(soundObject, soundObjectBuilder);
 wave.SetStartOffset(m_SoundOffset);
 wave.SetVolumeRelative(volume);
 
 m_LastBackSoundTime = GetGame().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 = GetGame().ConfigGetChildrenCount(path2);
 
 for (int i2 = 0; i2 < soundCount2; i2++)
 {
 string name2 = "";
 GetGame().ConfigGetChildName(path2, i2, name2);
 
 if (name2 == movementSurfaceType)
 {
 TStringArray stringArray2 = new TStringArray();
 GetGame().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 = GetGame().GetSoundScene().Play3D(soundObject2, soundObjectBuilder2);
 wave2.SetStartOffset(m_SoundOffset);
 wave2.SetVolumeRelative(volume2); 
 
 m_LastBackSoundTime2 = GetGame().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;
 
 if (ModCommandHandlerBefore(pDt, pCurrentCommandID, pCurrentCommandFinished))
 {
 return;
 }
 
 HumanInputController hic = GetInputController();
 EntityAI entityInHands = GetHumanInventory().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 (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(GetPosition()[1]);
 return;
 }
 
 if (m_Swimming.m_bWasSwimming)
 {
 StartCommand_Swim();
 return;
 }
 
 StartCommand_Move();
 
 if (GetHumanInventory().GetEntityInHands())
 ForceStandUpForHeavyItems(GetHumanInventory().GetEntityInHands());
 
 return;
 }
 
 
 //--------------------------------------------
 
 if (ModCommandHandlerInside(pDt, pCurrentCommandID, pCurrentCommandFinished))
 {
 return;
 }
 
 
 //--------------------------------------------
 // vehicle handling
 if (pCurrentCommandID == DayZPlayerConstants.COMMANDID_VEHICLE)
 {
 HumanCommandVehicle hcv = GetCommand_Vehicle();
 if (hcv.WasGearChange())
 {
 GearChangeActionCallback cb = GearChangeActionCallback.Cast(AddCommandModifier_Action(DayZPlayerConstants.CMD_ACTIONMOD_SHIFTGEAR, GearChangeActionCallback));
 cb.SetVehicleCommand(hcv);
 }
 
 return;
 }
 
 //--------------------------------------------
 HumanCommandMove hcm = GetCommand_Move();
 if (hcm && hcm.GetCurrentMovementSpeed() > 2.99 && m_MovementState.m_iMovement == DayZPlayerConstants.MOVEMENTIDX_SPRINT)
 {
 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))
 {
 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 - GetPosition()[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(GetPosition()[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 (hic.IsJumpClimb())
 {
 m_JumpClimb.JumpOrClimb();
 
 if (m_JumpClimb.WasSuccessful())
 {
 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 (GetGame().IsServer())
 {
 int now = GetGame().GetTime();
 if (now >= m_NextVoNNoiseTime)
 {
 m_NextVoNNoiseTime = now + 1000;
 
 int voiceLevel = GetGame().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.GetHumanInventory().GetEntityInHands();
 if (item_in_hands != NULL && player.CanDropEntity(item_in_hands) && GetGame().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)
 {
 ItemOptics optics = null;
 EntityAI entityInHands = GetHumanInventory().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 )
 {
 return DayZPlayerCameras.DAYZCAMERA_1ST_UNCONSCIOUS;
 }
 
 HumanCommandVehicle vehicleCommand = GetCommand_Vehicle();
 
 if (!m_Camera3rdPerson)
 {
 if (vehicleCommand)
 {
 return DayZPlayerCameras.DAYZCAMERA_1ST_VEHICLE;
 }
 
 return DayZPlayerCameras.DAYZCAMERA_1ST;
 }
 else
 {
 if (vehicleCommand)
 {
 Transport transport = vehicleCommand.GetTransport();
 if (transport && GetParent())
 {
 return transport.Get3rdPersonCameraType();
 }
 }
 
 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)
 {
 switch (m_MovementState.m_LocalMovement)
 {
 case DayZPlayerConstants.MOVEMENTIDX_CROUCH_RUN:
 {
 //OnCrouchRunEnd();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_SPRINT:
 {
 OnSprintEnd();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_RUN:
 {
 //OnRunEnd();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_WALK:
 {
 //OnWalkEnd();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_IDLE:
 {
 //OnIdleEnd();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_SLIDE:
 {
 //OnSlideEnd();
 break;
 }
 }
 
 switch (m_MovementState.m_iMovement)
 {
 case DayZPlayerConstants.MOVEMENTIDX_CROUCH_RUN:
 {
 //OnCrouchRunStart();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_SPRINT:
 {
 OnSprintStart();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_RUN:
 {
 //OnRunStart();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_WALK:
 {
 //OnWalkStart();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_IDLE:
 {
 //OnIdleStart();
 break;
 }
 case DayZPlayerConstants.MOVEMENTIDX_SLIDE:
 {
 //OnSlideStart();
 break;
 }
 }
 }
 
 void OnSprintStart()
 {
 if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
 {
 GetUApi().GetInputByID(UALeanLeft).Lock();
 GetUApi().GetInputByID(UALeanRight).Lock();
 }
 }
 
 void OnSprintEnd()
 {
 if (GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
 {
 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))
 {
 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;
 }
 
 string GetSurfaceType(SurfaceAnimationBone limbType)
 {
 string surfaceType;
 int liquidType;
 
 g_Game.SurfaceUnderObjectByBone(this, limbType, surfaceType, liquidType);
 
 return surfaceType;
 }
 
 //-------------------------------------------------------------
 
 AbstractWave PlaySound(SoundObject so, SoundObjectBuilder sob)
 {
 if (so == null)
 return null;
 
 so.SetPosition(GetPosition());
 AbstractWave wave = GetGame().GetSoundScene().Play3D(so, sob);
 return wave;
 }
 
 void AddNoise(NoiseParams noisePar, float noiseMultiplier = 1.0)
 {
 if (noisePar != null)
 GetGame().GetNoiseSystem().AddNoise(this, noisePar, noiseMultiplier);
 }
 
 //-------------------------------------------------------------
 
 void OnStepEvent(string pEventType, string pUserString, int pUserInt)
 {
 DayZPlayerType type = GetDayZPlayerType();
 ref HumanMovementState state = new HumanMovementState();
 GetMovementState(state);
 
 #ifndef SERVER
 DayZPlayerTypeStepSoundLookupTable table = type.GetStepSoundLookupTable();
 SoundObjectBuilder soundBuilder = NULL;
 if (pUserInt < 100)
 {
 string surface;
 if (pUserInt % 2 == 1)
 {
 surface = GetSurfaceType(SurfaceAnimationBone.LeftBackLimb);
 if (surface.Length() == 0)//if no surface found, try other leg
 surface = GetSurfaceType(SurfaceAnimationBone.RightBackLimb);
 }
 else
 {
 surface = GetSurfaceType(SurfaceAnimationBone.RightBackLimb);
 if (surface.Length() == 0)//if no surface found, try other leg
 surface = GetSurfaceType(SurfaceAnimationBone.LeftBackLimb);
 }
 
 if (surface.Length() != 0)
 m_LastSurfaceUnderHash = surface.Hash();
 
 soundBuilder = table.GetSoundBuilder(pUserInt, state.m_iMovement, m_LastSurfaceUnderHash, GetBootsType());
 }
 else
 {
 string surface2 = GetSurfaceType();
 if (surface2.Length() != 0)
 m_LastSurfaceUnderHash = surface2.Hash();
 
 soundBuilder = table.GetSoundBuilder(pUserInt, state.m_iMovement, m_LastSurfaceUnderHash, GetBootsType());
 }
 
 if (soundBuilder != NULL && GetGame().GetPlayer())
 {
 vector orientation = Vector(0, 0, 0);
 vector edgeLength = Vector(1.5, 3.0, 1.5);
 array<Object> excludedObjects = new array<Object>;
 array<Object> collidedObjects = new array<Object>;
 
 if (GetGame().IsBoxColliding(GetPosition(), orientation, edgeLength, excludedObjects, collidedObjects))
 {
 for (int i = 0; i < collidedObjects.Count(); ++i)
 {
 string objectClass = collidedObjects.Get(i).GetType();
 
 if (objectClass.Contains("BushSoft") || objectClass.Contains("BushHard"))
 {
 for (int j = 0; j < type.GetVegetationSounds().Count(); ++j)
 {
 VegetationSound vegetationSound = type.GetVegetationSounds().Get(j);
 
 if (vegetationSound.GetAnimEventIds().Find(pUserInt) >= 0)
 {
 SoundObjectBuilder vegSoundObjectBuilder = vegetationSound.GetSoundObjectBuilder();
 SoundObject vegSoundObject = vegetationSound.GetSoundObjectBuilder().BuildSoundObject();
 
 if (vegSoundObject != NULL)
 {
 AttenuateSoundIfNecessary(vegSoundObject);
 PlaySound(vegSoundObject, vegSoundObjectBuilder);
 }
 
 break;
 }
 }
 
 break;
 }
 }
 }
 
 SoundObject soundObject = soundBuilder.BuildSoundObject();
 if (soundObject != NULL)
 {
 AttenuateSoundIfNecessary(soundObject);
 PlaySound(soundObject, soundBuilder);
 }
 }
 #endif
 
 if (GetGame().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 = type.GetNoiseParamsStand();
 else if (state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_CROUCH || state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDCROUCH)
 noiseParams = type.GetNoiseParamsCrouch();
 else if (state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE || state.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
 noiseParams = type.GetNoiseParamsProne();
 else
 {
 Debug.Log(string.Format("Wrong stance, id: %1 using backup with stand stance (id: 0)", state.m_iStanceIdx));
 noiseParams = type.GetNoiseParamsStand();
 }
 
 noiseMultiplier = NoiseAIEvaluate.GetNoiseMultiplier(this);
 
 AddNoise(noiseParams, noiseMultiplier);
 
 if ((m_StepCounter % PlayerConstants.CHECK_EVERY_N_STEP) == 0)
 {
 ProcessFeetDamageServer(pUserInt);
 }
 }
 }
 
 void OnSoundEvent(string pEventType, string pUserString, int pUserInt)
 {
 if (pEventType == "Sound")
 {
 ProcessSoundEvent(pEventType, pUserString, pUserInt);
 }
 else if (pEventType == "SoundWeapon")
 {
 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)
 {
 int event_id = m_PlayerSoundEventHandler.ConvertAnimIDtoEventID(pUserInt);
 if (event_id > 0)
 {
 PlaySoundEvent(event_id);
 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 = GetHumanInventory().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 (!GetGame().IsDedicatedServer())
 {
 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);
 PlaySound(soundObject, builder);
 }
 }
 else
 {
 //TODO:Userful error message
 }
 }
 
 if (GetGame().IsServer())
 {
 AddNoise(soundEvent.m_NoiseParams);
 }
 }
 }
 
 void ProcessAttachmentEvent(string pEventType, string pUserString, int pUserInt)
 {
 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);
 }
 }
 }
 }
 
 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 (!GetGame().IsDedicatedServer())
 {
 SoundObjectBuilder objectBuilder = soundEvent.GetSoundBuilder();
 if (GetCommand_Ladder())
 {
 SetVariablesLadderSoundObjectBuilder(objectBuilder);
 }
 objectBuilder.AddEnvSoundVariables(GetPosition());
 
 SoundObject soundObject = objectBuilder.BuildSoundObject();
 if (soundObject != NULL)
 {
 AttenuateSoundIfNecessary(soundObject);
 PlaySound(soundObject, objectBuilder);
 }
 }
 
 if (GetGame().IsServer())
 {
 if (soundEvent.m_NoiseParams != NULL)
 GetGame().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;
 EntityAI mask = GetInventory().FindAttachment(InventorySlots.MASK);
 EntityAI head_gear = GetInventory().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);
 
 
 //-------------------------------------------------------------
 
 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 (GetGame().IsServer())
 {
 RegisterTransportHit(transport);
 }
 }
 }
 
 protected void AttenuateSoundIfNecessary(SoundObject soundObject)
 {
 if (GetGame().GetPlayer() != NULL && (IsSoundInsideBuilding() != GetGame().GetPlayer().IsSoundInsideBuilding() || IsCameraInsideVehicle() != GetGame().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();
 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);
 }
 
#ifdef DIAG_DEVELOPER
 Weapon_Base SpawnWeaponInHands(string type)
 {
 return Weapon_Base.Cast(GetHumanInventory().CreateInHands(type));
 }
#endif
 
//Obsolete stuff below this point//
 
 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
 void SetReturnToOptics(bool state); //DEPRECATED
 void RunADSTimer(); //DEPRECATED
 void StopADSTimer(); //DEPRECATED
}