StaminaHandler Class Reference

Collaboration diagram for StaminaHandler:

Protected Member Functions
void	StaminaHandler (PlayerBase player)
void	Init ()
void	ActivateDepletionModifier (EStaminaMultiplierTypes type)
void	DeactivateDepletionModifier (EStaminaMultiplierTypes type)
void	RecalculateDepletionMultiplier ()
void	ActivateRecoveryModifier (EStaminaMultiplierTypes type)
void	DeactivateRecoveryModifier (EStaminaMultiplierTypes type)
void	RecalculateRecoveryMultiplier ()
void	Update (float deltaT, int pCurrentCommandID)
void	OnRPC (float stamina, float stamina_cap, bool cooldown)
	deprecated use, StaminaHandler uses SyncJunctures now
void	OnSyncJuncture (int pJunctureID, ParamsReadContext pCtx)
	called from PlayerBase - syncs stamina values on server with client AND sets the value to match on server and client both (m_StaminaSynced guarantees identical values)
void	StaminaProcessor_Move (HumanMovementState pHumanMovementState)
void	StaminaProcessor_Ladder (HumanMovementState pHumanMovementState)
void	StaminaProcessor_Swimming (HumanMovementState pHumanMovementState)
void	SyncStamina (float stamina, float stamina_cap, bool cooldown)
	stamina sync - server part
void	SyncAdditionalStaminaInfo (Param par)
	Method to sync more info for stamina manager. Template parameter means it is very extendable for further use.
void	ReadAdditionalStaminaInfo (ParamsReadContext pCtx)
	Order of read parameters must match the order of writing above.
void	RegisterStaminaConsumers ()
void	RegisterStaminaModifiers ()
float	CalcStaminaGainBonus ()
	Calulates stamina regain bonus coef based on current stamina cap and level.
void	ApplyExhaustion ()
void	CheckStaminaState ()
	check if the stamina is completely depleted
void	SetCooldown (float time, int modifier=-1)
	set cooldown timer between each consume of stamina
void	ResetCooldown (int modifier=-1)
Timer	GetCooldownTimer (int modifier)
bool	HasEnoughStaminaFor (EStaminaConsumers consumer)
bool	HasEnoughStaminaToStart (EStaminaConsumers consumer)
void	SetStamina (float stamina_value)
float	GetStamina ()
float	GetStaminaNormalized ()
float	GetSyncedStamina ()
float	GetSyncedStaminaNormalized ()
float	GetStaminaCap ()
float	GetStaminaMax ()
void	SetDepletionMultiplier (float val)
void	SetRecoveryMultiplier (float val)
float	GetDepletionMultiplier ()
float	GetRecoveryMultiplier ()
void	DepleteStamina (EStaminaModifiers modifier, float dT=-1)

Protected Attributes
float	m_PlayerLoad
float	m_StaminaDelta
float	m_Stamina
float	m_StaminaSynced
float	m_StaminaCap
float	m_StaminaDepletion
float	m_StaminaDepletionMultiplier
float	m_StaminaRecoveryMultiplier
float	m_Time
ref Param3< float, float, bool >	m_StaminaParams
ref HumanMovementState	m_State
SHumanCommandMoveSettings	m_HumanMoveSettings
PlayerBase	m_Player
bool	m_Debug
bool	m_StaminaDepleted
	DEPRECATED.
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
bool	m_IsInCooldown
ref StaminaConsumers	m_StaminaConsumers
ref StaminaModifiers	m_StaminaModifiers

Detailed Description

Definition at line 258 of file StaminaHandler.c.

Constructor & Destructor Documentation

StaminaHandler()

void StaminaHandler::StaminaHandler ( PlayerBase player )

inlineprotected

Definition at line 293 of file StaminaHandler.c.

  {
    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();
  }

