Класс DayZPlayerImplementAiming

Защищенные члены
void	DayZPlayerImplementAiming (DayZPlayerImplement player)
void	SetRecoil (Weapon_Base weapon)
void	RequestKuruShake (float amount)
void	OnRaiseBegin (DayZPlayerImplement player)
void	OnFinisherBegin (float currentAimY)
void	OnSwayStateChange (int state)
float	GetSwayWeight ()
void	SetAimNoiseAllowed (bool state)
bool	IsAimNoiseAllowed ()
void	SetProceduralRecoilEnabled (bool state)
bool	IsProceduralRecoilEnabled ()
void	SetCamShakeValues (float x_axis, float y_axis)
bool	ProcessStealthFilters (float pDt, SDayZPlayerAimingModel pModel)
bool	ProcessAimFilters (float pDt, SDayZPlayerAimingModel pModel, int stance_index)
float	CalculateSwayMultiplier ()
float	CalculateSpeedMultiplier (float stamina)
bool	UpdateSwayState (int state)
int	GetCurrentSwayState ()
void	ApplyBreathingPattern (out float x_axis, out float y_axis, float pAmplitude, float pTotalTime, float weight)
void	ApplyHorizontalNoise (out float x_axis, out float y_axis, float smooth_time, float max_velocity_low, float max_velocity_high, float velocity_modifier, float max_distance, float weight, float pDt)
void	ApplyShakes (out float x_axis, out float y_axis, int level)
float	CalculateWeight (int stance_index, float current_stamina, float camera_sway_modifier, bool holding_breath)
void	DbgPrintAimingImplement (string val)

Защищенные данные
const float	SWAY_WEIGHT_SCALER = 1
float	m_HorizontalNoise
float	m_HorizontalTargetValue
float	m_HorizontalNoiseVelocity [1] = {0}
DayZPlayerImplement	m_PlayerDpi
PlayerBase	m_PlayerPb
float	m_TotalTime
float	m_ReferenceTime = 0
float	m_SwayStateStartTime
float	m_LastSwayMultiplier = PlayerSwayConstants.SWAY_MULTIPLIER_DEFAULT
float	m_StateStartSwayMultiplier
float	m_HorizontalNoiseXAxisOffset
float	m_BreathingXAxisOffset
float	m_BreathingYAxisOffset
bool	m_HoldingBreathSet
bool	m_AimNoiseAllowed = true
bool	m_ProceduralRecoilEnabled = true
ref RecoilBase	m_CurrentRecoil
int	m_ShakeCount
float	m_SwayWeight
float	m_MaxVelocity
ref KuruShake	m_KuruShake
float	m_CamShakeX
float	m_CamShakeY
vector	m_SwayModifier = "1 1 1"
int	m_SwayState = -1
float	m_StealthAimY_Last
float	m_FilterVelocityStealthAimY [1] = {0}

Статические защищенные данные
static float	m_AimXClampRanges [] = { -180, -20, 90, 0, -50, 90, 180, -20, 90 }

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

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

DayZPlayerImplementAiming()

void DayZPlayerImplementAiming ( DayZPlayerImplement player )

inlineprotected

    {
        m_PlayerDpi = player;
        Class.CastTo(m_PlayerPb, player);
        UpdateSwayState(eSwayStates.DEFAULT);
    }

Перекрестные ссылки Class::CastTo(), m_PlayerDpi, m_PlayerPb и UpdateSwayState().

Методы

ApplyBreathingPattern()

void ApplyBreathingPattern ( out float x_axis, out float y_axis, float pAmplitude, float pTotalTime, float weight )

