Removed platform code, refactored logging to account for it and removed logging global var.

common/CMakeLists.txt

@@ -73,7 +73,6 @@ SET(common_sources
 	textures.cpp
 	timer.cpp
 	unix.cpp
-	platform.cpp
 	json/jsoncpp.cpp
 	net/console_server.cpp
 	net/console_server_connection.cpp
@@ -184,7 +183,6 @@ SET(common_headers
 	packet_dump.h
 	packet_dump_file.h
 	packet_functions.h
-	platform.h
 	proc_launcher.h
 	profanity_manager.h
 	profiler.h

common/cli/eqemu_command_handler.cpp

@@ -21,7 +21,6 @@
 #include <fmt/format.h>
 #include "eqemu_command_handler.h"
 #include "terminal_color.hpp"
-#include "../platform.h"
 
 namespace EQEmuCommand {
 
@@ -119,6 +118,7 @@ namespace EQEmuCommand {
 			std::string &description
 		)> &in_function_map,
 		argh::parser &cmd,
+		const std::string& platform,
 		int argc,
 		char **argv
 	)
@@ -137,7 +137,7 @@ namespace EQEmuCommand {
 			std::cout <<
 					  "> " <<
 					  termcolor::yellow <<
-					  "EQEmulator [" + GetPlatformName() + "] CLI Menu" <<
+					  "EQEmulator [" + platform + "] CLI Menu" <<
 					  termcolor::reset
 					  << std::endl
 					  << std::endl;

common/cli/eqemu_command_handler.h

@@ -66,6 +66,7 @@ namespace EQEmuCommand {
 			std::string &description
 		)> &in_function_map,
 		argh::parser &cmd,
+		const std::string &platform,
 		int argc,
 		char **argv
 	);

common/database.cpp

@@ -2195,7 +2195,7 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings *log_settings)
 		 * If we go through this whole loop and nothing is set to any debug level, there is no point to create a file or keep anything open
 		 */
 		if (log_settings[log_category_id].log_to_file > 0) {
-			LogSys.file_logs_enabled = true;
+			EQEmuLogSys::Get()->file_logs_enabled = true;
 		}
 
 		categories_in_database[log_category_id] = 1;

common/dbcore.cpp

@@ -117,7 +117,7 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 
 		/* Implement Logging at the Root */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0) {
-			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
+			if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)
 				Log(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
@@ -141,7 +141,7 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 		(uint32) mysql_insert_id(&mysql)
 	);
 
