pluginitemdiagnostic.c

Go to the documentation of this file.

class PluginItemDiagnosticEventHandler extends ScriptedWidgetEventHandler
{
    PluginItemDiagnostic m_Owner;
    override bool OnMouseEnter(Widget w, int x, int y)
    {
        if( ButtonWidget.Cast(w))
        {
            GetGame().GetMission().AddActiveInputExcludes({"menu"});
        }
        return true;
 
    }
    
    override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
    {
        if( ButtonWidget.Cast(w))
        {
            GetGame().GetMission().RemoveActiveInputExcludes({"menu"},true);
        }
        
        return true;
    }
    
    override bool OnClick( Widget w, int x, int y, int button )
    {
        return m_Owner.OnClick( w, x, y, button );
    }
    
    override bool OnMouseButtonDown(Widget w, int x, int y, int button)
    {
        return m_Owner.OnMouseButtonDown( w, x, y, button );
    }
    override bool OnMouseButtonUp(Widget w, int x, int y, int button)
    {
        return m_Owner.OnMouseButtonUp( w, x, y, button );
    }
}
 
 
 
class PluginItemDiagnostic extends PluginDeveloper
{
    Object m_Entity;
 
    
    ref Timer                       myTimer1;
    ref map<PlayerBase,Object>  m_ObserversMap = new map<PlayerBase,Object>;
    ref array<string>               m_Agents = new array<string>;
    ref map<string,float>           m_Floats = new map<string,float>;
    ref map<string,float>           m_VarsNumbersFinalServer = new map<string,float>;
    ref map<string,float>           m_VarsFinalClient = new map<string,float>;
    ref array<ref Param>        m_Properties = new array<ref Param>;
    bool                                    m_IsActive  = false;
    bool                                    m_ScriptMenuOpened;
    string                                  m_NoteClient;
    ref PluginItemDiagnosticEventHandler    m_EventHandler;
    bool                                    m_IsDragging;
    PluginConfigDebugProfile m_ConfigDebugProfile;
    
    Widget              m_DebugRootWidget;
    Widget              m_FrameWidget;
    
    TextListboxWidget   m_DebugAgentListWidget;
    TextWidget          m_DebugOutputServer;
    TextWidget          m_DebugOutputClient;
    TextListboxWidget   m_DebugFloatsProperListWidget;
    TextListboxWidget   m_DebugClientVarsWidget;
    TextWidget          m_ClassNameWidget;
    TextWidget          m_DistanceWidget;
    ItemPreviewWidget   m_ItemPreviewWidget;
    
    ButtonWidget        m_DebugButtonWidget1;
    ButtonWidget        m_DebugButtonWidget2;
    ButtonWidget        m_DebugButtonWidget3;
    ButtonWidget        m_DebugButtonWidget4;
    
    ButtonWidget        m_CloseButton;
 
    Shape               m_ItemLine;
    vector              m_DraggingOffset;
    
    
    void PluginItemDiagnostic()
    {
        
        #ifndef NO_GUI
        InitializeWidgets();
        ShowWidgets(false);
        #endif
    }
 
    void ~PluginItemDiagnostic()
    {
        ClearProperties();
        if (m_ItemLine)
        {
            m_ItemLine.Destroy();
            m_ItemLine = null;
        }
    }
    
    override void OnInit()
    {
        m_ConfigDebugProfile = PluginConfigDebugProfile.Cast( GetPlugin(PluginConfigDebugProfile) );
        if ( m_ConfigDebugProfile )
        {
            vector pos = m_ConfigDebugProfile.GetItemDebugPos();
            if (m_DebugRootWidget && pos != vector.Zero)
            {
                float wx = pos[0];
                float wy = pos[1];
                m_DebugRootWidget.SetPos(wx, wy);
            }
        }
    }
 
    bool OnMouseButtonDown(Widget w, int x, int y, int button)
    {
        if (button == 0)
            SetDragging(true);
        if (button == 1)
        {
            if (m_Entity)
            {
                float xx, yy;
                m_DebugRootWidget.GetPos(xx,yy);
                ContextMenu.DisplayContextMenu(x - xx, y - yy, EntityAI.Cast(m_Entity), m_DebugRootWidget, this);
            }
        }
        return true;
    }
    
