Класс StaminaHandler

Защищенные члены
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)

Защищенные данные
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

Подробное описание

Конструктор(ы)

StaminaHandler()

void StaminaHandler ( PlayerBase player )

inlineprotected

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

Перекрестные ссылки 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() и RegisterStaminaModifiers().

Методы

ActivateDepletionModifier()

void ActivateDepletionModifier ( EStaminaMultiplierTypes type )

inlineprotected

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

Перекрестные ссылки Error(), m_ActiveDepletionModifiers, m_RegisteredDepletionModifiers и RecalculateDepletionMultiplier().

ActivateRecoveryModifier()

void ActivateRecoveryModifier ( EStaminaMultiplierTypes type )

inlineprotected

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

Перекрестные ссылки Error(), m_ActiveRecoveryModifiers, m_RegisteredRecoveryModifiers и RecalculateRecoveryMultiplier().

ApplyExhaustion()

void ApplyExhaustion ( )

inlineprotected

sets exhaustion look of player based on stamina level

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

Перекрестные ссылки HumanCommandAdditives(), m_Player, m_Stamina, m_StaminaCap и Math::Min().

Используется в Update().

CalcStaminaGainBonus()

float CalcStaminaGainBonus ( )

inlineprotected

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

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

Перекрестные ссылки m_Stamina, m_StaminaDepletion, Math::Min() и GameConstants::STAMINA_GAIN_BONUS_CAP.

Используется в StaminaProcessor_Ladder(), StaminaProcessor_Move() и StaminaProcessor_Swimming().

CheckStaminaState()

void CheckStaminaState ( )

inlineprotected

check if the stamina is completely depleted

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

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

Перекрестные ссылки m_IsInCooldown, m_Stamina, m_StaminaDepleted, SetCooldown() и GameConstants::STAMINA_REGEN_COOLDOWN_EXHAUSTION.

Используется в Update().

DeactivateDepletionModifier()

void DeactivateDepletionModifier ( EStaminaMultiplierTypes type )

inlineprotected

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

Перекрестные ссылки m_ActiveDepletionModifiers и RecalculateDepletionMultiplier().

DeactivateRecoveryModifier()

void DeactivateRecoveryModifier ( EStaminaMultiplierTypes type )

inlineprotected

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

Перекрестные ссылки m_ActiveRecoveryModifiers и RecalculateRecoveryMultiplier().

DepleteStamina()

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

inlineprotected

run cooldown right after depletion

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

Перекрестные ссылки 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() и SetCooldown().

GetCooldownTimer()

Timer GetCooldownTimer ( int modifier )

inlineprotected

    {
        
    }

GetDepletionMultiplier()

float GetDepletionMultiplier ( )

inlineprotected

    {
        return m_StaminaDepletionMultiplier;
    }

Перекрестные ссылки m_StaminaDepletionMultiplier.

GetRecoveryMultiplier()

float GetRecoveryMultiplier ( )

inlineprotected

    {
        return m_StaminaRecoveryMultiplier;
    }

Перекрестные ссылки m_StaminaRecoveryMultiplier.

GetStamina()

float GetStamina ( )

inlineprotected

    {
        return m_Stamina;
    }

Перекрестные ссылки m_Stamina.

GetStaminaCap()

float GetStaminaCap ( )

inlineprotected

    {
        return m_StaminaCap;
    }

Перекрестные ссылки m_StaminaCap.

GetStaminaMax()

float GetStaminaMax ( )

inlineprotected

    {
        return CfgGameplayHandler.GetStaminaMax();
    }

Перекрестные ссылки CfgGameplayHandler::GetStaminaMax().

Используется в GetStaminaNormalized() и GetSyncedStaminaNormalized().

GetStaminaNormalized()

float GetStaminaNormalized ( )

inlineprotected

    {
        return m_Stamina / GetStaminaMax();
    }

Перекрестные ссылки GetStaminaMax() и m_Stamina.

GetSyncedStamina()

float GetSyncedStamina ( )

inlineprotected

    {
        return m_StaminaSynced;
    }

Перекрестные ссылки m_StaminaSynced.