inlineprotected

    {
 
        float multiplier = Math.Lerp(PlayerSwayConstants.SWAY_MULTIPLIER_DEFAULT,0,m_LastSwayMultiplier); //TODO revise
        #ifdef DEVELOPER
        DbgPrintAimingImplement("m_LastSwayMultiplier: " + m_LastSwayMultiplier);
        DbgPrintAimingImplement("pAmplitude: " + pAmplitude);
        DbgPrintAimingImplement("pTotalTime: " + pTotalTime);
        DbgPrintAimingImplement("weight: " + weight);
        DbgPrintAimingImplement("multiplier: " + multiplier);
        #endif
        
        x_axis = (Math.Sin(pTotalTime) * pAmplitude / 4) * weight;
        y_axis = (Math.Sin((pTotalTime) * 0.8 + 0.6) * pAmplitude) * weight;
        #ifdef DEVELOPER 
        DbgPrintAimingImplement("y_axis_midproduct: " + y_axis); 
        #endif
        x_axis += m_BreathingXAxisOffset * multiplier;
        y_axis += m_BreathingYAxisOffset * multiplier;
    }

Перекрестные ссылки DbgPrintAimingImplement(), Math::Lerp(), m_BreathingXAxisOffset, m_BreathingYAxisOffset, m_LastSwayMultiplier и Math::Sin().

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

ApplyHorizontalNoise()

void ApplyHorizontalNoise ( out float x_axis, out float y_axis, float smooth_time, float max_velocity_low, float max_velocity_high, float velocity_modifier, float max_distance, float weight, float pDt )

inlineprotected

    {
        if (Math.AbsFloat(m_HorizontalTargetValue - m_HorizontalNoise) < 0.01)
        {
            //acquire new target
            m_MaxVelocity = m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, max_velocity_low, max_velocity_high);
 
            float r = m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, 0, 1);
            m_HorizontalTargetValue = (r - 0.5) * 2 * max_distance;
            m_HorizontalNoiseVelocity[0] = 0;
        }
 
        m_HorizontalNoise = Math.SmoothCD(m_HorizontalNoise, m_HorizontalTargetValue, m_HorizontalNoiseVelocity, smooth_time, m_MaxVelocity * velocity_modifier, pDt);
        x_axis = m_HorizontalNoise * weight;
        float multiplier = Math.Lerp(PlayerSwayConstants.SWAY_MULTIPLIER_DEFAULT,0,m_LastSwayMultiplier); //TODO revise
        x_axis += m_HorizontalNoiseXAxisOffset * multiplier;
    }

Перекрестные ссылки Math::AbsFloat(), Math::Lerp(), m_HorizontalNoise, m_HorizontalNoiseVelocity, m_HorizontalNoiseXAxisOffset, m_HorizontalTargetValue, m_LastSwayMultiplier, m_MaxVelocity, m_PlayerPb и Math::SmoothCD().

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

ApplyShakes()

void ApplyShakes ( out float x_axis, out float y_axis, int level )

inlineprotected

    {
        float weight = level / PlayerBase.SHAKE_LEVEL_MAX;
        m_ShakeCount++;
        int shakes_threshold = Math.Round(m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, 2, 4));
        if (m_ShakeCount > shakes_threshold)
        {
            m_ShakeCount = 0;
 
            float modifier = m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, 0.45, 0.9);
            x_axis = modifier * weight * m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, 0, 1);
            y_axis = modifier * weight * m_PlayerPb.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSAimingModel, 0, 1);
        }
    }

Перекрестные ссылки m_PlayerPb, m_ShakeCount и Math::Round().

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

CalculateSpeedMultiplier()

float CalculateSpeedMultiplier ( float stamina )

inlineprotected

    {
        return (((1.0 - stamina) * 3.0) + 1.0) * m_SwayModifier[2]; // just 'm_SwayModifier[2]' for HoldBreath
    }

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

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

CalculateSwayMultiplier()

float CalculateSwayMultiplier ( )

