modifierbase.c

Go to the documentation of this file.

enum eModifiersTickType//bitmask
{
 TICK = 1,
 ACTIVATE_CHECK = 2,
 DEACTIVATE_CHECK = 4,
}
 
 
class ModifierBase
{
 int m_ID = 0;
 ModifiersManager m_Manager;//the manager instance
 string m_System = "Modifiers";
 float m_ActivatedTime;//overall time this modifier was active
 bool m_TrackActivatedTime;//should this modifier track overall time it was active ?
 bool m_IsPersistent;//is this modifier saved to the DB ?
 PlayerBase m_Player;
 float m_TickIntervalInactive = 5;
 float m_TickIntervalActive = 3;
 bool m_IsActive;
 bool m_ShouldBeActive;
 float m_AccumulatedTimeActive;
 float m_AccumulatedTimeInactive;
 float m_LastTickedActive;
 int m_TickType = (eModifiersTickType.TICK | eModifiersTickType.ACTIVATE_CHECK | eModifiersTickType.DEACTIVATE_CHECK);//some modifiers do not need to check activate condition, as they get activated by request 
 float m_LastTickedInactive;
 bool m_IsLocked = false;
 EActivationType m_ActivationType;
 eModifierSyncIDs m_SyncID;//max 32 synced modifiers supported, 0 == no sync
 PluginPlayerStatus m_ModulePlayerStatus;
 
 void ModifierBase()
 {
 Class.CastTo(m_ModulePlayerStatus, GetPlugin(PluginPlayerStatus));
 }
 
 void InitBase(PlayerBase player, ModifiersManager manager)
 {
 m_Manager = manager;
 m_Player = player;
 Init();
 }
 
 void Init(){}
 
 
 PlayerBase GetPlayer()
 {
 return m_Player;
 }
 
 bool IsPersistent()
 {
 return m_IsPersistent;
 }
 
 void MakeParamObjectPersistent(Param object)
 {
 m_Manager.m_ParamList.Insert(object);
 }
 
 
 void ResetLastTickTime()
 {
 m_LastTickedActive = 0;
 }
 
 string GetDebugText()
 {
 return "";
 }
 
 string GetDebugTextSimple()
 {
 return "";
 }
 
 void DisableActivateCheck()
 {
 m_TickType = (m_TickType & ~eModifiersTickType.ACTIVATE_CHECK);
 } 
 
 void DisableDeactivateCheck()
 {
 m_TickType = (m_TickType & ~eModifiersTickType.DEACTIVATE_CHECK);
 }
 
 void Tick(float delta_time)
 {
 
 if( !m_IsActive && m_ShouldBeActive )
 {
 Activate();
 }
 
 if( m_IsActive )
 {
 m_AccumulatedTimeActive += delta_time;
 if( m_AccumulatedTimeActive > m_TickIntervalActive )
 {
 if( m_TickType & eModifiersTickType.DEACTIVATE_CHECK && DeactivateCondition(m_Player) && !IsLocked() )
 {
 Deactivate();
 }
 else//if(m_TickType & eModifiersTickType.TICK)
 {
 m_ActivatedTime += m_AccumulatedTimeActive;
 OnTick(m_Player, m_AccumulatedTimeActive);
 }
 m_AccumulatedTimeActive = 0;
 }
 }
 else if(m_TickType & eModifiersTickType.ACTIVATE_CHECK)
 {
 m_AccumulatedTimeInactive += delta_time;
 if( m_AccumulatedTimeInactive > m_TickIntervalInactive )
 {
 if( ActivateCondition(m_Player) )
 {
 if( !IsLocked() ) 
 {
 ActivateRequest(EActivationType.TRIGGER_EVENT_ON_ACTIVATION);
 }
 }
 m_AccumulatedTimeInactive = 0;
 }
 }
 }
 
 bool IsActive()
 {
 return m_IsActive;
 }
 
 void SetLock(bool state)
 {
 m_IsLocked = state;
 }
 
 bool IsLocked()
 {
 return m_IsLocked; 
 }
 
 bool IsTrackAttachedTime()
 {
 return m_TrackActivatedTime;
 }
 
 float GetAttachedTime()
 {
 return m_ActivatedTime;
 }
 
 void SetAttachedTime(float time)
 {
 m_ActivatedTime = time;
 }
 
 int GetModifierID()
 {
 return m_ID;
 }
 
 string GetName()
 {
 string name = ClassName();
 int index_start = name.Length() - 4;
 int index_end = name.Length();
 name = name.SubstringInverted(name, index_start, index_end);
 return name;
 }
 
 bool ActivateCondition(PlayerBase player)
 {
 return false;
 }
 
 bool DeactivateCondition(PlayerBase player)
 {
 return false;
 }
 
 void OnActivate(PlayerBase player)
 {
 
 }
 
 void OnReconnect(PlayerBase player)
 {
 
 }
 
 void OnDeactivate(PlayerBase player)
 {
 
 }
 
 void Activate()
 {
 m_IsActive = true;
 m_Player.m_SyncedModifiers = (m_Player.m_SyncedModifiers | m_SyncID);
 if( m_ActivationType == EActivationType.TRIGGER_EVENT_ON_ACTIVATION ) OnActivate(m_Player);
 else if(m_ActivationType == EActivationType.TRIGGER_EVENT_ON_CONNECT ) OnReconnect(m_Player);
 m_Player.SetSynchDirty();
 }
 
 void ActivateRequest(EActivationType trigger)
 {
 m_ShouldBeActive = true;
 m_ActivationType = trigger;
 }
 
 void Deactivate(bool trigger = true)
 {
 if(!m_IsActive)
 return;
 m_Player.m_SyncedModifiers = (m_Player.m_SyncedModifiers & ~m_SyncID);
 m_ShouldBeActive = false;
 m_IsActive = false;
 m_ActivatedTime = 0;
 if(trigger) 
 OnDeactivate(m_Player);
 }
 
 
 void OnStoreSave( ParamsWriteContext ctx )
 {
 }
 
 
 private void OnTick(PlayerBase player, float deltaT)
 {
 
 }
}