staminahandler.c

Go to the documentation of this file.

enum EStaminaMultiplierTypes
{
 MASK = 1,
 FATIGUE,
 EPINEPHRINE,
 DROWNING,
}
 
 
class StaminaConsumer
{
 protected float m_ActivationThreshold;
 protected float m_DrainThreshold
 protected bool m_State;
 
 void StaminaConsumer(float threshold, float threshold2, bool state)
 {
 m_ActivationThreshold = threshold; //can be activated if above this threshold
 m_DrainThreshold = threshold2; //can continually drain until it reaches this threshold
 m_State = state;
 }
 
 bool GetState() { return m_State; }
 void SetState(bool state) { m_State = state; }
 
 float GetActivationThreshold() { return m_ActivationThreshold; }
 void SetActivationThreshold(float threshold) { m_ActivationThreshold = threshold; }
 
 float GetDrainThreshold() { return m_DrainThreshold; }
 void SetDrainThreshold(float threshold) { m_DrainThreshold = threshold; } 
}
 
class StaminaConsumers
{
 protected ref map<EStaminaConsumers, ref StaminaConsumer> m_StaminaConsumers;
 
 void StaminaConsumers()
 {
 m_StaminaConsumers = new map<EStaminaConsumers, ref StaminaConsumer>;
 }
 
 void RegisterConsumer(EStaminaConsumers consumer, float threshold, float depletion_threshold = -1)
 {
 if (depletion_threshold == -1)
 {
 depletion_threshold = threshold;
 }
 
 if ( !m_StaminaConsumers.Contains(consumer) )
 {
 StaminaConsumer sc = new StaminaConsumer(threshold, depletion_threshold, true);
 m_StaminaConsumers.Set(consumer, sc);
 }
 }
 
 bool HasEnoughStaminaFor(EStaminaConsumers consumer, float curStamina, bool isDepleted, float cap)
 {
 if ( m_StaminaConsumers && m_StaminaConsumers.Contains(consumer) )
 {
 StaminaConsumer sc = m_StaminaConsumers.Get(consumer);
 
 if ( consumer != EStaminaConsumers.SPRINT )
 {
 if ( (isDepleted || (curStamina < sc.GetDrainThreshold()/* && curStamina < cap*/)) )
 {
 sc.SetState(false);
 return false;
 }
 }
 else
 {
 if ( !isDepleted )
 {
 if ( sc.GetState() ) 
 {
 sc.SetState(true);
 return true;
 }
 }
 else
 {
 sc.SetState(false);
 return false;
 }
 }
 
 if ( curStamina > sc.GetDrainThreshold() || curStamina == cap ) //Sometimes player can't go up to drain threshold
 {
 sc.SetState(true);
 return true;
 }
 }
 
 return false;
 }
 
 bool HasEnoughStaminaToStart(EStaminaConsumers consumer, float curStamina, bool isDepleted, float cap)
 {
 if ( m_StaminaConsumers && m_StaminaConsumers.Contains(consumer) )
 {
 StaminaConsumer sc = m_StaminaConsumers.Get(consumer);
 
 if ( (isDepleted || (curStamina < sc.GetActivationThreshold() && curStamina < cap)) )
 {
 sc.SetState(false);
 return false;
 }
 else
 {
 sc.SetState(true);
 return true;
 }
 }
 
 return false;
 }
}
 
 
class StaminaModifier
{
 bool m_InUse = false;
 int m_Type;
 float m_MinValue, m_MaxValue, m_Multiplier, m_Cooldown, m_StartTime, m_StartTimeAdjustment, m_Duration, m_ProgressTime, m_Tick;
 
 void StaminaModifier(int type, float min, float max, float cooldown, float startTime = 0, float duration = 0)
 {
 m_Type = type;
 m_MinValue = min;
 m_MaxValue = max;
 m_Cooldown = cooldown;
 m_StartTimeAdjustment = startTime;
 m_Duration = duration;
 m_Tick = 1;
 }
 
 int GetType() { return m_Type; }
 
 float GetMinValue() { return m_MinValue; }
 void SetMinValue(float val) { m_MinValue = val; } 
 
 float GetMaxValue() { return m_MaxValue; }
 void SetMaxValue(float val) { m_MaxValue = val; }
 
 float GetCooldown() { return m_Cooldown; }
 void SetCooldown(float val) { m_Cooldown = val; }
 
