PluginRemotePlayerDebugClient.c

Go to the documentation of this file.

enum eRemoteDebugType
{
  NONE,
  DAMAGE_ONLY,
  ALL,
}
 
class PluginRemotePlayerDebugClient extends PluginBase
{
  const int MAX_SIMULTANIOUS_PLAYERS = 10;
  ref array<ref RemotePlayerStatDebug> m_PlayerDebugStats = new array<ref RemotePlayerStatDebug>;
  ref map<PlayerBase, ref RemotePlayerDamageDebug> m_PlayerDebugDamage = new map<PlayerBase, ref RemotePlayerDamageDebug>;
 
  ref Widget m_RootWidget[MAX_SIMULTANIOUS_PLAYERS];
  ref Widget m_RootWidgetDamage[MAX_SIMULTANIOUS_PLAYERS];
  ref TextListboxWidget m_StatListWidgets[MAX_SIMULTANIOUS_PLAYERS];
  ref TextListboxWidget m_DamageListWidgets[MAX_SIMULTANIOUS_PLAYERS];
  ref TextWidget m_DistanceWidget[MAX_SIMULTANIOUS_PLAYERS];
  eRemoteDebugType m_DebugType;
 
  override void OnInit()
  {
#ifndef NO_GUI
    InitWidgets();
#endif
  }
 
  override void OnUpdate(float delta_time)
  {
#ifndef NO_GUI
    if (m_DebugType != 0) UpdateWidgetsStats();
#endif
  }
 
  void InitWidgets()
  {
    for (int i = 0; i < MAX_SIMULTANIOUS_PLAYERS; ++i)
    {
      m_RootWidget[i] = GetGame().GetWorkspace().CreateWidgets("gui/layouts/debug/day_z_debug_remoteinfo.layout");
      m_RootWidgetDamage[i] = GetGame().GetWorkspace().CreateWidgets("gui/layouts/debug/day_z_debug_remoteinfo_damage.layout");
      m_DamageListWidgets[i] = TextListboxWidget.Cast(m_RootWidgetDamage[i].FindAnyWidget("TextListboxWidget1"));
      m_StatListWidgets[i] = TextListboxWidget.Cast(m_RootWidget[i].FindAnyWidget("TextListboxWidget0"));
      m_DistanceWidget[i] = TextWidget.Cast(m_RootWidget[i].FindAnyWidget("TextWidget0"));
    }
  }
 
  void EnableWidgets(bool enable)
  {
    for (int i = 0; i < MAX_SIMULTANIOUS_PLAYERS; ++i)
    {
      m_RootWidget[i].Show(enable);
      m_RootWidgetDamage[i].Show(enable);
    }
  }
 
  void UpdateWidgetsStats()
  {
    int i = 0;
    for (; i < m_PlayerDebugStats.Count(); ++i)
    {
      RemotePlayerStatDebug rpd = m_PlayerDebugStats.Get(i);
      PlayerBase player = rpd.GetPlayer();
 
      if (player)
      {
        vector pos = player.GetPosition();
        vector screen_pos_stats = GetGame().GetScreenPos(pos + "0 0 0");
        vector screen_pos_damage = GetGame().GetScreenPos(pos + "0 2 0");
        m_RootWidget[i].SetPos(screen_pos_stats[0], screen_pos_stats[1]);
        m_RootWidgetDamage[i].SetPos(screen_pos_damage[0], screen_pos_damage[1]);
 
        if (screen_pos_stats[2] > 0 && screen_pos_stats[0] > 0 && screen_pos_stats[1] > 0)
        {
          m_RootWidget[i].Show(true);
          m_RootWidgetDamage[i].Show(true);
          UpdateStatsWidget(i, rpd);
          UpdateDistanceWidget(i, player);
          UpdateDamageWidget(i, player);
        }
        else
        {
          m_RootWidget[i].Show(false);
          m_RootWidgetDamage[i].Show(false);
        }
 
      }
    }
    for (; i < MAX_SIMULTANIOUS_PLAYERS; ++i)
    {
      m_RootWidget[i].Show(false);
      m_RootWidgetDamage[i].Show(false);
    }
  }
 
 
  void UpdateDamageWidget(int index, PlayerBase player)
  {
    array<ref DamageData> damage_list = new array<ref DamageData>;
    if (m_PlayerDebugDamage.Contains(player))
    {
      RemotePlayerDamageDebug value = m_PlayerDebugDamage.Get(player);
      value.GetReversed(damage_list);
 
      m_DamageListWidgets[index].ClearItems();
      if (damage_list.Count() > 0)
      {
        m_DamageListWidgets[index].Show(true);
        for (int i = 0; i < damage_list.Count(); ++i)
        {
          DamageData data = damage_list[i];
          float value_global = data.GetValueGlobal();
          float value_blood = data.GetValueBlood();
          float value_shock = data.GetValueShock();
 
          m_DamageListWidgets[index].AddItem(value_global.ToString(), null, 0, i);
          m_DamageListWidgets[index].SetItem(i, value_blood.ToString(), null, 1);
          m_DamageListWidgets[index].SetItem(i, value_shock.ToString(), null, 2);
        }
      }
      else
        m_DamageListWidgets[index].Show(false);
    }
  }
 