References GetGame(), CfgGameplayHandler::GetStaminaMax(), Init(), m_ActiveDepletionModifiers, m_ActiveRecoveryModifiers, m_HumanMoveSettings, m_IsInCooldown, m_Player, m_RegisteredDepletionModifiers, m_RegisteredRecoveryModifiers, m_Stamina, m_StaminaCap, m_StaminaDepleted, m_StaminaDepletion, m_StaminaDepletionMultiplier, m_StaminaParams, m_StaminaRecoveryMultiplier, m_State, m_Time, m_TimerMap, RegisterStaminaConsumers(), and RegisterStaminaModifiers().

Member Function Documentation

ActivateDepletionModifier()

void StaminaHandler::ActivateDepletionModifier ( EStaminaMultiplierTypes type )

inlineprotected

Definition at line 341 of file StaminaHandler.c.

  {
    if (m_RegisteredDepletionModifiers.Contains(type))
    {
      m_ActiveDepletionModifiers.Insert(type);
      RecalculateDepletionMultiplier();
    }
    else
      Error("attempting to activate unregistered depletion modifier");
  }

References Error(), m_ActiveDepletionModifiers, m_RegisteredDepletionModifiers, and RecalculateDepletionMultiplier().

ActivateRecoveryModifier()

void StaminaHandler::ActivateRecoveryModifier ( EStaminaMultiplierTypes type )

inlineprotected

Definition at line 373 of file StaminaHandler.c.

  {
    if (m_RegisteredRecoveryModifiers.Contains(type))
    {
      m_ActiveRecoveryModifiers.Insert(type);
      RecalculateRecoveryMultiplier();
    }
    else
      Error("attempting to activate unregistered recovery modifier");
  }

References Error(), m_ActiveRecoveryModifiers, m_RegisteredRecoveryModifiers, and RecalculateRecoveryMultiplier().

ApplyExhaustion()

void StaminaHandler::ApplyExhaustion ( )

inlineprotected

sets exhaustion look of player based on stamina level

Definition at line 755 of file StaminaHandler.c.

  {
    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);
    }
  }

References HumanCommandAdditives(), m_Player, m_Stamina, m_StaminaCap, and Math::Min().

Referenced by Update().

CalcStaminaGainBonus()

float StaminaHandler::CalcStaminaGainBonus ( )

inlineprotected

Calulates stamina regain bonus coef based on current stamina cap and level.

Definition at line 744 of file StaminaHandler.c.

  {
    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
  }

References m_Stamina, m_StaminaDepletion, Math::Min(), and GameConstants::STAMINA_GAIN_BONUS_CAP.

Referenced by StaminaProcessor_Ladder(), StaminaProcessor_Move(), and StaminaProcessor_Swimming().

CheckStaminaState()

void StaminaHandler::CheckStaminaState ( )

inlineprotected

check if the stamina is completely depleted

in case of complete depletion - start a cooldown timer before the regeneration cycle start

Definition at line 776 of file StaminaHandler.c.

  {
    if (m_Stamina <= 0)
    {
      m_StaminaDepleted = true;
      if (!m_IsInCooldown)
      {
        // set this only once
        SetCooldown(GameConstants.STAMINA_REGEN_COOLDOWN_EXHAUSTION);
      }
    }
    else
      m_StaminaDepleted = false;
  }

References m_IsInCooldown, m_Stamina, m_StaminaDepleted, SetCooldown(), and GameConstants::STAMINA_REGEN_COOLDOWN_EXHAUSTION.

Referenced by Update().

DeactivateDepletionModifier()

void StaminaHandler::DeactivateDepletionModifier ( EStaminaMultiplierTypes type )

inlineprotected

Definition at line 352 of file StaminaHandler.c.

  {
    int index = m_ActiveDepletionModifiers.Find(type);
    if (index != -1)
    {
      m_ActiveDepletionModifiers.Remove(index);
      RecalculateDepletionMultiplier();
    }
  }

References m_ActiveDepletionModifiers, and RecalculateDepletionMultiplier().

DeactivateRecoveryModifier()

void StaminaHandler::DeactivateRecoveryModifier ( EStaminaMultiplierTypes type )