    bool OnMouseButtonUp(Widget w, int x, int y, int button)
    {
        if (button == 0)
            SetDragging(false);
        return true;
    }
    
    void SetDragging(bool enable)
    {
        if(enable && !m_IsDragging)
            OnDraggingStart();
        else if (!enable && m_IsDragging)
            OnDraggingEnd();
        m_IsDragging = enable;
    }
    
    void OnDraggingStart()
    {
        int mx, my;
        float wx, wy;
        GetMousePos(mx,my);
        m_DebugRootWidget.GetScreenPos(wx,wy);
        m_DraggingOffset[0] = wx - mx;
        m_DraggingOffset[1] = wy - my;
    }
    
    void OnDraggingEnd()
    {
        if ( m_ConfigDebugProfile )
        {
            float wx, wy;
            m_DebugRootWidget.GetScreenPos(wx,wy);
            m_ConfigDebugProfile.SetItemDebugPos(Vector(wx,wy,0));
        }
    }
    
 
    
    bool OnClick( Widget w, int x, int y, int button )
    {
        SetDragging(false);
        
        if (w == m_CloseButton)
        {
            ToggleDebugWindowEvent();
            return true;
        }
        return true;
    }
    
    void RegisterDebugItem(Object item, PlayerBase player)
    {
        if(!myTimer1)
        {
            myTimer1 = new Timer();
            myTimer1.Run(1, this, "Tick", NULL, true);
        }
        
        if(m_ObserversMap.Contains(player))
        {
            m_ObserversMap.Set(player,item);
        }
        else
        {
            m_ObserversMap.Insert(player,item);
        }
        #ifdef DEVELOPER
        SetDebugDeveloper_item(item);
        #endif
    }
    
    Object GetWatchedItem(PlayerBase player)
    {
        return m_ObserversMap.Get(player);
    }
    
    
    bool IsActive()
    {
        return m_IsActive;
    }
 
    void OnScriptMenuOpened(bool opened/*1 - opened , 0 - closed*/)
    {
        m_ScriptMenuOpened = opened;
    }
    
    
    void ShowWidgets(bool show)
    {
        
        m_IsActive = show;
            
        if(m_DebugRootWidget) 
            m_DebugRootWidget.Show(show);
    }
 