-	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
+	if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
 		if ((strncasecmp(query, "select", 6) == 0)) {
 			LogF(
 				Logs::General,

common/eq_packet.cpp

@@ -21,7 +21,6 @@
 #include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
-#include "platform.h"
 #include <iomanip>
 #include <iostream>
 #include <sstream>
@@ -154,52 +153,6 @@ void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 #endif
 }
 
-void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
-{
-	BasePacket::build_raw_header_dump(buffer, seq);
-	buffer += strlen(buffer);
-
-#ifdef STATIC_OPCODE
-	buffer += sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	buffer += sprintf(buffer, "[OpCode %s (0x%04x) Size=%u]\n", OpcodeManager::EmuToName(emu_opcode), opcode,size);
-#endif
-}
-
-void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
-{
-	char buff[196];
-	build_raw_header_dump(buff, seq);
-	fprintf(to, "%s", buff);
-}
-
-void EQRawApplicationPacket::build_header_dump(char *buffer) const
-{
-#ifdef STATIC_OPCODE
-	sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	sprintf(buffer, "[OpCode %s (0x%04x) Size=%u]", OpcodeManager::EmuToName(emu_opcode), opcode,size);
-#endif
-}
-
-void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
-{
-	if (src_ip) {
-		std::string sIP,dIP;;
-		sIP=long2ip(src_ip);
-		dIP=long2ip(dst_ip);
-		fprintf(to, "[%s:%d->%s:%d] ",sIP.c_str(),src_port,dIP.c_str(),dst_port);
-	}
-	if (seq != 0xffff)
-		fprintf(to, "[Seq=%u] ",seq);
-
-#ifdef STATIC_OPCODE
-	fprintf(to, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	fprintf(to, "[OpCode %s (0x%04x) Size=%lu]\n", OpcodeManager::EmuToName(emu_opcode), opcode,(unsigned long)size);
-#endif
-}
-
 uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 {
 	if (opcode>0xff) {
@@ -456,52 +409,6 @@ EQApplicationPacket *EQApplicationPacket::Copy() const {
 	return(new EQApplicationPacket(*this));
 }
 
-EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
-	res->copyInfo(this);
-	return(res);
-}
-
-EQRawApplicationPacket::EQRawApplicationPacket(uint16 opcode, const unsigned char *buf, const uint32 len)
-:	EQApplicationPacket(OP_Unknown, buf, len),
-	opcode(opcode)
-{
-}
-EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const uint32 len)
-: EQApplicationPacket(OP_Unknown, buf+sizeof(uint16), len-sizeof(uint16))
-{
-	if(GetExecutablePlatform() != ExePlatformUCS) {
-		opcode = *((const uint16 *) buf);
-		if(opcode == 0x0000)
-		{
-			if(len >= 3)
-			{
-				opcode = *((const uint16 *) (buf + 1));
-				const unsigned char *packet_start = (buf + 3);
-				const int32 packet_length = len - 3;
-				safe_delete_array(pBuffer);
-				if(packet_length >= 0)
-				{
-					size = packet_length;
-					pBuffer = new unsigned char[size];
-					memcpy(pBuffer, packet_start, size);
-				}
-				else
-				{
-					size = 0;
-				}
-			}
-			else
-			{
-				safe_delete_array(pBuffer);
-				size = 0;
-			}
-		}
-	} else {
-		opcode = *((const uint8 *) buf);
-	}
-}
-
 void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
 	if (iShowInfo) {
 		std::cout << "Dumping Applayer: 0x" << std::hex << std::setfill('0') << std::setw(4) << app->GetOpcode() << std::dec;
@@ -515,4 +422,4 @@ std::string DumpPacketToString(const EQApplicationPacket* app){
 	std::ostringstream out;
 	out << DumpPacketHexToString(app->pBuffer, app->size);
 	return out.str();
-}
+}

common/eq_packet.h

@@ -19,7 +19,6 @@
 #define _EQPACKET_H
 
 #include "base_packet.h"
-#include "platform.h"
 #include <iostream>
 
 #ifdef STATIC_OPCODE
@@ -57,8 +56,6 @@ protected:
 
 };
 
-class EQRawApplicationPacket;
-
 class EQProtocolPacket : public BasePacket {
 	friend class EQStream;
 	friend class EQStreamPair;
@@ -68,7 +65,6 @@ public:
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
 	EQProtocolPacket *Copy() { return new EQProtocolPacket(opcode,pBuffer,size); }
-	EQRawApplicationPacket *MakeAppPacket() const;
 
 	bool acked;
 	uint32 sent_time;
@@ -98,15 +94,15 @@ class EQApplicationPacket : public EQPacket {
 	friend class EQStream;
 public:
 	EQApplicationPacket() : EQPacket(OP_Unknown, nullptr, 0), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op) : EQPacket(op, nullptr, 0), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, const uint32 len) : EQPacket(op, nullptr, len), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op, buf, len), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, SerializeBuffer &buf) : EQPacket(op, buf), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
 	uint32 Size() const { return size+app_opcode_size; }
@@ -134,25 +130,6 @@ private:
 
 };
 
-class EQRawApplicationPacket : public EQApplicationPacket {
-	friend class EQStream;
-public:
-	EQRawApplicationPacket(uint16 opcode, const unsigned char *buf, const uint32 len);
-	uint16 GetRawOpcode() const { return(opcode); }
-
-	virtual void build_raw_header_dump(char *buffer, uint16 seq=0xffff) const;
-	virtual void build_header_dump(char *buffer) const;
-	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
-	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;
-
-protected:
-
-	//the actual raw EQ opcode
-	uint16 opcode;
-
-	EQRawApplicationPacket(const unsigned char *buf, const uint32 len);
-};
-
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
 extern std::string DumpPacketToString(const EQApplicationPacket* app);
 

common/eqemu_logsys.cpp

@@ -20,7 +20,6 @@
 
 #include "eqemu_logsys.h"
 #include "rulesys.h"
-#include "platform.h"
 #include "string_util.h"
 #include "database.h"
 #include "misc.h"
@@ -96,13 +95,8 @@ EQEmuLogSys::EQEmuLogSys()
  */
 EQEmuLogSys::~EQEmuLogSys() = default;
 
-void EQEmuLogSys::LoadLogSettingsDefaults()
+void EQEmuLogSys::LoadLogSettingsDefaults(const std::string& platform)
 {
-	/**
-	 * Get Executable platform currently running this code (Zone/World/etc)
-	 */
-	log_platform = GetExecutablePlatformInt();
-
 	for (int log_category_id = Logs::AA; log_category_id != Logs::MaxCategoryID; log_category_id++) {
 		log_settings[log_category_id].log_to_console      = 0;
 		log_settings[log_category_id].log_to_file         = 0;
@@ -149,30 +143,7 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		}
 	}
 