inlineprotected

Definition at line 385 of file StaminaHandler.c.

  {
    int index = m_ActiveRecoveryModifiers.Find(type);
    if (index != -1)
    {
      m_ActiveRecoveryModifiers.Remove(index);
      RecalculateRecoveryMultiplier();
    }
  }

References m_ActiveRecoveryModifiers, and RecalculateRecoveryMultiplier().

DepleteStamina()

void StaminaHandler::DepleteStamina ( EStaminaModifiers modifier, float dT = -1 )

inlineprotected

run cooldown right after depletion

Definition at line 908 of file StaminaHandler.c.

  {
#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;
  }

References Math::AbsFloat(), Class::CastTo(), Math::Clamp(), ErrorEx, CfgGameplayHandler::GetStaminaMax(), Math::Lerp(), m_Player, m_StaminaDepletion, m_StaminaDepletionMultiplier, m_StaminaModifiers, Math::Max(), Math::Min(), Math::Pow(), Math::RandomFloat(), and SetCooldown().

GetCooldownTimer()

Timer StaminaHandler::GetCooldownTimer ( int modifier )

inlineprotected

Definition at line 829 of file StaminaHandler.c.

  {
 
  }

GetDepletionMultiplier()

float StaminaHandler::GetDepletionMultiplier ( )

inlineprotected

Definition at line 898 of file StaminaHandler.c.

  {
    return m_StaminaDepletionMultiplier;
  }

References m_StaminaDepletionMultiplier.

GetRecoveryMultiplier()

float StaminaHandler::GetRecoveryMultiplier ( )

inlineprotected

Definition at line 903 of file StaminaHandler.c.

  {
    return m_StaminaRecoveryMultiplier;
  }

References m_StaminaRecoveryMultiplier.

GetStamina()

float StaminaHandler::GetStamina ( )

inlineprotected

Definition at line 851 of file StaminaHandler.c.

  {
    return m_Stamina;
  }

References m_Stamina.

GetStaminaCap()

float StaminaHandler::GetStaminaCap ( )

inlineprotected

Definition at line 871 of file StaminaHandler.c.

  {
    return m_StaminaCap;
  }

References m_StaminaCap.

GetStaminaMax()

float StaminaHandler::GetStaminaMax ( )

inlineprotected

Definition at line 876 of file StaminaHandler.c.

  {
    return CfgGameplayHandler.GetStaminaMax();
  }

References CfgGameplayHandler::GetStaminaMax().

Referenced by GetStaminaNormalized(), and GetSyncedStaminaNormalized().

GetStaminaNormalized()

float StaminaHandler::GetStaminaNormalized ( )

inlineprotected

Definition at line 856 of file StaminaHandler.c.

  {
    return m_Stamina / GetStaminaMax();
  }

References GetStaminaMax(), and m_Stamina.

GetSyncedStamina()

float StaminaHandler::GetSyncedStamina ( )

inlineprotected

Definition at line 861 of file StaminaHandler.c.

  {
    return m_StaminaSynced;
  }

References m_StaminaSynced.

Referenced by GetSyncedStaminaNormalized().

GetSyncedStaminaNormalized()

float StaminaHandler::GetSyncedStaminaNormalized ( )

inlineprotected

Definition at line 866 of file StaminaHandler.c.

  {
    return GetSyncedStamina() / GetStaminaMax();
  }

References GetStaminaMax(), and GetSyncedStamina().

HasEnoughStaminaFor()

bool StaminaHandler::HasEnoughStaminaFor ( EStaminaConsumers consumer )

inlineprotected

Definition at line 835 of file StaminaHandler.c.

  {
    return m_StaminaConsumers.HasEnoughStaminaFor(consumer, m_Stamina, m_StaminaDepleted, m_StaminaCap);
  }

References m_Stamina, m_StaminaCap, m_StaminaConsumers, and m_StaminaDepleted.

HasEnoughStaminaToStart()

bool StaminaHandler::HasEnoughStaminaToStart ( EStaminaConsumers consumer )

