plugindayzcreatureaidebug.c

Go to the documentation of this file.

typedef Param4<float, string, int, string> DayZCreatureAnimScriptDebugAnimEventData;
typedef Param1<string> DayZCreatureAnimScriptDebugAnimPredictionData;
typedef Param1<string> DayZCreatureAnimScriptDebugAnimTagData;
 
class DayZCreatureAnimScriptDebug
{ 
 proto native void SetCreature(DayZCreature creature);
 
 proto native int GetVariableCount();
 proto native owned string GetVariableName(int index);
 proto native int GetVariableType(int index);
 proto native int GetVariableInt(int index);
 proto native float GetVariableFloat(int index);
 proto native bool GetVariableBool(int index);
 
 proto native int SetVariableInt(int index, int value);
 proto native float SetVariableFloat(int index, float value);
 proto native bool SetVariableBool(int index, bool value);
 
 proto native int GetCommandCount();
 proto native owned string GetCommandName(int index);
 proto native int GetCommandID(int index);
 
 proto native void ActivateCommand(int index, int userInt, float userFloat);
 
 const int m_iMaxAnimEventsCount = 50;
 ref array<string> m_EventsFilter = new array<string>;
 
 ref array<ref DayZCreatureAnimScriptDebugAnimEventData> m_AnimEvents = new array<ref DayZCreatureAnimScriptDebugAnimEventData>;
 ref array<ref DayZCreatureAnimScriptDebugAnimPredictionData> m_AnimPredictions = new array<ref DayZCreatureAnimScriptDebugAnimPredictionData>;
 ref array<ref DayZCreatureAnimScriptDebugAnimTagData> m_AnimTags = new array<ref DayZCreatureAnimScriptDebugAnimTagData>;
 
 void OnAnimationEventsStart()
 {
 m_AnimPredictions.Clear();
 m_AnimTags.Clear();
 }
 
 void OnAnimationEvent(string evType, int userInt, string userString)
 {
 if (m_EventsFilter.Find(evType) != -1)
 {
 return;
 }
 
 m_AnimEvents.InsertAt(new DayZCreatureAnimScriptDebugAnimEventData(GetWorldTime(), evType, userInt, userString), 0);
 
 if (m_AnimEvents.Count() > m_iMaxAnimEventsCount)
 {
 m_AnimEvents.Remove(m_AnimEvents.Count() - 1);
 }
 }
 
 void OnAnimationPrediction(string predName)
 {
 m_AnimPredictions.Insert(new DayZCreatureAnimScriptDebugAnimPredictionData(predName));
 }
 
 void OnAnimationTag(string tagName)
 {
 m_AnimTags.Insert(new DayZCreatureAnimScriptDebugAnimTagData(tagName));
 }
}
 
enum PluginDayZCreatureAIDebugSyncMessageType
{
 INIT_DEBUG_OBJECT,
 RELEASE_DEBUG_OBJECT,
 SET_VALUE_INT,
 SET_VALUE_FLOAT,
 SET_VALUE_BOOL,
 ACTIVATE_COMMAND,
 ENABLE_AI,
 DISABLE_AI,
 COUNT
}
 
class PluginDayZCreatureAIDebug extends PluginBase
{
 int m_iDebugMenu = -1;
 
 DayZCreatureAI m_DebugEntity = NULL;
 string m_sDebugEntityName = "";
 ref DayZCreatureAnimScriptDebug m_EntityAnimDbg = NULL;
 
 ref Timer m_TickTimer;
 bool m_IsActive = false;
 bool m_ShowDbgUI = false;
 
 bool m_bIsCaptureMode = false;
 bool m_bEditMode = false;
 bool m_bAIEnabled = true;
 bool m_bShowAnimEvents = false;
 
 bool m_bBulkSet = false;
 ref array<bool> m_SetVariableCheckStates = new array<bool>;
 ref array<bool> m_SetCommandCheckStates = new array<bool>;
 
 ref array<ref Param> m_SyncMessages = new array<ref Param>;
 