Используется в GetSyncedStaminaNormalized().

GetSyncedStaminaNormalized()

float GetSyncedStaminaNormalized ( )

inlineprotected

    {
        return GetSyncedStamina() / GetStaminaMax();
    }

Перекрестные ссылки GetStaminaMax() и GetSyncedStamina().

HasEnoughStaminaFor()

bool HasEnoughStaminaFor ( EStaminaConsumers consumer )

inlineprotected

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

Перекрестные ссылки m_Stamina, m_StaminaCap, m_StaminaConsumers и m_StaminaDepleted.

HasEnoughStaminaToStart()

bool HasEnoughStaminaToStart ( EStaminaConsumers consumer )

inlineprotected

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

Перекрестные ссылки m_Stamina, m_StaminaCap, m_StaminaConsumers и m_StaminaDepleted.

Init()

void Init ( )

inlineprotected

    {
        //----------------- 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);
        m_RegisteredDepletionModifiers.Insert(EStaminaMultiplierTypes.VOMIT_EXHAUSTION, VomitSymptom.STAMINA_DEPLETION_MULTIPLIER);
        m_RegisteredDepletionModifiers.Insert(EStaminaMultiplierTypes.DISEASE_PNEUMONIA, PneumoniaMdfr.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);
        m_RegisteredRecoveryModifiers.Insert(EStaminaMultiplierTypes.VOMIT_EXHAUSTION, VomitSymptom.STAMINA_RECOVERY_MULTIPLIER);
        m_RegisteredRecoveryModifiers.Insert(EStaminaMultiplierTypes.DISEASE_PNEUMONIA, PneumoniaMdfr.STAMINA_RECOVERY_MULTIPLIER);
        
    }

Перекрестные ссылки m_RegisteredDepletionModifiers, m_RegisteredRecoveryModifiers, MaskMdfr::STAMINA_DEPLETION_MODIFIER, FatigueMdfr::STAMINA_DEPLETION_MULTIPLIER, PneumoniaMdfr::STAMINA_DEPLETION_MULTIPLIER, EpinephrineMdfr::STAMINA_DEPLETION_MULTIPLIER, VomitSymptom::STAMINA_DEPLETION_MULTIPLIER, MaskMdfr::STAMINA_RECOVERY_MODIFIER, FatigueMdfr::STAMINA_RECOVERY_MULTIPLIER, PneumoniaMdfr::STAMINA_RECOVERY_MULTIPLIER, DrowningMdfr::STAMINA_RECOVERY_MULTIPLIER и VomitSymptom::STAMINA_RECOVERY_MULTIPLIER.

Используется в StaminaHandler().

OnRPC()

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

inlineprotected

deprecated use, StaminaHandler uses SyncJunctures now

    {
    }

OnSyncJuncture()

void 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)

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

Перекрестные ссылки m_IsInCooldown, m_Player, m_Stamina, m_StaminaCap, m_StaminaSynced, ReadAdditionalStaminaInfo(), DayZPlayerSyncJunctures::SJ_STAMINA и DayZPlayerSyncJunctures::SJ_STAMINA_MISC.

Используется в ManBase::OnSyncJuncture().

ReadAdditionalStaminaInfo()

void ReadAdditionalStaminaInfo ( ParamsReadContext pCtx )

inlineprotected

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

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

Перекрестные ссылки m_StaminaDepletionMultiplier и m_StaminaRecoveryMultiplier.

Используется в OnSyncJuncture().

RecalculateDepletionMultiplier()

void RecalculateDepletionMultiplier ( )

inlineprotected

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

Перекрестные ссылки m_ActiveDepletionModifiers, m_RegisteredDepletionModifiers, m_StaminaDepletionMultiplier и SetDepletionMultiplier().

Используется в ActivateDepletionModifier() и DeactivateDepletionModifier().

RecalculateRecoveryMultiplier()

void RecalculateRecoveryMultiplier ( )

inlineprotected

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

Перекрестные ссылки m_ActiveRecoveryModifiers, m_RegisteredRecoveryModifiers, m_StaminaRecoveryMultiplier и SetRecoveryMultiplier().