inlineprotected

    {
        float max;
        float time;
        float time_clamped;
        float ret;
        
        if (m_PlayerPb.IsHoldingBreath())
        {
            time = m_TotalTime - m_ReferenceTime;
            
            if (time < PlayerSwayConstants.SWAY_TIME_IN)
            {
                UpdateSwayState(eSwayStates.HOLDBREATH_IN);
                max = PlayerSwayConstants.SWAY_TIME_IN;
                time_clamped = Math.Clamp((m_TotalTime - m_SwayStateStartTime),0,max);
                ret = Math.Lerp(m_LastSwayMultiplier,PlayerSwayConstants.SWAY_MULTIPLIER_STABLE,time_clamped/max);
            }
            else if (time >= PlayerSwayConstants.SWAY_TIME_IN && time < (PlayerSwayConstants.SWAY_TIME_IN + PlayerSwayConstants.SWAY_TIME_STABLE))
            {
                UpdateSwayState(eSwayStates.HOLDBREATH_STABLE);
                ret = PlayerSwayConstants.SWAY_MULTIPLIER_STABLE;
            }
            else
            {
                UpdateSwayState(eSwayStates.HOLDBREATH_EXHAUSTED);
                max = PlayerSwayConstants.SWAY_TIME_EXHAUSTED;
                time_clamped = Math.Clamp((m_TotalTime - m_SwayStateStartTime),0,max);
                ret = Math.Lerp(PlayerSwayConstants.SWAY_MULTIPLIER_STABLE,PlayerSwayConstants.SWAY_MULTIPLIER_EXHAUSTED,(time_clamped/max));
            }
        }
        else
        {
            UpdateSwayState(eSwayStates.DEFAULT);
            max = PlayerSwayConstants.SWAY_TIME_OUT;
            time_clamped = Math.Clamp((m_TotalTime - m_SwayStateStartTime),0,max);
            ret = Math.Lerp(m_LastSwayMultiplier,1,time_clamped/max);
        }
        return ret;
    }

Перекрестные ссылки Math::Clamp(), Math::Lerp(), m_LastSwayMultiplier, m_PlayerPb, m_ReferenceTime, m_SwayStateStartTime, m_TotalTime и UpdateSwayState().

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

CalculateWeight()

float CalculateWeight ( int stance_index, float current_stamina, float camera_sway_modifier, bool holding_breath )

inlineprotected

    {
        if (m_PlayerDpi.GetCommand_Move() && m_PlayerDpi.GetCommand_Move().IsInRoll())//when the player is rolling, set a constant and disregard everything else
        {
            return PlayerSwayConstants.SWAY_ROLL;
        }
        float stance_modifier;
        switch (stance_index)
        {
            case DayZPlayerConstants.STANCEIDX_RAISEDERECT:
                stance_modifier = 0.5;
            break;
            case DayZPlayerConstants.STANCEIDX_RAISEDCROUCH:
                stance_modifier = 0.75;
            break;
            case DayZPlayerConstants.STANCEIDX_RAISEDPRONE:
                stance_modifier = 0.9;
            break;
            default:
                stance_modifier = 0.75;
                //Debug.LogError("stance mask out of definition");
            break;
        }
        
        #ifdef DEVELOPER
        DbgPrintAimingImplement("current_stamina: " + current_stamina);
        DbgPrintAimingImplement("camera_sway_modifier: " + camera_sway_modifier);
        DbgPrintAimingImplement("holding_breath: " + holding_breath);
        #endif
        
        return (1 - stance_modifier) * m_AimNoiseAllowed * camera_sway_modifier * SWAY_WEIGHT_SCALER;
    }

Перекрестные ссылки DbgPrintAimingImplement(), m_AimNoiseAllowed, m_PlayerDpi и SWAY_WEIGHT_SCALER.

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

DbgPrintAimingImplement()

void DbgPrintAimingImplement ( string val )

inlineprotected

    {
        #ifdef DEVELOPER
        if (GetDayZGame().IsAimLogEnabled())
            Print("DayZPlayerImplementAiming | " + val);
        #endif
    }