inlineprotected

Definition at line 840 of file StaminaHandler.c.

  {
    return m_StaminaConsumers.HasEnoughStaminaToStart(consumer, m_Stamina, m_StaminaDepleted, m_StaminaCap);
  }

References m_Stamina, m_StaminaCap, m_StaminaConsumers, and m_StaminaDepleted.

Init()

void StaminaHandler::Init ( )

inlineprotected

Definition at line 327 of file StaminaHandler.c.

  {
    //----------------- 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);
 
  }

References m_RegisteredDepletionModifiers, m_RegisteredRecoveryModifiers, MaskMdfr::STAMINA_DEPLETION_MODIFIER, FatigueMdfr::STAMINA_DEPLETION_MULTIPLIER, EpinephrineMdfr::STAMINA_DEPLETION_MULTIPLIER, MaskMdfr::STAMINA_RECOVERY_MODIFIER, FatigueMdfr::STAMINA_RECOVERY_MULTIPLIER, and DrowningMdfr::STAMINA_RECOVERY_MULTIPLIER.

Referenced by StaminaHandler().

OnRPC()

void StaminaHandler::OnRPC ( float stamina, float stamina_cap, bool cooldown )

inlineprotected

deprecated use, StaminaHandler uses SyncJunctures now

Definition at line 487 of file StaminaHandler.c.

  {
  }

OnSyncJuncture()

void StaminaHandler::OnSyncJuncture ( int pJunctureID, ParamsReadContext pCtx )

inlineprotected

called from PlayerBase - syncs stamina values on server with client AND sets the value to match on server and client both (m_StaminaSynced guarantees identical values)

Definition at line 492 of file StaminaHandler.c.

  {
    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;
    }
  }

References m_IsInCooldown, m_Player, m_Stamina, m_StaminaCap, m_StaminaSynced, ReadAdditionalStaminaInfo(), DayZPlayerSyncJunctures::SJ_STAMINA, and DayZPlayerSyncJunctures::SJ_STAMINA_MISC.

Referenced by ManBase::OnSyncJuncture().

ReadAdditionalStaminaInfo()

void StaminaHandler::ReadAdditionalStaminaInfo ( ParamsReadContext pCtx )

inlineprotected

Order of read parameters must match the order of writing above.

Definition at line 644 of file StaminaHandler.c.

  {
    float depletionMultiplier;
    float recoveryMultiplier;
    if (!pCtx.Read(depletionMultiplier) || !pCtx.Read(recoveryMultiplier))
      return;
 
    m_StaminaDepletionMultiplier = depletionMultiplier;
    m_StaminaRecoveryMultiplier = recoveryMultiplier;
  }

References m_StaminaDepletionMultiplier, and m_StaminaRecoveryMultiplier.

Referenced by OnSyncJuncture().

RecalculateDepletionMultiplier()

void StaminaHandler::RecalculateDepletionMultiplier ( )

inlineprotected

Definition at line 362 of file StaminaHandler.c.

  {
    float value = 1;
 
    foreach (int multiplier: m_ActiveDepletionModifiers)
      value *= m_RegisteredDepletionModifiers.Get(multiplier);
 
    if (value != m_StaminaDepletionMultiplier)
      SetDepletionMultiplier(value);
  }

References m_ActiveDepletionModifiers, m_RegisteredDepletionModifiers, m_StaminaDepletionMultiplier, and SetDepletionMultiplier().

Referenced by ActivateDepletionModifier(), and DeactivateDepletionModifier().

RecalculateRecoveryMultiplier()

void StaminaHandler::RecalculateRecoveryMultiplier ( )

inlineprotected

Definition at line 395 of file StaminaHandler.c.

  {
    float value = 1;
 
    foreach (int multiplier: m_ActiveRecoveryModifiers)
      value *= m_RegisteredRecoveryModifiers.Get(multiplier);
 
    if (value != m_StaminaRecoveryMultiplier)
      SetRecoveryMultiplier(value);
  }