 float GetStartTime() { return m_StartTime; } //Actual game time (progressive modifiers only)
 void SetStartTime(float val) { m_StartTime = val; }
 
 float GetStartTimeAdjustment() {return m_StartTimeAdjustment;} //adjustment to current time (progressive modifiers only)
 
 float GetDuration() { return m_Duration; }
 float GetDurationAdjusted() { return m_Duration / m_Tick; }
 
 bool IsInUse() { return m_InUse; }
 void SetInUse(bool val) { m_InUse = val; }
 
 float GetRunTime() { return m_ProgressTime; }
 void AddRunTime(float val) { m_ProgressTime += val; }
 void SetRunTimeTick(float val) { m_Tick = val; }
 void ResetRunTime() { m_ProgressTime = 0 }
}
 
class StaminaModifierExponential : StaminaModifier
{
 protected ref SMDataExponential m_SMDataEx;
 
 float GetBaseValue() { return m_SMDataEx.m_BaseValue; }
 float GetExponent() { return m_SMDataEx.m_Exponent; }
 float GetMultiplier() { return m_SMDataEx.m_Multiplier; }
 override float GetCooldown() { return m_SMDataEx.m_Cooldown; }
 override float GetStartTimeAdjustment() { return m_SMDataEx.m_StartTimeAdjustment; }
 override float GetDuration() { return m_SMDataEx.m_Duration; }
 override float GetDurationAdjusted() { return m_SMDataEx.m_Duration / m_Tick; }
 
 void SetData(SMDataExponential data) { m_SMDataEx = data; }
}
 
class StaminaModifiers
{
 const int FIXED = 0;
 const int RANDOMIZED = 1;
 const int LINEAR = 2; //Useful ONLY for regular, over-time stamina drain
 const int EXPONENTIAL = 3; //Useful ONLY for regular, over-time stamina drain
 
 protected ref map<EStaminaModifiers, ref StaminaModifier> m_StaminaModifiers;
 
 void StaminaModifiers()
 {
 m_StaminaModifiers = new map<EStaminaModifiers, ref StaminaModifier>;
 }
 
 void RegisterFixed(EStaminaModifiers modifier, float value, float cooldown = GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION)
 { 
 if ( !m_StaminaModifiers.Contains(modifier) )
 {
 StaminaModifier sm = new StaminaModifier(FIXED, -1, value, cooldown);
 m_StaminaModifiers.Set(modifier, sm);
 }
 }
 
 void RegisterRandomized(EStaminaModifiers modifier, float minValue, float maxValue, float cooldown = GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION)
 {
 if ( !m_StaminaModifiers.Contains(modifier) )
 {
 StaminaModifier sm = new StaminaModifier(RANDOMIZED, minValue, maxValue, cooldown);
 m_StaminaModifiers.Set(modifier, sm);
 }
 }
 
 void RegisterLinear(EStaminaModifiers modifier, float startValue, float endValue, float startTime, float duration, float cooldown = GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION)
 {
 StaminaModifier sm = new StaminaModifier(LINEAR, startValue, endValue, cooldown, startTime, duration);
 m_StaminaModifiers.Set(modifier, sm);
 }
 
 void RegisterExponential(EStaminaModifiers modifier, float startValue, float exponent, float startTime, float duration, float cooldown = GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION)
 {
 StaminaModifier sm = new StaminaModifier(EXPONENTIAL, startValue, exponent, cooldown, startTime, duration);
 m_StaminaModifiers.Set(modifier, sm);
 }
 
 void RegisterExponentialEx(EStaminaModifiers modifier, SMDataExponential data)
 {
 StaminaModifierExponential smex = new StaminaModifierExponential(EXPONENTIAL, data.m_BaseValue, data.m_Exponent, data.m_Cooldown, data.m_StartTimeAdjustment, data.m_Duration);
 smex.SetData(data);
 m_StaminaModifiers.Set(modifier, smex);
 }
 
 StaminaModifier GetModifierData(EStaminaModifiers modifier)
 {
 return m_StaminaModifiers.Get(modifier);
 }
}
 
 
class StaminaHandler
{ 
 protected float m_PlayerLoad;
 protected float m_StaminaDelta;
 protected float m_Stamina;
 protected float m_StaminaSynced; //guaranteed to be identical on server and client
 protected float m_StaminaCap;
 protected float m_StaminaDepletion;
 protected float m_StaminaDepletionMultiplier; //controls depletion rate
 protected float m_StaminaRecoveryMultiplier; //controls recovery rate
 protected float m_Time;
 protected ref Param3<float,float,bool> m_StaminaParams; 
 protected ref HumanMovementState m_State;
 protected SHumanCommandMoveSettings m_HumanMoveSettings;
 protected PlayerBase m_Player;
 
