debug.c

Go to the documentation of this file.

class Debug
{   
    private static const string LOG_DEBUG                   = "Debug";
    private static const string LOG_DEBUG_ACTION            = "Action";
    private static const string LOG_DEBUG_SYMPTOM           = "Symptom";
    private static const string LOG_DEBUG_INV_MOVE          = "Inv Move";
    private static const string LOG_DEBUG_INV_RESERVATION   = "Inv Rrsv";
    private static const string LOG_DEBUG_INV_HFSM          = "HFSM";
    private static const string LOG_DEBUG_QUICKBAR          = "Quickbar";
    private static const string LOG_DEBUG_BASEBUILDING      = "Base Building";
    private static const string LOG_DEBUG_BLEEDING_CHANCES  = "Bleeding";
    private static const string LOG_DEBUG_TRIGGER           = "Trigger";
    private static const string LOG_DEBUG_PARTICLE          = "Particle";
    private static const string LOG_DEBUG_TF                = "TestFramework";
    private static const string LOG_DEBUG_WEIGHT            = "Weight";
    private static const string LOG_DEBUG_MELEE             = "Melee";
    private static const string LOG_DEBUG_WEATHER           = "Weather";
 
    private static const string LOG_INFO                    = "Info";
    private static const string LOG_WARNING                 = "Warning";
    private static const string LOG_ERROR                   = "Error";
    private static const string LOG_DEFAULT                 = "n/a";
    
    private static ref array<Shape> m_DebugShapes;
    private static ref array<ref DebugTextScreenSpace> m_DebugTextsSS;
    private static ref array<ref DebugTextWorldSpace> m_DebugTextsWS;
    
    static Widget m_DebugLayoutCanvas;
    static CanvasWidget m_CanvasDebug;
    
    static string GetDebugName(Managed entity)
    {
        if (!entity)
            return "";
        
        Object obj;
        if (CastTo(obj, entity))
            return obj.GetDebugNameNative();
        
        return entity.GetDebugName();
    }
    
    static void InitCanvas()
    {
        if (!m_DebugLayoutCanvas)
        {
            m_DebugLayoutCanvas = g_Game.GetWorkspace().CreateWidgets("gui/layouts/debug/day_z_debugcanvas.layout");
            m_CanvasDebug = CanvasWidget.Cast( m_DebugLayoutCanvas.FindAnyWidget( "CanvasWidget" ) );
        }
    }
 
    static void ClearCanvas()
    {
        if (m_CanvasDebug)
            m_CanvasDebug.Clear();
    }
    
    static void CanvasDrawLine(float x1, float y1, float x2, float y2, float width, int color)
    {
        InitCanvas();
        m_CanvasDebug.DrawLine(x1, y1, x2, y2, width, color);
    }
    
    
    static void CanvasDrawPoint(float x1, float y1, int color)
    {
        CanvasDrawLine(x1, y1, x1+1, y1, 1, color);
    }
    
    static void Init()
    {
        m_DebugShapes   = new array<Shape>();
        m_DebugTextsSS  = new array<ref DebugTextScreenSpace>();
        m_DebugTextsWS  = new array<ref DebugTextWorldSpace>();
    }
    
    static void DestroyAll()
    {
        DestroyAllShapes();
        DestroyAllTextSS();
        DestroyAllTextWS();
    }
    
    static void DestroyAllShapes()
    {
        foreach (Shape debugShape : m_DebugShapes)
            debugShape.Destroy();
        
        m_DebugShapes.Clear();
    }
        
    static void DestroyAllTextSS()
    {
        m_DebugTextsSS.Clear();
    }
    
    static void DestroyAllTextWS()
    {
        m_DebugTextsWS.Clear();
    }
    
    static void RemoveShape(out Shape shape)
    {
        if (!shape)
            return;
 
        int nDebugShapes = m_DebugShapes.Count();
        for (int i = 0; i < nDebugShapes; ++i)
        {
            Shape foundShape = m_DebugShapes.Get(i);
            
            if (foundShape && foundShape == shape)
            {
                foundShape.Destroy();
                m_DebugShapes.Remove(i); // Mandatory! Otherwise the Destroy() function causes crash!
                shape = null;
                return;
            }
        }
    }
    
