ModifiersManager.c

Go to the documentation of this file.

//max 32 synced modifiers supported
enum eModifierSyncIDs
{
 
  MODIFIER_SYNC_WOUND_INFECT_1 = 0x00000001,
  MODIFIER_SYNC_WOUND_INFECT_2 = 0x00000002,
  MODIFIER_SYNC_CONTAMINATION = 0x00000004,//stage1
  MODIFIER_SYNC_CONTAMINATION2 = 0x00000008,//stage2 and stage3 share the same sync id
  MODIFIER_SYNC_ZONE_EXPOSURE = 0x00000010,
  MODIFIER_SYNC_DROWNING = 0x00000020,
  MODIFIER_SYNC_FEVER = 0x00000040,
  //0x00000080,
  //0x00000100,
  //0x00000200,
  //0x00000400,
  //0x00000800,
  //0x00001000,
  LAST_INDEX,
};
 
 
enum EActivationType
{
 
  TRIGGER_EVENT_OFF,
  TRIGGER_EVENT_ON_ACTIVATION,
  TRIGGER_EVENT_ON_CONNECT
};
 
const int DEFAULT_TICK_TIME_ACTIVE = 3;
const int DEFAULT_TICK_TIME_ACTIVE_SHORT = 1;
const int DEFAULT_TICK_TIME_INACTIVE = 3;
const int DEFAULT_TICK_TIME_INACTIVE_LONG = 10;
 
class ModifierDebugObj
{
  string m_Name;
  int m_ID;
  bool m_IsActive;
  bool m_IsLocked;
 
  void ModifierDebugObj(int id, string name, bool active, bool locked)
  {
    m_Name = name;
    m_ID = id;
    m_IsActive = active;
    m_IsLocked = locked;
  }
 
  string GetName()
  {
    return m_Name;
  }
 
  int GetID()
  {
    return m_ID;
  }
 
  bool IsActive()
  {
    return m_IsActive;
  }
 
  bool IsLocked()
  {
    return m_IsLocked;
  }
}
 
class ModifiersManager
{
  PlayerBase m_Player;
  ref map<int, ref ModifierBase> m_ModifierList;
  ref array< ref ModifierBase> m_ModifierListArray = new array< ref ModifierBase>;
  ref array<ref Param> m_ParamList;
  bool m_AllowModifierTick = false;
  const int STORAGE_VERSION = 121;
  void ModifiersManager(PlayerBase player)
  {
    m_ModifierList = new map<int, ref ModifierBase>;
    m_ParamList = new array<ref Param>;
    m_Player = player;
 
    Init();
  }
 
