Collaboration diagram for DayZPlayerImplementAiming:

[legend]

Protected Member Functions
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)

Protected Attributes
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 Protected Attributes
static float	m_AimXClampRanges [] = { -180, -20, 90, 0, -50, 90, 180, -20, 90 }

Detailed Description

Definition at line 31 of file DayZPlayerImplementAiming.c.

Constructor & Destructor Documentation

◆ DayZPlayerImplementAiming()

void DayZPlayerImplementAiming::DayZPlayerImplementAiming ( DayZPlayerImplement player )

inlineprotected

Definition at line 72 of file DayZPlayerImplementAiming.c.

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

References Class::CastTo(), m_PlayerDpi, m_PlayerPb, and UpdateSwayState().

Member Function Documentation

◆ ApplyBreathingPattern()

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

inlineprotected

Definition at line 346 of file DayZPlayerImplementAiming.c.

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

References DbgPrintAimingImplement(), Math::Lerp(), m_BreathingXAxisOffset, m_BreathingYAxisOffset, m_LastSwayMultiplier, and Math::Sin().

Referenced by ProcessAimFilters().

◆ ApplyHorizontalNoise()

void DayZPlayerImplementAiming::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

Definition at line 367 of file DayZPlayerImplementAiming.c.

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

References Math::AbsFloat(), Math::Lerp(), m_HorizontalNoise, m_HorizontalNoiseVelocity, m_HorizontalNoiseXAxisOffset, m_HorizontalTargetValue, m_LastSwayMultiplier, m_MaxVelocity, m_PlayerPb, and Math::SmoothCD().

Referenced by ProcessAimFilters().

◆ ApplyShakes()

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

inlineprotected

Definition at line 385 of file DayZPlayerImplementAiming.c.

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

References m_PlayerPb, m_ShakeCount, and Math::Round().

Referenced by ProcessAimFilters().

◆ CalculateSpeedMultiplier()

float DayZPlayerImplementAiming::CalculateSpeedMultiplier ( float stamina )

inlineprotected

Definition at line 322 of file DayZPlayerImplementAiming.c.

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

References m_SwayModifier.

Referenced by ProcessAimFilters().

◆ CalculateSwayMultiplier()

float DayZPlayerImplementAiming::CalculateSwayMultiplier ( )

inlineprotected

Definition at line 281 of file DayZPlayerImplementAiming.c.

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

References Math::Clamp(), Math::Lerp(), m_LastSwayMultiplier, m_PlayerPb, m_ReferenceTime, m_SwayStateStartTime, m_TotalTime, and UpdateSwayState().

Referenced by ProcessAimFilters().

◆ CalculateWeight()

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

inlineprotected

Definition at line 400 of file DayZPlayerImplementAiming.c.

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

References DbgPrintAimingImplement(), m_AimNoiseAllowed, m_PlayerDpi, and SWAY_WEIGHT_SCALER.

Referenced by ProcessAimFilters().

◆ DbgPrintAimingImplement()

void DayZPlayerImplementAiming::DbgPrintAimingImplement ( string val )

inlineprotected

Definition at line 431 of file DayZPlayerImplementAiming.c.

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

References GetDayZGame(), and Print().

Referenced by ApplyBreathingPattern(), CalculateWeight(), and ProcessAimFilters().

◆ GetCurrentSwayState()

int DayZPlayerImplementAiming::GetCurrentSwayState ( )

inlineprotected

Definition at line 341 of file DayZPlayerImplementAiming.c.

  {
    return m_SwayState;
  }

References m_SwayState.

◆ GetSwayWeight()

float DayZPlayerImplementAiming::GetSwayWeight ( )

inlineprotected

Definition at line 117 of file DayZPlayerImplementAiming.c.

  {
    return m_SwayWeight;
  }

References m_SwayWeight.

◆ IsAimNoiseAllowed()

bool DayZPlayerImplementAiming::IsAimNoiseAllowed ( )

inlineprotected

Definition at line 127 of file DayZPlayerImplementAiming.c.

  {
    return m_AimNoiseAllowed;
  }

References m_AimNoiseAllowed.

◆ IsProceduralRecoilEnabled()

bool DayZPlayerImplementAiming::IsProceduralRecoilEnabled ( )

inlineprotected

Definition at line 137 of file DayZPlayerImplementAiming.c.

  {
    return m_ProceduralRecoilEnabled;
  }

References m_ProceduralRecoilEnabled.

◆ OnFinisherBegin()

void DayZPlayerImplementAiming::OnFinisherBegin ( float currentAimY )

inlineprotected

Definition at line 98 of file DayZPlayerImplementAiming.c.

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

References m_FilterVelocityStealthAimY, and m_StealthAimY_Last.

◆ OnRaiseBegin()

void DayZPlayerImplementAiming::OnRaiseBegin ( DayZPlayerImplement player )

inlineprotected

Definition at line 91 of file DayZPlayerImplementAiming.c.

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

References m_SwayModifier.

◆ OnSwayStateChange()

void DayZPlayerImplementAiming::OnSwayStateChange ( int state )

inlineprotected

Definition at line 104 of file DayZPlayerImplementAiming.c.

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

References m_PlayerPb.

Referenced by UpdateSwayState().

◆ ProcessAimFilters()

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

inlineprotected

get sway

get recoil

hands offset

cam offset

clamp aim ranges

mouse offset

Definition at line 155 of file DayZPlayerImplementAiming.c.

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

References 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, and m_TotalTime.

◆ ProcessStealthFilters()

bool DayZPlayerImplementAiming::ProcessStealthFilters	(	float	pDt,
		SDayZPlayerAimingModel	pModel )

inlineprotected

Definition at line 148 of file DayZPlayerImplementAiming.c.

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

References m_FilterVelocityStealthAimY, m_StealthAimY_Last, and Math::SmoothCD().

◆ RequestKuruShake()

void DayZPlayerImplementAiming::RequestKuruShake ( float amount )

inlineprotected

Definition at line 85 of file DayZPlayerImplementAiming.c.

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

References m_KuruShake, and m_PlayerPb.

◆ SetAimNoiseAllowed()

void DayZPlayerImplementAiming::SetAimNoiseAllowed ( bool state )

inlineprotected

Definition at line 122 of file DayZPlayerImplementAiming.c.

  {
    m_AimNoiseAllowed = state;
  }

References m_AimNoiseAllowed.

◆ SetCamShakeValues()

void DayZPlayerImplementAiming::SetCamShakeValues	(	float	x_axis,
		float	y_axis )

inlineprotected

Definition at line 142 of file DayZPlayerImplementAiming.c.

  {
    m_CamShakeX = x_axis;
    m_CamShakeY = y_axis;
  }

References m_CamShakeX, and m_CamShakeY.

◆ SetProceduralRecoilEnabled()

void DayZPlayerImplementAiming::SetProceduralRecoilEnabled ( bool state )

inlineprotected

Definition at line 132 of file DayZPlayerImplementAiming.c.

  {
    m_ProceduralRecoilEnabled = state;
  }

References m_ProceduralRecoilEnabled.

◆ SetRecoil()

void DayZPlayerImplementAiming::SetRecoil ( Weapon_Base weapon )

inlineprotected

Definition at line 79 of file DayZPlayerImplementAiming.c.

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

References m_CurrentRecoil, and m_ProceduralRecoilEnabled.

◆ UpdateSwayState()

bool DayZPlayerImplementAiming::UpdateSwayState ( int state )

inlineprotected

Definition at line 327 of file DayZPlayerImplementAiming.c.

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