    void OnSelectAction(EntityAI ent, int actionId)
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        player.GetActionManager().OnInstantAction(ActionDebug,new Param2<EntityAI,int>(ent,actionId));
    }
 
    void ReleaseFocus()
    {
        GetGame().GetInput().ResetGameFocus();
        GetGame().GetUIManager().ShowUICursor(false);
        if (GetGame().GetUIManager())   
        {
            if (GetGame().GetUIManager().IsDialogVisible())
            {
                GetGame().GetUIManager().CloseDialog();
                
            }
        }
    }
    
    void ToggleDebugWindowEvent()
    {
        if (m_IsActive)
        {       
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
            GetGame().RPCSingleParam(player, ERPCs.RPC_ITEM_DIAG_CLOSE,null, true);
            ShowWidgets(false);
            ClearWidgets();
            
            GetGame().GetCallQueue( CALL_CATEGORY_GUI ).CallLater( ReleaseFocus, 100);
            //m_IsActive = false;
            SetDragging(false);
        }
        else
        {
            ShowWidgets(true);
            //m_IsActive = true;
        }
 
    }
 
    void ClearWidgets()
    {
        m_DebugAgentListWidget.ClearItems();
        m_DebugOutputServer.SetText("");
        m_DebugOutputClient.SetText("");
        m_DebugFloatsProperListWidget.ClearItems();
        m_ItemPreviewWidget.SetItem(NULL);
        m_ClassNameWidget.SetText("");      
    }
    
    void Tick()
    {
        for(int i = 0; i < m_ObserversMap.Count();i++)
        {
            Object item = m_ObserversMap.GetElement(i);
            PlayerBase player = m_ObserversMap.GetKey(i);
 
            if (item && player) 
            {
                GeneratePropertiesObject(EntityAI.Cast(item));
                SendRPC(item, player);
            }
            else
            {
                Debug.LogError("PluginItemDiagnostic: dead debug record, removing record");
                m_ObserversMap.RemoveElement(i);
            }
        }
        
    }
    
    void ClearProperties()
    {
        m_Properties.Clear();
    }
 
 
    void GeneratePropertiesObject(EntityAI item)
    {
        ClearProperties();
        GetLocalProperties(item, m_Properties);
 
    }
    
    void SendRPC(Object item, PlayerBase player)
    {
        Param1<Object> p1 = new Param1<Object>(item);
        m_Properties.InsertAt(p1,0);
        GetGame().RPC(player,ERPCs.RPC_ITEM_DIAG,m_Properties,true,player.GetIdentity());
        
        if (!GetGame().IsMultiplayer())
        {
            m_Entity = item;
        }
 
    }
    
    void StopWatchRequest(PlayerBase player)//called from player after an RPC call
    {
        if( m_ObserversMap.Contains(player) )
        {
            m_ObserversMap.Remove(player);
        }
    }
 
    void OnRPC(Object entity, ParamsReadContext ctx)
    {
        
        if (!GetGame().IsMultiplayer())
        {
            entity = m_Entity;
        }
        else
        {
            m_Entity = entity;
        }
        
        ItemBase item = ItemBase.Cast(entity);
        
        
        
        #ifdef DEVELOPER
        SetDebugDeveloper_item(entity);
        #endif
        if( !IsActive() )
        {
            ShowWidgets(true);
        }
 
        ctx.Read(CachedObjectsParams.PARAM1_STRING);
        string debug_output_server = CachedObjectsParams.PARAM1_STRING.param1;
        array<ref Param> vars_client;
        array<ref Param> vars_server;
        if (item)
        {
            ctx.Read(CachedObjectsParams.PARAM1_INT);//hardcoded to index 1
            int agents_count    = CachedObjectsParams.PARAM1_INT.param1;
 
            ctx.Read(CachedObjectsParams.PARAM1_INT);//hardcoded to index 2
            int individual_items_count  = CachedObjectsParams.PARAM1_INT.param1;
            
            FillAgentArray(ctx, agents_count);
            
            vars_server = new array<ref Param>;
            FillServerFinalVars(individual_items_count, ctx, vars_server);
 
            vars_client = new array<ref Param>;
            GetLocalProperties(item, vars_client, true);
        }
        if (EntityAI.Cast(entity))
        {
            DisplayAll(EntityAI.Cast(entity), vars_server, vars_client, debug_output_server );
        }
        if (GetDayZGame().IsInventoryOpen() || GetGame().GetUIManager().FindMenu(MENU_SCRIPTCONSOLE))
            m_DebugRootWidget.SetSort(-1);
        else
            m_DebugRootWidget.SetSort(10);
        m_DebugRootWidget.Show(true);
 
            
    }
    
    void FillServerFinalVars(int count, ParamsReadContext ctx, array<ref Param> params )
    {
        for(int i = 0; i < count; i++)
        {
            Param2<string,float> p2 = new Param2<string,float>("",0);
            
            ctx.Read(p2);
            /*
            string name = CachedObjectsParams.PARAM2_STRING_FLOAT.param1;
            float value = CachedObjectsParams.PARAM2_STRING_FLOAT.param2;
            PrintString(name+","+value.ToString());
            */
            params.Insert(p2);
        }
        //PrintString("----------------------------------------------------");
    }
    
    void InitializeWidgets()
    {
        m_EventHandler = new PluginItemDiagnosticEventHandler;
        m_EventHandler.m_Owner = this;
        
        if(!m_DebugRootWidget) 
            m_DebugRootWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/debug/debug_item.layout");
 
        m_DebugRootWidget.SetHandler(m_EventHandler);
 
        m_FrameWidget = m_DebugRootWidget.FindAnyWidget("FrameWidget0");
        m_DebugAgentListWidget = TextListboxWidget.Cast(m_DebugRootWidget.FindAnyWidget("w_Agents"));
        m_DebugOutputServer = TextWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugOutputServer"));
        m_DebugOutputClient = TextWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugOutputClient"));
        m_DebugFloatsProperListWidget = TextListboxWidget.Cast(m_DebugRootWidget.FindAnyWidget("w_FloatsProper"));
        m_ItemPreviewWidget = ItemPreviewWidget.Cast(m_DebugRootWidget.FindAnyWidget("w_ItemPreview"));
        m_ClassNameWidget = TextWidget.Cast(m_DebugRootWidget.FindAnyWidget("w_ClassName"));
        m_DistanceWidget = TextWidget.Cast(m_DebugRootWidget.FindAnyWidget("w_Distance"));
        
        m_DebugButtonWidget1 = ButtonWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugButton1"));
        m_DebugButtonWidget2 = ButtonWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugButton2"));
        m_DebugButtonWidget3 = ButtonWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugButton3"));
        m_DebugButtonWidget4 = ButtonWidget.Cast(m_DebugRootWidget.FindAnyWidget("DebugButton4"));
        
        m_CloseButton = ButtonWidget.Cast(m_DebugRootWidget.FindAnyWidget("CloseButton"));
    }
 
    override void OnUpdate(float delta_time)
    {
        super.OnUpdate(delta_time);
        
        if (!m_Entity || !m_IsActive)
        {
            
            if (m_ItemLine)
            {
                m_ItemLine.Destroy();
                m_ItemLine = null;
            }
            return;
        }
        
        m_ItemPreviewWidget.Show(!m_ScriptMenuOpened);
        
        
        if (m_IsDragging)
        {
            int x,y;
            GetMousePos(x,y);
            m_DebugRootWidget.SetPos(x + m_DraggingOffset[0], y + m_DraggingOffset[1]);
        }
        vector pts[2];
        pts[0] = GetGame().GetPlayer().GetPosition();
        pts[1] = m_Entity.GetPosition();
        if (m_ItemLine)
        {
            m_ItemLine.Destroy();
            m_ItemLine = null;
            
        }
        m_ItemLine = Shape.CreateLines(COLOR_BLUE, ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE|ShapeFlags.NOZBUFFER, pts, 2);
        m_DistanceWidget.SetText(vector.Distance(pts[0], pts[1]).ToString()+"m.");
    }
    
    void DisplayAll(EntityAI item, array<ref Param> vars_server, array<ref Param> vars_client, string debug_text_server)
    {
        m_ClassNameWidget.SetText( item.GetType() );
        m_ItemPreviewWidget.SetItem(item);
        UpdateAgentWidget();
        //UpdateFloatWidget();
        if (vars_server && vars_client)
            UpdateNumericalVarsWidget(vars_server, vars_client);
        m_DebugOutputServer.SetText(debug_text_server);
        m_DebugOutputClient.SetText(item.GetDebugText());
        
        /*
        string button1, button2, button3, button4;
        item.GetDebugButtonNames(button1, button2, button3, button4);
        m_DebugButtonWidget1.SetText(button1);
        m_DebugButtonWidget2.SetText(button2);
        m_DebugButtonWidget3.SetText(button3);
        m_DebugButtonWidget4.SetText(button4);
        */
        
    
    }   
 
    void FillAgentArray(ParamsReadContext ctx, int agents_count)
    {
        m_Agents.Clear();
        for(int i = 0; i < agents_count; i++)
        {
            if(ctx.Read(CachedObjectsParams.PARAM1_STRING))
            {
                string agent = CachedObjectsParams.PARAM1_STRING.param1;
                m_Agents.Insert(agent);
            }
        }
    }
 
 
    void UpdateAgentWidget()
    {
        m_DebugAgentListWidget.ClearItems();
        for(int i = 0; i < m_Agents.Count(); i++)
        {
            string agent = m_Agents.Get(i);
            m_DebugAgentListWidget.AddItem(agent,NULL,0);
        }
    }   
 
    
    void UpdateNumericalVarsWidget(array<ref Param> vars_server, array<ref Param> vars_client)
    {
        m_DebugFloatsProperListWidget.ClearItems();
        for(int i = 0; i < vars_server.Count(); i++)
        {
            Param param_server = vars_server.Get(i);
            Param2<string,float> p2_server = Param2<string,float>.Cast(param_server);
            
            Param param_client = vars_client.Get(i);
            Param2<string,float> p2_client = Param2<string,float>.Cast(param_client);
            
            string name = p2_server.param1;
            m_DebugFloatsProperListWidget.AddItem(name,NULL,0);
            m_DebugFloatsProperListWidget.SetItem(i,p2_server.param2.ToString(),NULL,1);
            m_DebugFloatsProperListWidget.SetItem(i,p2_client.param2.ToString(),NULL,2);
        }
    }   
    
    
    void PrintOut()
    {
        Debug.LogArrayString(m_Agents,"ItemDebug");
        Debug.Log("----------------------","ItemDebug");
    }
    
    //-------------------------
    // QUERY FOR DEBUG PROPERTIES
    //-------------------------
    void GetLocalProperties(EntityAI entity, array<ref Param> properties, bool client = false)
    {
        if(!entity)
            return;
        ItemBase item = ItemBase.Cast(entity);
 
        if(!client)
        {
            // -------- DEBUG OUTPUT ------
            Param1<string> debug_output = new Param1<string>(entity.GetDebugText());
            properties.Insert(debug_output);
            if(!item)
                return;
            // -------- AGENTS ------------
            int num_of_agents = FillWithAgents(item, properties);
            Param1<int> agents_count = new Param1<int>(num_of_agents);
            properties.InsertAt(agents_count,1);// hard coded index 1 !!
        }
        if(!item)
            return;
        // ------ INDIVIDUAL VARS------
        int number_of_items = 0;
        Param2<string, float> quantity = new Param2<string, float>("quantity", item.GetQuantity() );
        properties.Insert(quantity);
        number_of_items++;
        //-----------------------------
        Param2<string, float> liquid_type = new Param2<string, float>("liquid_type", item.GetLiquidType() );
        properties.Insert(liquid_type);
        number_of_items++;
        //-----------------------------
        Param2<string, float> wetness = new Param2<string, float>("wetness", item.GetWet() );
        properties.Insert(wetness);
        number_of_items++;
        //-----------------------------
        Param2<string, float> temperature = new Param2<string, float>("temperature", item.GetTemperature() );
        properties.Insert(temperature);
        number_of_items++;
        //-----------------------------
        Param2<string, float> energy = new Param2<string, float>("energy", item.GetEnergy() );
        properties.Insert(energy);
        number_of_items++;
        //-----------------------------
        Param2<string, float> health;
        if(!client)
        {
            health = new Param2<string, float>("health", item.GetHealth("", "") );
        }
        else
        {
            health = new Param2<string, float>("NO SYNC",0 );
        }
        properties.Insert(health);
        number_of_items++;
        //-----------------------------
        int r,g,b,a;
        item.GetColor(r,g,b,a);
        Param2<string, float> p2r = new Param2<string, float>("R",r);
        properties.Insert(p2r);
        number_of_items++;
        Param2<string, float> p2g = new Param2<string, float>("G",g);
        properties.Insert(p2g);
        number_of_items++;
        Param2<string, float> p2b = new Param2<string, float>("B",b);
        properties.Insert(p2b);
        number_of_items++;
        Param2<string, float> p2a = new Param2<string, float>("A",a);
        properties.Insert(p2a);
        number_of_items++;
        //-----------------------------
        if(!client)
        {
            Param1<int> item_count = new Param1<int>(number_of_items);
            properties.InsertAt(item_count,2);
        }
    }
 
    int FillWithAgents(ItemBase item, array<ref Param> properties)
    {
        if (!item)
        {
            return 0;
        }
        int agents = item.GetAgents();
        if(agents == 0) return 0;
        int num_of_agents = 0;
        ref array<int> agents_aray = new array<int>;
        PluginTransmissionAgents.BuildAgentArray(agents, agents_aray);
        int agents_count = agents_aray.Count();
    
        for(int i = 0; i < agents_count; i++)
        {
            //PluginTransmissionAgents mta = PluginTransmissionAgents.Cast(GetPlugin(PluginTransmissionAgents));
            string agent_name = PluginTransmissionAgents.GetNameByID(agents_aray.Get(i));
            Param1<string> param1 = new Param1<string>(agent_name);
            properties.Insert(param1);
            num_of_agents++;
        }
 
        return num_of_agents;
    }
}