 protected bool m_Debug; 
 protected bool m_StaminaDepleted;
 
 protected ref map<int,ref Timer> m_TimerMap;
 ref map<EStaminaMultiplierTypes, float> m_RegisteredDepletionModifiers;
 ref set<EStaminaMultiplierTypes> m_ActiveDepletionModifiers;
 
 ref map<EStaminaMultiplierTypes, float> m_RegisteredRecoveryModifiers;
 ref set<EStaminaMultiplierTypes> m_ActiveRecoveryModifiers;
 
 protected bool m_IsInCooldown;
 
 protected ref StaminaConsumers m_StaminaConsumers;
 protected ref StaminaModifiers m_StaminaModifiers;
 
 #ifdef DIAG_DEVELOPER
 protected bool m_StaminaDisabled;
 #endif
 
 void StaminaHandler(PlayerBase player)
 {
 if (GetGame().IsServer() || !GetGame().IsMultiplayer())
 m_StaminaParams = new Param3<float,float,bool>(0,0, false); 
 
 m_State = new HumanMovementState();
 m_Player = player;
 m_Stamina = CfgGameplayHandler.GetStaminaMax(); 
 m_StaminaCap = CfgGameplayHandler.GetStaminaMax();
 m_StaminaDepletion = 0;
 m_StaminaDepletionMultiplier = 1;
 m_StaminaRecoveryMultiplier = 1;
 m_Time = 0;
 m_StaminaDepleted = false;
 m_IsInCooldown = false;
 m_HumanMoveSettings = m_Player.GetDayZPlayerType().CommandMoveSettingsW();
 
 RegisterStaminaConsumers();
 RegisterStaminaModifiers();
 
 m_TimerMap = new map<int,ref Timer>;
 
 //----------------- depletion --------------------
 m_RegisteredDepletionModifiers = new map<EStaminaMultiplierTypes, float>;
 m_ActiveDepletionModifiers = new set<EStaminaMultiplierTypes>;
 
 //----------------- recovery --------------------
 m_RegisteredRecoveryModifiers = new map<EStaminaMultiplierTypes, float>;
 m_ActiveRecoveryModifiers = new set<EStaminaMultiplierTypes>;
 
 Init();
 }
 
 
 void Init()
 {
 //----------------- depletion --------------------
 m_RegisteredDepletionModifiers.Insert(EStaminaMultiplierTypes.MASK, MaskMdfr.STAMINA_DEPLETION_MODIFIER);
 m_RegisteredDepletionModifiers.Insert(EStaminaMultiplierTypes.FATIGUE, FatigueMdfr.STAMINA_DEPLETION_MULTIPLIER);
 m_RegisteredDepletionModifiers.Insert(EStaminaMultiplierTypes.EPINEPHRINE, EpinephrineMdfr.STAMINA_DEPLETION_MULTIPLIER);
 
 //----------------- recovery --------------------
 m_RegisteredRecoveryModifiers.Insert(EStaminaMultiplierTypes.MASK, MaskMdfr.STAMINA_RECOVERY_MODIFIER);
 m_RegisteredRecoveryModifiers.Insert(EStaminaMultiplierTypes.FATIGUE, FatigueMdfr.STAMINA_RECOVERY_MULTIPLIER);
 m_RegisteredRecoveryModifiers.Insert(EStaminaMultiplierTypes.DROWNING, DrowningMdfr.STAMINA_RECOVERY_MULTIPLIER);
 
 }
 
 void ActivateDepletionModifier(EStaminaMultiplierTypes type)
 {
 if (m_RegisteredDepletionModifiers.Contains(type))
 {
 m_ActiveDepletionModifiers.Insert(type);
 RecalculateDepletionMultiplier();
 }
 else
 {
 Error("attempting to activate unregistered depletion modifier");
 }
 } 
 
 void DeactivateDepletionModifier(EStaminaMultiplierTypes type)
 {
 int index = m_ActiveDepletionModifiers.Find(type);
 if (index != -1)
 {
 m_ActiveDepletionModifiers.Remove(index);
 RecalculateDepletionMultiplier();
 }
 }
 
