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;
 }
}