 void PluginDayZCreatureAIDebug()
 {
 }
 
 void ~PluginDayZCreatureAIDebug()
 {
 }
 
 override void OnInit()
 {
 }
 
 override void OnDestroy()
 {
 }
 
 void CheckShowMode()
 {
 int actMenuValue = DiagMenu.GetEngineValue(DayZCreatureAIConstants.DEBUG_SHOWDEBUGPLUGIN);
 if (actMenuValue != m_iDebugMenu)
 {
 SetDebugShowMode(actMenuValue);
 m_iDebugMenu = actMenuValue;
 }
 } 
 
 override void OnUpdate(float delta_time)
 {
 if (!GetGame().IsDedicatedServer())
 {
 CheckShowMode();
 }
 }
 
 string GetStrValue(int index)
 {
 string strVal;
 switch (m_EntityAnimDbg.GetVariableType(index))
 {
 case DayZCreatureAnimScriptDebugVarType.INT:
 int valInt = m_EntityAnimDbg.GetVariableInt(index);
 strVal = valInt.ToString();
 break;
 case DayZCreatureAnimScriptDebugVarType.FLOAT:
 float valFloat = m_EntityAnimDbg.GetVariableFloat(index);
 strVal = valFloat.ToString();
 break;
 case DayZCreatureAnimScriptDebugVarType.BOOL:
 bool valBool = m_EntityAnimDbg.GetVariableBool(index);
 if (valBool)
 {
 strVal = "true";
 }
 else
 {
 strVal = "false";
 }
 break;
 default:
 strVal = "unk";
 }
 return strVal;
 }
 
 string GetStrValueType(int index)
 {
 string strValType;
 switch (m_EntityAnimDbg.GetVariableType(index))
 {
 case DayZCreatureAnimScriptDebugVarType.INT:
 strValType = "int";
 break;
 case DayZCreatureAnimScriptDebugVarType.FLOAT:
 strValType = "float";
 break;
 case DayZCreatureAnimScriptDebugVarType.BOOL:
 strValType = "bool";
 break;
 default:
 strValType = "unk";
 }
 
 return strValType;
 }
 
 void InitDebugObject(Object obj)
 {
 m_EntityAnimDbg = new DayZCreatureAnimScriptDebug();
 m_EntityAnimDbg.SetCreature( DayZCreature.Cast( obj ) );
 
 m_DebugEntity = DayZCreatureAI.Cast( obj );
 m_sDebugEntityName = obj.GetType();
 
 
 int varCount = m_EntityAnimDbg.GetVariableCount();
 int cmdCount = m_EntityAnimDbg.GetCommandCount();
 int toAddCount = 0;
 
 if (m_SetVariableCheckStates.Count() < varCount)
 {
 toAddCount = varCount - m_SetVariableCheckStates.Count();
 for (int idxVar = 0; idxVar < toAddCount; idxVar++)
 {
 m_SetVariableCheckStates.Insert(false);
 }
 }
 
 if (m_SetCommandCheckStates.Count() < cmdCount)
 {
 toAddCount = cmdCount - m_SetCommandCheckStates.Count();
 for (int idxCmd = 0; idxCmd < toAddCount; idxCmd++)
 {
 m_SetCommandCheckStates.Insert(false);
 }
 }
 }
 
 void ReleaseDebugObject()
 {
 m_DebugEntity = NULL;
 m_EntityAnimDbg = NULL;
 m_sDebugEntityName = "";
 
 m_SetVariableCheckStates.Clear();
 m_SetCommandCheckStates.Clear();
 }
 
 void SetValueInt(int index, int value)
 {
 m_EntityAnimDbg.SetVariableInt(index, value);
 }
 
 void SetValueFloat(int index, float value)
 {
 m_EntityAnimDbg.SetVariableFloat(index, value);
 }
 
 void SetValueBool(int index, bool value)
 {
 m_EntityAnimDbg.SetVariableBool(index, value);
 }
 