Используется в ActivateRecoveryModifier() и DeactivateRecoveryModifier().

RegisterStaminaConsumers()

void RegisterStaminaConsumers ( )

inlineprotected

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

Перекрестные ссылки 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 и StaminaConsumers().

Используется в StaminaHandler().

RegisterStaminaModifiers()

void RegisterStaminaModifiers ( )

inlineprotected

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

Перекрестные ссылки 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 и StaminaModifiers().

Используется в StaminaHandler().

ResetCooldown()

void ResetCooldown ( int modifier = -1 )

inlineprotected

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

Перекрестные ссылки m_IsInCooldown и m_StaminaModifiers.

Используется в SetCooldown().

SetCooldown()

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

inlineprotected

set cooldown timer between each consume of stamina

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

Перекрестные ссылки m_IsInCooldown, m_Stamina, m_StaminaDepleted, m_TimerMap и ResetCooldown().

Используется в CheckStaminaState(), DepleteStamina(), StaminaProcessor_Ladder(), StaminaProcessor_Move() и StaminaProcessor_Swimming().

SetDepletionMultiplier()

void SetDepletionMultiplier ( float val )

inlineprotected

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

Перекрестные ссылки m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier и SyncAdditionalStaminaInfo().

Используется в RecalculateDepletionMultiplier().

SetRecoveryMultiplier()

void SetRecoveryMultiplier ( float val )

inlineprotected

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

Перекрестные ссылки m_StaminaDepletionMultiplier, m_StaminaRecoveryMultiplier и SyncAdditionalStaminaInfo().

Используется в RecalculateRecoveryMultiplier().

SetStamina()

void SetStamina ( float stamina_value )

inlineprotected

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

Перекрестные ссылки Math::Clamp(), CfgGameplayHandler::GetStaminaMax(), m_IsInCooldown, m_Stamina, m_StaminaCap и SyncStamina().

Используется в ManBase::EEHitBy(), ManBase::ResetPlayer() и Update().

StaminaProcessor_Ladder()

void StaminaProcessor_Ladder ( HumanMovementState pHumanMovementState )

inlineprotected

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

Перекрестные ссылки 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 и GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Используется в Update().

StaminaProcessor_Move()

void StaminaProcessor_Move ( HumanMovementState pHumanMovementState )

inlineprotected

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

Перекрестные ссылки 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 и GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Используется в Update().

StaminaProcessor_Swimming()

void StaminaProcessor_Swimming ( HumanMovementState pHumanMovementState )

inlineprotected

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

Перекрестные ссылки 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 и GameConstants::STAMINA_REGEN_COOLDOWN_DEPLETION.

Используется в Update().

SyncAdditionalStaminaInfo()

void SyncAdditionalStaminaInfo ( Param par )

inlineprotected

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

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

Перекрестные ссылки m_Player и DayZPlayerSyncJunctures::SJ_STAMINA_MISC.

Используется в SetDepletionMultiplier() и SetRecoveryMultiplier().

SyncStamina()

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

inlineprotected

stamina sync - server part

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

Перекрестные ссылки m_IsInCooldown, m_Player, m_Stamina, m_StaminaCap и DayZPlayerSyncJunctures::SJ_STAMINA.

Используется в SetStamina().

Update()

void 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

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

Перекрестные ссылки 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() и StaminaProcessor_Swimming().

Используется в ManBase::CommandHandler().

Поля

m_ActiveDepletionModifiers

ref set<EStaminaMultiplierTypes> m_ActiveDepletionModifiers

protected

Используется в ActivateDepletionModifier(), DeactivateDepletionModifier(), RecalculateDepletionMultiplier() и StaminaHandler().

m_ActiveRecoveryModifiers

ref set<EStaminaMultiplierTypes> m_ActiveRecoveryModifiers

protected

Используется в ActivateRecoveryModifier(), DeactivateRecoveryModifier(), RecalculateRecoveryMultiplier() и StaminaHandler().

m_Debug

bool m_Debug

protected

m_HumanMoveSettings

SHumanCommandMoveSettings m_HumanMoveSettings

protected

Используется в StaminaHandler() и StaminaProcessor_Move().