 void RecalculateDepletionMultiplier()
 {
 float value = 1;
 
 foreach (int multiplier: m_ActiveDepletionModifiers)
 {
 value *= m_RegisteredDepletionModifiers.Get(multiplier);
 }
 
 if (value != m_StaminaDepletionMultiplier)
 SetDepletionMultiplier(value);
 }
 
 void ActivateRecoveryModifier(EStaminaMultiplierTypes type)
 {
 if (m_RegisteredRecoveryModifiers.Contains(type))
 {
 m_ActiveRecoveryModifiers.Insert(type);
 RecalculateRecoveryMultiplier();
 }
 else
 {
 Error("attempting to activate unregistered recovery modifier");
 }
 }
 
 
 void DeactivateRecoveryModifier(EStaminaMultiplierTypes type)
 {
 int index = m_ActiveRecoveryModifiers.Find(type);
 if (index != -1)
 {
 m_ActiveRecoveryModifiers.Remove(index);
 RecalculateRecoveryMultiplier();
 }
 }
 
 void RecalculateRecoveryMultiplier()
 {
 float value = 1;
 
 foreach (int multiplier: m_ActiveRecoveryModifiers)
 {
 value *= m_RegisteredRecoveryModifiers.Get(multiplier);
 }
 
 if (value != m_StaminaRecoveryMultiplier)
 {
 SetRecoveryMultiplier(value);
 }
 }
 
