hitdirectionbase.c

Go to the documentation of this file.

 
 
class HitDirectionEffectBase
{
    const float DURATION_COEF_MIN = 0.6;
    const float INTENSITY_MIN = 0.6;
    
    float m_HitDirection;
    float m_Duration;
    float m_BreakPoint;
    float m_TimeActive;
    float m_IntensityMax;
    
    Widget m_LayoutRoot;
    Widget m_Image;
    
    DayZPlayer m_Player;
    
    bool m_Initialized;
    int m_SizeXEnf;
    int m_SizeYEnf;
    float m_PosX;
    float m_PosY;
    float m_PosXScreenEdge;
    float m_PosYScreenEdge;
    float m_AngleRad;
    float m_AngleRadPrev;
    float m_SmoothVel[1];
    
    ref HitDirectionImagesBase m_ImageData;
    
    void HitDirectionEffectBase()
    {
        m_Initialized = false;
        m_PosX = 0.0;
        m_PosY = 0.0;
        m_AngleRad = 0.0;
        m_SmoothVel[0] = 0.0;
        
        m_ImageData = GetImageData();
        m_ImageData.GetCurrentImageData(m_LayoutRoot,m_Image);
    }
    
    void Init(DayZPlayer player, float hit_direction, float intensity_max)
    {
        m_Player = player;
        float duration_coef = Math.Clamp(intensity_max,DURATION_COEF_MIN,1);
        m_IntensityMax = Math.Clamp(intensity_max,INTENSITY_MIN,1);
        m_Duration = m_DurationMax * duration_coef;
        m_BreakPoint = Math.Clamp(m_BreakPointBase * m_Duration,0,m_Duration);
        m_Scatter = Math.Clamp(m_Scatter,0.0,180.0);
        m_HitDirection = hit_direction + (Math.RandomFloatInclusive(0,m_Scatter) * Math.Pow(-1.0,Math.RandomIntInclusive(0,1)));
        
        Widget w = m_LayoutRoot;
        w = w.GetChildren();
        while (w)
        {
            w.Show(m_Image == w);
            w = w.GetSibling();
        }
        
        m_Image.SetColor(m_Color);
        
        m_LayoutRoot.Show(true);
        
        CalculateArrowPosition();
        SetIndicatorRotation();
        SetIndicatorPositon();
        m_Initialized = true;
    }
    
    HitDirectionImagesBase GetImageData(){}
    
    void ~HitDirectionEffectBase()
    {
        m_LayoutRoot.Show(false);
        delete m_LayoutRoot;
    }
    
    bool DurationCheck()
    {
        if ( m_TimeActive >= m_Duration )
        {
            return true;
        }
        return false;
    }
    
    void Update( float timeslice )
    {
        float intensity;
        
        if ( m_TimeActive <= m_BreakPoint )
        {
            intensity = m_IntensityMax;
        }
        else
        {
            float tmp_value = Math.InverseLerp(m_BreakPoint, m_Duration, m_TimeActive);
            intensity = Math.Lerp(m_IntensityMax,0.0,tmp_value);
        }
        
        m_TimeActive += timeslice;
        intensity = Math.Clamp(intensity,0,1);
        
        if ( m_TimeActive >= m_Duration )
        {
            m_LayoutRoot.Show(false);
        }
        else
        {
            m_LayoutRoot.SetAlpha(intensity);
            if ( m_Mode == HitDirectionModes.DYNAMIC )
            {
                CalculateArrowPosition(timeslice);
                SetIndicatorPositon(timeslice);
                SetIndicatorRotation(timeslice);
            }
        }
    }
    