 void ActivateCommand(int commandIdx, int userInt, float userFloat)
 {
 int commandId = m_EntityAnimDbg.GetCommandID(commandIdx);
 m_EntityAnimDbg.ActivateCommand(commandId, userInt, userFloat);
 }
 
 void EnableAI(bool enable)
 {
 if (m_DebugEntity.IsInherited(DayZCreatureAI))
 {
 DayZCreatureAI creatureAI = m_DebugEntity;
 if (enable)
 {
 #ifdef DIAG_DEVELOPER
 creatureAI.DebugRestoreAIControl();
 #endif
 }
 else
 {
 #ifdef DIAG_DEVELOPER
 creatureAI.DebugDisableAIControl(); 
 #endif
 } 
 }
 }
 
 DayZCreatureAnimScriptDebugVarType GetVariableType(int index)
 {
 return m_EntityAnimDbg.GetVariableType(index);
 }
 
 void OnGUI_Variables()
 {
 int varCount = m_EntityAnimDbg.GetVariableCount();
 for (int i=0; i < varCount; i++)
 {
 DbgUI.BeginCleanupScope();
 DbgUI.Text(m_EntityAnimDbg.GetVariableName(i) + ": " + GetStrValue(i));
 DbgUI.EndCleanupScope();
 }
 }
 
 void OnGUI_VariablesEdit()
 {
 const int INPUT_BOX_SIZE = 35;
 
 DbgUI.PushID_Str("VariablesEdit");
 
 int varCount = m_EntityAnimDbg.GetVariableCount();
 for (int i=0; i < varCount; i++)
 {
 DbgUI.BeginCleanupScope();
 
 DbgUI.PushID_Int(i);
 
 bool result;
 DbgUI.Check("", result);
 m_SetVariableCheckStates[i] = result;
 
 DbgUI.SameLine(); 
 bool setButtonPressed = DbgUI.Button("Set");
 
 DbgUI.SameLine();
 
 string strUserVal;
 DbgUI.InputText(GetStrValueType(i), strUserVal, INPUT_BOX_SIZE);
 
 DbgUI.SameLine();
 DbgUI.Text(m_EntityAnimDbg.GetVariableName(i));
 
 if (setButtonPressed || (m_bBulkSet && m_SetVariableCheckStates[i]))
 {
 GUIAction_SetValue(i, strUserVal);
 }
 
 DbgUI.PopID();
 
 DbgUI.EndCleanupScope();
 }
 
 DbgUI.PopID();
 }
 
 void OnGUI_CommandsEdit()
 {
 const int INPUT_BOX_SIZE = 35;
 
 DbgUI.PushID_Str("CommandsEdit");
 int cmdCount = m_EntityAnimDbg.GetCommandCount();
 for (int i=0; i < cmdCount; i++)
 {
 DbgUI.BeginCleanupScope();
 
 DbgUI.PushID_Int(i);
 
 bool result;
 DbgUI.Check("", result);
 m_SetCommandCheckStates[i] = result; 
 
 DbgUI.SameLine();
 bool setButtonPressed = DbgUI.Button("Set");
 
 DbgUI.SameLine(); 
 string strUserInt;
 DbgUI.InputText("int", strUserInt, INPUT_BOX_SIZE);
 
 DbgUI.SameLine();
 string strUserFloat;
 DbgUI.InputText("float", strUserFloat, INPUT_BOX_SIZE); 
 
 DbgUI.SameLine();
 DbgUI.Text(m_EntityAnimDbg.GetCommandName(i) + "[" + m_EntityAnimDbg.GetCommandID(i) + "]");
 
 if (setButtonPressed || (m_bBulkSet && m_SetCommandCheckStates[i]))
 {
 GUIAction_ActivateCommand(i, strUserInt.ToInt(), strUserFloat.ToFloat());
 }
 
 DbgUI.PopID();
 
 DbgUI.EndCleanupScope();
 }
 
 DbgUI.PopID();
 }
 
