recoilbase.c

Go to the documentation of this file.

class RecoilBase
{
    bool m_DebugMode;
    
    Weapon_Base m_Weapon;
    PlayerBase m_Player;
    protected bool m_DeleteRequested;
    protected float m_Time;//how much time has elapsed since first update
    protected float m_ReloadTime;//reload time config parameter of the weapon
    protected vector m_RecoilModifier;
    protected bool m_IsClient;
    // for mouse offset
    float m_MouseOffsetRangeMin;//in degrees min
    float m_MouseOffsetRangeMax;//in degrees max
    float m_MouseOffsetRelativeTime = 1;//[0..1] a time it takes to move the mouse the required distance relative to the reload time of the weapon(firing mode)
    float m_HandsOffsetRelativeTime = 1;//[0..1] a time it takes to move the hands the required distance given by the curve relative to the reload time of the weapon(firing mode)
    float m_CamOffsetRelativeTime = 1;//[0..1] a time it takes to move the camera the required distance relative to the reload time of the weapon(firing mode)
    float m_CamOffsetDistance = 0.05;//how far the camera will travel along the z-axis in cm
    float m_MouseOffsetDistance;//how far should the mouse travel
    float m_TimeNormalized;
    //protected float m_MouseOffsetResult;//in degrees max
    protected vector m_MouseOffsetTarget;//move the mouse towards this point
    protected vector m_MouseOffsetTargetAccum;//the overall mouse offset so far(all deltas accumulated)
    protected float m_Angle;//result between the min and max
    // mouse end
    
    protected ref array<vector> m_HandsCurvePoints;
    
    void RecoilBase(Weapon_Base weapon)
    {
        m_Weapon = weapon;
        //m_DebugMode = false;
        m_DebugMode = GetDayZGame().IsAimLogEnabled();
        m_Player = PlayerBase.Cast(weapon.GetHierarchyRootPlayer());
        m_HandsCurvePoints = new array<vector>;
        Init();
        PostInit(weapon);
    }
    
    void Init();
    
    Weapon_Base GetWeapon()
    {
        return m_Weapon;
    }
    
    void PostInit(Weapon_Base weapon)
    {
        int muzzleIndex = weapon.GetCurrentMuzzle();
        m_Angle = m_Player.GetRandomGeneratorSyncManager().GetRandomInRange(RandomGeneratorSyncUsage.RGSRecoil, m_MouseOffsetRangeMin, m_MouseOffsetRangeMax);
        m_RecoilModifier = GetRecoilModifier( GetWeapon() );
        if(m_DebugMode) Print(m_Angle);
        
        m_ReloadTime = weapon.GetReloadTime(muzzleIndex);
        m_MouseOffsetTarget = vector.YawToVector(m_Angle);
        m_MouseOffsetTarget = m_MouseOffsetTarget * m_MouseOffsetDistance;
        m_IsClient = !GetGame().IsDedicatedServer();
        m_CamOffsetDistance *= m_RecoilModifier[2];
    }
    
    void Destroy()
    {
        m_DeleteRequested = true;
    }
    
    // called externally per update, not to be overriden in children
    void Update( SDayZPlayerAimingModel pModel, out float axis_mouse_x, out float axis_mouse_y, out float axis_hands_x, out float axis_hands_y, float pDt )
    {
        if( m_DeleteRequested )
        {
            delete this;
        }
            
        m_TimeNormalized = Math.InverseLerp(0, m_ReloadTime, m_Time);
        m_TimeNormalized = Math.Clamp(m_TimeNormalized, 0,0.99);
        
        ApplyMouseOffset(pDt, axis_mouse_x, axis_mouse_y);
        ApplyHandsOffset(pDt, axis_hands_x, axis_hands_y);
        if(m_IsClient)
            ApplyCamOffset(pModel);
        #ifdef DEVELOPER
        if(m_DebugMode)
            PrintString("RecoilBase | BEFORE | axis_mouse_y: " + axis_mouse_y.ToString());
        #endif
        axis_mouse_x = axis_mouse_x * m_RecoilModifier[0];
        axis_mouse_y = axis_mouse_y * m_RecoilModifier[1];
        
        axis_hands_x = axis_hands_x * m_RecoilModifier[0];
        axis_hands_y = axis_hands_y * m_RecoilModifier[1];
        
        #ifdef DEVELOPER
        if(m_DebugMode)
        {
            PrintString("RecoilBase | AFTER | axis_mouse_y: " + axis_mouse_y.ToString());
        }
        #endif
        m_Time += pDt;
        
        if( m_Time >= m_ReloadTime )
        {
            Destroy();
        }
    }
    