References m_ActiveRecoveryModifiers, m_RegisteredRecoveryModifiers, m_StaminaRecoveryMultiplier, and SetRecoveryMultiplier().

Referenced by ActivateRecoveryModifier(), and DeactivateRecoveryModifier().

RegisterStaminaConsumers()

void StaminaHandler::RegisterStaminaConsumers ( )

inlineprotected

Definition at line 655 of file StaminaHandler.c.

  {
    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);
  }

References CfgGameplayHandler::GetStaminaMinCap(), m_StaminaConsumers, GameConstants::STAMINA_CLIMB_THRESHOLD, GameConstants::STAMINA_HOLD_BREATH_THRESHOLD_ACTIVATE, GameConstants::STAMINA_HOLD_BREATH_THRESHOLD_DRAIN, GameConstants::STAMINA_JUMP_THRESHOLD, GameConstants::STAMINA_MELEE_EVADE_THRESHOLD, GameConstants::STAMINA_MELEE_HEAVY_THRESHOLD, GameConstants::STAMINA_ROLL_THRESHOLD, GameConstants::STAMINA_VAULT_THRESHOLD, and StaminaConsumers().

Referenced by StaminaHandler().

RegisterStaminaModifiers()

void StaminaHandler::RegisterStaminaModifiers ( )

inlineprotected

Definition at line 696 of file StaminaHandler.c.

  {
    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);
  }

References CfgGameplayHandler::GetMeleeStaminaModifier(), CfgGameplayHandler::GetObstacleTraversalStaminaModifier(), CfgGameplayHandler::GetStaminaMax(), m_StaminaModifiers, GameConstants::STAMINA_DRAIN_CLIMB, GameConstants::STAMINA_DRAIN_JUMP, GameConstants::STAMINA_DRAIN_MELEE_EVADE, GameConstants::STAMINA_DRAIN_MELEE_HEAVY, GameConstants::STAMINA_DRAIN_MELEE_LIGHT, GameConstants::STAMINA_DRAIN_ROLL, GameConstants::STAMINA_DRAIN_VAULT, and StaminaModifiers().

Referenced by StaminaHandler().

ResetCooldown()

void StaminaHandler::ResetCooldown ( int modifier = -1 )

inlineprotected

Definition at line 815 of file StaminaHandler.c.

  {
    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;
  }

References m_IsInCooldown, and m_StaminaModifiers.

Referenced by SetCooldown().

SetCooldown()

void StaminaHandler::SetCooldown ( float time, int modifier = -1 )

inlineprotected

set cooldown timer between each consume of stamina

Definition at line 793 of file StaminaHandler.c.

  {
    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());
  }

References m_IsInCooldown, m_Stamina, m_StaminaDepleted, m_TimerMap, and ResetCooldown().

Referenced by CheckStaminaState(), DepleteStamina(), StaminaProcessor_Ladder(), StaminaProcessor_Move(), and StaminaProcessor_Swimming().

SetDepletionMultiplier()

void StaminaHandler::SetDepletionMultiplier ( float val )

inlineprotected

Definition at line 882 of file StaminaHandler.c.

  {
    if (m_StaminaDepletionMultiplier < 0)
      m_StaminaDepletionMultiplier = 0;
    m_StaminaDepletionMultiplier = val;
    SyncAdditionalStaminaInfo(new Param2<float, float>(m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier));
  }

References m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier, and SyncAdditionalStaminaInfo().

Referenced by RecalculateDepletionMultiplier().

SetRecoveryMultiplier()

void StaminaHandler::SetRecoveryMultiplier ( float val )

inlineprotected

Definition at line 890 of file StaminaHandler.c.

  {
    if (m_StaminaRecoveryMultiplier < 0)
      m_StaminaRecoveryMultiplier = 0;
    m_StaminaRecoveryMultiplier = val;
    SyncAdditionalStaminaInfo(new Param2<float, float>(m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier));
  }

