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