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