-	/**
-	 * Declare process file names for log writing=
-	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld) {
-		platform_file_name = "world";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ) {
-		platform_file_name = "query_server";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
-		platform_file_name = "zone";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS) {
-		platform_file_name = "ucs";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin) {
-		platform_file_name = "login";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch) {
-		platform_file_name = "launcher";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC) {
-		platform_file_name = "hc";
-	}
+	platform_file_name = platform;
 }
 
 /**
@@ -206,7 +177,7 @@ std::string EQEmuLogSys::FormatOutMessageString(
 	std::string return_string;
 
 	if (IsRfc5424LogCategory(log_category)) {
-		return_string = "[" + GetPlatformName() + "] ";
+		return_string = "[" + platform_file_name + "] ";
 	}
 
 	return return_string + "[" + Logs::LogCategoryName[log_category] + "] " + in_message;
@@ -233,7 +204,7 @@ void EQEmuLogSys::ProcessGMSay(
 	/**
 	 * Check to see if the process that actually ran this is zone
 	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+	if (on_log_gmsay_hook) {
 		on_log_gmsay_hook(log_category, message);
 	}
 }
@@ -535,7 +506,7 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 	/**
 	 * Zone
 	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+	if (platform_file_name == "zone") {
 		if (!log_name.empty()) {
 			platform_file_name = log_name;
 		}

common/eqemu_logsys.h

@@ -192,15 +192,19 @@ namespace Logs {
 
 class EQEmuLogSys {
 public:
-	EQEmuLogSys();
 	~EQEmuLogSys();
 
+	static EQEmuLogSys* Get() {
+		static EQEmuLogSys inst;
+		return &inst;
+	}
+
 	/**
 	 * Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else.
 	 * This should be handled on deconstructor but to be safe we use it anyways.
 	 */
 	void CloseFileLogs();
-	void LoadLogSettingsDefaults();
+	void LoadLogSettingsDefaults(const std::string &platform);
 
 	/**
 	 * @param directory_name
@@ -263,11 +267,6 @@ public:
 
 	bool file_logs_enabled = false;
 
-	/**
-	 * Sets Executable platform (Zone/World/UCS) etc.
-	 */
-	int log_platform = 0;
-
 	/**
 	 * File name used in writing logs
 	 */
@@ -302,6 +301,9 @@ public:
 	void EnableConsoleLogging();
 
 private:
+	EQEmuLogSys();
+	EQEmuLogSys(const EQEmuLogSys&);
+	EQEmuLogSys& operator=(const EQEmuLogSys&);
 
 	/**
 	 * Callback pointer to zone process for hooking logs to zone using GMSay
@@ -355,12 +357,10 @@ private:
 	bool IsRfc5424LogCategory(uint16 log_category);
 };
 
-extern EQEmuLogSys LogSys;
-
 /**
 template<typename... Args>
 void OutF(
-	EQEmuLogSys &ls,
+	EQEmuLogSys *ls,
 	Logs::DebugLevel debug_level,
 	uint16 log_category,
 	const char *file,
@@ -377,7 +377,7 @@ void OutF(
 
 #define OutF(ls, debug_level, log_category, file, func, line, formatStr, ...) \
 do { \
-    ls.Out(debug_level, log_category, file, func, line, fmt::format(formatStr, ##__VA_ARGS__).c_str()); \
+    ls->Out(debug_level, log_category, file, func, line, fmt::format(formatStr, ##__VA_ARGS__).c_str()); \
 } while(0)
 
 #endif

common/eqemu_logsys_log_aliases.h

@@ -28,43 +28,43 @@
  */
 
 #define LogEmergency(message, ...) do {\