References m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier, and SyncAdditionalStaminaInfo().

Referenced by RecalculateRecoveryMultiplier().

SetStamina()

void StaminaHandler::SetStamina ( float stamina_value )

inlineprotected

Definition at line 845 of file StaminaHandler.c.

  {
    m_Stamina = Math.Clamp(stamina_value, 0, CfgGameplayHandler.GetStaminaMax());
    SyncStamina(m_Stamina, m_StaminaCap, m_IsInCooldown);
  }

References Math::Clamp(), CfgGameplayHandler::GetStaminaMax(), m_IsInCooldown, m_Stamina, m_StaminaCap, and SyncStamina().

Referenced by ManBase::EEHitBy(), ManBase::ResetPlayer(), and Update().

StaminaProcessor_Ladder()

void StaminaHandler::StaminaProcessor_Ladder ( HumanMovementState pHumanMovementState )

inlineprotected

Definition at line 578 of file StaminaHandler.c.

  {
    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;
    }
  }

References CalcStaminaGainBonus(), CfgGameplayHandler::GetSprintLadderStaminaModifier(), m_IsInCooldown, m_StaminaDelta, SetCooldown(), GameConstants::STAMINA_DRAIN_LADDER_FAST_PER_SEC, GameConstants::STAMINA_GAIN_IDLE_PER_SEC, GameConstants::STAMINA_GAIN_LADDER_PER_SEC, and GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Referenced by Update().

StaminaProcessor_Move()

void StaminaHandler::StaminaProcessor_Move ( HumanMovementState pHumanMovementState )

inlineprotected

Definition at line 523 of file StaminaHandler.c.

  {
    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;
    }
  }

References CalcStaminaGainBonus(), CfgGameplayHandler::GetSprintStaminaModifierCro(), CfgGameplayHandler::GetSprintStaminaModifierErc(), m_HumanMoveSettings, m_IsInCooldown, m_Player, m_StaminaDelta, SetCooldown(), GameConstants::STAMINA_DRAIN_CROUCHED_SPRINT_PER_SEC, GameConstants::STAMINA_DRAIN_STANDING_SPRINT_PER_SEC, GameConstants::STAMINA_GAIN_IDLE_PER_SEC, GameConstants::STAMINA_GAIN_JOG_PER_SEC, GameConstants::STAMINA_GAIN_ROLL_PER_SEC, GameConstants::STAMINA_GAIN_WALK_PER_SEC, and GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Referenced by Update().

StaminaProcessor_Swimming()

void StaminaHandler::StaminaProcessor_Swimming ( HumanMovementState pHumanMovementState )

inlineprotected

Definition at line 599 of file StaminaHandler.c.

  {
    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;
    }
  }

References CalcStaminaGainBonus(), CfgGameplayHandler::GetSprintSwimmingStaminaModifier(), m_IsInCooldown, m_StaminaDelta, SetCooldown(), GameConstants::STAMINA_DRAIN_SWIM_FAST_PER_SEC, GameConstants::STAMINA_GAIN_IDLE_PER_SEC, GameConstants::STAMINA_GAIN_SWIM_PER_SEC, and GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Referenced by Update().

SyncAdditionalStaminaInfo()

void StaminaHandler::SyncAdditionalStaminaInfo ( Param par )

inlineprotected

Method to sync more info for stamina manager. Template parameter means it is very extendable for further use.

Definition at line 633 of file StaminaHandler.c.

  {
    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);
  }

References m_Player, and DayZPlayerSyncJunctures::SJ_STAMINA_MISC.

Referenced by SetDepletionMultiplier(), and SetRecoveryMultiplier().

SyncStamina()

void StaminaHandler::SyncStamina ( float stamina, float stamina_cap, bool cooldown )

inlineprotected

stamina sync - server part

Definition at line 622 of file StaminaHandler.c.

  {
    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);
  }

References m_IsInCooldown, m_Player, m_Stamina, m_StaminaCap, and DayZPlayerSyncJunctures::SJ_STAMINA.