Перекрестные ссылки GetDayZGame() и Print().

Используется в ApplyBreathingPattern(), CalculateWeight() и ProcessAimFilters().

GetCurrentSwayState()

int GetCurrentSwayState ( )

inlineprotected

    {
        return m_SwayState;
    }

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

GetSwayWeight()

float GetSwayWeight ( )

inlineprotected

    {
        return m_SwayWeight;        
    }

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

IsAimNoiseAllowed()

bool IsAimNoiseAllowed ( )

inlineprotected

    {
        return m_AimNoiseAllowed;   
    }

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

IsProceduralRecoilEnabled()

bool IsProceduralRecoilEnabled ( )

inlineprotected

    {
        return m_ProceduralRecoilEnabled;
    }

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

OnFinisherBegin()

void OnFinisherBegin ( float currentAimY )

inlineprotected

    {
        m_StealthAimY_Last = currentAimY;
        m_FilterVelocityStealthAimY[0] = 0;
    }

Перекрестные ссылки m_FilterVelocityStealthAimY и m_StealthAimY_Last.

OnRaiseBegin()

void OnRaiseBegin ( DayZPlayerImplement player )

inlineprotected

    {
        Weapon_Base weapon = Weapon_Base.Cast(player.GetHumanInventory().GetEntityInHands());
        if (weapon)
        {
            m_SwayModifier = weapon.GetPropertyModifierObject().m_SwayModifiers;
        }
    }

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

OnSwayStateChange()

void OnSwayStateChange ( int state )

inlineprotected

    {
        switch (state)
        {
            case eSwayStates.HOLDBREATH_EXHAUSTED:
                m_PlayerPb.OnHoldBreathExhausted();
            break;
            
            default:
            break;
        }
    }

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

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

ProcessAimFilters()

bool ProcessAimFilters ( float pDt, SDayZPlayerAimingModel pModel, int stance_index )

inlineprotected

get sway

get recoil

hands offset

cam offset

clamp aim ranges