-    if (LogSys.log_settings[Logs::Emergency].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Emergency, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Emergency].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Emergency, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAlert(message, ...) do {\
-    if (LogSys.log_settings[Logs::Alert].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Alert, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Alert].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Alert, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCritical(message, ...) do {\
-    if (LogSys.log_settings[Logs::Critical].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Critical, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Critical].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Critical, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogError(message, ...) do {\
-    if (LogSys.log_settings[Logs::Error].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Error, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Error].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Error, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogWarning(message, ...) do {\
-    if (LogSys.log_settings[Logs::Warning].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Warning, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Warning].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Warning, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNotice(message, ...) do {\
-    if (LogSys.log_settings[Logs::Notice].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Notice, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Notice].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Notice, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogInfo(message, ...) do {\
-    if (LogSys.log_settings[Logs::Info].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Info, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Info].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Info, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogDebug(message, ...) do {\
-    if (LogSys.log_settings[Logs::Debug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Debug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Debug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Debug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 /**
@@ -72,493 +72,493 @@
  */
 
 #define LogAA(message, ...) do {\
-    if (LogSys.log_settings[Logs::AA].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAADetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AA].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAI(message, ...) do {\
-    if (LogSys.log_settings[Logs::AI].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAIDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AI].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAggro(message, ...) do {\
-    if (LogSys.log_settings[Logs::Aggro].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAggroDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Aggro].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAttack(message, ...) do {\
-    if (LogSys.log_settings[Logs::Attack].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAttackDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Attack].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogPacketClientServer(message, ...) do {\
-    if (LogSys.log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogPacketClientServerDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCombat(message, ...) do {\
-    if (LogSys.log_settings[Logs::Combat].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCombatDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Combat].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCommands(message, ...) do {\
-    if (LogSys.log_settings[Logs::Commands].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCommandsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Commands].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCrash(message, ...) do {\
-    if (LogSys.log_settings[Logs::Crash].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogCrashDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Crash].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogDoors(message, ...) do {\
-    if (LogSys.log_settings[Logs::Doors].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogDoorsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Doors].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogGuilds(message, ...) do {\
-    if (LogSys.log_settings[Logs::Guilds].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogGuildsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Guilds].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogInventory(message, ...) do {\
-    if (LogSys.log_settings[Logs::Inventory].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogInventoryDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Inventory].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogLauncher(message, ...) do {\
-    if (LogSys.log_settings[Logs::Launcher].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogLauncherDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Launcher].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNetcode(message, ...) do {\
-    if (LogSys.log_settings[Logs::Netcode].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNetcodeDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Netcode].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNormal(message, ...) do {\
-    if (LogSys.log_settings[Logs::Normal].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNormalDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Normal].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogObject(message, ...) do {\
-    if (LogSys.log_settings[Logs::Object].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogObjectDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Object].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogPathing(message, ...) do {\
-    if (LogSys.log_settings[Logs::Pathing].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogPathingDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Pathing].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQSServer(message, ...) do {\
-    if (LogSys.log_settings[Logs::QSServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQSServerDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::QSServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQuests(message, ...) do {\
-    if (LogSys.log_settings[Logs::Quests].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQuestsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Quests].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogRules(message, ...) do {\
-    if (LogSys.log_settings[Logs::Rules].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogRulesDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Rules].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSkills(message, ...) do {\
-    if (LogSys.log_settings[Logs::Skills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSkillsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Skills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSpawns(message, ...) do {\
-    if (LogSys.log_settings[Logs::Spawns].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSpawnsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Spawns].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSpells(message, ...) do {\
-    if (LogSys.log_settings[Logs::Spells].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogSpellsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Spells].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTCPConnection(message, ...) do {\
-    if (LogSys.log_settings[Logs::TCPConnection].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTCPConnectionDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::TCPConnection].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTasks(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tasks].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTasksDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tasks].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTradeskills(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tradeskills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTradeskillsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tradeskills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTrading(message, ...) do {\
-    if (LogSys.log_settings[Logs::Trading].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTradingDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Trading].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTribute(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tribute].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTributeDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Tribute].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMySQLError(message, ...) do {\
-    if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMySQLErrorDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMySQLQuery(message, ...) do {\
-    if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMySQLQueryDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMercenaries(message, ...) do {\
-    if (LogSys.log_settings[Logs::Mercenaries].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMercenariesDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Mercenaries].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQuestDebug(message, ...) do {\
-    if (LogSys.log_settings[Logs::QuestDebug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogQuestDebugDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::QuestDebug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogLoginserver(message, ...) do {\
-    if (LogSys.log_settings[Logs::Loginserver].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogLoginserverDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Loginserver].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogClientLogin(message, ...) do {\
-    if (LogSys.log_settings[Logs::ClientLogin].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogClientLoginDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::ClientLogin].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogHeadlessClient(message, ...) do {\
-    if (LogSys.log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogHeadlessClientDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogHPUpdate(message, ...) do {\
-    if (LogSys.log_settings[Logs::HPUpdate].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogHPUpdateDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::HPUpdate].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFixZ(message, ...) do {\
-    if (LogSys.log_settings[Logs::FixZ].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFixZDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::FixZ].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFood(message, ...) do {\
-    if (LogSys.log_settings[Logs::Food].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFoodDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Food].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTraps(message, ...) do {\
-    if (LogSys.log_settings[Logs::Traps].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogTrapsDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Traps].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNPCRoamBox(message, ...) do {\
-    if (LogSys.log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNPCRoamBoxDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNPCScaling(message, ...) do {\
-    if (LogSys.log_settings[Logs::NPCScaling].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogNPCScalingDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::NPCScaling].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMobAppearance(message, ...) do {\
-    if (LogSys.log_settings[Logs::MobAppearance].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogMobAppearanceDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::MobAppearance].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogStatus(message, ...) do {\
-    if (LogSys.log_settings[Logs::Status].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogStatusDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Status].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAIScanClose(message, ...) do {\
-    if (LogSys.log_settings[Logs::AIScanClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAIScanCloseDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AIScanClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAIYellForHelp(message, ...) do {\
-    if (LogSys.log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAIYellForHelpDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAICastBeneficialClose(message, ...) do {\
-    if (LogSys.log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAICastBeneficialCloseDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAoeCast(message, ...) do {\
-    if (LogSys.log_settings[Logs::AoeCast].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogAoeCastDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::AoeCast].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogEntityManagement(message, ...) do {\
-    if (LogSys.log_settings[Logs::EntityManagement].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogEntityManagementDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::EntityManagement].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFlee(message, ...) do {\
-    if (LogSys.log_settings[Logs::Flee].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogFleeDetail(message, ...) do {\
-    if (LogSys.log_settings[Logs::Flee].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define Log(debug_level, log_category, message, ...) do {\
-    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-        LogSys.Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
+        EQEmuLogSys::Get()->Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogF(debug_level, log_category, message, ...) do {\
-    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-        OutF(LogSys, debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #else
@@ -849,4 +849,4 @@
 } while (0)
 #endif
 
-#endif //EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H
+#endif //EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H

common/platform.cpp

@@ -1,73 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#include "platform.h"
-
-EQEmuExePlatform exe_platform = ExePlatformNone;
-
-void RegisterExecutablePlatform(EQEmuExePlatform p) {
-	exe_platform = p;
-}
-
-const EQEmuExePlatform& GetExecutablePlatform() {
-	return exe_platform;
-}
-
-/**
- * @return
- */
-int GetExecutablePlatformInt(){
-	return exe_platform;
-}
-
-/**
- * Returns platform name by string
- *
- * @return
- */
-std::string GetPlatformName()
-{
-	switch (GetExecutablePlatformInt()) {
-		case EQEmuExePlatform::ExePlatformWorld:
-			return "WorldServer";
-		case EQEmuExePlatform::ExePlatformQueryServ:
-			return "QueryServer";
-		case EQEmuExePlatform::ExePlatformZone:
-			return "ZoneServer";
-		case EQEmuExePlatform::ExePlatformUCS:
-			return "UCS";
-		case EQEmuExePlatform::ExePlatformLogin:
-			return "LoginServer";
-		case EQEmuExePlatform::ExePlatformSocket_Server:
-			return "SocketServer";
-		case EQEmuExePlatform::ExePlatformSharedMemory:
-			return "SharedMemory";
-		case EQEmuExePlatform::ExePlatformClientImport:
-			return "ClientImport";
-		case EQEmuExePlatform::ExePlatformClientExport:
-			return "ClientExport";
-		case EQEmuExePlatform::ExePlatformLaunch:
-			return "Launch";
-		case EQEmuExePlatform::ExePlatformHC:
-			return "HC";
-		default:
-			return "";
-	}
-}

common/platform.h

@@ -1,47 +0,0 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#ifndef EQEMU_PLATFORM_H
-#define EQEMU_PLATFORM_H
-
-#include "iostream"
-
-enum EQEmuExePlatform
-{
-	ExePlatformNone = 0,
-	ExePlatformZone,
-	ExePlatformWorld,
-	ExePlatformLogin,
-	ExePlatformQueryServ,
-	ExePlatformSocket_Server,
-	ExePlatformUCS,
-	ExePlatformLaunch,
-	ExePlatformSharedMemory,
-	ExePlatformClientImport,
-	ExePlatformClientExport,
-	ExePlatformHC
-};
-
-void RegisterExecutablePlatform(EQEmuExePlatform p);
-const EQEmuExePlatform& GetExecutablePlatform();
-int GetExecutablePlatformInt();
-std::string GetPlatformName();
-
-#endif