Referenced by SetStamina().

Update()

void StaminaHandler::Update ( float deltaT, int pCurrentCommandID )

inlineprotected

gets the actual players load

StaminaCap calculation starts when PlayerLoad exceeds STAMINA_WEIGHT_LIMIT_THRESHOLD

processed on event

processed on event

processed on event

Definition at line 406 of file StaminaHandler.c.

  {
#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
 
    }
  }

References ApplyExhaustion(), CheckStaminaState(), GetGame(), CfgGameplayHandler::GetStaminaKgToStaminaPercentPenalty(), CfgGameplayHandler::GetStaminaMax(), CfgGameplayHandler::GetStaminaMinCap(), CfgGameplayHandler::GetStaminaWeightLimitThreshold(), m_IsInCooldown, m_Player, m_PlayerLoad, m_Stamina, m_StaminaCap, m_StaminaDelta, m_StaminaDepletion, m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier, m_StaminaSynced, m_State, m_Time, Math::Max(), Math::Min(), SetStamina(), GameConstants::STAMINA_GAIN_IDLE_PER_SEC, GameConstants::STAMINA_KG_TO_GRAMS, GameConstants::STAMINA_SYNC_RATE, StaminaProcessor_Ladder(), StaminaProcessor_Move(), and StaminaProcessor_Swimming().

Referenced by ManBase::CommandHandler().

Member Data Documentation

m_ActiveDepletionModifiers

ref set<EStaminaMultiplierTypes> StaminaHandler::m_ActiveDepletionModifiers

protected

Definition at line 279 of file StaminaHandler.c.

Referenced by ActivateDepletionModifier(), DeactivateDepletionModifier(), RecalculateDepletionMultiplier(), and StaminaHandler().

m_ActiveRecoveryModifiers

ref set<EStaminaMultiplierTypes> StaminaHandler::m_ActiveRecoveryModifiers

protected

Definition at line 282 of file StaminaHandler.c.

Referenced by ActivateRecoveryModifier(), DeactivateRecoveryModifier(), RecalculateRecoveryMultiplier(), and StaminaHandler().

m_Debug

bool StaminaHandler::m_Debug

protected

Definition at line 274 of file StaminaHandler.c.

m_HumanMoveSettings

SHumanCommandMoveSettings StaminaHandler::m_HumanMoveSettings

protected

Definition at line 271 of file StaminaHandler.c.

Referenced by StaminaHandler(), and StaminaProcessor_Move().

m_IsInCooldown

bool StaminaHandler::m_IsInCooldown

protected

Definition at line 284 of file StaminaHandler.c.

Referenced by CheckStaminaState(), OnSyncJuncture(), ResetCooldown(), SetCooldown(), SetStamina(), StaminaHandler(), StaminaProcessor_Ladder(), StaminaProcessor_Move(), StaminaProcessor_Swimming(), SyncStamina(), and Update().

m_Player

PlayerBase StaminaHandler::m_Player

protected

Definition at line 272 of file StaminaHandler.c.

Referenced by ApplyExhaustion(), DepleteStamina(), OnSyncJuncture(), StaminaHandler(), StaminaProcessor_Move(), SyncAdditionalStaminaInfo(), SyncStamina(), and Update().

m_PlayerLoad

float StaminaHandler::m_PlayerLoad

protected

Definition at line 260 of file StaminaHandler.c.

Referenced by Update().

m_RegisteredDepletionModifiers

ref map<EStaminaMultiplierTypes, float> StaminaHandler::m_RegisteredDepletionModifiers

protected

Definition at line 278 of file StaminaHandler.c.

Referenced by ActivateDepletionModifier(), Init(), RecalculateDepletionMultiplier(), and StaminaHandler().

m_RegisteredRecoveryModifiers

ref map<EStaminaMultiplierTypes, float> StaminaHandler::m_RegisteredRecoveryModifiers

protected

Definition at line 281 of file StaminaHandler.c.