 void OnGUI_AIControlEdit()
 {
 bool buttonPressed = false;
 if (m_bAIEnabled)
 {
 buttonPressed = DbgUI.Button("Disable AI");
 }
 else
 {
 buttonPressed = DbgUI.Button("Enable AI");
 }
 
 if (buttonPressed)
 {
 m_bAIEnabled = !m_bAIEnabled;
 
 GUIAction_EnableAI(m_bAIEnabled);
 }
 }
 
 void OnGUI_BulkSet()
 {
 m_bBulkSet = false;
 
 if (DbgUI.Button("Bulk set"))
 {
 m_bBulkSet = true; 
 }
 }
 
 void OnGUI_AnimEvents()
 {
 DbgUI.PushID_Str("AnimEvents");
 
 const int panelMinSizeX = 350;
 
 DbgUI.Panel("MinimumSize", panelMinSizeX, 1);
 
 string strTags;
 for (int tagIdx = 0; tagIdx < m_EntityAnimDbg.m_AnimTags.Count(); ++tagIdx)
 {
 if (tagIdx != 0)
 strTags += ", ";
 
 strTags += m_EntityAnimDbg.m_AnimTags[tagIdx].param1;
 }
 
 string strPredictions;
 for (int predIdx = 0; predIdx < m_EntityAnimDbg.m_AnimPredictions.Count(); ++predIdx)
 {
 if (predIdx != 0)
 strPredictions += ", ";
 
 strPredictions += m_EntityAnimDbg.m_AnimPredictions[predIdx].param1;
 }
 
 DbgUI.PushID_Str("AnimTagsDisplay");
 DbgUI.Text(strTags);
 DbgUI.PopID();
 
 DbgUI.PushID_Str("AnimPredictionsDisplay");
 DbgUI.Text(strPredictions);
 DbgUI.PopID();
 
 string strFilter;
 DbgUI.InputText("Filter", strFilter, panelMinSizeX);
 
 m_EntityAnimDbg.m_EventsFilter.Clear();
 strFilter.Split(" ", m_EntityAnimDbg.m_EventsFilter);
 
 DbgUI.Button("TakeMyFocus");
 
 const int evDisplayCount = 15;
 int evToDisplayCount = (int)Math.Min(m_EntityAnimDbg.m_AnimEvents.Count(), evDisplayCount);
 
 for (int evIdx = 0; evIdx < evToDisplayCount; ++evIdx)
 { 
 DbgUI.PushID_Int(evIdx);
 if (m_EntityAnimDbg.m_AnimEvents[evIdx].param2.Length() > 0)
 {
 DbgUI.Text((m_EntityAnimDbg.m_AnimEvents[evIdx].param1 / 1000.0).ToString() + " - " + m_EntityAnimDbg.m_AnimEvents[evIdx].param2);
 }
 DbgUI.PopID();
 } 
 
 DbgUI.PopID();
 }
 