mouse offset

    {
        float breathing_offset_x;
        float breathing_offset_y;
        
        float noise_offset_x;
        float noise_offset_y;       
        
        float shake_offset_x;
        float shake_offset_y;
        
        float recoil_offset_mouse_x;
        float recoil_offset_mouse_y;
        
        float recoil_offset_hands_x;
        float recoil_offset_hands_y;
        
        float kuru_offset_x;
        float kuru_offset_y;
        
        float player_stamina = m_PlayerPb.GetStaminaHandler().GetSyncedStaminaNormalized();
        
        #ifdef DEVELOPER
        DbgPrintAimingImplement("Player: " + m_PlayerPb + " | ProcessAimFilters | timestamp: " + m_PlayerPb.GetSimulationTimeStamp());
        #endif
        
        //negates stamina effect during hold breath
        if (m_PlayerPb.IsHoldingBreath())
        {
            player_stamina = 1;
        }
        float speed = CalculateSpeedMultiplier(player_stamina);
        m_TotalTime += pDt * speed;
        
        if (m_PlayerPb.IsHoldingBreath() && !m_HoldingBreathSet)
        {
            m_ReferenceTime = m_TotalTime;
        }
        else if (!m_PlayerPb.IsHoldingBreath() && m_HoldingBreathSet)
        {
            m_ReferenceTime = m_TotalTime;
        }
        
        float adjusted_sway_multiplier = CalculateSwayMultiplier();
        m_LastSwayMultiplier = adjusted_sway_multiplier;
        
        m_SwayWeight = CalculateWeight( stance_index, player_stamina, 0.5/*m_PlayerPb.m_CameraSwayModifier*/, m_PlayerPb.IsHoldingBreath()) * adjusted_sway_multiplier;
 
        ApplyBreathingPattern(breathing_offset_x, breathing_offset_y, 3.0, m_TotalTime, m_SwayWeight);
        ApplyHorizontalNoise(noise_offset_x, noise_offset_y, 0.2, 0.5, 3.0 * m_SwayModifier[0], speed, 3 * m_SwayModifier[1], m_SwayWeight, pDt);
        
        int shake_level = m_PlayerPb.GetShakeLevel();
        if (shake_level != 0)
        {
            ApplyShakes(shake_offset_x, shake_offset_y, shake_level);
        }
 
        if (m_CurrentRecoil)
        {
            m_CurrentRecoil.Update(pModel, recoil_offset_mouse_x, recoil_offset_mouse_y, recoil_offset_hands_x, recoil_offset_hands_y, pDt);
        }
        
        if (m_KuruShake)
        {
            m_KuruShake.Update(pDt, kuru_offset_x, kuru_offset_y);
        }
        
        pModel.m_fAimXHandsOffset = breathing_offset_x + noise_offset_x + recoil_offset_hands_x + shake_offset_x + kuru_offset_x;
        pModel.m_fAimYHandsOffset = breathing_offset_y + noise_offset_y + recoil_offset_hands_y + shake_offset_y + kuru_offset_y;
        
        #ifdef DEVELOPER
        DbgPrintAimingImplement("breathing_offset_y: " + breathing_offset_y);
        DbgPrintAimingImplement("noise_offset_y: " + noise_offset_y);
        DbgPrintAimingImplement("recoil_offset_hands_y: " + recoil_offset_hands_y);
        DbgPrintAimingImplement("shake_offset_y: " + shake_offset_y);
        DbgPrintAimingImplement("kuru_offset_y: " + kuru_offset_y);
        DbgPrintAimingImplement("pModel.m_fAimYHandsOffset: " + pModel.m_fAimYHandsOffset);
        #endif
        pModel.m_fAimXCamOffset = -shake_offset_x - recoil_offset_hands_x - kuru_offset_x + m_CamShakeX;
        pModel.m_fAimYCamOffset = -shake_offset_y - recoil_offset_hands_y - kuru_offset_y + m_CamShakeY;
        
        
        #ifdef DEVELOPER
        DbgPrintAimingImplement("m_CamShakeY: " + m_CamShakeY);
        DbgPrintAimingImplement("pModel.m_fAimYCamOffset: " + pModel.m_fAimYCamOffset);
        #endif
        
        if (stance_index == DayZPlayerConstants.STANCEIDX_RAISEDPRONE)
        {
            float newVal = DayZPlayerUtils.LinearRangeClamp(pModel.m_fCurrentAimX, pModel.m_fCurrentAimY, m_AimXClampRanges);
            pModel.m_fAimYHandsOffset += newVal - pModel.m_fCurrentAimY;
        }
        float absAimY = Math.AbsFloat(pModel.m_fCurrentAimY);
        pModel.m_fAimYHandsOffset = Math.Clamp(pModel.m_fAimYHandsOffset,absAimY - 89.9,89.9 - absAimY); //'90' leads to rounding errors down the line
        
        if (m_PlayerDpi.IsInOptics() && m_KuruShake)
        {
            //TODO - do not offset mouse
        }
        pModel.m_fAimXMouseShift = recoil_offset_mouse_x -kuru_offset_x / 10;
        pModel.m_fAimYMouseShift = recoil_offset_mouse_y + kuru_offset_y / 10;
 
        #ifdef DEVELOPER
        DbgPrintAimingImplement("recoil_offset_mouse_y: " + recoil_offset_mouse_y);
        DbgPrintAimingImplement("pModel.m_fAimYMouseShift: " + pModel.m_fAimYMouseShift);
        #endif
        
        if (m_PlayerPb.IsHoldingBreath() && !m_HoldingBreathSet)
        {
            m_HoldingBreathSet = true;
            m_HorizontalNoiseXAxisOffset = noise_offset_x;
            m_BreathingXAxisOffset = breathing_offset_x;
            m_BreathingYAxisOffset = breathing_offset_y;
        }
        else if (!m_PlayerPb.IsHoldingBreath() && m_HoldingBreathSet)
        {
            m_HoldingBreathSet = false;
        }
        
        if (!m_PlayerPb.IsHoldingBreath() && m_LastSwayMultiplier == PlayerSwayConstants.SWAY_MULTIPLIER_DEFAULT && m_HorizontalNoiseXAxisOffset != 0)
        {
            m_HorizontalNoiseXAxisOffset = 0;
            m_BreathingXAxisOffset = 0;
            m_BreathingYAxisOffset = 0;
        }
        
        if (m_PlayerPb.IsHoldingBreath())
        {
            m_PlayerPb.DepleteStamina(EStaminaModifiers.HOLD_BREATH,pDt*speed);
        }
        #ifdef DEVELOPER
        DbgPrintAimingImplement("----------------------------");
        #endif
        return true;
    }