  void Init()
  {
#ifdef DEVELOPER
    AddModifier(new TestDiseaseMdfr);
#endif
    AddModifier(new BloodRegenMdfr);
    //AddModifier(new BoneRegen);
    //AddModifier(new Health);
    AddModifier(new SalineMdfr);
    AddModifier(new HealthRegenMdfr);
    AddModifier(new HungerMdfr);
    //AddModifier(new Shock);
    AddModifier(new ImmuneSystemMdfr);
    AddModifier(new StomachMdfr);
    AddModifier(new HeatComfortMdfr);
    AddModifier(new ThirstMdfr);
    AddModifier(new BleedingCheckMdfr);
    //AddModifier(new Blinded);
    //AddModifier(new BrokenArms);
    AddModifier(new BrokenLegsMdfr); // <-- Broken legs are here
    AddModifier(new VomitStuffedMdfr);
    AddModifier(new BurningMdfr);
    AddModifier(new FeverMdfr);
    AddModifier(new HeartAttackMdfr);
    AddModifier(new HemolyticReactionMdfr);
    AddModifier(new PoisoningMdfr);
    AddModifier(new StuffedStomachMdfr);
    //AddModifier(new Tremor);
    AddModifier(new UnconsciousnessMdfr);
    AddModifier(new ShockDamageMdfr);
    AddModifier(new CommonColdMdfr);
    AddModifier(new CholeraMdfr);
    AddModifier(new InfluenzaMdfr);
    AddModifier(new SalmonellaMdfr);
    AddModifier(new BrainDiseaseMdfr);
    AddModifier(new WetMdfr);
    AddModifier(new ImmunityBoost);
    AddModifier(new AntibioticsMdfr);
    AddModifier(new ToxicityMdfr);
    AddModifier(new BreathVapourMdfr);
    AddModifier(new ShockMdfr);
    AddModifier(new WoundInfectStage1Mdfr);
    AddModifier(new WoundInfectStage2Mdfr);
    AddModifier(new CharcoalMdfr);
    AddModifier(new MorphineMdfr);
    AddModifier(new PainKillersMdfr);
    AddModifier(new EpinephrineMdfr);
    AddModifier(new HeatBufferMdfr);
    AddModifier(new DisinfectionMdfr);
    AddModifier(new FatigueMdfr);
    AddModifier(new ContaminationStage1Mdfr);
    AddModifier(new ContaminationStage2Mdfr);
    AddModifier(new ContaminationStage3Mdfr);
    AddModifier(new AreaExposureMdfr);
    AddModifier(new MaskMdfr);
    AddModifier(new FliesMdfr);
    AddModifier(new DrowningMdfr);
  }
 
  void SetModifiers(bool enable)
  {
    if (m_AllowModifierTick == enable)
      return;
 
    m_AllowModifierTick = enable;
 
#ifdef DIAG_DEVELOPER
#ifndef SERVER
    DiagMenu.SetValue(DiagMenuIDs.CHEATS_MODIFIERS, enable);
#endif
#endif
 
    if (!enable)
    {
      for (int i = 0; i < m_ModifierList.Count(); i++)
        m_ModifierList.GetElement(i).ResetLastTickTime();
    }
  }
 
  int GetStorageVersion()
  {
    return STORAGE_VERSION;
  }
 
  bool IsModifiersEnable()
  {
    return m_AllowModifierTick;
  }
 
  void AddModifier(ModifierBase modifier)
  {
    modifier.InitBase(m_Player, this);
    int id = modifier.GetModifierID();
 
    if (id < 1)
      Error("modifiers ID must be 1 or higher(for debugging reasons)");
 
    //TODO: add a check for duplicity
    m_ModifierList.Insert(id, modifier);
    m_ModifierListArray.Insert(modifier);
  }
 
  bool IsModifierActive(eModifiers modifier_id)
  {
    return m_ModifierList.Get(modifier_id).IsActive();
  }
 
  void OnScheduledTick(float delta_time)
  {
    if (!m_AllowModifierTick) return;
 
    foreach (ModifierBase m: m_ModifierListArray)
      m.Tick(delta_time);
 
  }
 
  void DeactivateAllModifiers()
  {
    for (int i = 0; i < m_ModifierList.Count(); i++)
      m_ModifierList.GetElement(i).Deactivate();
  }
 
  void ActivateModifier(int modifier_id, bool triggerEvent = EActivationType.TRIGGER_EVENT_ON_ACTIVATION)
  {
    m_ModifierList.Get(modifier_id).ActivateRequest(triggerEvent);
  }
 
  void DeactivateModifier(int modifier_id, bool triggerEvent = true)
  {
    m_ModifierList.Get(modifier_id).Deactivate(triggerEvent);
  }
 
