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)
    {
        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));
        }
        
        float valuesSum = 0;
 
        for (i = 0; i < values.Count(); i++)
        {
            float value = values.Get(i);
            valuesSum += value;
        }
        
        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;
        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)
    {
        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;
 
        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.0;
    }
}