DebugMonitorValues.c

Go to the documentation of this file.

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 (GetGame().IsClient()) return;
    if (!GetGame().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());
      GetGame().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);
      GetGame().RPCSingleParam(m_Player, ERPCs.RPC_DEBUG_MONITOR_STR, CachedObjectsParams.PARAM2_INT_STRING, true, m_Player.GetIdentity());
    }
    break;
    }
  }
 
  void ReceiveValue(int value_type, Param param)
  {
    GetGame().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);
  }
};