debug.c

Go to the documentation of this file.

// TODO:
// 1. Alredy exist some key in array / map
// 2. Object is null (check object & log error)
// 3. Debug version only
// 4. Destructor of static classes
// 5. Debug Console Interface:
// - Clear Log
// - Filter
// - Log per frame
// 6. Per frame log ?
// 7. Zapis do fajlu
 
class Debug
{ 
 static private const string LOG_DEBUG = "Debug";
 static private const string LOG_DEBUG_ACTION = "Action";
 static private const string LOG_DEBUG_SYMPTOM = "Symptom";
 static private const string LOG_DEBUG_INV_MOVE = "Inv Move";
 static private const string LOG_DEBUG_INV_RESERVATION = "Inv Rrsv";
 static private const string LOG_DEBUG_INV_HFSM = "HFSM";
 static private const string LOG_DEBUG_QUICKBAR = "Quickbar";
 static private const string LOG_DEBUG_BASEBUILDING = "Base Building";
 static private const string LOG_DEBUG_BLEEDING_CHANCES = "Bleeding";
 static private const string LOG_DEBUG_TRIGGER = "Trigger";
 static private const string LOG_DEBUG_PARTICLE = "Particle";
 static private const string LOG_DEBUG_TF = "TestFramework";
 static private const string LOG_DEBUG_WEIGHT = "Weight";
 static private const string LOG_DEBUG_MELEE = "Melee";
 static private const string LOG_DEBUG_WEATHER = "Weather";
 
 static private const string LOG_INFO = "Info";
 static private const string LOG_WARNING = "Warning";
 static private const string LOG_ERROR = "Error";
 static private const string LOG_DEFAULT = "n/a";
 
 static private ref array<Shape> m_DebugShapes;
 
 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 = GetGame().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>;
 }
 
 static void DestroyAllShapes()
 {
 for ( int i = 0; i < m_DebugShapes.Count(); ++i )
 {
 if ( m_DebugShapes.Get(i) )
 {
 m_DebugShapes.Get(i).Destroy();
 }
 }
 
 m_DebugShapes.Clear();
 }
 
 static void RemoveShape(out Shape shape)
 {
 if (!shape) return;
 for ( int i = 0; i < m_DebugShapes.Count(); i++ )
 {
 Shape found_shape = m_DebugShapes.Get(i);
 
 if ( found_shape && found_shape == shape )
 {
 found_shape.Destroy();
 m_DebugShapes.Remove(i); // Mandatory! Otherwise the Destroy() function causes crash!
 shape = 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)
 {
 string res = LogMessage(LOG_DEBUG, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void ActionLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_ACTION, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void SymptomLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_SYMPTOM, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void InventoryMoveLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_INV_MOVE, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void InventoryReservationLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_INV_RESERVATION, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void InventoryHFSMLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_INV_HFSM, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void QuickbarLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_QUICKBAR, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 } 
 
 static void BaseBuildingLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_BASEBUILDING, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void BleedingChancesLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_BLEEDING_CHANCES, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void TriggerLog(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_DEBUG_TRIGGER, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void ParticleLog(string message = LOG_DEFAULT, Managed caller = null, string function = "", Managed entity = null)
 {
 string res = LogMessage(LOG_DEBUG_PARTICLE, GetDebugName(caller), GetDebugName(entity), "", function, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void TFLog(string message = LOG_DEFAULT, TestFramework caller = null, string function = "")
 {
 string res = LogMessage(LOG_DEBUG_TF, GetDebugName(caller), "", "", function, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void WeightLog(string message = LOG_DEFAULT, Managed caller = null, string function = "", Managed entity = null)
 {
 /*
 string res = LogMessage(LOG_DEBUG_WEIGHT, GetDebugName(caller), GetDebugName(entity), "", function, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 */
 }
 
 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);
 string res = LogMessage(LOG_DEBUG_MELEE, plugin, GetDebugName(entity), author, label, logMessage);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 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;
 }
 
 string res = LogMessage(LOG_DEBUG_WEATHER, plugin, entity, author, label, message);
 
 #ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
 #endif
 }
 
 static void LogInfo(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_INFO, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void LogWarning(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_WARNING, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void LogError(string message = LOG_DEFAULT, string plugin = LOG_DEFAULT, string author = LOG_DEFAULT, string label = LOG_DEFAULT, string entity = LOG_DEFAULT)
 {
 string res = LogMessage(LOG_ERROR, plugin, entity, author, label, message);
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 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;
 
 string res;
 
 for (int i = 0; i < arr.Count(); i++)
 {
 res += LogMessage(LOG_DEBUG, plugin, entity, author, label, arr.Get(i).ToString());
 }
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 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;
 
 string res;
 
 for (int i = 0; i < arr.Count(); i++)
 {
 res += LogMessage(LOG_DEBUG, plugin, entity, author, label, arr.Get(i));
 }
 
#ifdef LOG_TO_RPT
 if (res.Length() > 0)
 {
 PrintToRPT("" + res);
 }
#endif
 }
 
 static void ReceivedLogMessageFromServer(string message)
 {
 if (!LogManager.IsLogsEnable())
 {
 return;
 }
 
 SaveLog(message);
 
#ifdef LOG_TO_RPT
 if (message.Length() > 0)
 {
 PrintToRPT("" + message);
 }
#endif
 }
 
 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 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 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();
 
 for ( int s = 0; s < searching_in.Count(); ++s )
 {
 string config_path = searching_in.Get(s);
 
 int objects_count = GetGame().ConfigGetChildrenCount(config_path);
 for (int i = 0; i < objects_count; i++)
 {
 string childName;
 GetGame().ConfigGetChildName(config_path, i, childName);
 
 if ( only_public )
 {
 int scope = GetGame().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
 
 static private bool m_EnabledLogs; 
 
 static private string LogMessage(string level, string plugin, string entity, string author, string label, string message)
 {
 if (GetGame() == null || !LogManager.IsLogsEnable())
 return string.Empty;
 
 bool is_server_log = ( GetGame().IsServer() && GetGame().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 DEVELOPER //not sendig log to clients on stable
 Param1<string> msg_p = new Param1<string>(msg);
 CallMethod(CALL_ID_SEND_LOG, msg_p);
 #endif
 }
 else
 {
 SaveLog(msg);
 }
 
 return msg;
 }
 
 static private void SaveLog(string log_message)
 {
 #ifndef SERVER
 CachedObjectsParams.PARAM1_STRING.param1 = log_message;
 GetDispatcher().CallMethod(CALL_ID_SCR_CNSL_ADD_PRINT, CachedObjectsParams.PARAM1_STRING);
 #endif 
 
 FileHandle fileHandle = OpenFile(GetFileName(), FileMode.APPEND); 
 if (fileHandle == 0)
 return;
 
 FPrintln(fileHandle, log_message);
 CloseFile(fileHandle);
 
 #ifndef LOG_TO_RPT
 #ifdef DIAG_DEVELOPER
 Print(string.Format("%1", log_message));
 #endif
 #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;
 }
 
 static private 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 DIAG_DEVELOPER
 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
{
 static private 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);
 for(int i = 0; i < items.Count(); i++)
 {
 EntityAI item = items.Get(i);
 if (m_WeightDebugData.Get(item))
 {
 m_WeightDebugData.Get(item).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);
 }
 //-------------------------------------------------------------
 
}