    static void RemoveTextSS(out DebugTextScreenSpace text)
    {
        if (!text)
            return;
 
        int nDebugTextsSS = m_DebugTextsSS.Count();
        for (int i = 0; i < nDebugTextsSS; ++i)
        {
            DebugTextScreenSpace foundText = m_DebugTextsSS.Get(i);
            
            if (foundText && foundText == text)
            {
                foundText = null;
                m_DebugTextsSS.Remove(i);
                text = null;
                return;
            }
        }
    }
    
    static void RemoveTextWS(out DebugTextWorldSpace text)
    {
        if (!text)
            return;
 
        int nDebugTextsWS = m_DebugTextsWS.Count();
        for (int i = 0; i < nDebugTextsWS; ++i)
        {
            DebugTextWorldSpace foundText = m_DebugTextsWS.Get(i);
            
            if (foundText && foundText == text)
            {
                foundText = null;
                m_DebugTextsWS.Remove(i);
                text = null;
                return;
            }
        }
    }

    static void Log(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG, plugin, entity, author, label, message);
    }
    
    static void ActionLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_ACTION, plugin, entity, author, label, message);
    }
    
    static void SymptomLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_SYMPTOM, plugin, entity, author, label, message);
    }
    
    static void InventoryMoveLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_INV_MOVE, plugin, entity, author, label, message);
    }
    
    static void InventoryReservationLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_INV_RESERVATION, plugin, entity, author, label, message);
    }
    
    static void InventoryHFSMLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_INV_HFSM, plugin, entity, author, label, message);
    }
    
    static void QuickbarLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_QUICKBAR, plugin, entity, author, label, message);
    }   
    
    static void BaseBuildingLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_BASEBUILDING, plugin, entity, author, label, message);
    }
    
    static void BleedingChancesLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_BLEEDING_CHANCES, plugin, entity, author, label, message);
    }
    
    static void TriggerLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_DEBUG_TRIGGER, plugin, entity, author, label, message);
    }
    
    static void ParticleLog(string message = LOG_DEFAULT, Managed caller = null, string function = "", Managed entity = null)
    {
        LogMessage(LOG_DEBUG_PARTICLE, GetDebugName(caller), GetDebugName(entity), "", function, message);
    }
    
    static void TFLog(string message = LOG_DEFAULT, TestFramework caller = null, string function = "")
    {
        LogMessage(LOG_DEBUG_TF, GetDebugName(caller), "", "", function, message);
    }
    
    static void WeightLog(string message = LOG_DEFAULT, Managed caller = null, string function = "", Managed entity = null)
    {
        /*
        LogMessage(LOG_DEBUG_WEIGHT, GetDebugName(caller), GetDebugName(entity), "", function, message);
        */
    }
    
    static void MeleeLog(Entity entity, string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT)
    {
        string logMessage = string.Format("%1: %2", entity.GetSimulationTimeStamp(), message);
        LogMessage(LOG_DEBUG_MELEE, plugin, GetDebugName(entity), author, label, logMessage);
    }
    
    static void WeatherLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        if (!LogManager.IsWeatherLogEnabled())
        {
            return;
        }
 
        LogMessage(LOG_DEBUG_WEATHER, plugin, entity, author, label, message);
    }
    
    static void LogInfo(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_INFO, plugin, entity, author, label, message);
    }
    
    static void LogWarning(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_WARNING, plugin, entity, author, label, message);
    }
    
    static void LogError(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        LogMessage(LOG_ERROR, plugin, entity, author, label, message);
    }
    
    static void LogArrayInt(array<int> arr = NULL, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        if (arr == null)
            return;
        
        int nArr = arr.Count();
        for (int i = 0; i < nArr; ++i)
        {
            LogMessage(LOG_DEBUG, plugin, entity, author, label, arr.Get(i).ToString());
        }
    }
    
    static void LogArrayString(array<string> arr = NULL, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
    {
        if (arr == null)
            return;
 
        int nArr = arr.Count();
        for (int i = 0; i < nArr; ++i)
        {
            LogMessage(LOG_DEBUG, plugin, entity, author, label, arr.Get(i));
        }
    }
    
    static void ReceivedLogMessageFromServer(string message)
    {
        if (!LogManager.IsLogsEnable())
        {
            return;
        }
 
        SaveLog(message);
    }
    
    static void ClearScriptLogs()
    {
        ClearLogs();
    }
 
    static Shape DrawBox(vector pos1, vector pos2, int color = 0x1fff7f7f)
    {
        return DrawBoxEx(pos1, pos2, color, ShapeFlags.TRANSP|ShapeFlags.NOZWRITE);
    }
    
    static Shape DrawBoxEx(vector pos1, vector pos2, int color = 0x1fff7f7f, ShapeFlags flags = ShapeFlags.TRANSP|ShapeFlags.NOZWRITE)
    {
        Shape shape = Shape.Create(ShapeType.BBOX, color, flags, pos1, pos2);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static Shape DrawCube(vector pos, float size = 1, int color = 0x1fff7f7f)
    {
        vector min = pos;
        vector max = pos;
        
        float size_h = size * 0.5;
    
        min[0] = min[0] - size_h;
        min[1] = min[1] - size_h;
        min[2] = min[2] - size_h;
        
        max[0] = max[0] + size_h;
        max[1] = max[1] + size_h;
        max[2] = max[2] + size_h;
        
        Shape shape = Shape.Create(ShapeType.DIAMOND, color, ShapeFlags.TRANSP|ShapeFlags.NOZWRITE, min, max);
        m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static Shape DrawSphere(vector pos, float size = 1, int color = 0x1fff7f7f, ShapeFlags flags = ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE)
    {
        Shape shape = Shape.CreateSphere(color, flags, pos, size);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static Shape DrawFrustum(float horizontalAngle, float verticalAngle, float length, int color = 0x1fff7f7f, ShapeFlags flags = ShapeFlags.TRANSP|ShapeFlags.WIREFRAME)
    {
        Shape shape = Shape.CreateFrustum(horizontalAngle, verticalAngle, length, color, flags);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static Shape DrawCylinder(vector pos, float radius, float height = 1, int color = 0x1fff7f7f, ShapeFlags flags = ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE )
    {
        Shape shape = Shape.CreateCylinder(color, flags, pos, radius, height);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static array<Shape> DrawCone(vector pos, float lenght, float halfAngle, float offsetAngle, int color = 0xFFFFFFFF, int flags = 0)
    {
        array<Shape> shapes = new array<Shape>;
        
        vector endL, endR;
        Math3D.ConePoints(pos, lenght, halfAngle, offsetAngle, endL, endR);
 
        // Left side
        shapes.Insert( Debug.DrawLine(pos, endL, color, flags) );
        // Rigth side
        shapes.Insert( Debug.DrawLine(pos, endR, color, flags) );
        // Top side
        shapes.Insert( Debug.DrawLine(endL, endR, color, flags) );
        // Middle (height) line     
        shapes.Insert( Debug.DrawLine(pos, pos + Vector(Math.Cos(offsetAngle), 0, Math.Sin(offsetAngle)).Normalized() * lenght, color, flags) );
        
        return shapes;
    }
    
    static void CleanupDrawShapes(array<Shape> shapes)
    {
        foreach (Shape shape : shapes)
            Debug.RemoveShape(shape);
        
        shapes.Clear();
    }
    
    static void CleanupTextsSS(array<ref DebugTextScreenSpace> texts)
    {
        foreach (DebugTextScreenSpace text : texts)
            Debug.RemoveTextSS(text);
        
        texts.Clear();
    }
    
    static void CleanupTextsWS(array<ref DebugTextWorldSpace> texts)
    {
        foreach (DebugTextWorldSpace text : texts)
            Debug.RemoveTextWS(text);
        
        texts.Clear();
    }
    
    static Shape DrawLine(vector from, vector to, int color = 0xFFFFFFFF, int flags = 0)
    {
        vector pts[2]
        pts[0] = from;
        pts[1] = to;
        
        Shape shape = Shape.CreateLines(color, flags, pts, 2);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        //m_DebugShapes.Debug();
        return shape;
    }
 
    static Shape DrawLines(vector[] positions, int count, int color = 0xFFFFFFFF, int flags = 0)
    {
        
        Shape shape = Shape.CreateLines(color, flags, positions, count);
        if (( flags & ShapeFlags.ONCE ) == 0)
            m_DebugShapes.Insert(shape);
        return shape;
    }
    
    static Shape DrawArrow(vector from, vector to, float size = 0.5, int color = 0xFFFFFFFF, int flags = 0)
    {
        Shape shape = Shape.CreateArrow(from, to, size, color, flags);
        m_DebugShapes.Insert(shape);
        return shape;
    }
    
    
    
    static DebugTextScreenSpace DrawTextSS(string text, float x, float y, float size = 20.0, int color = 0xFFFFFFFF, int bgColor = 0x00000000, DebugTextFlags flags = DebugTextFlags.DEFAULT, int priority = 1000)
    {
        DebugTextScreenSpace textSS = DebugTextScreenSpace.Create(text, flags, x, y, size, color, bgColor, priority);
        if ((flags & DebugTextFlags.ONCE) == 0)
            m_DebugTextsSS.Insert(textSS);
        
        return textSS;
    }
 
    static DebugTextWorldSpace DrawTextWS(string text, vector position, float size = 20.0, int color = 0xFFFFFFFF, int bgColor = 0x00000000, DebugTextFlags flags = DebugTextFlags.DEFAULT, int priority = 1000)
    {
        DebugTextWorldSpace textWS = DebugTextWorldSpace.Create(text, flags, position[0], position[1], position[2], size, color, bgColor, priority);
        if ((flags & DebugTextFlags.ONCE) == 0)
            m_DebugTextsWS.Insert(textWS);
 
        return textWS;
    }

    static void GetBaseConfigClasses( out TStringArray base_classes )
    {
        base_classes.Clear();
        base_classes.Insert(CFG_VEHICLESPATH);
        base_classes.Insert(CFG_WEAPONSPATH);
        base_classes.Insert(CFG_MAGAZINESPATH);
        base_classes.Insert(CFG_AMMO);
        base_classes.Insert(CFG_WORLDS);
        base_classes.Insert(CFG_SURFACES);
        base_classes.Insert(CFG_SOUND_SETS);
        base_classes.Insert(CFG_SOUND_SHADERS);
        base_classes.Insert(CFG_NONAI_VEHICLES);
        base_classes.Insert(CFG_SOUND_TABLES);
    }
    
    static void GetFiltredConfigClasses( string search_string, out TStringArray filtered_classes, bool only_public = true )
    {   
        TStringArray searching_in = new TStringArray;
        GetBaseConfigClasses( searching_in );
        
        filtered_classes.Clear();
        
        search_string.ToLower();
        
        int nSearchingIn = searching_in.Count();
        for ( int s = 0; s < nSearchingIn; ++s )
        {
            string config_path = searching_in.Get(s);
            
            int objects_count = g_Game.ConfigGetChildrenCount(config_path);
            for (int i = 0; i < objects_count; i++)
            {
                string childName;
                g_Game.ConfigGetChildName(config_path, i, childName);
    
                if ( only_public )
                {
                    int scope = g_Game.ConfigGetInt( config_path + " " + childName + " scope" );
                    if ( scope == 0 )
                    {
                        continue;
                    }
                }
                
                string nchName = childName;
                nchName.ToLower();
    
                if ( nchName.Contains(search_string) != -1)
                {
                    filtered_classes.Insert(childName);
                }
            }
        }
    }
    
    //---------------------------------------------------------------
    //-------private
    
    private static bool             m_EnabledLogs; 
        
    private static string LogMessage(string level, string plugin, string entity, string author, string label, string message)
    {
        if (g_Game == null || !LogManager.IsLogsEnable())
            return string.Empty;
        
        bool is_server_log = ( g_Game.IsServer() && g_Game.IsMultiplayer() );
        
        
        // Formation output to external file
        // %date{MM-dd HH:mm:ss} | %Enviroment | %Level | %Module | %Entity | %Author | %Label | %Message   
        string date         = GetDate();
        string env          = "Client";
        string msg          = string.Empty;
        
        if ( is_server_log )
        {
            env = "Server";
        }
        
        msg = string.Format("%1 | %2 | %3 | %4 | %5 | %6 | %7", date, env, level, plugin, entity, label, message);
    
        if ( is_server_log )
        {
            SaveLog(msg);
            
#ifdef DIAG_DEVELOPER // do not send log to clients on retail
            Param1<string> msg_p = new Param1<string>(msg);
            CallMethod(CALL_ID_SEND_LOG, msg_p);
#endif
        }
        else
        {
            SaveLog(msg);
        }
 
        return msg;
    }
 
    private static void SaveLog(string log_message)
    {
        if (log_message.Length() == 0)
            return;

#ifdef DIAG_DEVELOPER
#ifndef SERVER
        CachedObjectsParams.PARAM1_STRING.param1 = log_message;
        GetDispatcher().CallMethod(CALL_ID_SCR_CNSL_ADD_PRINT, CachedObjectsParams.PARAM1_STRING);
#endif
#endif
        
#ifdef DIAG_DEVELOPER
#ifdef LOG_TO_FILE
        FileHandle fileHandle = OpenFile(GetFileName(), FileMode.APPEND);       
        if (fileHandle != 0)
        {
            FPrintln(fileHandle, log_message);
            CloseFile(fileHandle);
        }
#endif
#endif

#ifdef LOG_TO_RPT
        PrintToRPT("" + log_message);
#endif

#ifdef LOG_TO_SCRIPT
        Print(string.Format("%1", log_message));
#endif
    }
    
    static void ClearLogs()
    {
        if (FileExist(GetFileName()))
        {
            FileHandle fileHandle = OpenFile(GetFileName(), FileMode.WRITE);
            if (fileHandle == 0)
                return;
                
            FPrintln(fileHandle, "");
            CloseFile(fileHandle);  
        }
    }
    
    static string GetFileName()
    {
        return CFG_FILE_SCRIPT_LOG_EXT;
    }
    
    private static string GetDate()
    {
        int year;
        int month;
        int day;
        int hour;
        int minute;
        int second;
        
        GetYearMonthDay(year, month, day);
        GetHourMinuteSecond(hour, minute, second);
        
        string date = month.ToStringLen(2) + "-" + day.ToStringLen(2) + " " + hour.ToStringLen(2) + ":" + minute.ToStringLen(2) + ":" + second.ToStringLen(2);
        
        return date;
    }
};
 
class LogManager
{
    static bool m_DoLogs;
    static bool m_DoActionDebugLog;
    static bool m_DoSymptomDebugLog;
    static bool m_DoInventoryMoveLog;
    static bool m_DoInventoryReservationLog;
    static bool m_DoInventoryHFSMLog;
    static bool m_DoSyncLog;
    static bool m_DoQuickbarLog;
    static bool m_DoBaseBuildingLog;
    static bool m_DoWeaponLog;
    static bool m_DoWeatherLog;
    static bool m_DoBleedingChanceLog;
    
    static void Init()
    {
        #ifdef ENABLE_LOGGING
        m_DoLogs                    = true;
        #else
        m_DoLogs                    = IsCLIParam("doLogs");
        #endif
 
        m_DoActionDebugLog          = IsCLIParam("doActionLog");
        m_DoSymptomDebugLog         = IsCLIParam("doSymptomLog");
        m_DoInventoryMoveLog        = IsCLIParam("doInvMoveLog");
        m_DoInventoryReservationLog = IsCLIParam("doInvReservLog");
        m_DoInventoryHFSMLog        = IsCLIParam("doInvHFSMLog");
        m_DoSyncLog                 = IsCLIParam("doSyncLog");
        m_DoQuickbarLog             = IsCLIParam("doQuickbarLog");
        m_DoBaseBuildingLog         = IsCLIParam("doBaseBuildingLog");
        m_DoWeaponLog               = IsCLIParam("doWeaponLog");
        m_DoWeatherLog              = IsCLIParam("doWeatherLog");
    }
    
    static bool IsLogsEnable()
    {
        return m_DoLogs;
    }
    
    static void SetLogsEnabled(bool enable)
    {
        m_DoLogs = enable;
    }
    
    static bool IsActionLogEnable()
    {
        return m_DoActionDebugLog;
    }
    
    static void ActionLogEnable(bool enable)
    {
        m_DoActionDebugLog = enable;
    }
    
    static bool IsInventoryMoveLogEnable()
    {
        return m_DoInventoryMoveLog;
    }
    
    static void InventoryMoveLogEnable(bool enable)
    {
        m_DoInventoryMoveLog = enable;
    }
    
    static bool IsInventoryReservationLogEnable()
    {
        return m_DoInventoryReservationLog;
    }
    
    static void InventoryReservationLogEnable(bool enable)
    {
        m_DoInventoryReservationLog = enable;
    }
    
    static bool IsInventoryHFSMLogEnable()
    {
        return m_DoInventoryHFSMLog;
    }
    
    static void InventoryHFSMLogEnable(bool enable)
    {
        m_DoInventoryHFSMLog = enable;
    }
    
    static bool IsSyncLogEnable()
    {
        return m_DoSyncLog;
    }
    
    static void SyncLogEnable(bool enable)
    {
        m_DoSyncLog = enable;
    }
    
    static bool IsQuickbarLogEnable()
    {
        return m_DoQuickbarLog;
    }
    
    static void QuickbarLogEnable(bool enable)
    {
        m_DoQuickbarLog = enable;
    }
    
    static bool IsBaseBuildingLogEnable()
    {
        return m_DoBaseBuildingLog;
    }
    
    static void BaseBuildingLogEnable(bool enable)
    {
        m_DoBaseBuildingLog = enable;
    }
    
    static bool IsSymptomLogEnable()
    {
        return m_DoSymptomDebugLog;
    }
    
    static void SymptomLogEnable(bool enable)
    {
        m_DoSymptomDebugLog = enable;
    }
    
    static bool IsWeaponLogEnable()
    {
        return m_DoWeaponLog;
    }
    
    static void WeaponLogEnable(bool enable)
    {
        m_DoWeaponLog = enable;
    }
    
    static bool IsWeatherLogEnabled()
    {
        return m_DoWeatherLog;
    }
    
    static bool IsBleedingChancesLogEnable()
    {
        return m_DoBleedingChanceLog;
    }
    
    static void BleedingChancesLogEnable(bool enable)
    {
        m_DoBleedingChanceLog = enable;
    } 
}
 
enum WeightDebugType
{
    NONE            = 0,
    RECALC_FORCED   = 1,
    RECALC_DIRTY    = 2,
    DUMP_STACK      = 4,
    SET_DIRTY_FLAG  = 8,
}
 
class WeightDebug
{
    private static ref map<EntityAI, ref WeightDebugData> m_WeightDebugData     = new map<EntityAI, ref WeightDebugData>();
    static WeightDebugType m_VerbosityFlags;
    
    //-------------------------------------------------------------
    static WeightDebugData GetWeightDebug(EntityAI entity)
    {
        if (!m_WeightDebugData.Get(entity))
        {
            WeightDebugData data = new WeightDebugData(entity);
            m_WeightDebugData.Insert(entity,data);
            return data;
        }
        return m_WeightDebugData.Get(entity);
    }
    //-------------------------------------------------------------
    static void ClearWeightDebug()
    {
        m_WeightDebugData.Clear();
    }
    //-------------------------------------------------------------
    static void PrintAll(EntityAI entity)
    {
        GameInventory inv = entity.GetInventory();
        if (!inv)
            return;
        array<EntityAI> items = new array<EntityAI>;
        inv.EnumerateInventory(InventoryTraversalType.PREORDER, items);
        int nItems = items.Count();
        for(int i = 0; i < nItems; ++i)
        {
            EntityAI item = items.Get(i);
            WeightDebugData data = m_WeightDebugData.Get(item);
            if (data)
            {
                data.Output();
            }
        }
    }
    //-------------------------------------------------------------
    static void SetVerbosityFlags(WeightDebugType type)
    {
        m_VerbosityFlags = type;
    }
}
 
class WeightDebugData
{
    string  m_Classname;
    string  m_Weight;
    int     m_InventoryDepth;
    string  m_CalcDetails;
    //-------------------------------------------------------------
    void WeightDebugData(EntityAI entity)
    {
        m_Classname = entity.GetType();
        m_InventoryDepth = entity.GetHierarchyLevel();
    }
    //-------------------------------------------------------------
    void SetWeight(float weight)
    {
        m_Weight = weight.ToString();
    }
    //-------------------------------------------------------------
    void SetCalcDetails(string details)
    {
        m_CalcDetails = details;
    }
    
    //-------------------------------------------------------------
    void AddCalcDetails(string details)
    {
        m_CalcDetails += "+ "+details;
    }
    //-------------------------------------------------------------
    void Output()
    {
        string spaces;
        for(int i = 0; i < m_InventoryDepth;i++)
            spaces+="--------";
 
        Print(spaces+">" + m_Classname + " Overall entity weight: "+ m_Weight + " Calculation details:" + m_CalcDetails);
    }
    //-------------------------------------------------------------
 
}