  void OnStoreSave(ParamsWriteContext ctx)
  {
    CachedObjectsArrays.ARRAY_INT.Clear();
 
    int modifier_count;
    for (int x = 0; x < m_ModifierList.Count(); x++)
    {
      ModifierBase mdfr = m_ModifierList.GetElement(x);
      if (mdfr.IsActive() && mdfr.IsPersistent())
      {
        modifier_count++;
        //save the modifier id
        CachedObjectsArrays.ARRAY_INT.Insert(mdfr.GetModifierID());
        if (mdfr.IsTrackAttachedTime())
        {
          //save the overall attached time
          CachedObjectsArrays.ARRAY_INT.Insert(mdfr.GetAttachedTime());
        }
      }
    }
 
    //write the count
    //CachedObjectsParams.PARAM1_INT.param1 = modifier_count;
    //PrintString("Saving modifiers count: "+ modifier_count);
    ctx.Write(modifier_count);
 
    //write the individual modifiers and respective attached times
    for (int i = 0; i < CachedObjectsArrays.ARRAY_INT.Count(); i++)
    {
      int item = CachedObjectsArrays.ARRAY_INT.Get(i);
      //PrintString( "saving item: "+item );
      ctx.Write(item);
    }
 
    for (int z = 0; z < m_ParamList.Count(); z++)
      m_ParamList.Get(z).Serialize(ctx);
 
  }
 
  bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    int modifier_count;
    if (!ctx.Read(modifier_count))
      return false;
    //PrintString("Loading modifiers count: "+ modifier_count);
    for (int i = 0; i < modifier_count; i++)
    {
      int modifier_id;
      if (!ctx.Read(modifier_id))
        return false;
      //PrintString( "loading item: "+modifier_id );
      //int modifier_id = CachedObjectsParams.PARAM1_INT.param1;
      ModifierBase modifier = GetModifier(modifier_id);
      if (modifier)
      {
        if (modifier.IsTrackAttachedTime())
        {
          int time;
          if (!ctx.Read(time)) //get the attached time
            return false;
          modifier.SetAttachedTime(time);
        }
 
        ActivateModifier(modifier_id, EActivationType.TRIGGER_EVENT_ON_CONNECT);
      }
      else
        Debug.LogError("DB loading: non-existent modifier with id:" + modifier_id.ToString());
    }
 
    for (int x = 0; x < m_ParamList.Count(); x++)
    {
      if (!m_ParamList.Get(x).Deserializer(ctx))
        return false;
    }
    return true;
  }
 
  ModifierBase GetModifier(int modifier_id)
  {
    return m_ModifierList.Get(modifier_id);
  }
 
  PlayerBase GetPlayer()
  {
    return m_Player;
  }
 
  void SetModifierLock(int modifier_id, bool state)
  {
    m_ModifierList.Get(modifier_id).SetLock(state);
  }
 
 
  bool GetModifierLock(int modifier_id)
  {
    return m_ModifierList.Get(modifier_id).IsLocked();
  }
 
  void DbgGetModifiers(array<ref ModifierDebugObj> modifiers)
  {
    modifiers.Clear();
    for (int i = 1; i < eModifiers.COUNT; i++)
    {
      if (m_ModifierList.Contains(i))
      {
        ModifierBase modifier = m_ModifierList.Get(i);
        int modifier_id = modifier.GetModifierID();
        string modifier_name = modifier.GetName();
        bool active = modifier.IsActive();
        string debug_text = modifier.GetDebugTextSimple();
        bool is_locked = modifier.IsLocked();
 
        if (active && debug_text != "")
          modifier_name += " | " + debug_text;
        ModifierDebugObj obj = new ModifierDebugObj(modifier_id, modifier_name, active, is_locked);
 
        modifiers.Insert(obj);
      }
    }
  }
 
  void ResetAll()
  {
    bool hasAreaExposureModifier = IsModifierActive(eModifiers.MDF_AREAEXPOSURE);
    bool hasMaksModifier = IsModifierActive(eModifiers.MDF_MASK);
 
    DeactivateAllModifiers();
 
    if (hasAreaExposureModifier)
      ActivateModifier(eModifiers.MDF_AREAEXPOSURE);
 
    if (hasMaksModifier)
      ActivateModifier(eModifiers.MDF_MASK);
  }
}