pluginremoteplayerdebugserver.c

Go to the documentation of this file.

class PluginRemotePlayerDebugServer extends PluginBase
{   
    ref set<PlayerBase> m_ClientList = new set<PlayerBase>;
    
    ref array<ref RemotePlayerStatDebug> m_PlayerDebugStats = new array<ref RemotePlayerStatDebug>;
    ref map<PlayerBase, ref RemotePlayerDamageDebug> m_PlayerDebugDamage = new map<PlayerBase, ref RemotePlayerDamageDebug>;
    float m_AccuTime;
    const int INTERVAL = 1;
    
    eRemoteDebugType m_DebugType;
    bool m_Watching;
    
    override void OnUpdate(float delta_time)
    {
        #ifdef SERVER
        if ( m_ClientList.Count() != 0 )
        {
            m_AccuTime += delta_time;
            
            if ( m_AccuTime > INTERVAL )
            {
                m_AccuTime = 0;
                SendDebug();
            }
        }
        #endif
    }
    
    void SetWatching(bool enable)
    {
        m_Watching = enable;
    }
    
    bool GetWatching()
    {
        return m_Watching;
    }
    
    void GatherPlayerInfo()
    {
        if (!g_Game.IsDedicatedServer())
            return;
        
        array<Man> players = new array<Man>;
        g_Game.GetPlayers(players);
        m_PlayerDebugStats.Clear();
        
        foreach (Man playerMan : players)
        {
            PlayerBase player = PlayerBase.Cast(playerMan);
            RemotePlayerStatDebug rpd = new RemotePlayerStatDebug(player);
            m_PlayerDebugStats.Insert(rpd);
        }       
    }
    
    void SendDebug()
    {
#ifdef DIAG_DEVELOPER
        GatherPlayerInfo();
        array<ref RemotePlayerDamageDebug> player_damage = new array<ref RemotePlayerDamageDebug>;
        
        for(int i = 0; i < m_ClientList.Count(); ++i)
        {
            PlayerBase player = m_ClientList[i];
            if (player)
            {
                ScriptRPC rpc = new ScriptRPC();
                rpc.Write(m_PlayerDebugStats);
                
                foreach (PlayerBase player2, RemotePlayerDamageDebug value : m_PlayerDebugDamage)
                {
                    if (player2)
                    {
                        player_damage.Insert(value);
                        
                    }
                    //int xs = 1 + 1;
                }
                
                rpc.Write(player_damage);
                
                rpc.Send(player, ERPCs.DEV_PLAYER_DEBUG_DATA, true, player.GetIdentity());
                m_PlayerDebugDamage.Clear();
            }
            else
            {
                m_ClientList.Remove(i);
                --i;
            }       
        }
#endif
    }
    
 
    void OnDamageEvent(PlayerBase player, TotalDamageResult damageResult)
    {
        if ( !GetWatching() || !damageResult )
            return;
        
        float damage_global = damageResult.GetDamage("","");
        float damage_blood = damageResult.GetDamage("","Blood");
        float damage_shock = damageResult.GetDamage("","Shock");
        
        if ( m_PlayerDebugDamage.Contains(player) )
        {
            m_PlayerDebugDamage.Get(player).AddDamage( damage_global, damage_blood, damage_shock );
        }
        else
        {
            RemotePlayerDamageDebug rpdd = new RemotePlayerDamageDebug(player);
            rpdd.AddDamage(damage_global, damage_blood, damage_shock);
            m_PlayerDebugDamage.Insert(player, rpdd);
        }
    }
    
 
    void OnRequestReceived(PlayerBase player, bool enable)
    {
        int index = m_ClientList.Find(player);
        
        if (enable)
        {
            m_ClientList.Insert(player);
            SetWatching(true);
        }
        else if (index != -1 && m_ClientList.Count() != 0)
        {
            m_ClientList.Remove(index);
        }
        
        if ( m_ClientList.Count() == 0 )
        {
            SetWatching(false);
        }
    }
    
    void OnRPC(ParamsReadContext ctx, PlayerBase player)
    {
        bool enable;
        ctx.Read(enable);
        OnRequestReceived(player, enable);
    }
}