Перекрестные ссылки Math::AbsFloat(), ApplyBreathingPattern(), ApplyHorizontalNoise(), ApplyShakes(), CalculateSpeedMultiplier(), CalculateSwayMultiplier(), CalculateWeight(), Math::Clamp(), DayZPlayerUtils(), DbgPrintAimingImplement(), m_AimXClampRanges, m_BreathingXAxisOffset, m_BreathingYAxisOffset, m_CamShakeX, m_CamShakeY, m_CurrentRecoil, m_HoldingBreathSet, m_HorizontalNoiseXAxisOffset, m_KuruShake, m_LastSwayMultiplier, m_PlayerDpi, m_PlayerPb, m_ReferenceTime, m_SwayModifier, m_SwayWeight и m_TotalTime.

ProcessStealthFilters()

bool ProcessStealthFilters ( float pDt, SDayZPlayerAimingModel pModel )

inlineprotected

    {       
        m_StealthAimY_Last = Math.SmoothCD(m_StealthAimY_Last, 0, m_FilterVelocityStealthAimY, 0.3, 1000, pDt);
        pModel.m_fAimYMouseShift = -(pModel.m_fCurrentAimY - m_StealthAimY_Last);
        return true;
    }

Перекрестные ссылки m_FilterVelocityStealthAimY, m_StealthAimY_Last и Math::SmoothCD().

RequestKuruShake()

void RequestKuruShake ( float amount )

inlineprotected

    {
        if (!m_KuruShake)
            m_KuruShake = new KuruShake(m_PlayerPb, amount);
    }

Перекрестные ссылки m_KuruShake и m_PlayerPb.

SetAimNoiseAllowed()

void SetAimNoiseAllowed ( bool state )

inlineprotected

    {
        m_AimNoiseAllowed = state;  
    }

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

SetCamShakeValues()

void SetCamShakeValues ( float x_axis, float y_axis )

inlineprotected

    {
        m_CamShakeX = x_axis;
        m_CamShakeY = y_axis;
    }

Перекрестные ссылки m_CamShakeX и m_CamShakeY.

SetProceduralRecoilEnabled()

void SetProceduralRecoilEnabled ( bool state )

inlineprotected

    {
        m_ProceduralRecoilEnabled = state;
    }

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

SetRecoil()

void SetRecoil ( Weapon_Base weapon )

inlineprotected

    {
        if (m_ProceduralRecoilEnabled)
        {
            m_CurrentRecoil = weapon.SpawnRecoilObject();
        }
    }

Перекрестные ссылки m_CurrentRecoil и m_ProceduralRecoilEnabled.

UpdateSwayState()

bool UpdateSwayState ( int state )

inlineprotected

    {
        if (state != m_SwayState)
        {
            m_SwayState = state;
            m_SwayStateStartTime = m_TotalTime;
            m_StateStartSwayMultiplier = m_LastSwayMultiplier;
            OnSwayStateChange(state);
            return true;
        }
        
        return false;
    }

