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)
  {
 
  }
}