  void UpdateDistanceWidget(int index, PlayerBase other_player)
  {
    float distance = vector.Distance(GetGame().GetCurrentCameraPosition(), other_player.GetPosition());
    m_DistanceWidget[index].SetText(distance.ToString() + "m");
  }
 
  void UpdateStatsWidget(int index, RemotePlayerStatDebug rpd)
  {
    array<string> names = new array<string>;
    array<string> values = new array<string>;
    rpd.SerializeNames(names, m_DebugType);
    rpd.SerializeValues(values, m_DebugType);
    m_StatListWidgets[index].ClearItems();
 
    for (int i = 0; i < names.Count(); ++i)
    {
      m_StatListWidgets[index].AddItem(names.Get(i), null, 0, i);
      m_StatListWidgets[index].SetItem(i, values.Get(i), null, 1);
    }
  }
 
  void RequestPlayerInfo(PlayerBase player, int type)
  {
#ifdef DIAG_DEVELOPER
    if (type == 0)
      EnableWidgets(false);
    /*
      else
      {
      EnableWidgets(true);
      }
    */
    ScriptRPC rpc = new ScriptRPC();
    m_DebugType = type;
    rpc.Write(type);
    rpc.Send(player, ERPCs.DEV_PLAYER_DEBUG_REQUEST, true, player.GetIdentity());
#endif
  }
 
  void MergeDamage(array<ref RemotePlayerDamageDebug> delta)
  {
    foreach (RemotePlayerDamageDebug valueDelta : delta)
    {
      PlayerBase playerDelta = valueDelta.GetPlayer();
 
      if (m_PlayerDebugDamage.Contains(null))
      {
        //cleans up garbage
        m_PlayerDebugDamage.Remove(null);
      }
 
      if (m_PlayerDebugDamage.Contains(playerDelta))
      {
        RemotePlayerDamageDebug valueLocal = m_PlayerDebugDamage.Get(playerDelta);
        array<ref DamageData> damageList = new array<ref DamageData>;
        valueDelta.GetReversed(damageList);
 
        foreach (DamageData data : damageList)
          valueLocal.InsertDamageObject(data);
      }
      else
        m_PlayerDebugDamage.Insert(playerDelta, valueDelta);
    }
  }
 
  void DebugDamage(PlayerBase player)
  {
    for (int i = 0; i < m_PlayerDebugStats.Count(); i++)
    {
      player = m_PlayerDebugStats.Get(i).GetPlayer();
 
      PrintString("player:" + player.ToString());
      m_PlayerDebugStats.Get(i).Debug();
      PrintString("-------------------------------------");
    }
 
    for (i = 0; i < m_PlayerDebugDamage.Count(); i++)
    {
      PrintString("-------------------------------------");
      if (m_PlayerDebugDamage.GetElement(i)) m_PlayerDebugDamage.GetElement(i).Debug();
      PrintString("-------------------------------------");
    }
 
    for (i = 0; i < m_PlayerDebugDamage.Count(); i++)
    {
      PrintString("------------Debug Damage Start--------------");
      PlayerBase player2 = m_PlayerDebugDamage.GetKey(i);
      RemotePlayerDamageDebug obj = m_PlayerDebugDamage.Get(player2);
      obj.Debug();
      PrintString("-------------Debug Damage End-------------");
    }
  }
 
  void OnRPC(ParamsReadContext ctx)
  {
    ctx.Read(m_PlayerDebugStats);
 
    array<ref RemotePlayerDamageDebug> player_damage = new array<ref RemotePlayerDamageDebug>;
 
    ctx.Read(player_damage);
    PlayerBase player;
    for (int x = 0; x < player_damage.Count(); x++)
    {
      RemotePlayerDamageDebug value = player_damage.Get(x);
      if (value)
      {
        player = value.GetPlayer();
        PrintString("debug damage: " + x.ToString() + "," + player.ToString());
        value.Debug();
 
        int xs = 1 + 1;
      }
    }
 
    if (player_damage.Count() > 0) MergeDamage(player_damage);
  }
}