 void Update(float deltaT, int pCurrentCommandID)
 {
 #ifdef DIAG_DEVELOPER
 if (m_StaminaDisabled)
 return;
 #endif
 if (m_Player)
 {
 // Calculates actual max stamina based on player's load
 if (GetGame().IsServer() || !GetGame().IsMultiplayer())
 {
 m_PlayerLoad = m_Player.GetWeightEx();
 
 if (m_PlayerLoad >= CfgGameplayHandler.GetStaminaWeightLimitThreshold())
 {
 m_StaminaCap = Math.Max((CfgGameplayHandler.GetStaminaMax() - (((m_PlayerLoad - CfgGameplayHandler.GetStaminaWeightLimitThreshold())/GameConstants.STAMINA_KG_TO_GRAMS) * CfgGameplayHandler.GetStaminaKgToStaminaPercentPenalty())),CfgGameplayHandler.GetStaminaMinCap());
 }
 else
 {
 m_StaminaCap = CfgGameplayHandler.GetStaminaMax();
 }
 }
 
 // Calculates stamina gain/loss based on movement and load
 m_Player.GetMovementState(m_State);
 
 switch (m_State.m_CommandTypeId)
 {
 case DayZPlayerConstants.COMMANDID_MOVE:
 StaminaProcessor_Move(m_State);
 break;
 case DayZPlayerConstants.COMMANDID_LADDER:
 StaminaProcessor_Ladder(m_State);
 break;
 case DayZPlayerConstants.COMMANDID_SWIM:
 StaminaProcessor_Swimming(m_State);
 break;
 case DayZPlayerConstants.COMMANDID_FALL: 
 case DayZPlayerConstants.COMMANDID_MELEE2: 
 case DayZPlayerConstants.COMMANDID_CLIMB: 
 break;
 default:
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = GameConstants.STAMINA_GAIN_IDLE_PER_SEC;
 }
 break;
 }
 
 //Sets current stamina & stores + syncs data with client
 float temp = m_StaminaDelta * deltaT;
 if (temp < 0)
 {
 temp *= m_StaminaDepletionMultiplier;
 }
 else
 {
 temp *= m_StaminaRecoveryMultiplier;
 }
 
 m_Stamina = Math.Max(0, Math.Min((m_Stamina + temp), m_StaminaCap));
 m_Stamina = m_Stamina - m_StaminaDepletion;
 
 if (GetGame().IsServer() || !GetGame().IsMultiplayer())
 {
 m_Player.GetStatStamina().Set(m_Stamina);
 m_Time += deltaT;
 
 if (m_Time >= GameConstants.STAMINA_SYNC_RATE)
 {
 m_Time = 0;
 SetStamina(m_Stamina);
 }
 }
 
 #ifndef SERVER
 m_Player.SetStamina(m_StaminaSynced, m_StaminaCap);
 #endif
 
 ApplyExhaustion();
 CheckStaminaState();
 
 m_StaminaDelta = 0;
 m_StaminaDepletion = 0; // resets depletion modifier
 
 }
 }
 
 void OnRPC(float stamina, float stamina_cap, bool cooldown)
 {
 }
 
 void OnSyncJuncture(int pJunctureID, ParamsReadContext pCtx)
 {
 switch ( pJunctureID )
 {
 case DayZPlayerSyncJunctures.SJ_STAMINA:
 float stamina;
 float stamina_cap;
 bool cooldown;
 
 if (!pCtx.Read(stamina) || !pCtx.Read(stamina_cap) || !pCtx.Read(cooldown))
 {
 return;
 }
 
 m_Stamina = stamina; //?
 m_StaminaSynced = stamina;
 
 if (m_Player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
 {
 return;
 }
 
 if ( stamina_cap != m_StaminaCap )
 {
 m_StaminaCap = stamina_cap;
 }
 
 m_IsInCooldown = cooldown;
 m_Player.SetStamina(m_Stamina, m_StaminaCap);
 break;
 
 case DayZPlayerSyncJunctures.SJ_STAMINA_MISC:
 ReadAdditionalStaminaInfo(pCtx);
 break;
 }
 }
 
 protected void StaminaProcessor_Move(HumanMovementState pHumanMovementState)
 {
 switch (pHumanMovementState.m_iMovement)
 {
 case DayZPlayerConstants.MOVEMENTIDX_SPRINT: //sprint
 if (pHumanMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_ERECT)
 {
 m_StaminaDelta = -GameConstants.STAMINA_DRAIN_STANDING_SPRINT_PER_SEC * CfgGameplayHandler.GetSprintStaminaModifierErc();
 SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION);
 break;
 }
 else if ( pHumanMovementState.m_iStanceIdx == DayZPlayerConstants.STANCEIDX_CROUCH)
 {
 m_StaminaDelta = -GameConstants.STAMINA_DRAIN_CROUCHED_SPRINT_PER_SEC * CfgGameplayHandler.GetSprintStaminaModifierCro();
 SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION);
 break;
 }
 
 m_StaminaDelta = GameConstants.STAMINA_GAIN_JOG_PER_SEC;
 break;
 
 case DayZPlayerConstants.MOVEMENTIDX_RUN: //jog
 if (m_Player.GetCurrentWaterLevel() >= m_HumanMoveSettings.m_fWaterLevelSpeedRectrictionHigh)
 {
 m_StaminaDelta = -GameConstants.STAMINA_DRAIN_STANDING_SPRINT_PER_SEC * CfgGameplayHandler.GetSprintStaminaModifierErc();
 break;
 }
 
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = (GameConstants.STAMINA_GAIN_JOG_PER_SEC + CalcStaminaGainBonus());
 }
 break;
 
 case DayZPlayerConstants.MOVEMENTIDX_WALK: //walk
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = (GameConstants.STAMINA_GAIN_WALK_PER_SEC + CalcStaminaGainBonus());
 }
 break;
 
 case DayZPlayerConstants.MOVEMENTIDX_IDLE: //idle
 if (m_Player.IsRolling())
 {
 m_StaminaDelta = GameConstants.STAMINA_GAIN_ROLL_PER_SEC;
 break;
 }
 
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = (GameConstants.STAMINA_GAIN_IDLE_PER_SEC + CalcStaminaGainBonus());
 }
 break;
 
 default:
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = GameConstants.STAMINA_GAIN_IDLE_PER_SEC;
 }
 break;
 }
 }
 
 protected void StaminaProcessor_Ladder(HumanMovementState pHumanMovementState)
 {
 switch (pHumanMovementState.m_iMovement)
 {
 case 2: //climb up (fast)
 m_StaminaDelta = -GameConstants.STAMINA_DRAIN_LADDER_FAST_PER_SEC * CfgGameplayHandler.GetSprintLadderStaminaModifier();
 SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION);
 break;
 
 case 1: //climb up (slow)
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = (GameConstants.STAMINA_GAIN_LADDER_PER_SEC + CalcStaminaGainBonus());
 }
 break;
 
 default:
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = GameConstants.STAMINA_GAIN_IDLE_PER_SEC + CalcStaminaGainBonus();
 }
 break;
 }
 }
 
 protected void StaminaProcessor_Swimming(HumanMovementState pHumanMovementState)
 {
 switch (pHumanMovementState.m_iMovement)
 {
 case 3: //swim fast
 m_StaminaDelta = -GameConstants.STAMINA_DRAIN_SWIM_FAST_PER_SEC * CfgGameplayHandler.GetSprintSwimmingStaminaModifier();
 SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_DEPLETION);
 break;
 
 
 case 2: //swim slow
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = (GameConstants.STAMINA_GAIN_SWIM_PER_SEC + CalcStaminaGainBonus());
 }
 break;
 
 default:
 if (!m_IsInCooldown)
 {
 m_StaminaDelta = GameConstants.STAMINA_GAIN_IDLE_PER_SEC + CalcStaminaGainBonus();
 }
 break;
 }
 }
 
 protected void SyncStamina(float stamina, float stamina_cap, bool cooldown)
 {
 m_Player.GetStatStamina().Set(m_Stamina);
 ScriptJunctureData pCtx = new ScriptJunctureData();
 pCtx.Write(m_Stamina);
 pCtx.Write(m_StaminaCap);
 pCtx.Write(m_IsInCooldown);
 m_Player.SendSyncJuncture(DayZPlayerSyncJunctures.SJ_STAMINA,pCtx);
 }
 
 protected void SyncAdditionalStaminaInfo(Param par)
 {
 Param2<float,float> p = Param2<float,float>.Cast(par);
 
 ScriptJunctureData pCtx = new ScriptJunctureData();
 pCtx.Write(p.param1);
 pCtx.Write(p.param2);
 m_Player.SendSyncJuncture(DayZPlayerSyncJunctures.SJ_STAMINA_MISC,pCtx);
 }
 
 protected void ReadAdditionalStaminaInfo(ParamsReadContext pCtx)
 {
 float depletionMultiplier;
 float recoveryMultiplier;
 if (!pCtx.Read(depletionMultiplier) || !pCtx.Read(recoveryMultiplier))
 {
 return;
 }
 
 m_StaminaDepletionMultiplier = depletionMultiplier;
 m_StaminaRecoveryMultiplier = recoveryMultiplier;
 }
 
 protected void RegisterStaminaConsumers()
 {
 m_StaminaConsumers = new StaminaConsumers();
 
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.HOLD_BREATH,
 GameConstants.STAMINA_HOLD_BREATH_THRESHOLD_ACTIVATE,
 GameConstants.STAMINA_HOLD_BREATH_THRESHOLD_DRAIN,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.SPRINT,
 CfgGameplayHandler.GetStaminaMinCap() + 15,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.JUMP,
 GameConstants.STAMINA_JUMP_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.VAULT,
 GameConstants.STAMINA_VAULT_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.CLIMB,
 GameConstants.STAMINA_CLIMB_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.MELEE_HEAVY,
 GameConstants.STAMINA_MELEE_HEAVY_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.MELEE_EVADE,
 GameConstants.STAMINA_MELEE_EVADE_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(
 EStaminaConsumers.ROLL,
 GameConstants.STAMINA_ROLL_THRESHOLD,
 );
 m_StaminaConsumers.RegisterConsumer(EStaminaConsumers.DROWN, 0);
 m_StaminaConsumers.RegisterConsumer(EStaminaConsumers.PUSH, 0);
 }
 
 protected void RegisterStaminaModifiers()
 {
 m_StaminaModifiers = new StaminaModifiers();
 
 SMDataHoldBreath data = new SMDataHoldBreath();
 m_StaminaModifiers.RegisterExponentialEx(
 EStaminaModifiers.HOLD_BREATH,
 data,
 );
 m_StaminaModifiers.RegisterExponentialEx(
 EStaminaModifiers.PUSH_CAR,
 data,
 );
 m_StaminaModifiers.RegisterFixed(EStaminaModifiers.DROWN, 10);
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.JUMP,
 GameConstants.STAMINA_DRAIN_JUMP * CfgGameplayHandler.GetObstacleTraversalStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.VAULT,
 GameConstants.STAMINA_DRAIN_VAULT * CfgGameplayHandler.GetObstacleTraversalStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.CLIMB,
 GameConstants.STAMINA_DRAIN_CLIMB * CfgGameplayHandler.GetObstacleTraversalStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.MELEE_LIGHT,
 GameConstants.STAMINA_DRAIN_MELEE_LIGHT * CfgGameplayHandler.GetMeleeStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.MELEE_HEAVY,
 GameConstants.STAMINA_DRAIN_MELEE_HEAVY * CfgGameplayHandler.GetMeleeStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(
 EStaminaModifiers.OVERALL_DRAIN,
 CfgGameplayHandler.GetStaminaMax(),
 5.0,
 );
 m_StaminaModifiers.RegisterRandomized(
 EStaminaModifiers.MELEE_EVADE,
 3 * CfgGameplayHandler.GetMeleeStaminaModifier(),
 GameConstants.STAMINA_DRAIN_MELEE_EVADE * CfgGameplayHandler.GetMeleeStaminaModifier(),
 );
 m_StaminaModifiers.RegisterFixed(EStaminaModifiers.ROLL, GameConstants.STAMINA_DRAIN_ROLL);
 }
 
 protected float CalcStaminaGainBonus()
 {
 if (m_StaminaDepletion > 0)
 return 0;
 
 if (m_Stamina > 25)
 return Math.Min((m_Stamina/10),GameConstants.STAMINA_GAIN_BONUS_CAP); // exp version
 else
 return GameConstants.STAMINA_GAIN_BONUS_CAP; // linear version
 }
 
 protected void ApplyExhaustion()
 {
 HumanCommandAdditives ad = m_Player.GetCommandModifier_Additives();
 
 float exhaustion_value = 1;
 if (m_StaminaCap != 0)
 {
 exhaustion_value = 1 - ((m_Stamina / (m_StaminaCap * 0.01)) * 0.01);
 }
 
 exhaustion_value = Math.Min(1, exhaustion_value);
 if (ad)
 {
 // do not apply exhaustion on local client if player is in ADS/Optics (camera shakes)
 if (m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT && (m_Player.IsInOptics() || m_Player.IsInIronsights()))
 {
 ad.SetExhaustion(0, true);
 }
 else
 {
 ad.SetExhaustion(exhaustion_value, true);
 }
 }
 }
 
 protected void CheckStaminaState()
 {
 if (m_Stamina <= 0)
 {
 m_StaminaDepleted = true;
 if (!m_IsInCooldown)
 {
 // set this only once
 SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_EXHAUSTION); 
 }
 }
 else
 {
 m_StaminaDepleted = false;
 }
 }
 
 protected void SetCooldown(float time, int modifier = -1)
 {
 if ( m_StaminaDepleted || m_Stamina <= 0.0 )
 {
 ResetCooldown(modifier);
 return;
 }
 
 m_IsInCooldown = true;
 
 Timer timer;
 if (m_TimerMap.Find(modifier, timer) && timer.IsRunning())
 {
 timer.Stop();
 }
 else
 {
 timer = new ref Timer;
 m_TimerMap.Set(modifier,timer);
 }
 timer.Run(time, this, "ResetCooldown", new Param1<int>( modifier ));
 //Print(m_TimerMap.Count());
 }
 
 protected void ResetCooldown(int modifier = -1)
 {
 StaminaModifier sm = m_StaminaModifiers.GetModifierData(modifier);
 if (sm)
 {
 //Print(modifier);
 //Error("Error: No StaminaModifier found! | StaminaHandler | ResetCooldown");
 sm.SetStartTime(-1);
 sm.ResetRunTime();
 sm.SetInUse(false);
 }
 m_IsInCooldown = false;
 }
 
 Timer GetCooldownTimer(int modifier)
 {
 
 }
 
 // ---------------------------------------------------
 bool HasEnoughStaminaFor(EStaminaConsumers consumer)
 {
 return m_StaminaConsumers.HasEnoughStaminaFor(consumer, m_Stamina, m_StaminaDepleted, m_StaminaCap);
 }
 
 bool HasEnoughStaminaToStart(EStaminaConsumers consumer)
 {
 return m_StaminaConsumers.HasEnoughStaminaToStart(consumer, m_Stamina, m_StaminaDepleted, m_StaminaCap);
 }
 
 void SetStamina(float stamina_value)
 {
 m_Stamina = Math.Clamp(stamina_value, 0, CfgGameplayHandler.GetStaminaMax());
 SyncStamina(m_Stamina, m_StaminaCap, m_IsInCooldown);
 }
 
 float GetStamina()
 {
 return m_Stamina;
 }
 
 float GetStaminaNormalized()
 {
 return m_Stamina / GetStaminaMax();
 }
 
 float GetSyncedStamina()
 {
 return m_StaminaSynced;
 }
 
 float GetSyncedStaminaNormalized()
 {
 return GetSyncedStamina() / GetStaminaMax();
 }
 
 float GetStaminaCap()
 {
 return m_StaminaCap;
 }
 
 float GetStaminaMax()
 {
 return CfgGameplayHandler.GetStaminaMax();
 }
 
 //obsolete, use ActivateDepletionModifier/DeactivateDepletionModifier instead
 void SetDepletionMultiplier(float val)
 {
 if (m_StaminaDepletionMultiplier < 0)
 m_StaminaDepletionMultiplier = 0;
 m_StaminaDepletionMultiplier = val;
 SyncAdditionalStaminaInfo(new Param2<float,float>(m_StaminaDepletionMultiplier,m_StaminaRecoveryMultiplier));
 }
 //obsolete, use ActivateRecoveryModifier/DeactivateRecoveryModifier instead
 void SetRecoveryMultiplier(float val)
 {
 if (m_StaminaRecoveryMultiplier < 0)
 m_StaminaRecoveryMultiplier = 0;
 m_StaminaRecoveryMultiplier = val;
 SyncAdditionalStaminaInfo(new Param2<float,float>(m_StaminaDepletionMultiplier,m_StaminaRecoveryMultiplier));
 }
 
 float GetDepletionMultiplier()
 {
 return m_StaminaDepletionMultiplier;
 }
 
 float GetRecoveryMultiplier()
 {
 return m_StaminaRecoveryMultiplier;
 }
 
 void DepleteStamina(EStaminaModifiers modifier, float dT = -1)
 {
 #ifdef DIAG_DEVELOPER
 if (m_StaminaDisabled)
 return;
 #endif
 float val = 0.0;
 float current_time = m_Player.GetSimulationTimeStamp();
 float valueProgress;
 StaminaModifier sm = m_StaminaModifiers.GetModifierData(modifier);
 
 // select by modifier type and drain stamina
 switch (sm.GetType())
 {
 case m_StaminaModifiers.FIXED:
 if (dT == -1)
 {
 dT = 1;
 }
 m_StaminaDepletion = m_StaminaDepletion + sm.GetMaxValue() * dT;
 
 break;
 
 case m_StaminaModifiers.RANDOMIZED:
 val = Math.RandomFloat(sm.GetMinValue(), sm.GetMaxValue());
 m_StaminaDepletion = m_StaminaDepletion + val;
 
 break;
 
 case m_StaminaModifiers.LINEAR:
 if (!sm.IsInUse())
 {
 sm.SetStartTime(current_time + sm.GetStartTimeAdjustment()/dT);
 sm.SetRunTimeTick(dT);
 sm.SetInUse(true);
 }
 valueProgress = Math.Clamp((current_time - sm.GetStartTime())/sm.GetDurationAdjusted(), 0, 1 );
 val = Math.Lerp(sm.GetMinValue(), sm.GetMaxValue(), valueProgress);
 m_StaminaDepletion = m_StaminaDepletion + val;
 
 break;
 
 case m_StaminaModifiers.EXPONENTIAL:
 StaminaModifierExponential smex;
 if (!Class.CastTo(smex,sm))
 {
 ErrorEx("StaminaModifierExponential not found for modifier type: " + sm.GetType());
 break;
 }
 
 if (!smex.IsInUse())
 {
 smex.SetStartTime(current_time + smex.GetStartTimeAdjustment()/dT);
 smex.SetRunTimeTick(dT);
 smex.SetInUse(true);
 }
 valueProgress = Math.Clamp((current_time - smex.GetStartTime())/smex.GetDurationAdjusted(), 0, 1 );
 float exp;
 if (Math.AbsFloat(smex.GetBaseValue()) < 1)
 {
 exp = 1 - Math.Lerp(0, smex.GetExponent(), valueProgress);
 val = Math.Pow(smex.GetBaseValue(),exp);
 }
 else
 {
 exp = Math.Lerp(Math.Min(0, smex.GetExponent()), Math.Max(0, smex.GetExponent()), valueProgress);
 val = Math.Pow(smex.GetBaseValue(),exp) + smex.GetBaseValue() - 1;
 }
 
 m_StaminaDepletion = m_StaminaDepletion + val;
 m_StaminaDepletion *= smex.GetMultiplier();
 
 break;
 }
 
 SetCooldown(sm.GetCooldown(),modifier);
 m_StaminaDepletion = Math.Clamp(m_StaminaDepletion, 0, CfgGameplayHandler.GetStaminaMax());
 
 m_StaminaDepletion = m_StaminaDepletion * m_StaminaDepletionMultiplier;
 }
 
 #ifdef DIAG_DEVELOPER
 void SetStaminaDisabled(bool value)
 {
 m_StaminaDisabled = value;
 }
 #endif
}