DayZOfficialSourceCode/Scripts/4_world/plugins/pluginbase/plugindayzcreatureaidebug.c

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;
					}
				}
			}
		}
	}
	
	///	
	//! GUI actions
	///
	
	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);
		}		
	}
	
	///
	//! sync
	///

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