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