DebugMonitorValues.c

class DebugMonitorValues
{
	const int TYPE_HEALTH 		= 1;
	const int TYPE_BLOOD 		= 2;
	const int TYPE_BODY_TEMP 	= 3;
	const int TYPE_POSITION 	= 4;
	const int TYPE_LAST_DAMAGE 	= 5;
	
	const int LAST_DAMAGE_FALL	= 1;
	const int LAST_DAMAGE_HIT	= 2;

	const float VALUE_CHECK_INTERVAL	 	= 1;
	const float SENSITIVTY_PERCENTAGE 		= 1;//how much the value needs to change up/down from previous update to trigger a new update(in percent)

	PlayerBase m_Player;
	float m_TimeSinceLastTick = VALUE_CHECK_INTERVAL + 1;
	
	string m_CurrentLastDamage;
	
	float m_LastHealthUpdate;
	float m_LastBloodUpdate;
	string m_lastDamageUpdate;
	
	float m_HealthMaxValue;
	float m_BloodMaxValue;

	float m_BloodClient;
	float m_HealthClient;
	string m_LastDamageClient;
	
	void DebugMonitorValues(PlayerBase player)
	{
		m_Player = player;
		Init();
	}

	void Init()
	{
		m_HealthMaxValue 	= m_Player.GetMaxHealth("", "Health");
		m_BloodMaxValue 	= m_Player.GetMaxHealth("", "Blood");
	}
	
	void OnScheduledTick(float deltatime)
	{
		if ( g_Game.IsClient() ) return;
		if ( !g_Game.IsDebugMonitor() ) return; // turned off in server config
		
		m_TimeSinceLastTick += deltatime;
		
		if ( m_TimeSinceLastTick > VALUE_CHECK_INTERVAL )
		{
			m_TimeSinceLastTick = 0;
			CheckValues();
		}
	}
	
	void CheckValues()
	{
		CheckHealth();
		CheckBlood();
		CheckLastDamage();
	}
	
	float GetBlood()
	{
		return m_BloodClient;
	}
	
	float GetHealth()
	{
		return m_HealthClient;
	}
	
	string GetLastDamage()
	{
		return m_LastDamageClient;
	}
	
	void SetLastDamage(string value)
	{
		m_CurrentLastDamage = value;
	}
	
	void CheckHealth()
	{
		float health_current = m_Player.GetHealth("","Health");
		float health_normalized = health_current / m_HealthMaxValue;
		float difference_normalized = health_normalized - m_LastHealthUpdate;
		float diff_abs = Math.AbsFloat(difference_normalized);
		
		if ( diff_abs > ( SENSITIVTY_PERCENTAGE /100 ) )
		{
			Param1<float> param = new Param1<float>( health_current );

			SendValue(TYPE_HEALTH, param);
			m_LastHealthUpdate = health_normalized;
		}
	}
	
	void CheckBlood()
	{
		float blood_current = m_Player.GetHealth("","Blood");
		float blood_normalized = blood_current / m_BloodMaxValue;
		float difference_normalized = blood_normalized - m_LastBloodUpdate;
		float diff_abs = Math.AbsFloat(difference_normalized);
		
		if ( diff_abs > ( SENSITIVTY_PERCENTAGE /100 ) )
		{
			Param1<float> param = new Param1<float>( blood_current );
			
			SendValue(TYPE_BLOOD, param);
			m_LastBloodUpdate = blood_normalized;
		}
	}
	
	void CheckLastDamage()
	{
		if (m_CurrentLastDamage != m_lastDamageUpdate)
		{
			Param1<string> param = new Param1<string>(m_CurrentLastDamage);
			SendValue(TYPE_LAST_DAMAGE, param);
			m_lastDamageUpdate = m_CurrentLastDamage;
		}
	}
	
	void SendValue(int value_type, Param param)
	{
		switch(value_type)
		{
		case DebugMonitorValues.TYPE_HEALTH:
		case DebugMonitorValues.TYPE_BLOOD:
			{	
				Param1<float> value_float = Param1<float>.Cast( param );

				CachedObjectsParams.PARAM2_INT_FLOAT.param1 = value_type;
				CachedObjectsParams.PARAM2_INT_FLOAT.param2 = value_float.param1;
				//Print("SendingValue type " + value_type.ToString() + " value "  + value_float.ToString());
				g_Game.RPCSingleParam(m_Player, ERPCs.RPC_DEBUG_MONITOR_FLT, CachedObjectsParams.PARAM2_INT_FLOAT, true, m_Player.GetIdentity());
			}
			break;
		case DebugMonitorValues.TYPE_LAST_DAMAGE:
			{
				Param1<string> value_string = Param1<string>.Cast( param );

				CachedObjectsParams.PARAM2_INT_STRING.param1 = value_type;
				CachedObjectsParams.PARAM2_INT_STRING.param2 = value_string.param1;
				//Print("SendingValue type " + value_type.ToString() + " value "  + value_string);
				g_Game.RPCSingleParam(m_Player, ERPCs.RPC_DEBUG_MONITOR_STR, CachedObjectsParams.PARAM2_INT_STRING, true, m_Player.GetIdentity());
			}
			break;
		}
	}

	void ReceiveValue(int value_type, Param param)
	{	
		g_Game.GetMission().CreateDebugMonitor();
		
		switch (value_type)
		{
		case DebugMonitorValues.TYPE_HEALTH:
			{
				Param1<float> valueHealth = Param1<float>.Cast( param );
				//Print("ReceivedValue health " + valueHealth.param1.ToString());
				m_HealthClient = valueHealth.param1;
			}
			break;
		case DebugMonitorValues.TYPE_BLOOD:
			{
				Param1<float> valueBlood = Param1<float>.Cast( param );
				//Print("ReceivedValue blood " + valueBlood.param1.ToString());
				m_BloodClient = valueBlood.param1;
			}
			break;
		case DebugMonitorValues.TYPE_LAST_DAMAGE:
			{
				Param1<string> valueLastDamage = Param1<string>.Cast( param );
				//Print("ReceivedValue lastdamage " + valueLastDamage.param1);
				m_LastDamageClient = valueLastDamage.param1;
			}
			break; 		
		}
	}

	void OnRPCFloat(ParamsReadContext ctx)
	{
		Param1<float> value = new Param1<float>(0);
		
		ctx.Read(CachedObjectsParams.PARAM2_INT_FLOAT);
		int value_type 	= CachedObjectsParams.PARAM2_INT_FLOAT.param1;
		value.param1 	= CachedObjectsParams.PARAM2_INT_FLOAT.param2;
		
		ReceiveValue(value_type, value);
	}
	
	void OnRPCString(ParamsReadContext ctx)
	{
		Param1<string> value = new Param1<string>("");

		ctx.Read(CachedObjectsParams.PARAM2_INT_STRING);
		int value_type 	= CachedObjectsParams.PARAM2_INT_STRING.param1;
		value.param1 	= CachedObjectsParams.PARAM2_INT_STRING.param2;
		
		ReceiveValue(value_type, value);
	}
};