NotifierBase.c

Go to the documentation of this file.

class NotifierBase
{
 
  float m_DeltaT; // time in seconds since the last tick
  ref Timer m_Timer1; // timer which can be used for whatever
  PlayerBase m_Player; //the player this Notifier belongs to
  int m_Type;
  NotifiersManager m_Manager;
  int m_TendencyBufferSize = 3;//for best results, this should be somewhat aligned with modifier frequency
  const int TENDENCY_BUFFER_SIZE = 30;//this needs to be bigger or same size as buffer size of any invidual buffer size
  bool m_ShowTendency;
  bool m_Active;
  //private float   m_SecsToSound; //internal counter
  //protected float   m_MinPauseBetweenSounds; //minimal amount of seconds that needs to pass till sound is played
  //protected float   m_MaxPauseBetweenSounds; //maximal amount of seconds that can pass till sound is played
  //private float   m_SecsSinceLastAnimation; //internal counter
  //private float   m_SecsToAnimation; //internal counter
  //protected float   m_MinPauseBetweenAnimations; //minimal amount of seconds that needs to pass till animation played
  //protected float   m_MaxPauseBetweenAnimations; //maximal amount of seconds that can pass till animation is splayed
  int m_TickInterval;
  int m_TickIntervalLastTick;
  float m_TendencyBuffer[TENDENCY_BUFFER_SIZE];
  int m_TendencyBufferWriteIterator;
  float m_LastTendency;
  float m_LastMA;
  bool m_FirstPass = true;
  //int         m_TendencyID;
 
  PluginPlayerStatus m_ModulePlayerStatus;
 
  void NotifierBase(NotifiersManager manager)
  {
 
    //m_Timer1 = new Timer();
    m_ModulePlayerStatus = PluginPlayerStatus.Cast(GetPlugin(PluginPlayerStatus));
    m_Active = true;
    m_Manager = manager;
    m_Player = manager.GetPlayer();
    m_TickInterval = 1000;
    manager.RegisterItself(GetNotifierType(), this);
  }
 
  bool IsTimeToTick(int current_time)
  {
    return (current_time > m_TickIntervalLastTick + m_TickInterval);
  }
 
 
  VirtualHud GetVirtualHud()
  {
    return m_Player.GetVirtualHud();
  }
 
  int GetNotifierType()
  {
    return m_Type;
  }
 
  string GetName()
  {
    return this.ClassName() + " Notifier";
  }
 
  bool IsActive()
  {
    return m_Active;
  }
 
  void SetActive(bool state)
  {
    m_Active = state;
    if (!state) HideBadge();
  }
 
  void DisplayTendency(float delta)
  {
  }
 
  void AddToCyclicBuffer(float value)//for tendency
  {
    m_TendencyBuffer[m_TendencyBufferWriteIterator] = value;
    m_TendencyBufferWriteIterator++;
    if (m_TendencyBufferWriteIterator == m_TendencyBufferSize)
    {
      m_TendencyBufferWriteIterator = 0;
      m_ShowTendency = true;
    }
  }
 
  float ReadFromCyclicBuffer(int index)
  {
    int indx = m_TendencyBufferWriteIterator + index;
    if (indx >= m_TendencyBufferSize)
      indx = indx - m_TendencyBufferSize;
    return m_TendencyBuffer[indx];
  }
 
  float GetDeltaAvaraged()//for tendency
  {
    array<float> values = new array<float>;
    for (int i = 0; i < m_TendencyBufferSize; i++)
      values.Insert(ReadFromCyclicBuffer(i));
    //SmoothOutFloatValues(values);
 
    //--------------------------------------------------------------------------
 
    float values_sum = 0;
    //PrintString("----------------------------");
    //PrintString("tendency:" + this.ClassName() );
    for (i = 0; i < values.Count(); i++)
    {
      float value = values.Get(i);
      values_sum += value;
      //PrintString( value.ToString() );
    }
 
    float sma = values_sum / m_TendencyBufferSize;
    if (m_FirstPass)
    {
      m_LastMA = sma;
      m_FirstPass = false;
    }
 
    float tnd = sma - m_LastMA;
    m_LastMA = sma;
    /*
      PrintString(GetName()+" tendency:" + tnd.ToString() );
      PrintString("----------------------------");
    */
    return tnd;
 
    //--------------------------------------------------------------------------
 
  }
 
  void SmoothOutFloatValues(array<float> values)
  {
    float value1;
    float value2;
    for (int i = 0; i < values.Count() - 1; i++)
    {
      value1 = values.Get(i);
      value2 = values.Get(i + 1);
      float average = (value1 + value2) / 2;
      values.Set(i, average);
      values.Set(i + 1, average);
    }
    int index = values.Count() - 1;
    values.Set(index, value2);
  }
 
  void OnTick(float current_time)
  {
    //------------
    /*
      float time = GetGame().GetTime();
      Print("ticking notifier "+ this.ClassName() +" for player " + m_Player.ToString() + " at time:" + time.ToString());
    */
    //------------
    m_TickIntervalLastTick = current_time;
    DisplayBadge();
    AddToCyclicBuffer(GetObservedValue());
    if (m_ShowTendency) DisplayTendency(GetDeltaAvaraged());
 
  }
 
  protected int CalculateTendency(float delta, float inctresholdlow, float inctresholdmed, float inctresholdhigh, float dectresholdlow, float dectresholdmed, float dectresholdhigh)
  {
    int tendency = TENDENCY_STABLE;
    if (delta > inctresholdlow) tendency = TENDENCY_INC_LOW;
    if (delta > inctresholdmed) tendency = TENDENCY_INC_MED;
    if (delta > inctresholdhigh) tendency = TENDENCY_INC_HIGH;
    if (delta < dectresholdlow) tendency = TENDENCY_DEC_LOW;
    if (delta < dectresholdmed) tendency = TENDENCY_DEC_MED;
    if (delta < dectresholdhigh) tendency = TENDENCY_DEC_HIGH;
    //Print(" " + delta + " tendency:  " + tendency +" " + this);
    return tendency;
  }
 
 
  protected eBadgeLevel DetermineBadgeLevel(float value, float lvl_1, float lvl_2, float lvl_3)
  {
    eBadgeLevel level = eBadgeLevel.NONE;
    if (value >= lvl_1) level = eBadgeLevel.FIRST;
    if (value >= lvl_2) level = eBadgeLevel.SECOND;
    if (value >= lvl_3) level = eBadgeLevel.THIRD;
    return level;
  }
 
 
  protected void DisplayBadge()
  {
  }
 
  protected void HideBadge()
  {
  }
 
  protected float GetObservedValue()
  {
    return 0;
  }
}