BleedingDrop.c

Go to the documentation of this file.

 
class BleedingIndicatorDropData
{
  protected ImageWidget m_Widget;
  protected int m_Severity;
  protected float m_TimeTotal;
  protected float m_ProgressBreakpointTime;
  protected float m_ProgressFadingDuration; //remaining duration AFTER breakpoint
  protected float m_ProgressBreakpoint;
  protected float m_Duration;
  protected float m_SpeedCoef;
  protected int m_ScatterPx;
  protected float m_SlideDistance;
 
  protected float m_ColorAlphaStart;
  protected float m_ColorAlphaEnd;
  protected float m_ColorAlphaCurrent;
 
  protected float m_ImageBaseSizeX;
  protected float m_ImageBaseSizeY;
  protected float m_ImageStartingSizeX; //adjusted by percentage
  protected float m_ImageStartingSizeY; //adjusted by percentage
  protected float m_ImageEndSizeX; //adjusted by percentage
  protected float m_ImageEndSizeY; //adjusted by percentage
  protected float m_ImageMaxSizeX;
  protected float m_ImageMaxSizeY;
  protected float m_ImageBaseRotation;
  protected bool m_IsRunning;
  protected vector m_BasePosition;
  protected int m_ScreenSizeX;
  protected int m_ScreenSizeY;
  protected float m_PosX, m_PosY;
  protected float m_StartSizeCoef;
  protected float m_EndSizeCoef;
  protected float m_RandomSizeMin;
  protected float m_RandomSizeMax;
 
  //Written with relative positioning in mind
  void BleedingIndicatorDropData(ImageWidget image, int severity)
  {
    m_Widget = image;
    m_Severity = severity;
    m_TimeTotal = 0;
    m_IsRunning = false;
 
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
    {
      m_Duration = DbgBleedingIndicationStaticInfo.m_DbgDropDurationBase;
      m_ProgressBreakpointTime = m_Duration * DbgBleedingIndicationStaticInfo.m_DbgDropProgressTreshold;
      m_ProgressBreakpoint = DbgBleedingIndicationStaticInfo.m_DbgDropProgressTreshold;
      m_StartSizeCoef = DbgBleedingIndicationStaticInfo.m_DbgDropStartSize;
      m_EndSizeCoef = DbgBleedingIndicationStaticInfo.m_DbgDropEndSize;
      m_RandomSizeMin = DbgBleedingIndicationStaticInfo.m_DbgDropSizeVariationMin;
      m_RandomSizeMax = DbgBleedingIndicationStaticInfo.m_DbgDropSizeVariationMax;
      m_ScatterPx = DbgBleedingIndicationStaticInfo.m_DbgDropScatter;
      m_SlideDistance = DbgBleedingIndicationStaticInfo.m_DbgDropSlideDistance;
    }
    else
#endif
    {
      switch (m_Severity)
      {
      case BleedingIndicationConstants.INDICATOR_SEVERITY_LOW:
      {
        m_Duration = BleedingIndicationConstants.DROP_DURATION_LOW;
        m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_LOW;
        m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_LOW;
        m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_LOW;
        m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_LOW;
        m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_LOW;
        m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_LOW;
        break;
      }
      case BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM:
      {
        m_Duration = BleedingIndicationConstants.DROP_DURATION_MEDIUM;
        m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_MEDIUM;
        m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_MEDIUM;
        m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_MEDIUM;
        m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_MEDIUM;
        m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_MEDIUM;
        m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_MEDIUM;
        break;
      }
      case BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH:
      {
        m_Duration = BleedingIndicationConstants.DROP_DURATION_HIGH;
        m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_HIGH;
        m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_HIGH;
        m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_HIGH;
        m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_HIGH;
        m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_HIGH;
        m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_HIGH;
        break;
      }
      }
 
      m_ProgressBreakpointTime = m_Duration * BleedingIndicationConstants.DROP_PROGRESS_THRESHOLD;
      m_ProgressBreakpoint = BleedingIndicationConstants.DROP_PROGRESS_THRESHOLD;
    }
    m_ProgressFadingDuration = Math.Max(0.0001, m_Duration - m_ProgressBreakpointTime);
 
    m_SpeedCoef = 1.0; //TODO ??
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
    {
      m_ColorAlphaStart = DbgBleedingIndicationStaticInfo.m_DbgDropColorAlphaStart / 255;
      m_ColorAlphaEnd = DbgBleedingIndicationStaticInfo.m_DbgDropColorAlphaEnd / 255;
    }
    else
#endif
    {
      m_ColorAlphaStart = BleedingIndicationConstants.DROP_COLOR_ALPHA_START / 255;
      m_ColorAlphaEnd = BleedingIndicationConstants.DROP_COLOR_ALPHA_END / 255;
    }
    InitImageScale();
    GetScreenSize(m_ScreenSizeX, m_ScreenSizeY);
    AdjustColorSaturation();
  }
 
  void ~BleedingIndicatorDropData()
  {
  }
 
  protected void InitImageScale()
  {
    m_Widget.GetSize(m_ImageBaseSizeX, m_ImageBaseSizeY);
    float randomScaleCoef = Math.RandomFloatInclusive(m_RandomSizeMin, m_RandomSizeMax);
 
    m_ImageStartingSizeX = m_ImageBaseSizeX * m_StartSizeCoef * randomScaleCoef;
    m_ImageEndSizeX = m_ImageBaseSizeX * m_EndSizeCoef * randomScaleCoef;
    m_ImageStartingSizeY = m_ImageBaseSizeY * m_StartSizeCoef * randomScaleCoef;
    m_ImageEndSizeY = m_ImageBaseSizeY * m_EndSizeCoef * randomScaleCoef;
  }
 