 void OnGUI(bool show)
 {
 const int windowPosX = 0;
 const int windowPosY = 300;
 const int mainPanelSizeX = 200;
 const int mainPanelSizeY = 1;
 const int margin = 10;
 
 DbgUI.BeginCleanupScope();
 DbgUI.Begin("CretureAI debug", windowPosX, windowPosY);
 if (show)
 {
 if (m_EntityAnimDbg == NULL)
 {
 if (m_bIsCaptureMode == true)
 {
 DbgUI.Text("Capturing..."); 
 }
 else
 {
 if (DbgUI.Button("Capture"))
 {
 m_bIsCaptureMode = true;
 }
 }
 
 // Clear additional windows
 DbgUI.Begin("CreatureAI EditMenu");
 DbgUI.End();
 
 DbgUI.Begin("CreatureAI AnimEvents");
 DbgUI.End();
 }
 else
 {
 DbgUI.Panel("MinimumSize", mainPanelSizeX, mainPanelSizeY);
 
 DbgUI.Text(m_sDebugEntityName);
 DbgUI.SameLine();
 bool btnReleasePressed = DbgUI.Button("Release");
 
 DbgUI.Check("Edit", m_bEditMode);
 DbgUI.Check("ShowAnimEvents", m_bShowAnimEvents);
 
 #ifdef _DAYZ_CREATURE_DEBUG_SHADOW
 if (!GetGame().IsMultiplayer())
 {
 DbgUI.SameLine();
 if (DbgUI.Button("CreateShadow"))
 {
 GUIAction_CreateShadow();
 }
 }
 #endif
 
 if (!GetGame().IsMultiplayer())
 {
 const int simLODInputSize = 20;
 int simLOD;
 DbgUI.InputInt("SimLOD", simLOD, simLODInputSize);
 DbgUI.SameLine();
 if (DbgUI.Button("UpdateSimulationPrecision"))
 {
 GUIAction_UpdateSimulationPrecision(simLOD);
 }
 }
 
 if (btnReleasePressed)
 {
 GUIAction_ReleaseDebugObject();
 }
 else
 {
 OnGUI_Variables();
 DbgUI.Begin("CreatureAI EditMenu", windowPosX + mainPanelSizeX + margin, windowPosY);
 if (m_bEditMode)
 { 
 OnGUI_AIControlEdit();
 OnGUI_BulkSet();
 OnGUI_VariablesEdit();
 DbgUI.Spacer(20);
 OnGUI_CommandsEdit(); 
 } 
 DbgUI.End();
 
 DbgUI.Begin("CreatureAI AnimEvents", windowPosX + mainPanelSizeX + margin, windowPosY);
 if (m_bShowAnimEvents)
 {
 OnGUI_AnimEvents();
 }
 DbgUI.End();
 }
 }
 }
 DbgUI.End();
 DbgUI.EndCleanupScope();
 }
 
 void OnGUITimer()
 {
 OnGUI(m_IsActive);
 
 if (GetGame().IsMultiplayer() && GetGame().IsClient())
 {
 SendSyncMessages();
 } 
 }
 
 void SetDebugShowMode(int mode)
 {
 switch (mode)
 {
 case 0:
 {
 Hide();
 } break;
 case 1:
 {
 Show();
 } break;
 }
 }
 
 void Show()
 {
 m_IsActive = true;
 
 m_TickTimer = new Timer();
 m_TickTimer.Run(0.1, this, "OnGUITimer", NULL, true);
 }
 
 void Hide()
 {
 m_IsActive = false;
 m_TickTimer = NULL;
 OnGUI(false);
 }
 