    void ApplyCamOffset(SDayZPlayerAimingModel pModel)
    {
        float time_rel = Math.Clamp(Math.InverseLerp(0, m_CamOffsetRelativeTime, m_TimeNormalized), 0, 1);
        float offset = 0;
        float time = Easing.EaseOutBack(time_rel);
        if(time == 1)
        {
            offset = 0;
        }
        else
        {
            offset = Math.Lerp(0,m_CamOffsetDistance,time);
        }
        
        pModel.m_fCamPosOffsetZ = offset;
        
        m_Player.GetCurrentCamera().SendRecoilOffsetZ(offset);
    }
    
    void ApplyHandsOffset(float pDt, out float pRecResultX, out float pRecResultY)
    {
        float relative_time = m_TimeNormalized / Math.Clamp(m_HandsOffsetRelativeTime, 0.001,1);
        vector pos_on_curve = GetPositionOnCurve(m_HandsCurvePoints, relative_time);
 
        /*if(m_DebugMode)
        {
            PrintString("pos_on_curve: " + pos_on_curve.ToString());
            PrintString("normalized time: " + m_TimeNormalized.ToString());
            PrintString("elapsed time: " + m_Time.ToString());
            PrintString("curve pos x: " + pos_on_curve[0].ToString());
            PrintString("curve pos y: " + pos_on_curve[1].ToString());
            PrintString("relative_time: " + relative_time.ToString());
        }*/
        
        pRecResultX = pos_on_curve[0];
        pRecResultY = pos_on_curve[1];
    }
    
    void ApplyMouseOffset(float pDt, out float pRecResultX, out float pRecResultY)
    {
        #ifdef DEVELOPER
        if(m_DebugMode)
        {
            bool b1 = m_MouseOffsetTargetAccum[1] < m_MouseOffsetTarget[1];
            PrintString( "RecoilBase | ApplyMouseOffset processing: " + b1 );
            PrintString( "RecoilBase | m_MouseOffsetTargetAccum : " + m_MouseOffsetTargetAccum.ToString() );
            PrintString( "RecoilBase | m_MouseOffsetTarget : " + m_MouseOffsetTarget.ToString() );
        }
        #endif
        
        if( m_MouseOffsetTargetAccum[1] < m_MouseOffsetTarget[1] )
        {
            float relative_delta = pDt / m_ReloadTime / Math.Clamp(m_MouseOffsetRelativeTime, 0.001,1);
            
            float delta_mouse_offset_x = m_MouseOffsetTarget[0] * relative_delta;
            float delta_mouse_offset_y = m_MouseOffsetTarget[1] * relative_delta;
            
            if( ( m_MouseOffsetTargetAccum[1] + delta_mouse_offset_y) > m_MouseOffsetTarget[1] )
            {
                delta_mouse_offset_x = m_MouseOffsetTarget[0] - m_MouseOffsetTargetAccum[0];
                delta_mouse_offset_y = m_MouseOffsetTarget[1] - m_MouseOffsetTargetAccum[1];
            }
            
            m_MouseOffsetTargetAccum[0] = m_MouseOffsetTargetAccum[0] + delta_mouse_offset_x;
            m_MouseOffsetTargetAccum[1] = m_MouseOffsetTargetAccum[1] + delta_mouse_offset_y;
            
            pRecResultX = delta_mouse_offset_x;
            pRecResultY = delta_mouse_offset_y;
            
            /*if(m_DebugMode)
            {
                PrintString( "delta x: "+ delta_mouse_offset_x );
                PrintString( "delta y: "+ delta_mouse_offset_y );
                PrintString( "target x: "+ m_MouseOffsetTarget[0] );
                PrintString( "target y: "+ m_MouseOffsetTarget[1] );
                PrintString( "accum x: "+ m_MouseOffsetTargetAccum[0] );
                PrintString( "accum y: "+ m_MouseOffsetTargetAccum[1] );
            }*/
        }
        #ifdef DEVELOPER
        if(m_DebugMode)
        {
            PrintString( "RecoilBase | pRecResultY: " + pRecResultY );
        }
        #endif
    }
    
    vector GetRecoilModifier(Weapon_Base weapon)
    {
        if( weapon )
        {
            return weapon.GetPropertyModifierObject().m_RecoilModifiers;
        }
        else return "1 1 1";
    }
    
    vector GetPositionOnCurve(array<vector> points, float time)
    {
        return Math3D.Curve(ECurveType.CatmullRom, time, points);
    }
}