    void CalculateArrowPosition(float timeslice = -1.0)
    {
        m_HitDirection = Math.NormalizeAngle(m_HitDirection);
        
        float angle_direction = m_Player.GetOrientation()[0];
        angle_direction = Math.NormalizeAngle(angle_direction);
        float camera_angle = GetGame().GetCurrentCameraDirection().VectorToAngles()[0];
        camera_angle = Math.NormalizeAngle(camera_angle);
        
        float angle_camera_diff = angle_direction - camera_angle;
        m_AngleRad = m_HitDirection + angle_camera_diff;
        m_AngleRad = Math.NormalizeAngle(m_AngleRad);
        m_AngleRad = m_AngleRad * Math.DEG2RAD;
        
        m_PosX = 0.0;
        m_PosY = 0.0;
        
        GetScreenSize(m_SizeXEnf,m_SizeYEnf);
        
        if ( m_Initialized && timeslice != -1.0 )
        {
            float val = m_AngleRadPrev - m_AngleRad + Math.PI;
            val = Math.ModFloat(val, Math.PI2);
            val -= Math.PI;
            m_AngleRad = m_AngleRadPrev - Math.SmoothCD(0, val, m_SmoothVel, 0.1, 1000, timeslice);
        }
        m_AngleRadPrev = m_AngleRad;
        
        m_PosXScreenEdge = Math.Clamp(Math.Sin(m_AngleRad)/Math.Sin(Math.PI/4),-1,1) * ( m_SizeXEnf/2 + m_DistanceAdjust * m_SizeXEnf);
        m_PosYScreenEdge = Math.Clamp(-1 * Math.Cos(m_AngleRad)/Math.Cos(Math.PI/4),-1,1) * ( m_SizeYEnf/2 + m_DistanceAdjust * m_SizeYEnf);
        
        FinalizePositionCalculation();
    }
    
    void FinalizePositionCalculation(){}
    void SetIndicatorRotation(float timeslice = -1.0){}
    
    void SetIndicatorPositon(float timeslice = -1.0)
    {
        m_LayoutRoot.SetPos(m_PosX,m_PosY,true);
    }
    
    //-----------------------------------------------------------------------
    //Static stuff below
    //-----------------------------------------------------------------------
    static bool m_ServerOverrideEnabled;
    static int m_Mode;
    static int m_ID;
    static int m_Color;
    static protected typename m_Type;
    static float m_DurationMax;
    static float m_BreakPointBase; 
    static float m_DistanceAdjust;
    static int m_RotationOverride;
    static float m_Scatter; 
    
    static void CheckValues()
    {
        m_ServerOverrideEnabled = CfgGameplayHandler.GetHitIndicationOverrideEnabled();
        if (m_ServerOverrideEnabled)
        {
            m_Mode = CfgGameplayHandler.GetHitIndicationMode();
            m_ID = CfgGameplayHandler.GetHitIndicationTypeID();
            m_Color = CfgGameplayHandler.GetHitIndicationIndicatorColor();
            m_DurationMax = CfgGameplayHandler.GetHitIndicationMaxDuration();
            m_BreakPointBase = CfgGameplayHandler.GetHitIndicationBreakPoint();
            m_Scatter = CfgGameplayHandler.GetHitIndicationScatter();
        }
        else
        {
            m_Mode = HitDirectionModes.STATIC;
            m_ID = HitIndicatorType.SPLASH;
            m_Color = HitDirectionConstants.COLOR_DEFAULT;
            m_DurationMax = HitDirectionConstants.DURATION_BASE;
            m_BreakPointBase = HitDirectionConstants.BREAKPOINT_BASE;
            m_Scatter = HitDirectionConstants.SCATTER;
        }
        m_DistanceAdjust = HitDirectionConstants.DISTANCE_ADJUST;
        m_RotationOverride = HitDirectionConstants.ROTATION_DEFAULT;
    }
    
    static typename GetCurrentType()
    {
        switch (m_ID)
        {
            case HitIndicatorType.SPLASH:
                m_Type = HitDirectionEffectSplash;
            break;
            
            case HitIndicatorType.SPIKE:
                m_Type = HitDirectionEffectSpike;
            break;
            
            case HitIndicatorType.ARROW:
                m_Type = HitDirectionEffectArrow;
            break;
            
            default:
                ErrorEx("Unknown HitDirection mode, using HitIndicatorType.SPLASH",ErrorExSeverity.INFO);
                m_Type = HitDirectionEffectSplash;
            break;
        }
        
        return m_Type;
    }
}