 void Event_OnClick()
 {
 if (m_IsActive == false)
 return;
 
 const float MAX_RAYCAST_RANGE = 1000;
 if (m_bIsCaptureMode)
 { 
 vector dir = GetGame().GetPointerDirection();
 vector pos = GetGame().GetCurrentCameraPosition(); 
 
 // Raycast
 vector from = pos;
 vector to = pos + (dir * MAX_RAYCAST_RANGE);
 vector contact_pos;
 vector contact_dir;
 int contact_component;
 set<Object> objects = new set<Object>;
 
 if (DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component, objects, NULL, GetGame().GetPlayer()))
 {
 for ( int i = 0; i < objects.Count(); i++ )
 {
 Object obj = objects.Get(i);
 if (obj && obj.IsInherited(DayZCreature))
 {
 m_bIsCaptureMode = false;
 GUIAction_InitDebugObject(obj);
 return;
 }
 }
 }
 }
 }
 
 
 void GUIAction_InitDebugObject(Object obj)
 {
 InitDebugObject(obj);
 if (GetGame().IsMultiplayer())
 {
 SyncInitDebugObject(obj);
 }
 }
 
 #ifdef _DAYZ_CREATURE_DEBUG_SHADOW
 void GUIAction_CreateShadow()
 {
 auto shadowEntity = GetGame().CreateObject(m_sDebugEntityName, m_DebugEntity.GetPosition(), false, true);
 m_DebugEntity.DebugSetShadow(shadowEntity);
 }
 #endif
 
 void GUIAction_UpdateSimulationPrecision(int simLOD)
 {
 m_DebugEntity.UpdateSimulationPrecision(simLOD);
 }
 
 void GUIAction_ReleaseDebugObject()
 {
 ReleaseDebugObject(); 
 if (GetGame().IsMultiplayer())
 {
 SyncReleaseDebugObject();
 }
 }
 
 void GUIAction_SetValue(int index, string strVal)
 {
 switch (GetVariableType(index))
 {
 case DayZCreatureAnimScriptDebugVarType.INT:
 int intValue = strVal.ToInt();
 if (GetGame().IsMultiplayer())
 {
 SyncSetValueInt(index, intValue);
 }
 else
 {
 SetValueInt(index, intValue);
 }
 break;
 case DayZCreatureAnimScriptDebugVarType.FLOAT:
 float floatValue = strVal.ToFloat();
 if (GetGame().IsMultiplayer())
 {
 SyncSetValueFloat(index, floatValue);
 }
 else
 {
 SetValueFloat(index, floatValue);
 }
 break;
 case DayZCreatureAnimScriptDebugVarType.BOOL:
 bool boolValue;
 strVal.ToLower();
 if (strVal.Contains("true"))
 {
 boolValue = true;
 }
 else if (strVal.Contains("false"))
 {
 boolValue = false;
 }
 else
 {
 boolValue = (bool)strVal.ToInt();
 }
 
 if (GetGame().IsMultiplayer())
 {
 SyncSetValueBool(index, boolValue);
 }
 else
 {
 SetValueBool(index, boolValue);
 }
 break;
 }
 }
 
 void GUIAction_ActivateCommand(int commandIdx, int userInt, float userFloat)
 {
 if (GetGame().IsMultiplayer())
 {
 SyncActivateCommand(commandIdx, userInt, userFloat);
 }
 else
 {
 ActivateCommand(commandIdx, userInt, userFloat); 
 }
 
 }
 
 void GUIAction_EnableAI(bool enable)
 {
 if (GetGame().IsMultiplayer())
 {
 SyncEnableAI(enable);
 }
 else
 {
 EnableAI(enable);
 } 
 }
 
 
 void SendSyncMessages()
 {
 int count = m_SyncMessages.Count();
 if (count > 0)
 {
 Param1<int> paramCount = new Param1<int>(count);
 m_SyncMessages.InsertAt(paramCount, 0);
 
 GetGame().GetPlayer().RPC(ERPCs.DEV_RPC_PLUGIN_DZCREATURE_DEBUG, m_SyncMessages, true);
 
 m_SyncMessages.Clear();
 }
 }
 
 void OnRpc(PlayerBase player, int rpc_type, ParamsReadContext ctx)
 {
 if (rpc_type == ERPCs.DEV_RPC_PLUGIN_DZCREATURE_DEBUG)
 {
 SyncReceiveMessage(ctx);
 }
 } 
 
 void SyncReceiveMessage(ParamsReadContext ctx)
 {
 Param1<int> count = new Param1<int>(0);
 
 if (ctx.Read(count))
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.COUNT);
 for (int i=0; i < count.param1; ++i)
 {
 if (ctx.Read(type))
 {
 switch (type.param1)
 {
 case PluginDayZCreatureAIDebugSyncMessageType.INIT_DEBUG_OBJECT:
 SyncReceiveInitDebugObject(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.RELEASE_DEBUG_OBJECT:
 SyncReceiveReleaseDebugObject(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_INT:
 SyncReceiveValueInt(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_FLOAT:
 SyncReceiveValueFloat(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_BOOL:
 SyncReceiveValueBool(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.ACTIVATE_COMMAND:
 SyncReceiveActivateCommand(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.ENABLE_AI:
 SyncReceiveEnableAI(ctx);
 break;
 case PluginDayZCreatureAIDebugSyncMessageType.DISABLE_AI:
 SyncReceiveDisableAI(ctx);
 break;
 }
 }
 type.param1 = PluginDayZCreatureAIDebugSyncMessageType.COUNT;
 }
 }
 }
 
 void SyncInitDebugObject(Object obj)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.INIT_DEBUG_OBJECT); 
 Param1<Object> object = new Param1<Object>(obj);
 
 m_SyncMessages.Insert(type);
 m_SyncMessages.Insert(object);
 }
 
 void SyncReceiveInitDebugObject(ParamsReadContext ctx)
 {
 Param1<Object> object = new Param1<Object>(NULL);
 if (ctx.Read(object))
 {
 InitDebugObject(object.param1);
 }
 }
 
 void SyncReleaseDebugObject()
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.RELEASE_DEBUG_OBJECT);
 
 m_SyncMessages.Insert(type);
 }
 
 void SyncReceiveReleaseDebugObject(ParamsReadContext ctx)
 {
 ReleaseDebugObject();
 }
 
 void SyncSetValueInt(int index, int value)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_INT); 
 Param2<int, int> paramValue = new Param2<int, int>(index, value);
 
 m_SyncMessages.Insert(type);
 m_SyncMessages.Insert(paramValue);
 }
 
 void SyncReceiveValueInt(ParamsReadContext ctx)
 {
 Param2<int, int> paramValue = new Param2<int, int>(-1, 0);
 
 if (ctx.Read(paramValue))
 {
 SetValueInt(paramValue.param1, paramValue.param2);
 }
 }
 
 void SyncSetValueFloat(int index, float value)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_FLOAT); 
 Param2<int, float> paramValue = new Param2<int, float>(index, value);
 
 m_SyncMessages.Insert(type);
 m_SyncMessages.Insert(paramValue);
 }
 
 void SyncReceiveValueFloat(ParamsReadContext ctx)
 {
 Param2<int, float> paramValue = new Param2<int, float>(-1, 0.0);
 
 if (ctx.Read(paramValue))
 {
 SetValueFloat(paramValue.param1, paramValue.param2);
 }
 }
 
 void SyncSetValueBool(int index, bool value)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.SET_VALUE_BOOL); 
 Param2<int, bool> paramValue = new Param2<int, bool>(index, value);
 
 m_SyncMessages.Insert(type);
 m_SyncMessages.Insert(paramValue);
 }
 
 void SyncReceiveValueBool(ParamsReadContext ctx)
 {
 Param2<int, bool> paramValue = new Param2<int, bool>(-1, false);
 
 if (ctx.Read(paramValue))
 {
 SetValueBool(paramValue.param1, paramValue.param2);
 }
 }
 
 void SyncActivateCommand(int commandIdx, int userInt, float userFloat)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.ACTIVATE_COMMAND);
 Param3<int, int, float> command = new Param3<int, int, float>(commandIdx, userInt, userFloat);
 
 m_SyncMessages.Insert(type);
 m_SyncMessages.Insert(command);
 }
 
 void SyncReceiveActivateCommand(ParamsReadContext ctx)
 {
 Param3<int, int, float> command = new Param3<int, int, float>(-1, 0, 0.0);
 
 if (ctx.Read(command))
 {
 ActivateCommand(command.param1, command.param2, command.param3);
 }
 }
 
 void SyncEnableAI(bool enable)
 {
 Param1<int> type = new Param1<int>(PluginDayZCreatureAIDebugSyncMessageType.COUNT);
 if (enable)
 {
 type.param1 = PluginDayZCreatureAIDebugSyncMessageType.ENABLE_AI;
 }
 else
 {
 type.param1 = PluginDayZCreatureAIDebugSyncMessageType.DISABLE_AI;
 }
 
 m_SyncMessages.Insert(type);
 }
 
 void SyncReceiveEnableAI(ParamsReadContext ctx)
 {
 EnableAI(true);
 }
 
 void SyncReceiveDisableAI(ParamsReadContext ctx)
 {
 EnableAI(false);
 }
}