Перекрестные ссылки m_LastSwayMultiplier, m_StateStartSwayMultiplier, m_SwayState, m_SwayStateStartTime, m_TotalTime и OnSwayStateChange().

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

Поля

m_AimNoiseAllowed

bool m_AimNoiseAllowed = true

protected

Используется в CalculateWeight(), IsAimNoiseAllowed() и SetAimNoiseAllowed().

m_AimXClampRanges

float m_AimXClampRanges[] = { -180, -20, 90, 0, -50, 90, 180, -20, 90 }

staticprotected

{ -180, -20, 90,    0, -50, 90,  180, -20, 90 };

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

m_BreathingXAxisOffset

float m_BreathingXAxisOffset

protected

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

m_BreathingYAxisOffset

float m_BreathingYAxisOffset

protected

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

m_CamShakeX

float m_CamShakeX

protected

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

m_CamShakeY

float m_CamShakeY

protected

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

m_CurrentRecoil

ref RecoilBase m_CurrentRecoil

protected

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

m_FilterVelocityStealthAimY

float m_FilterVelocityStealthAimY[1] = {0}

protected

{0};

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

m_HoldingBreathSet

bool m_HoldingBreathSet

protected

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

m_HorizontalNoise

float m_HorizontalNoise

protected

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

m_HorizontalNoiseVelocity

float m_HorizontalNoiseVelocity[1] = {0}

protected

{0};

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

m_HorizontalNoiseXAxisOffset

float m_HorizontalNoiseXAxisOffset

protected

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

m_HorizontalTargetValue

float m_HorizontalTargetValue

protected

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

m_KuruShake

ref KuruShake m_KuruShake

protected

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

m_LastSwayMultiplier

float m_LastSwayMultiplier = PlayerSwayConstants.SWAY_MULTIPLIER_DEFAULT

protected

Используется в ApplyBreathingPattern(), ApplyHorizontalNoise(), CalculateSwayMultiplier(), ProcessAimFilters() и UpdateSwayState().

m_MaxVelocity

float m_MaxVelocity

protected

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

m_PlayerDpi

DayZPlayerImplement m_PlayerDpi

protected

Используется в CalculateWeight(), DayZPlayerImplementAiming() и ProcessAimFilters().

m_PlayerPb

PlayerBase m_PlayerPb

protected

Используется в ApplyHorizontalNoise(), ApplyShakes(), CalculateSwayMultiplier(), DayZPlayerImplementAiming(), OnSwayStateChange(), ProcessAimFilters() и RequestKuruShake().

m_ProceduralRecoilEnabled

bool m_ProceduralRecoilEnabled = true

protected

Используется в IsProceduralRecoilEnabled(), SetProceduralRecoilEnabled() и SetRecoil().

m_ReferenceTime

float m_ReferenceTime = 0

protected

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

m_ShakeCount

int m_ShakeCount

protected

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

m_StateStartSwayMultiplier

float m_StateStartSwayMultiplier

protected

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

m_StealthAimY_Last

float m_StealthAimY_Last

protected

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

m_SwayModifier

vector m_SwayModifier = "1 1 1"

protected

Используется в CalculateSpeedMultiplier(), OnRaiseBegin() и ProcessAimFilters().

m_SwayState

int m_SwayState = -1

protected

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

m_SwayStateStartTime

float m_SwayStateStartTime

protected

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

m_SwayWeight

float m_SwayWeight

protected

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

m_TotalTime

float m_TotalTime

protected

Используется в CalculateSwayMultiplier(), ProcessAimFilters() и UpdateSwayState().

SWAY_WEIGHT_SCALER

const float SWAY_WEIGHT_SCALER = 1

protected

This HeadingModel - Clamps heading

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

---

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

• D:/Ishodniki/scripts/4_World/Entities/DayZPlayerImplementAiming.c