Referenced by ActivateRecoveryModifier(), Init(), RecalculateRecoveryMultiplier(), and StaminaHandler().

m_Stamina

float StaminaHandler::m_Stamina

protected

Definition at line 262 of file StaminaHandler.c.

Referenced by ApplyExhaustion(), CalcStaminaGainBonus(), CheckStaminaState(), GetStamina(), GetStaminaNormalized(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), OnSyncJuncture(), SetCooldown(), SetStamina(), StaminaHandler(), SyncStamina(), and Update().

m_StaminaCap

float StaminaHandler::m_StaminaCap

protected

Definition at line 264 of file StaminaHandler.c.

Referenced by ApplyExhaustion(), GetStaminaCap(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), OnSyncJuncture(), SetStamina(), StaminaHandler(), SyncStamina(), and Update().

m_StaminaConsumers

ref StaminaConsumers StaminaHandler::m_StaminaConsumers

protected

Definition at line 286 of file StaminaHandler.c.

Referenced by HasEnoughStaminaFor(), HasEnoughStaminaToStart(), and RegisterStaminaConsumers().

m_StaminaDelta

float StaminaHandler::m_StaminaDelta

protected

Definition at line 261 of file StaminaHandler.c.

Referenced by StaminaProcessor_Ladder(), StaminaProcessor_Move(), StaminaProcessor_Swimming(), and Update().

m_StaminaDepleted

bool StaminaHandler::m_StaminaDepleted

protected

DEPRECATED.

Definition at line 275 of file StaminaHandler.c.

Referenced by CheckStaminaState(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), SetCooldown(), and StaminaHandler().

m_StaminaDepletion

float StaminaHandler::m_StaminaDepletion

protected

Definition at line 265 of file StaminaHandler.c.

Referenced by CalcStaminaGainBonus(), DepleteStamina(), StaminaHandler(), and Update().

m_StaminaDepletionMultiplier

float StaminaHandler::m_StaminaDepletionMultiplier

protected

Definition at line 266 of file StaminaHandler.c.

Referenced by DepleteStamina(), GetDepletionMultiplier(), ReadAdditionalStaminaInfo(), RecalculateDepletionMultiplier(), SetDepletionMultiplier(), SetRecoveryMultiplier(), StaminaHandler(), and Update().

m_StaminaModifiers

ref StaminaModifiers StaminaHandler::m_StaminaModifiers

protected

Definition at line 287 of file StaminaHandler.c.

Referenced by DepleteStamina(), RegisterStaminaModifiers(), and ResetCooldown().

m_StaminaParams

ref Param3<float, float, bool> StaminaHandler::m_StaminaParams

protected

Definition at line 269 of file StaminaHandler.c.

Referenced by StaminaHandler().

m_StaminaRecoveryMultiplier

float StaminaHandler::m_StaminaRecoveryMultiplier

protected

Definition at line 267 of file StaminaHandler.c.

Referenced by GetRecoveryMultiplier(), ReadAdditionalStaminaInfo(), RecalculateRecoveryMultiplier(), SetDepletionMultiplier(), SetRecoveryMultiplier(), StaminaHandler(), and Update().

m_StaminaSynced

float StaminaHandler::m_StaminaSynced

protected

Definition at line 263 of file StaminaHandler.c.

Referenced by GetSyncedStamina(), OnSyncJuncture(), and Update().

m_State

ref HumanMovementState StaminaHandler::m_State

protected

Definition at line 270 of file StaminaHandler.c.

Referenced by StaminaHandler(), and Update().

m_Time

float StaminaHandler::m_Time

protected

Definition at line 268 of file StaminaHandler.c.

Referenced by StaminaHandler(), and Update().

m_TimerMap

ref map<int, ref Timer> StaminaHandler::m_TimerMap

protected

Definition at line 277 of file StaminaHandler.c.

Referenced by SetCooldown(), and StaminaHandler().

---

The documentation for this class was generated from the following file:

• scripts/4_World/Classes/StaminaHandler.c