  void ScatterPosition(vector pos)
  {
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
      m_ScatterPx = DbgBleedingIndicationStaticInfo.m_DbgDropScatter;
#endif
    float rndRadius = Math.RandomFloatInclusive(0.0, m_ScatterPx);
    float rndPos = Math.RandomFloatInclusive(0.0, Math.PI2);
    m_PosX = pos[0];
    m_PosX = m_PosX + rndRadius * Math.Sin(rndPos);
 
    m_PosY = pos[1];
    m_PosY = m_PosY + rndRadius * Math.Cos(rndPos);
  }
 
  void StartDrop()
  {
    m_TimeTotal = 0;
 
    ScatterPosition(m_BasePosition);
    m_Widget.SetPos(m_PosX, m_PosY);
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues && !DbgBleedingIndicationStaticInfo.m_DbgDropRotationRandom)
      m_Widget.SetRotation(0, 0, 0);
    else
#endif
    {
      m_Widget.SetRotation(0, 0, Math.RandomFloatInclusive(0.0, 360.0));
    }
 
    m_Widget.Show(true);
    m_IsRunning = true;
  }
 
  void StopDrop()
  {
    m_IsRunning = false;
    m_Widget.SetSize(m_ImageBaseSizeX, m_ImageBaseSizeY); //resets image size
    m_Widget.Show(false);
  }
 
  void SetBasePosition(vector pos)
  {
    m_BasePosition = pos;
    m_BasePosition[0] = m_BasePosition[0] - m_ScreenSizeX / 2;
    m_BasePosition[1] = m_BasePosition[1] - m_ScreenSizeY / 2;
  }
 
  bool IsRunning()
  {
    return m_IsRunning;
  }
 
  ImageWidget GetImage()
  {
    return m_Widget;
  }
 
  void AdjustColorSaturation()
  {
    //color adjustment
    float r = BleedingIndicationConstants.DROP_COLOR_RED;
    float g = BleedingIndicationConstants.DROP_COLOR_GREEN;
    float b = BleedingIndicationConstants.DROP_COLOR_BLUE;
    float desaturationEnd = BleedingIndicationConstants.DROP_COLOR_DESATURATIONEND;
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
    {
      r = DbgBleedingIndicationStaticInfo.m_DbgDropColorRed;
      g = DbgBleedingIndicationStaticInfo.m_DbgDropColorGreen;
      b = DbgBleedingIndicationStaticInfo.m_DbgDropColorBlue;
      desaturationEnd = DbgBleedingIndicationStaticInfo.m_DbgDesaturationEnd;
    }
#endif
 
    //saturation adjustment
#ifdef DIAG_DEVELOPER
    if (!DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues || (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues && DbgBleedingIndicationStaticInfo.m_DbgDropDesaturate))
    {
#endif
      Param par = PPEManagerStatic.GetPPEManager().GetPostProcessCurrentValues(PostProcessEffectType.Glow, PPEGlow.PARAM_SATURATION);
      float saturationProgress = Param1<float>.Cast(par).param1;
      saturationProgress = Easing.EaseOutSine(saturationProgress);
      saturationProgress = Math.Lerp(desaturationEnd, 1.0, saturationProgress);
      float lowest_channel = Math.Min(Math.Min(r, g), b);
      r = Math.Lerp(lowest_channel, r, saturationProgress);
      g = Math.Lerp(lowest_channel, g, saturationProgress);
      b = Math.Lerp(lowest_channel, b, saturationProgress);
#ifdef DIAG_DEVELOPER
    }
#endif
 
    int color = ARGB(0x00, r, g, b);
    m_Widget.SetColor(color);
  }
 
  void UpdateAlpha(float progress, float progressFade)
  {
    if (progress <= m_ProgressBreakpoint)
      m_ColorAlphaCurrent = m_ColorAlphaStart;
    else
      m_ColorAlphaCurrent = Math.Lerp(m_ColorAlphaStart, m_ColorAlphaEnd, progressFade);
 
    m_Widget.SetAlpha(m_ColorAlphaCurrent);
  }
 
  void UpdateTransform(float progress, float progressFade)
  {
    float breakProgress = Math.Clamp(Math.InverseLerp(0.0, m_ProgressBreakpoint, progress), 0, 1);
    float sizeX = Math.Lerp(m_ImageStartingSizeX, m_ImageEndSizeX, breakProgress);
    float sizeY = Math.Lerp(m_ImageStartingSizeY, m_ImageEndSizeY, breakProgress);
    m_Widget.SetSize(sizeX, sizeY);
 
    if (progress <= m_ProgressBreakpoint)
    {
      //do stuff before breakpoint
    }
    else
    {
      //do stuff after breakpoint
      float posYTemp = Math.Lerp(m_PosY, m_PosY + m_SlideDistance, progressFade);
      m_Widget.SetPos(m_PosX, posYTemp);
    }
  }
 
  void Update(float timeSlice)
  {
    if (m_IsRunning)
    {
      float progress, progressFade;
      progress = m_TimeTotal / m_Duration;
      progressFade = (m_TimeTotal - m_ProgressBreakpointTime) / m_ProgressFadingDuration;
 
      //alpha
      UpdateAlpha(progress, progressFade);
      //transform + scaling
      UpdateTransform(progress, progressFade);
 
      m_TimeTotal += (timeSlice * m_SpeedCoef);
 
      if (m_TimeTotal >= m_Duration)
      {
        //deletes this;
        StopDrop();
      }
    }
  }
}