m_IsInCooldown

bool m_IsInCooldown

protected

Используется в CheckStaminaState(), OnSyncJuncture(), ResetCooldown(), SetCooldown(), SetStamina(), StaminaHandler(), StaminaProcessor_Ladder(), StaminaProcessor_Move(), StaminaProcessor_Swimming(), SyncStamina() и Update().

m_Player

PlayerBase m_Player

protected

Используется в ApplyExhaustion(), DepleteStamina(), OnSyncJuncture(), StaminaHandler(), StaminaProcessor_Move(), SyncAdditionalStaminaInfo(), SyncStamina() и Update().

m_PlayerLoad

float m_PlayerLoad

protected

Используется в Update().

m_RegisteredDepletionModifiers

ref map<EStaminaMultiplierTypes, float> m_RegisteredDepletionModifiers

protected

Используется в ActivateDepletionModifier(), Init(), RecalculateDepletionMultiplier() и StaminaHandler().

m_RegisteredRecoveryModifiers

ref map<EStaminaMultiplierTypes, float> m_RegisteredRecoveryModifiers

protected

Используется в ActivateRecoveryModifier(), Init(), RecalculateRecoveryMultiplier() и StaminaHandler().

m_Stamina

float m_Stamina

protected

Используется в ApplyExhaustion(), CalcStaminaGainBonus(), CheckStaminaState(), GetStamina(), GetStaminaNormalized(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), OnSyncJuncture(), SetCooldown(), SetStamina(), StaminaHandler(), SyncStamina() и Update().

m_StaminaCap

float m_StaminaCap

protected

Используется в ApplyExhaustion(), GetStaminaCap(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), OnSyncJuncture(), SetStamina(), StaminaHandler(), SyncStamina() и Update().

m_StaminaConsumers

ref StaminaConsumers m_StaminaConsumers

protected

Используется в HasEnoughStaminaFor(), HasEnoughStaminaToStart() и RegisterStaminaConsumers().

m_StaminaDelta

float m_StaminaDelta

protected

Используется в StaminaProcessor_Ladder(), StaminaProcessor_Move(), StaminaProcessor_Swimming() и Update().

m_StaminaDepleted

bool m_StaminaDepleted

protected

DEPRECATED.

Используется в CheckStaminaState(), HasEnoughStaminaFor(), HasEnoughStaminaToStart(), SetCooldown() и StaminaHandler().

m_StaminaDepletion

float m_StaminaDepletion

protected

Используется в CalcStaminaGainBonus(), DepleteStamina(), StaminaHandler() и Update().

m_StaminaDepletionMultiplier

float m_StaminaDepletionMultiplier

protected

Используется в DepleteStamina(), GetDepletionMultiplier(), ReadAdditionalStaminaInfo(), RecalculateDepletionMultiplier(), SetDepletionMultiplier(), SetRecoveryMultiplier(), StaminaHandler() и Update().

m_StaminaModifiers

ref StaminaModifiers m_StaminaModifiers

protected

Используется в DepleteStamina(), RegisterStaminaModifiers() и ResetCooldown().

m_StaminaParams

ref Param3<float,float,bool> m_StaminaParams

protected

Используется в StaminaHandler().

m_StaminaRecoveryMultiplier

float m_StaminaRecoveryMultiplier

protected

Используется в GetRecoveryMultiplier(), ReadAdditionalStaminaInfo(), RecalculateRecoveryMultiplier(), SetDepletionMultiplier(), SetRecoveryMultiplier(), StaminaHandler() и Update().

m_StaminaSynced

float m_StaminaSynced

protected

Используется в GetSyncedStamina(), OnSyncJuncture() и Update().

m_State

ref HumanMovementState m_State

protected

Используется в StaminaHandler() и Update().

m_Time

float m_Time

protected

Используется в StaminaHandler() и Update().

m_TimerMap

ref map<int,ref Timer> m_TimerMap

protected

Используется в SetCooldown() и StaminaHandler().

---

Объявления и описания членов класса находятся в файле:

• D:/Ishodniki/scripts/4_World/Classes/StaminaHandler.c