scripts/4_World/DayZ/Classes/PlayerModifiers/ModifiersManager.c

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