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;
    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;
    
    PluginPlayerStatus  m_ModulePlayerStatus;
        
    void NotifierBase(NotifiersManager manager)
    {
        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)
    {
        int tickTime = (m_TickIntervalLastTick + m_TickInterval);
        bool tick = (current_time >= tickTime);
        #ifdef DIAG_NOTIFIER_LOGS
        ErrorEx(string.Format("Tick time for notifier %1 is %2 | Current time= %3.", this, tickTime, current_time), ErrorExSeverity.INFO);
        if (tick)
        {
            float timePassed = (current_time - m_TickIntervalLastTick) / 1000.0;
            float expectedInterval = m_TickInterval / 1000.0;
            float drift = (current_time - tickTime) / 1000.0;
            ErrorEx(string.Format("Notifier %1 updated after %2s (expected: %3s, drift: +%4s)", this, timePassed, expectedInterval, drift), ErrorExSeverity.INFO);
        }
        #endif
        return tick;
    }
 
    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));
        }
        
        float valuesSum = 0;
 
        int nValues = values.Count();
        for (i = 0; i < nValues; ++i)
        {
            valuesSum += values.Get(i);
        }
        
        float sma = valuesSum / m_TendencyBufferSize;
        if (m_FirstPass)
        {
            m_LastMA = sma;
            m_FirstPass = false;
        }
        
        float tnd = sma - m_LastMA;
        m_LastMA = sma;
 
        return tnd;
    }
    
    void SmoothOutFloatValues(array<float> values)
    {
        float value1;
        float value2;
        int nValues = values.Count();
        for (int i = 0; i < nValues - 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 = nValues - 1;
        values.Set(index, value2);
    }
 
    void OnTick(float current_Time)
    {
        OnTick((int)current_Time);
    }
    
    void OnTick(int currentTime)
    {
        #ifdef DIAG_NOTIFIER_LOGS
        ErrorEx(string.Format("Set last tick interval time on notifier %1 | Time= %2.", m_TickIntervalLastTick, currentTime), ErrorExSeverity.INFO);
        #endif  
        m_TickIntervalLastTick = currentTime;
        
        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 > inctresholdhigh)
            tendency = TENDENCY_INC_HIGH;   
        else if (delta > inctresholdmed)
            tendency = TENDENCY_INC_MED;
        else if (delta > inctresholdlow)
            tendency = TENDENCY_INC_LOW;
        else if (delta < dectresholdhigh)
            tendency = TENDENCY_DEC_HIGH;       
        else if (delta < dectresholdmed)
            tendency = TENDENCY_DEC_MED;
        else if (delta < dectresholdlow)
            tendency = TENDENCY_DEC_LOW;
 
        return tendency;
    }
    
    
    protected eBadgeLevel DetermineBadgeLevel(float value, float lvl_1, float lvl_2, float lvl_3)
    {
        eBadgeLevel level = eBadgeLevel.NONE;
        if (value >= lvl_3)
            level = eBadgeLevel.THIRD;
        else if (value >= lvl_2)
            level = eBadgeLevel.SECOND;
        else if (value >= lvl_1)
            level = eBadgeLevel.FIRST;
 
        return  level;
    }
    
 
    protected void DisplayBadge();
    protected void HideBadge();
 
    protected float GetObservedValue()
    {
        return 0.0;
    }
}