Update fmtlib

client_files/export/main.cpp

@@ -22,21 +22,17 @@
 #include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
-#include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys LogSys;
-
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
 void ExportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
-	RegisterExecutablePlatform(ExePlatformClientExport);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("client_export");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	LogInfo("Client Files Export Utility");
@@ -56,8 +52,8 @@ int main(int argc, char **argv) {
 	}
 
 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	std::string arg_1;
 
@@ -87,7 +83,7 @@ int main(int argc, char **argv) {
 	ExportBaseData(&database);
 	ExportDBStrings(&database);
 
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 
 	return 0;
 }

client_files/import/main.cpp

@@ -20,21 +20,17 @@
 #include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
-#include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys LogSys;
-
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
 void ImportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
-	RegisterExecutablePlatform(ExePlatformClientImport);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("client_import");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	LogInfo("Client Files Import Utility");
@@ -54,15 +50,15 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
 	ImportDBStrings(&database);
 
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 	
 	return 0;
 }

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

@@ -341,88 +341,65 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 	return true;
 }
 
-/**
+/*
- * @param character_name
+	Delete the character with the name "name"
- * @return
+	returns false on failure, true otherwise
- */
+*/
-bool Database::DeleteCharacter(char *character_name) {
+bool Database::DeleteCharacter(char *name) {
-	uint32 character_id = 0;
+	uint32 charid = 0;
-	if(!character_name || !strlen(character_name)) {
+	if(!name ||	!strlen(name)) {
 		LogInfo("DeleteCharacter: request to delete without a name (empty char slot)");
 		return false;
 	}
+	LogInfo("Database::DeleteCharacter name : [{}]", name);
 
-	std::string query   = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", character_name);
+	/* Get id from character_data before deleting record so we can clean up the rest of the tables */
+	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
-	for (auto   row     = results.begin(); row != results.end(); ++row) {
+	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-		character_id = atoi(row[0]);
+	if (charid <= 0){
-	}
+		LogError("Database::DeleteCharacter :: Character ({}) not found, stopping delete...", name);
-
-	if (character_id <= 0) {
-		LogError("DeleteCharacter | Invalid Character ID [{}]", character_name);
 		return false;
 	}
 
-	std::string delete_type = "hard-deleted";
+	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	if (RuleB(Character, SoftDeletes)) {
+	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-		delete_type       = "soft-deleted";
+	query = StringFormat("DELETE FROM `character_enabledtasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-		std::string query = fmt::format(
+	query = StringFormat("DELETE FROM `character_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-			SQL(
+	query = StringFormat("DELETE FROM `completed_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-				UPDATE
+	query = StringFormat("DELETE FROM `friends` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-				character_data
+	query = StringFormat("DELETE FROM `mail` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-				SET
+	query = StringFormat("DELETE FROM `timers` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-				deleted_at = NOW()
+	query = StringFormat("DELETE FROM `inventory` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-				WHERE
+	query = StringFormat("DELETE FROM `char_recipe_list` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-				id = '{}'
+	query = StringFormat("DELETE FROM `adventure_stats` WHERE `player_id` ='%d'", charid); QueryDatabase(query);
-			),
+	query = StringFormat("DELETE FROM `zone_flags` WHERE `charID` = '%d'", charid); QueryDatabase(query);
-			character_id
+	query = StringFormat("DELETE FROM `titles` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-		);
+	query = StringFormat("DELETE FROM `player_titlesets` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-
+	query = StringFormat("DELETE FROM `keyring` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-		QueryDatabase(query);
+	query = StringFormat("DELETE FROM `faction_values` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-
+	query = StringFormat("DELETE FROM `instance_list_player` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-		return true;
+	query = StringFormat("DELETE FROM `character_data` WHERE `id` = '%d'", charid); QueryDatabase(query);
-	}
+	query = StringFormat("DELETE FROM `character_skills` WHERE `id` = %u", charid); QueryDatabase(query);
-
+	query = StringFormat("DELETE FROM `character_languages` WHERE `id` = %u", charid); QueryDatabase(query);
-	LogInfo("DeleteCharacter | Character [{}] ({}) is being [{}]", character_name, character_id, delete_type);
+	query = StringFormat("DELETE FROM `character_bind` WHERE `id` = %u", charid); QueryDatabase(query);
-
+	query = StringFormat("DELETE FROM `character_alternate_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_currency` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_data` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_enabledtasks` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_spells` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_tasks` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_memmed_spells` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `completed_tasks` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_disciplines` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `friends` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_material` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `mail` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_tribute` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `timers` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_bandolier` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `inventory` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_potionbelt` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `char_recipe_list` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_inspect_messages` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `adventure_stats` WHERE `player_id` ='%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_leadership_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `zone_flags` WHERE `charID` = '%d'", character_id); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_alt_currency` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `titles` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `player_titlesets` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `keyring` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `faction_values` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `instance_list_player` WHERE `charid` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_data` WHERE `id` = '%d'", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_skills` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_languages` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_bind` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_alternate_abilities` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_currency` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_data` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_spells` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_memmed_spells` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_disciplines` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_material` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_tribute` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_bandolier` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_potionbelt` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_inspect_messages` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_leadership_abilities` WHERE `id` = %u", character_id); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_alt_currency` WHERE `char_id` = '%d'", character_id); QueryDatabase(query);
 #ifdef BOTS
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", character_id); // note: only use of GetMobTypeById()
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid); // note: only use of GetMobTypeById()
 #else
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", character_id);
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
 #endif
 	QueryDatabase(query);
 
@@ -2218,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/database.h

@@ -107,7 +107,7 @@ public:
 
 	bool	AddToNameFilter(const char* name);
 	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
-	bool	DeleteCharacter(char* character_name);
+	bool	DeleteCharacter(char* name);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
 	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);

common/database_schema.h

@@ -33,6 +33,7 @@ namespace DatabaseSchema {
 	static std::vector<std::string> GetPlayerTables()
 	{
 		std::vector<std::string> tables = {
+			"aa_timers",
 			"account",
 			"account_ip",
 			"account_flags",

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;

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()
 		}
 	}
 
-	/**
+	platform_file_name = platform;
-	 * 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";
-	}
 }
 
 /**
@@ -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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Emergency].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Emergency, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Alert].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Alert, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Critical].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Critical, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Error].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Error, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Warning].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Warning, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Notice].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Notice, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Info].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Info, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Debug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Debug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
-        OutF(LogSys, Logs::General, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
-        OutF(LogSys, Logs::Detail, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
-        LogSys.Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        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)\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
-        OutF(LogSys, debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+        OutF(EQEmuLogSys::Get(), debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
 #else
@@ -842,42 +842,6 @@
 #define LogStatusDetail(message, ...) do {\
 } while (0)
 
-#define LogAIScanClose(message, ...) do {\
-} while (0)
-
-#define LogAIScanCloseDetail(message, ...) do {\
-} while (0)
-
-#define LogAIYellForHelp(message, ...) do {\
-} while (0)
-
-#define LogAIYellForHelpDetail(message, ...) do {\
-} while (0)
-
-#define LogAICastBeneficialClose(message, ...) do {\
-} while (0)
-
-#define LogAICastBeneficialCloseDetail(message, ...) do {\
-} while (0)
-
-#define LogAoeCast(message, ...) do {\
-} while (0)
-
-#define LogAoeCastDetail(message, ...) do {\
-} while (0)
-
-#define LogEntityManagement(message, ...) do {\
-} while (0)
-
-#define LogEntityManagementDetail(message, ...) do {\
-} while (0)
-
-#define LogFlee(message, ...) do {\
-} while (0)
-
-#define LogFleeDetail(message, ...) do {\
-} while (0)
-
 #define Log(debug_level, log_category, message, ...) do {\
 } while (0)
 

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

common/ruletypes.h

@@ -158,7 +158,6 @@ RULE_BOOL(Character, AllowCrossClassTrainers, false, "")
 RULE_BOOL(Character, PetsUseReagents, true, "Pets use reagent on spells")
 RULE_BOOL(Character, DismountWater, true, "Dismount horses when entering water")
 RULE_BOOL(Character, UseNoJunkFishing, false, "Disregards junk items when fishing")
-RULE_BOOL(Character, SoftDeletes, true, "When characters are deleted in character select, they are only soft deleted")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Mercs)

common/version.h

@@ -34,7 +34,7 @@
  * Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
  */
 
-#define CURRENT_BINARY_DATABASE_VERSION 9146
+#define CURRENT_BINARY_DATABASE_VERSION 9145
 
 #ifdef BOTS
 	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9026

eqlaunch/eqlaunch.cpp

@@ -21,7 +21,6 @@
 #include "../common/proc_launcher.h"
 #include "../common/eqemu_config.h"
 #include "../common/servertalk.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/unix.h"
 #include "worldserver.h"
@@ -32,15 +31,12 @@
 #include <signal.h>
 #include <time.h>
 
-EQEmuLogSys LogSys;
-
 bool RunLoops = false;
 
 void CatchSignal(int sig_num);
 
 int main(int argc, char *argv[]) {
-	RegisterExecutablePlatform(ExePlatformLaunch);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("eqlaunch");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	std::string launcher_name;
@@ -157,7 +153,7 @@ int main(int argc, char *argv[]) {
 		delete zone->second;
 	}
 
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 
 	return 0;
 }

hc/eq.cpp

@@ -28,7 +28,7 @@ EverQuest::EverQuest(const std::string &host, int port, const std::string &user,
 
 	EQ::Net::DNSLookup(m_host, port, false, [&](const std::string &addr) {
 		if (addr.empty()) {
-			Log.OutF(Logs::General, Logs::Headless_Client, "Could not resolve address: {0}", m_host);
+			LogError("Could not resolve address: {0}", m_host);
 			return;
 		}
 		else {
@@ -51,18 +51,18 @@ EverQuest::~EverQuest()
 void EverQuest::LoginOnNewConnection(std::shared_ptr<EQ::Net::DaybreakConnection> connection)
 {
 	m_login_connection = connection;
-	Log.OutF(Logs::General, Logs::Headless_Client, "Connecting...");
+	LogInfo("Connecting...");
 }
 
 void EverQuest::LoginOnStatusChangeReconnectEnabled(std::shared_ptr<EQ::Net::DaybreakConnection> conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to)
 {
 	if (to == EQ::Net::StatusConnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "Login connected.");
+		LogInfo("Login connected.");
 		LoginSendSessionReady();
 	}
 
 	if (to == EQ::Net::StatusDisconnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "Login connection lost before we got to world, reconnecting.");
+		LogInfo("Login connection lost before we got to world, reconnecting.");
 		m_key.clear();
 		m_dbid = 0;
 		m_login_connection.reset();
@@ -165,14 +165,14 @@ void EverQuest::LoginProcessLoginResponse(const EQ::Net::Packet & p)
 	auto response_error = sp.GetUInt16(1);
 
 	if (response_error > 101) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "Error logging in response code: {0}", response_error);
+		LogError("Error logging in response code: {0}", response_error);
 		LoginDisableReconnect();
 	}
 	else {
 		m_key = sp.GetCString(12);
 		m_dbid = sp.GetUInt32(8);
 
-		Log.OutF(Logs::General, Logs::Headless_Client, "Logged in successfully with dbid {0} and key {1}", m_dbid, m_key);
+		LogInfo("Logged in successfully with dbid {0} and key {1}", m_dbid, m_key);
 		LoginSendServerRequest();
 	}
 }
@@ -214,13 +214,13 @@ void EverQuest::LoginProcessServerPacketList(const EQ::Net::Packet & p)
 
 	for (auto server : m_world_servers) {
 		if (server.second.long_name.compare(m_server) == 0) {
-			Log.OutF(Logs::General, Logs::Headless_Client, "Found world server {0}, attempting to login.", m_server);
+			LogInfo("Found world server {0}, attempting to login.", m_server);
 			LoginSendPlayRequest(server.first);
 			return;
 		}
 	}
 
-	Log.OutF(Logs::General, Logs::Headless_Client, "Got response from login server but could not find world server {0} disconnecting.", m_server);
+	LogError("Got response from login server but could not find world server {0} disconnecting.", m_server);
 	LoginDisableReconnect();
 }
 
@@ -238,7 +238,7 @@ void EverQuest::LoginProcessServerPlayResponse(const EQ::Net::Packet &p)
 	}
 	else {
 		auto message = p.GetUInt16(13);
-		Log.OutF(Logs::General, Logs::Headless_Client, "Failed to login to server with message {0}");
+		LogError("Failed to login to server with message {0}");
 		LoginDisableReconnect();
 	}
 }
@@ -261,18 +261,18 @@ void EverQuest::ConnectToWorld()
 void EverQuest::WorldOnNewConnection(std::shared_ptr<EQ::Net::DaybreakConnection> connection)
 {
 	m_world_connection = connection;
-	Log.OutF(Logs::General, Logs::Headless_Client, "Connecting to world...");
+	LogInfo("Connecting to world...");
 }
 
 void EverQuest::WorldOnStatusChangeReconnectEnabled(std::shared_ptr<EQ::Net::DaybreakConnection> conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to)
 {
 	if (to == EQ::Net::StatusConnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "World connected.");
+		LogInfo("World connected.");
 		WorldSendClientAuth();
 	}
 
 	if (to == EQ::Net::StatusDisconnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "World connection lost, reconnecting.");
+		LogInfo("World connection lost, reconnecting.");
 		m_world_connection.reset();
 		m_world_connection_manager->Connect(m_host, 9000);
 	}
@@ -293,7 +293,7 @@ void EverQuest::WorldOnPacketRecv(std::shared_ptr<EQ::Net::DaybreakConnection> c
 		WorldProcessCharacterSelect(p);
 		break;
 	default:
-		Log.OutF(Logs::General, Logs::Headless_Client, "Unhandled opcode: {0:#x}", opcode);
+		LogDebug("Unhandled opcode: {0:#x}", opcode);
 		break;
 	}
 }
@@ -339,12 +339,11 @@ void EverQuest::WorldProcessCharacterSelect(const EQ::Net::Packet &p)
 
 		idx += 274;
 		if (m_character.compare(name) == 0) {
-			Log.OutF(Logs::General, Logs::Headless_Client, "Found {0}, would attempt to login here.", m_character);
+			LogDebug("Found {0}, would attempt to login here.", m_character);
 			WorldSendEnterWorld(m_character);
 			return;
 		}
 	}
 
-	Log.OutF(Logs::General, Logs::Headless_Client, "Could not find {0}, cannot continue to login.", m_character);
+	LogError("Could not find {0}, cannot continue to login.", m_character);
 }
- 

hc/main.cpp

@@ -1,20 +1,16 @@
 #include "../common/event/event_loop.h"
 #include "../common/eqemu_logsys.h"
 #include "../common/crash.h"
-#include "../common/platform.h"
 #include "../common/json_config.h"
 #include <thread>
 
 #include "eq.h"
 
-EQEmuLogSys Log;
-
 int main() {
-	RegisterExecutablePlatform(ExePlatformHC);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("headless_client");
-	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log.OutF(Logs::General, Logs::Headless_Client, "Starting EQEmu Headless Client.");
+	LogInfo("Starting EQEmu Headless Client.");
 
 	auto config = EQ::JsonConfigFile::Load("hc.json");
 	auto config_handle = config.RawHandle();
@@ -32,13 +28,13 @@ int main() {
 			auto server = c["server"].asString();
 			auto character = c["character"].asString();
 			
-			Log.OutF(Logs::General, Logs::Headless_Client, "Connecting to {0}:{1} as Account '{2}' to Server '{3}' under Character '{4}'", host, port, user, server, character);
+			LogInfo("Connecting to {0}:{1} as Account '{2}' to Server '{3}' under Character '{4}'", host, port, user, server, character);
 
 			eq_list.push_back(std::unique_ptr<EverQuest>(new EverQuest(host, port, user, pass, server, character)));
 		}
 	}
 	catch (std::exception &ex) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "Error parsing config file: {0}", ex.what());
+		LogError("Error parsing config file: {0}", ex.what());
 		return 0;
 	}
 

hc/world.cpp

@@ -21,18 +21,18 @@ WorldConnection::~WorldConnection() {
 void WorldConnection::OnNewConnection(std::shared_ptr<EQ::Net::DaybreakConnection> connection)
 {
 	m_connection = connection;
-	Log.OutF(Logs::General, Logs::Headless_Client, "Connecting to world...");
+	LogInfo("Connecting to world...");
 }
 
 void WorldConnection::OnStatusChangeActive(std::shared_ptr<EQ::Net::DaybreakConnection> conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to)
 {
 	if (to == EQ::Net::StatusConnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "World connected.");
+		LogInfo("World connected.");
 		SendClientAuth();
 	}
 
 	if (to == EQ::Net::StatusDisconnected) {
-		Log.OutF(Logs::General, Logs::Headless_Client, "World connection lost, reconnecting.");
+		LogInfo("World connection lost, reconnecting.");
 		m_connection.reset();
 		m_connection_manager->Connect(m_host, 9000);
 	}
@@ -48,7 +48,7 @@ void WorldConnection::OnStatusChangeInactive(std::shared_ptr<EQ::Net::DaybreakCo
 void WorldConnection::OnPacketRecv(std::shared_ptr<EQ::Net::DaybreakConnection> conn, const EQ::Net::Packet &p)
 {
 	auto opcode = p.GetUInt16(0);
-	Log.OutF(Logs::General, Logs::Headless_Client, "Packet in:\n{0}", p.ToString());
+	LogDebug("Packet in:\n{0}", p.ToString());
 }
 
 void WorldConnection::Kill()

loginserver/client.cpp

@@ -103,7 +103,7 @@ bool Client::Process()
 				break;
 			}
 			default: {
-				if (LogSys.log_settings[Logs::PacketClientServerUnhandled].is_category_enabled == 1) {
+				if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServerUnhandled].is_category_enabled == 1) {
 					char dump[64];
 					app->build_header_dump(dump);
 					LogError("Recieved unhandled application packet from the client: [{}]", dump);

loginserver/database.cpp

@@ -647,7 +647,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;

loginserver/loginserver_command_handler.cpp

@@ -59,7 +59,7 @@ namespace LoginserverCommandHandler {
 		function_map["world-admin:create"]                    = &LoginserverCommandHandler::CreateLoginserverWorldAdminAccount;
 		function_map["world-admin:update"]                    = &LoginserverCommandHandler::UpdateLoginserverWorldAdminAccountPassword;
 
-		EQEmuCommand::HandleMenu(function_map, cmd, argc, argv);
+		EQEmuCommand::HandleMenu(function_map, cmd, "loginserver", argc, argv);
 	}
 
 	/**

loginserver/main.cpp

@@ -23,7 +23,6 @@
 #include "../common/opcodemgr.h"
 #include "../common/event/event_loop.h"
 #include "../common/timer.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/eqemu_logsys.h"
 #include "../common/http/httplib.h"
@@ -36,7 +35,6 @@
 #include <sstream>
 
 LoginServer server;
-EQEmuLogSys LogSys;
 bool        run_server = true;
 
 void CatchSignal(int sig_num)
@@ -132,27 +130,26 @@ void LoadServerConfig()
 
 int main(int argc, char **argv)
 {
-	RegisterExecutablePlatform(ExePlatformLogin);
 	set_exception_handler();
 
 	LogInfo("Logging System Init");
 
 	if (argc == 1) {
-		LogSys.LoadLogSettingsDefaults();
+		EQEmuLogSys::Get()->LoadLogSettingsDefaults("loginserver");
 	}
 
 	/**
 	 * Command handler
 	 */
 	if (argc > 1) {
-		LogSys.SilenceConsoleLogging();
+		EQEmuLogSys::Get()->SilenceConsoleLogging();
 
 		LoadServerConfig();
 		LoadDatabaseConnection();
 
-		LogSys.LoadLogSettingsDefaults();
+		EQEmuLogSys::Get()->LoadLogSettingsDefaults("loginserver");
-		LogSys.log_settings[Logs::Debug].log_to_console      = static_cast<uint8>(Logs::General);
+		EQEmuLogSys::Get()->log_settings[Logs::Debug].log_to_console      = static_cast<uint8>(Logs::General);
-		LogSys.log_settings[Logs::Debug].is_category_enabled = 1;
+		EQEmuLogSys::Get()->log_settings[Logs::Debug].is_category_enabled = 1;
 
 		LoginserverCommandHandler::CommandHandler(argc, argv);
 	}
@@ -165,8 +162,8 @@ int main(int argc, char **argv)
 	LoadDatabaseConnection();
 
 	if (argc == 1) {
-		server.db->LoadLogSettings(LogSys.log_settings);
+		server.db->LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-		LogSys.StartFileLogs();
+		EQEmuLogSys::Get()->StartFileLogs();
 	}
 
 	/**
@@ -214,7 +211,7 @@ int main(int argc, char **argv)
 #endif
 
 	LogInfo("Server Started");
-	if (LogSys.log_settings[Logs::Loginserver].log_to_console == 1) {
+	if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].log_to_console == 1) {
 		LogInfo("Loginserver logging set to level [1] for more debugging, enable detail [3]");
 	}
 

queryserv/database.cpp

@@ -495,7 +495,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;

queryserv/queryserv.cpp

@@ -22,7 +22,6 @@
 #include "../common/opcodemgr.h"
 #include "../common/rulesys.h"
 #include "../common/servertalk.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/event/event_loop.h"
 #include "../common/timer.h"
@@ -40,15 +39,13 @@ LFGuildManager lfguildmanager;
 std::string WorldShortName;
 const queryservconfig *Config;
 WorldServer *worldserver = 0;
-EQEmuLogSys LogSys;
 
 void CatchSignal(int sig_num) { 
 	RunLoops = false; 
 }
 
 int main() {
-	RegisterExecutablePlatform(ExePlatformQueryServ);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("queryserv");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler(); 
 	Timer LFGuildExpireTimer(60000);  
 
@@ -75,8 +72,8 @@ int main() {
 	}
 
 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	if (signal(SIGINT, CatchSignal) == SIG_ERR)	{
 		LogInfo("Could not set signal handler");
@@ -102,7 +99,7 @@ int main() {
 		EQ::EventLoop::Get().Process();
 		Sleep(5);
 	}
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 }
 
 void UpdateWindowTitle(char* iNewTitle) {

shared_memory/main.cpp

@@ -22,7 +22,6 @@
 #include "../common/global_define.h"
 #include "../common/shareddb.h"
 #include "../common/eqemu_config.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/rulesys.h"
 #include "../common/eqemu_exception.h"
@@ -34,8 +33,6 @@
 #include "spells.h"
 #include "base_data.h"
 
-EQEmuLogSys LogSys;
-
 #ifdef _WINDOWS
 #include <direct.h>
 #else
@@ -70,8 +67,7 @@ inline bool MakeDirectory(const std::string &directory_name)
 }
 
 int main(int argc, char **argv) {
-	RegisterExecutablePlatform(ExePlatformSharedMemory);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("shared_memory");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	LogInfo("Shared Memory Loader Program");
@@ -91,8 +87,8 @@ int main(int argc, char **argv) {
 	}
 
 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	std::string shared_mem_directory = Config->SharedMemDir;
 	if (MakeDirectory(shared_mem_directory)) {
@@ -239,6 +235,6 @@ int main(int argc, char **argv) {
 		}
 	}
 	
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 	return 0;
 }

ucs/database.cpp

@@ -720,7 +720,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;

ucs/ucs.cpp

@@ -23,7 +23,6 @@
 #include "../common/opcodemgr.h"
 #include "../common/rulesys.h"
 #include "../common/servertalk.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/event/event_loop.h"
 #include "database.h"
@@ -38,7 +37,6 @@
 
 ChatChannelList *ChannelList;
 Clientlist *g_Clientlist;
-EQEmuLogSys LogSys;
 Database database;
 WorldServer *worldserver = nullptr;
 
@@ -63,8 +61,7 @@ std::string GetMailPrefix() {
 }
 
 int main() {
-	RegisterExecutablePlatform(ExePlatformUCS);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("ucs");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	// Check every minute for unused channels we can delete
@@ -97,8 +94,8 @@ int main() {
 	}
 
 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	char tmp[64];
 
@@ -162,7 +159,7 @@ int main() {
 
 	g_Clientlist->CloseAllConnections();
 
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 
 }
 

utils/sql/character_table_list.txt

@@ -1,15 +1,9 @@
-account
-account_ip
-account_flags
-account_rewards
-adventure_details
 adventure_stats
-buyer
 char_recipe_list
+character_auras
 character_activities
 character_alt_currency
 character_alternate_abilities
-character_auras
 character_bandolier
 character_bind
 character_buffs
@@ -26,22 +20,15 @@ character_leadership_abilities
 character_material
 character_memmed_spells
 character_pet_buffs
-character_pet_info
 character_pet_inventory
 character_potionbelt
 character_skills
 character_spells
-character_tasks
 character_tribute
 completed_tasks
-data_buckets
 faction_values
 friends
-guild_bank
 guild_members
-guild_ranks
-guild_relations
-guilds
 instance_list_player
 inventory
 inventory_snapshots
@@ -49,9 +36,6 @@ keyring
 mail
 player_titlesets
 quest_globals
-sharedbank
 timers
 titles
-trader
+zone_flags
-trader_audit
-zone_flags"

utils/sql/db_update_manifest.txt

@@ -399,7 +399,6 @@
 9143|2019_09_16_account_table_changes.sql|SHOW COLUMNS FROM `account` LIKE 'ls_id'|empty|
 9144|2019_11_09_logsys_description_update.sql|SELECT * FROM db_version WHERE version >= 9143|empty|
 9145|2019_12_24_banned_ips_update.sql|SHOW TABLES LIKE 'Banned_IPs'|not_empty|
-9146|2020_01_10_character_soft_deletes.sql|SHOW COLUMNS FROM `character_data` LIKE 'deleted_at'|empty|
 
 # Upgrade conditions:
 # 	This won't be needed after this system is implemented, but it is used database that are not

utils/sql/git/required/2020_01_10_character_soft_deletes.sql

@@ -1 +0,0 @@
-ALTER TABLE `character_data` ADD COLUMN `deleted_at` datetime NULL DEFAULT NULL;

world/main.cpp

@@ -40,7 +40,6 @@
 #include "../common/guilds.h"
 #include "../common/eq_stream_ident.h"
 #include "../common/rulesys.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "client.h"
 #include "worlddb.h"
@@ -105,7 +104,6 @@ uint32 numclients = 0;
 uint32 numzones = 0;
 bool holdzones = false;
 const WorldConfig *Config;
-EQEmuLogSys LogSys;
 WebInterfaceList web_interface;
 
 void CatchSignal(int sig_num);
@@ -206,8 +204,7 @@ void RegisterLoginservers()
  * @return
  */
 int main(int argc, char** argv) {
-	RegisterExecutablePlatform(ExePlatformWorld);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("world");
-	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
 	/**
@@ -226,7 +223,7 @@ int main(int argc, char** argv) {
 	 * Command handler
 	 */
 	if (argc > 1) {
-		LogSys.SilenceConsoleLogging();
+		EQEmuLogSys::Get()->SilenceConsoleLogging();
 
 		/**
 		 * Get Config
@@ -239,7 +236,7 @@ int main(int argc, char** argv) {
 		 */
 		LoadDatabaseConnections();
 
-		LogSys.EnableConsoleLogging();
+		EQEmuLogSys::Get()->EnableConsoleLogging();
 
 		WorldserverCommandHandler::CommandHandler(argc, argv);
 	}
@@ -276,8 +273,8 @@ int main(int argc, char** argv) {
 	/**
 	 * Logging
 	 */
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	/**
 	 * Parse simple CLI passes
@@ -601,7 +598,7 @@ int main(int argc, char** argv) {
 	zoneserver_list.KillAll();
 	LogInfo("Zone (TCP) listener stopped");
 	LogInfo("Signaling HTTP service to stop");
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 
 	return 0;
 }

world/world_server_command_handler.cpp

@@ -52,7 +52,7 @@ namespace WorldserverCommandHandler {
 		function_map["database:set-account-status"] = &WorldserverCommandHandler::DatabaseSetAccountStatus;
 		function_map["database:schema"]             = &WorldserverCommandHandler::DatabaseGetSchema;
 
-		EQEmuCommand::HandleMenu(function_map, cmd, argc, argv);
+		EQEmuCommand::HandleMenu(function_map, cmd, "world", argc, argv);
 	}
 
 	/**

world/worlddb.cpp

@@ -31,27 +31,23 @@ extern std::vector<RaceClassAllocation> character_create_allocations;
 extern std::vector<RaceClassCombos> character_create_race_class_combos;
 
 
-/**
+// the current stuff is at the bottom of this function
- * @param account_id
+void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **outApp, uint32 clientVersionBit)
- * @param out_app
- * @param client_version_bit
- */
-void WorldDatabase::GetCharSelectInfo(uint32 account_id, EQApplicationPacket **out_app, uint32 client_version_bit)
 {
-	EQEmu::versions::ClientVersion
+	/* Set Character Creation Limit */
-		   client_version  = EQEmu::versions::ConvertClientVersionBitToClientVersion(client_version_bit);
+	EQEmu::versions::ClientVersion client_version = EQEmu::versions::ConvertClientVersionBitToClientVersion(clientVersionBit);
 	size_t character_limit = EQEmu::constants::StaticLookup(client_version)->CharacterCreationLimit;
 	
-	if (character_limit > EQEmu::constants::CHARACTER_CREATION_LIMIT) {
+	// Validate against absolute server max
+	if (character_limit > EQEmu::constants::CHARACTER_CREATION_LIMIT)
 		character_limit = EQEmu::constants::CHARACTER_CREATION_LIMIT;
-	}
 
 	// Force Titanium clients to use '8'
-	if (client_version == EQEmu::versions::ClientVersion::Titanium) {
+	if (client_version == EQEmu::versions::ClientVersion::Titanium)
 		character_limit = 8;
-	}
 	
-	std::string character_list_query = StringFormat(
+	/* Get Character Info */
+	std::string cquery = StringFormat(
 		"SELECT                     "
 		"`id`,                      "  // 0
 		"name,                      "  // 1
@@ -75,182 +71,150 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, EQApplicationPacket **o
 		"zone_id		            "  // 19
 		"FROM                       "
 		"character_data             "
-		"WHERE `account_id` = %i AND deleted_at IS NULL ORDER BY `name` LIMIT %u",
+		"WHERE `account_id` = %i ORDER BY `name` LIMIT %u", accountID, character_limit);
-		account_id,
+	auto results = database.QueryDatabase(cquery);
-		character_limit
-	);
-
-	auto results = database.QueryDatabase(character_list_query);
 
 	size_t character_count = results.RowCount();
 	if (character_count == 0) {
-		*out_app                   = new EQApplicationPacket(OP_SendCharInfo, sizeof(CharacterSelect_Struct));
+		*outApp = new EQApplicationPacket(OP_SendCharInfo, sizeof(CharacterSelect_Struct));
-		CharacterSelect_Struct *cs = (CharacterSelect_Struct *) (*out_app)->pBuffer;
+		CharacterSelect_Struct *cs = (CharacterSelect_Struct *)(*outApp)->pBuffer;
 		cs->CharCount = 0;
 		cs->TotalChars = character_limit;
 		return;
 	}
 
 	size_t packet_size = sizeof(CharacterSelect_Struct) + (sizeof(CharacterSelectEntry_Struct) * character_count);
-	*out_app = new EQApplicationPacket(OP_SendCharInfo, packet_size);
+	*outApp = new EQApplicationPacket(OP_SendCharInfo, packet_size);
 
-	unsigned char          *buff_ptr = (*out_app)->pBuffer;
+	unsigned char *buff_ptr = (*outApp)->pBuffer;
-	CharacterSelect_Struct *cs       = (CharacterSelect_Struct *) buff_ptr;
+	CharacterSelect_Struct *cs = (CharacterSelect_Struct *)buff_ptr;
 
 	cs->CharCount = character_count;
 	cs->TotalChars = character_limit;
 
 	buff_ptr += sizeof(CharacterSelect_Struct);
 	for (auto row = results.begin(); row != results.end(); ++row) {
-		CharacterSelectEntry_Struct *p_character_select_entry_struct = (CharacterSelectEntry_Struct *) buff_ptr;
+		CharacterSelectEntry_Struct *cse = (CharacterSelectEntry_Struct *)buff_ptr;
-		PlayerProfile_Struct        player_profile_struct;
+		PlayerProfile_Struct pp;
-		EQEmu::InventoryProfile     inventory_profile;
+		EQEmu::InventoryProfile inv;
 
-		player_profile_struct.SetPlayerProfileVersion(EQEmu::versions::ConvertClientVersionToMobVersion(client_version));
+		pp.SetPlayerProfileVersion(EQEmu::versions::ConvertClientVersionToMobVersion(client_version));
-		inventory_profile.SetInventoryVersion(client_version);
+		inv.SetInventoryVersion(client_version);
-		inventory_profile.SetGMInventory(true); // charsel can not interact with items..but, no harm in setting to full expansion support
+		inv.SetGMInventory(true); // charsel can not interact with items..but, no harm in setting to full expansion support
 
-		uint32 character_id = (uint32) atoi(row[0]);
+		uint32 character_id = (uint32)atoi(row[0]);
 		uint8 has_home = 0;
 		uint8 has_bind = 0;
 
-		memset(&player_profile_struct, 0, sizeof(PlayerProfile_Struct));
+		memset(&pp, 0, sizeof(PlayerProfile_Struct));
 		
-		memset(p_character_select_entry_struct->Name, 0, sizeof(p_character_select_entry_struct->Name));
+		/* Fill CharacterSelectEntry_Struct */
-		strcpy(p_character_select_entry_struct->Name, row[1]);
+		memset(cse->Name, 0, sizeof(cse->Name));
-		p_character_select_entry_struct->Class       = (uint8) atoi(row[4]);
+		strcpy(cse->Name, row[1]);
-		p_character_select_entry_struct->Race        = (uint32) atoi(row[3]);
+		cse->Class = (uint8)atoi(row[4]);
-		p_character_select_entry_struct->Level       = (uint8) atoi(row[5]);
+		cse->Race = (uint32)atoi(row[3]);
-		p_character_select_entry_struct->ShroudClass = p_character_select_entry_struct->Class;
+		cse->Level = (uint8)atoi(row[5]);
-		p_character_select_entry_struct->ShroudRace  = p_character_select_entry_struct->Race;
+		cse->ShroudClass = cse->Class;
-		p_character_select_entry_struct->Zone        = (uint16) atoi(row[19]);
+		cse->ShroudRace = cse->Race;
-		p_character_select_entry_struct->Instance    = 0;
+		cse->Zone = (uint16)atoi(row[19]);
-		p_character_select_entry_struct->Gender      = (uint8) atoi(row[2]);
+		cse->Instance = 0;
-		p_character_select_entry_struct->Face        = (uint8) atoi(row[15]);
+		cse->Gender = (uint8)atoi(row[2]);
+		cse->Face = (uint8)atoi(row[15]);
 
-		for (uint32 material_slot = 0; material_slot < EQEmu::textures::materialCount; material_slot++) {
+		for (uint32 matslot = 0; matslot < EQEmu::textures::materialCount; matslot++) {	// Processed below
-			p_character_select_entry_struct->Equip[material_slot].Material        = 0;
+			cse->Equip[matslot].Material = 0;
-			p_character_select_entry_struct->Equip[material_slot].Unknown1        = 0;
+			cse->Equip[matslot].Unknown1 = 0;
-			p_character_select_entry_struct->Equip[material_slot].EliteModel      = 0;
+			cse->Equip[matslot].EliteModel = 0;
-			p_character_select_entry_struct->Equip[material_slot].HerosForgeModel = 0;
+			cse->Equip[matslot].HerosForgeModel = 0;
-			p_character_select_entry_struct->Equip[material_slot].Unknown2        = 0;
+			cse->Equip[matslot].Unknown2 = 0;
-			p_character_select_entry_struct->Equip[material_slot].Color           = 0;
+			cse->Equip[matslot].Color = 0;
 		}						
 
-		p_character_select_entry_struct->Unknown15       = 0xFF;
+		cse->Unknown15 = 0xFF;
-		p_character_select_entry_struct->Unknown19       = 0xFF;
+		cse->Unknown19 = 0xFF;
-		p_character_select_entry_struct->DrakkinTattoo   = (uint32) atoi(row[17]);
+		cse->DrakkinTattoo = (uint32)atoi(row[17]);
-		p_character_select_entry_struct->DrakkinDetails  = (uint32) atoi(row[18]);
+		cse->DrakkinDetails = (uint32)atoi(row[18]);
-		p_character_select_entry_struct->Deity           = (uint32) atoi(row[6]);
+		cse->Deity = (uint32)atoi(row[6]);
-		p_character_select_entry_struct->PrimaryIDFile   = 0;                            // Processed Below
+		cse->PrimaryIDFile = 0;							// Processed Below
-		p_character_select_entry_struct->SecondaryIDFile = 0;                        // Processed Below
+		cse->SecondaryIDFile = 0;						// Processed Below
-		p_character_select_entry_struct->HairColor       = (uint8) atoi(row[9]);
+		cse->HairColor = (uint8)atoi(row[9]);
-		p_character_select_entry_struct->BeardColor      = (uint8) atoi(row[10]);
+		cse->BeardColor = (uint8)atoi(row[10]);
-		p_character_select_entry_struct->EyeColor1       = (uint8) atoi(row[11]);
+		cse->EyeColor1 = (uint8)atoi(row[11]);
-		p_character_select_entry_struct->EyeColor2       = (uint8) atoi(row[12]);
+		cse->EyeColor2 = (uint8)atoi(row[12]);
-		p_character_select_entry_struct->HairStyle       = (uint8) atoi(row[13]);
+		cse->HairStyle = (uint8)atoi(row[13]);
-		p_character_select_entry_struct->Beard           = (uint8) atoi(row[14]);
+		cse->Beard = (uint8)atoi(row[14]);
-		p_character_select_entry_struct->GoHome          = 0;                                // Processed Below
+		cse->GoHome = 0;								// Processed Below
-		p_character_select_entry_struct->Tutorial        = 0;                                // Processed Below
+		cse->Tutorial = 0;								// Processed Below
-		p_character_select_entry_struct->DrakkinHeritage = (uint32) atoi(row[16]);
+		cse->DrakkinHeritage = (uint32)atoi(row[16]);
-		p_character_select_entry_struct->Unknown1        = 0;
+		cse->Unknown1 = 0;
-		p_character_select_entry_struct->Enabled         = 1;
+		cse->Enabled = 1;
-		p_character_select_entry_struct->LastLogin       = (uint32) atoi(row[7]);            // RoF2 value: 1212696584
+		cse->LastLogin = (uint32)atoi(row[7]);			// RoF2 value: 1212696584
-		p_character_select_entry_struct->Unknown2        = 0;
+		cse->Unknown2 = 0;
+		/* Fill End */
 
 		if (RuleB(World, EnableReturnHomeButton)) {
 			int now = time(nullptr);
-			if ((now - atoi(row[7])) >= RuleI(World, MinOfflineTimeToReturnHome)) {
+			if ((now - atoi(row[7])) >= RuleI(World, MinOfflineTimeToReturnHome))
-				p_character_select_entry_struct->GoHome = 1;
+				cse->GoHome = 1;
-			}
 		}
 
-		if (RuleB(World, EnableTutorialButton) && (p_character_select_entry_struct->Level <= RuleI(World, MaxLevelForTutorial))) {
+		if (RuleB(World, EnableTutorialButton) && (cse->Level <= RuleI(World, MaxLevelForTutorial))) {
-			p_character_select_entry_struct->Tutorial = 1;
+			cse->Tutorial = 1;
 		}
 
-		/**
+		/* Set Bind Point Data for any character that may possibly be missing it for any reason */
-		 * Bind
+		cquery = StringFormat("SELECT `zone_id`, `instance_id`, `x`, `y`, `z`, `heading`, `slot` FROM `character_bind`  WHERE `id` = %i LIMIT 5", character_id);
-		 */
+		auto results_bind = database.QueryDatabase(cquery);
-		character_list_query = StringFormat(
-			"SELECT `zone_id`, `instance_id`, `x`, `y`, `z`, `heading`, `slot` FROM `character_bind`  WHERE `id` = %i LIMIT 5",
-			character_id
-		);
-		auto      results_bind = database.QueryDatabase(character_list_query);
 		auto bind_count = results_bind.RowCount();
 		for (auto row_b = results_bind.begin(); row_b != results_bind.end(); ++row_b) {
 			if (row_b[6] && atoi(row_b[6]) == 4) {
 				has_home = 1;
 				// If our bind count is less than 5, we need to actually make use of this data so lets parse it
 				if (bind_count < 5) {
-					player_profile_struct.binds[4].zoneId      = atoi(row_b[0]);
+					pp.binds[4].zoneId = atoi(row_b[0]);
-					player_profile_struct.binds[4].instance_id = atoi(row_b[1]);
+					pp.binds[4].instance_id = atoi(row_b[1]);
-					player_profile_struct.binds[4].x           = atof(row_b[2]);
+					pp.binds[4].x = atof(row_b[2]);
-					player_profile_struct.binds[4].y           = atof(row_b[3]);
+					pp.binds[4].y = atof(row_b[3]);
-					player_profile_struct.binds[4].z           = atof(row_b[4]);
+					pp.binds[4].z = atof(row_b[4]);
-					player_profile_struct.binds[4].heading     = atof(row_b[5]);
+					pp.binds[4].heading = atof(row_b[5]);
 				}
 			}
-			if (row_b[6] && atoi(row_b[6]) == 0) { has_bind = 1; }
+			if (row_b[6] && atoi(row_b[6]) == 0){ has_bind = 1; }
 		}
 
 		if (has_home == 0 || has_bind == 0) {
-			character_list_query = StringFormat(
+			cquery = StringFormat("SELECT `zone_id`, `bind_id`, `x`, `y`, `z` FROM `start_zones` WHERE `player_class` = %i AND `player_deity` = %i AND `player_race` = %i",
-				"SELECT `zone_id`, `bind_id`, `x`, `y`, `z` FROM `start_zones` WHERE `player_class` = %i AND `player_deity` = %i AND `player_race` = %i",
+				cse->Class, cse->Deity, cse->Race);
-				p_character_select_entry_struct->Class,
+			auto results_bind = database.QueryDatabase(cquery);
-				p_character_select_entry_struct->Deity,
-				p_character_select_entry_struct->Race
-			);
-			auto      results_bind = database.QueryDatabase(character_list_query);
 			for (auto row_d = results_bind.begin(); row_d != results_bind.end(); ++row_d) {
 				/* If a bind_id is specified, make them start there */
 				if (atoi(row_d[1]) != 0) {
-					player_profile_struct.binds[4].zoneId = (uint32) atoi(row_d[1]);
+					pp.binds[4].zoneId = (uint32)atoi(row_d[1]);
-					GetSafePoints(player_profile_struct.binds[4].zoneId, 0, &player_profile_struct.binds[4].x, &player_profile_struct.binds[4].y, &player_profile_struct.binds[4].z);
+					GetSafePoints(pp.binds[4].zoneId, 0, &pp.binds[4].x, &pp.binds[4].y, &pp.binds[4].z);
 				}
 				/* Otherwise, use the zone and coordinates given */
 				else {
-					player_profile_struct.binds[4].zoneId = (uint32) atoi(row_d[0]);
+					pp.binds[4].zoneId = (uint32)atoi(row_d[0]);
 					float x = atof(row_d[2]);
 					float y = atof(row_d[3]);
 					float z = atof(row_d[4]);
-					if (x == 0 && y == 0 && z == 0) { GetSafePoints(player_profile_struct.binds[4].zoneId, 0, &x, &y, &z); }
+					if (x == 0 && y == 0 && z == 0){ GetSafePoints(pp.binds[4].zoneId, 0, &x, &y, &z); }
-					player_profile_struct.binds[4].x = x;
+					pp.binds[4].x = x; pp.binds[4].y = y; pp.binds[4].z = z;
-					player_profile_struct.binds[4].y = y;
-					player_profile_struct.binds[4].z = z;
 				}
 			}
-			player_profile_struct.binds[0] = player_profile_struct.binds[4];
+			pp.binds[0] = pp.binds[4];
 			/* If no home bind set, set it */
 			if (has_home == 0) {
-				std::string query        = StringFormat(
+				std::string query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
-					"REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 					" VALUES (%u, %u, %u, %f, %f, %f, %f, %i)",
-					character_id,
+					character_id, pp.binds[4].zoneId, 0, pp.binds[4].x, pp.binds[4].y, pp.binds[4].z, pp.binds[4].heading, 4);
-					player_profile_struct.binds[4].zoneId,
-					0,
-					player_profile_struct.binds[4].x,
-					player_profile_struct.binds[4].y,
-					player_profile_struct.binds[4].z,
-					player_profile_struct.binds[4].heading,
-					4
-				);
 				auto results_bset = QueryDatabase(query);
 			}
 			/* If no regular bind set, set it */
 			if (has_bind == 0) {
-				std::string query        = StringFormat(
+				std::string query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
-					"REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 					" VALUES (%u, %u, %u, %f, %f, %f, %f, %i)",
-					character_id,
+					character_id, pp.binds[0].zoneId, 0, pp.binds[0].x, pp.binds[0].y, pp.binds[0].z, pp.binds[0].heading, 0);
-					player_profile_struct.binds[0].zoneId,
-					0,
-					player_profile_struct.binds[0].x,
-					player_profile_struct.binds[0].y,
-					player_profile_struct.binds[0].z,
-					player_profile_struct.binds[0].heading,
-					0
-				);
 				auto results_bset = QueryDatabase(query);
 			}
 		}
@@ -259,97 +223,85 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, EQApplicationPacket **o
 			// we know that home and main bind must be valid here, so we don't check those
 			// we also use home to fill in the null data like live does.
 			for (int i = 1; i < 4;  i++) {
-				if (player_profile_struct.binds[i].zoneId != 0) { // we assume 0 is the only invalid one ...
+				if (pp.binds[i].zoneId != 0) // we assume 0 is the only invalid one ...
 					continue;
-				}
 
-				std::string query        = StringFormat(
+				std::string query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
-					"REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 					" VALUES (%u, %u, %u, %f, %f, %f, %f, %i)",
-					character_id,
+					character_id, pp.binds[4].zoneId, 0, pp.binds[4].x, pp.binds[4].y, pp.binds[4].z, pp.binds[4].heading, i);
-					player_profile_struct.binds[4].zoneId,
-					0,
-					player_profile_struct.binds[4].x,
-					player_profile_struct.binds[4].y,
-					player_profile_struct.binds[4].z,
-					player_profile_struct.binds[4].heading,
-					i
-				);
 				auto results_bset = QueryDatabase(query);
 			}
 		}
+		/* Bind End */
 
-		character_list_query = StringFormat(
+		/* Load Character Material Data for Char Select */
-			"SELECT slot, red, green, blue, use_tint, color FROM `character_material` WHERE `id` = %u",
+		cquery = StringFormat("SELECT slot, red, green, blue, use_tint, color FROM `character_material` WHERE `id` = %u", character_id);
-			character_id
+		auto results_b = database.QueryDatabase(cquery); uint8 slot = 0;
-		);
-		auto      results_b = database.QueryDatabase(character_list_query);
-		uint8     slot      = 0;
 		for (auto row_b = results_b.begin(); row_b != results_b.end(); ++row_b) {
 			slot = atoi(row_b[0]);
-			player_profile_struct.item_tint.Slot[slot].Red     = atoi(row_b[1]);
+			pp.item_tint.Slot[slot].Red = atoi(row_b[1]);
-			player_profile_struct.item_tint.Slot[slot].Green   = atoi(row_b[2]);
+			pp.item_tint.Slot[slot].Green = atoi(row_b[2]);
-			player_profile_struct.item_tint.Slot[slot].Blue    = atoi(row_b[3]);
+			pp.item_tint.Slot[slot].Blue = atoi(row_b[3]);
-			player_profile_struct.item_tint.Slot[slot].UseTint = atoi(row_b[4]);
+			pp.item_tint.Slot[slot].UseTint = atoi(row_b[4]);
 		}
+		/* Character Material Data End */
 
-		if (GetCharSelInventory(account_id, p_character_select_entry_struct->Name, &inventory_profile)) {
+		/* Load Inventory */
-			const EQEmu::ItemData     *item          = nullptr;
+		// If we ensure that the material data is updated appropriately, we can do away with inventory loads
-			const EQEmu::ItemInstance *inst          = nullptr;
+		if (GetCharSelInventory(accountID, cse->Name, &inv)) {
-			int16 inventory_slot = 0;
+			const EQEmu::ItemData* item = nullptr;
+			const EQEmu::ItemInstance* inst = nullptr;
+			int16 invslot = 0;
 
 			for (uint32 matslot = EQEmu::textures::textureBegin; matslot < EQEmu::textures::materialCount; matslot++) {
-				inventory_slot = EQEmu::InventoryProfile::CalcSlotFromMaterial(matslot);
+				invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(matslot);
-				if (inventory_slot == INVALID_INDEX) { continue; }
+				if (invslot == INVALID_INDEX) { continue; }
-				inst = inventory_profile.GetItem(inventory_slot);
+				inst = inv.GetItem(invslot);
-				if (inst == nullptr) {
+				if (inst == nullptr) { continue; }
-					continue;
-				}
 				item = inst->GetItem();
-				if (item == nullptr) {
+				if (item == nullptr) { continue; }
-					continue;
-				}
 
 				if (matslot > 6) {
-					uint32 item_id_file = 0;
+					uint32 idfile = 0;
 					// Weapon Models 
 					if (inst->GetOrnamentationIDFile() != 0) {
-						item_id_file = inst->GetOrnamentationIDFile();
+						idfile = inst->GetOrnamentationIDFile();
-						p_character_select_entry_struct->Equip[matslot].Material = item_id_file;
+						cse->Equip[matslot].Material = idfile;
 					}
 					else {
 						if (strlen(item->IDFile) > 2) {
-							item_id_file = atoi(&item->IDFile[2]);
+							idfile = atoi(&item->IDFile[2]);
-							p_character_select_entry_struct->Equip[matslot].Material = item_id_file;
+							cse->Equip[matslot].Material = idfile;
 						}
 					}
 					if (matslot == EQEmu::textures::weaponPrimary) {
-						p_character_select_entry_struct->PrimaryIDFile = item_id_file;
+						cse->PrimaryIDFile = idfile;
 					}
 					else {
-						p_character_select_entry_struct->SecondaryIDFile = item_id_file;
+						cse->SecondaryIDFile = idfile;
 					}
 				}
 				else {
 					uint32 color = 0;
-					if (player_profile_struct.item_tint.Slot[matslot].UseTint) {
+					if (pp.item_tint.Slot[matslot].UseTint) {
-						color = player_profile_struct.item_tint.Slot[matslot].Color;
+						color = pp.item_tint.Slot[matslot].Color;
 					}
 					else {
 						color = inst->GetColor();
 					}
 
 					// Armor Materials/Models
-					p_character_select_entry_struct->Equip[matslot].Material        = item->Material;
+					cse->Equip[matslot].Material = item->Material;
-					p_character_select_entry_struct->Equip[matslot].EliteModel      = item->EliteMaterial;
+					cse->Equip[matslot].EliteModel = item->EliteMaterial;
-					p_character_select_entry_struct->Equip[matslot].HerosForgeModel = inst->GetOrnamentHeroModel(matslot);
+					cse->Equip[matslot].HerosForgeModel = inst->GetOrnamentHeroModel(matslot);
-					p_character_select_entry_struct->Equip[matslot].Color           = color;
+					cse->Equip[matslot].Color = color;
 				}
 			}
 		}
 		else {
-			printf("Error loading inventory for %s\n", p_character_select_entry_struct->Name);
+			printf("Error loading inventory for %s\n", cse->Name);
 		}
+		/* Load Inventory End */
 
 		buff_ptr += sizeof(CharacterSelectEntry_Struct);
 	}

world/worlddb.h

@@ -30,7 +30,7 @@ struct CharacterSelect_Struct;
 class WorldDatabase : public SharedDatabase {
 public:
 	bool GetStartZone(PlayerProfile_Struct* in_pp, CharCreate_Struct* in_cc, bool isTitanium);
-	void GetCharSelectInfo(uint32 account_id, EQApplicationPacket **out_app, uint32 client_version_bit);
+	void GetCharSelectInfo(uint32 accountID, EQApplicationPacket **outApp, uint32 clientVersionBit);
 	int MoveCharacterToBind(int CharID, uint8 bindnum = 0);
 
 	void GetLauncherList(std::vector<std::string> &result);

world/zoneserver.cpp

@@ -809,7 +809,7 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 	}
 	case ServerOP_ReloadLogs: {
 		zoneserver_list.SendPacket(pack);
-		database.LoadLogSettings(LogSys.log_settings);
+		database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
 		break;
 	}
 	case ServerOP_ReloadRules: {

zone/api_service.cpp

@@ -841,9 +841,9 @@ Json::Value ApiGetLogsysCategories(EQ::Net::WebsocketServerConnection *connectio
 
 		row["log_category_id"]          = i;
 		row["log_category_description"] = Logs::LogCategoryName[i];
-		row["log_to_console"]           = LogSys.log_settings[i].log_to_console;
+		row["log_to_console"]           = EQEmuLogSys::Get()->log_settings[i].log_to_console;
-		row["log_to_file"]              = LogSys.log_settings[i].log_to_file;
+		row["log_to_file"]              = EQEmuLogSys::Get()->log_settings[i].log_to_file;
-		row["log_to_gmsay"]             = LogSys.log_settings[i].log_to_gmsay;
+		row["log_to_gmsay"]             = EQEmuLogSys::Get()->log_settings[i].log_to_gmsay;
 
 		response.append(row);
 	}
@@ -872,15 +872,15 @@ Json::Value ApiSetLoggingLevel(EQ::Net::WebsocketServerConnection *connection, J
 	if (logging_category < Logs::LogCategory::MaxCategoryID &&
 		logging_category > Logs::LogCategory::None
 		) {
-		LogSys.log_settings[logging_category].log_to_console = logging_level;
+		EQEmuLogSys::Get()->log_settings[logging_category].log_to_console = logging_level;
 		response["status"] = "Category log level updated";
 	}
 
 	if (logging_level > 0) {
-		LogSys.log_settings[logging_category].is_category_enabled = 1;
+		EQEmuLogSys::Get()->log_settings[logging_category].is_category_enabled = 1;
 	}
 	else {
-		LogSys.log_settings[logging_category].is_category_enabled = 0;
+		EQEmuLogSys::Get()->log_settings[logging_category].is_category_enabled = 0;
 	}
 
 	return response;
@@ -888,7 +888,7 @@ Json::Value ApiSetLoggingLevel(EQ::Net::WebsocketServerConnection *connection, J
 
 void RegisterApiLogEvent(std::unique_ptr<EQ::Net::WebsocketServer> &server)
 {
-	LogSys.SetConsoleHandler(
+	EQEmuLogSys::Get()->SetConsoleHandler(
 		[&](uint16 debug_level, uint16 log_category, const std::string &msg) {
 			Json::Value data;
 			data["debug_level"]  = debug_level;

zone/bot_command.cpp

@@ -3414,12 +3414,6 @@ void bot_command_help(Client *c, const Seperator *sep)
 		c->Message(m_usage, "%c%s - %s", BOT_COMMAND_CHAR, command_iter.first.c_str(), command_iter.second->desc == nullptr ? "[no description]" : command_iter.second->desc);
 		++bot_commands_shown;
 	}
-	if (parse->PlayerHasQuestSub(EVENT_BOT_COMMAND)) {
-		int i = parse->EventPlayer(EVENT_BOT_COMMAND, c, sep->msg, 0);
-		if (i >= 1) {
-			bot_commands_shown += i;
-		}
-	}
 	c->Message(m_message, "%d bot command%s listed.", bot_commands_shown, bot_commands_shown != 1 ? "s" : "");
 	c->Message(m_note, "type %ccommand [help | usage] for more information", BOT_COMMAND_CHAR);
 }

zone/client.cpp

@@ -1106,56 +1106,40 @@ void Client::ChannelMessageReceived(uint8 chan_num, uint8 language, uint8 lang_s
 	case ChatChannel_Say: { /* Say */
 		if(message[0] == COMMAND_CHAR) {
 			if(command_dispatch(this, message) == -2) {
-				if (parse->PlayerHasQuestSub(EVENT_COMMAND)) {
+				if(parse->PlayerHasQuestSub(EVENT_COMMAND)) {
 					int i = parse->EventPlayer(EVENT_COMMAND, this, message, 0);
-					if (i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
+					if(i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
 						Message(Chat::Red, "Command '%s' not recognized.", message);
 					}
-				}
+				} else {
-				else if (parse->PlayerHasQuestSub(EVENT_SAY)) {
+					if(!RuleB(Chat, SuppressCommandErrors))
-					int i = parse->EventPlayer(EVENT_SAY, this, message, 0);
-					if (i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
 						Message(Chat::Red, "Command '%s' not recognized.", message);
 				}
 			}
-				else {
-					if (!RuleB(Chat, SuppressCommandErrors)) {
-						Message(Chat::Red, "Command '%s' not recognized.", message);
-					}
-				}
-			}
 			break;
 		}
 
+		if (EQEmu::ProfanityManager::IsCensorshipActive())
+			EQEmu::ProfanityManager::RedactMessage(message);
+
 #ifdef BOTS
 		if (message[0] == BOT_COMMAND_CHAR) {
 			if (bot_command_dispatch(this, message) == -2) {
-				if (parse->PlayerHasQuestSub(EVENT_BOT_COMMAND)) {
+				if (parse->PlayerHasQuestSub(EVENT_COMMAND)) {
-					int i = parse->EventPlayer(EVENT_BOT_COMMAND, this, message, 0);
+					int i = parse->EventPlayer(EVENT_COMMAND, this, message, 0);
-					if (i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
-						Message(Chat::Red, "Bot command '%s' not recognized.", message);
-					}
-				}
-				else if (parse->PlayerHasQuestSub(EVENT_SAY)) {
-					int i = parse->EventPlayer(EVENT_SAY, this, message, 0);
 					if (i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
 						Message(Chat::Red, "Bot command '%s' not recognized.", message);
 					}
 				}
 				else {
-					if (!RuleB(Chat, SuppressCommandErrors)) {
+					if (!RuleB(Chat, SuppressCommandErrors))
 						Message(Chat::Red, "Bot command '%s' not recognized.", message);
 				}
 			}
-			}
 			break;
 		}
 #endif
 
-		if (EQEmu::ProfanityManager::IsCensorshipActive()) {
-			EQEmu::ProfanityManager::RedactMessage(message);
-		}
-
 		Mob* sender = this;
 		if (GetPet() && GetTarget() == GetPet() && GetPet()->FindType(SE_VoiceGraft))
 			sender = GetPet();

zone/client_packet.cpp

@@ -417,16 +417,16 @@ void ClearMappedOpcode(EmuOpcode op)
 // client methods
 int Client::HandlePacket(const EQApplicationPacket *app)
 {
-	if (LogSys.log_settings[Logs::LogCategory::Netcode].is_category_enabled == 1) {
+	if (EQEmuLogSys::Get()->log_settings[Logs::LogCategory::Netcode].is_category_enabled == 1) {
 		char buffer[64];
 		app->build_header_dump(buffer);
 		Log(Logs::Detail, Logs::PacketClientServer, "Dispatch opcode: %s", buffer);
 	}
 
-	if (LogSys.log_settings[Logs::PacketClientServer].is_category_enabled == 1)
+	if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)
 		Log(Logs::General, Logs::PacketClientServer, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(app->GetOpcode()), app->GetOpcode(), app->Size());
 
-	if (LogSys.log_settings[Logs::PacketClientServerWithDump].is_category_enabled == 1)
+	if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServerWithDump].is_category_enabled == 1)
 		Log(Logs::General, Logs::PacketClientServerWithDump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(app->GetOpcode()), app->GetOpcode(), app->Size(), DumpPacketToString(app).c_str());
 
 	EmuOpcode opcode = app->GetOpcode();
@@ -470,7 +470,7 @@ int Client::HandlePacket(const EQApplicationPacket *app)
 			args.push_back(const_cast<EQApplicationPacket*>(app));
 			parse->EventPlayer(EVENT_UNHANDLED_OPCODE, this, "", 0, &args);
 
-			if (LogSys.log_settings[Logs::PacketClientServerUnhandled].is_category_enabled == 1) {
+			if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServerUnhandled].is_category_enabled == 1) {
 				char buffer[64];
 				app->build_header_dump(buffer);
 				Log(Logs::General, Logs::PacketClientServerUnhandled, "%s %s", buffer, DumpPacketToString(app).c_str());
@@ -905,8 +905,6 @@ void Client::CompleteConnect()
 	entity_list.RefreshClientXTargets(this);
 
 	worldserver.RequestTellQueue(GetName());
-
-	entity_list.ScanCloseMobs(close_mobs, this);
 }
 
 // connecting opcode handlers
@@ -5050,7 +5048,7 @@ void Client::Handle_OP_CrashDump(const EQApplicationPacket *app)
 
 void Client::Handle_OP_CreateObject(const EQApplicationPacket *app)
 {
-	if (LogSys.log_settings[Logs::Inventory].is_category_enabled)
+	if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled)
 		LogInventory("Handle_OP_CreateObject() [psize: [{}]] [{}]", app->size, DumpPacketToString(app).c_str());
 
 	DropItem(EQEmu::invslot::slotCursor);
@@ -8288,19 +8286,8 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
 			if (GetTarget() && GetTarget()->IsNPC()) {
 				if (silentsaylink) {
 					parse->EventNPC(EVENT_SAY, GetTarget()->CastToNPC(), this, response.c_str(), 0);
-
-					if (response[0] == '#' && parse->PlayerHasQuestSub(EVENT_COMMAND)) {
-						parse->EventPlayer(EVENT_COMMAND, this, response.c_str(), 0);
-					}
-#ifdef BOTS
-					else if (response[0] == '^' && parse->PlayerHasQuestSub(EVENT_BOT_COMMAND)) {
-						parse->EventPlayer(EVENT_BOT_COMMAND, this, response.c_str(), 0);
-					}
-#endif
-					else {
 					parse->EventPlayer(EVENT_SAY, this, response.c_str(), 0);
 				}
-				}
 				else {
 					Message(Chat::LightGray, "You say, '%s'", response.c_str());
 					ChannelMessageReceived(8, 0, 100, response.c_str());
@@ -8309,18 +8296,8 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
 			}
 			else {
 				if (silentsaylink) {
-					if (response[0] == '#' && parse->PlayerHasQuestSub(EVENT_COMMAND)) {
-						parse->EventPlayer(EVENT_COMMAND, this, response.c_str(), 0);
-					}
-#ifdef BOTS
-					else if (response[0] == '^' && parse->PlayerHasQuestSub(EVENT_BOT_COMMAND)) {
-						parse->EventPlayer(EVENT_BOT_COMMAND, this, response.c_str(), 0);
-					}
-#endif
-					else {
 					parse->EventPlayer(EVENT_SAY, this, response.c_str(), 0);
 				}
-				}
 				else {
 					Message(Chat::LightGray, "You say, '%s'", response.c_str());
 					ChannelMessageReceived(8, 0, 100, response.c_str());

zone/client_process.cpp

@@ -256,7 +256,28 @@ bool Client::Process() {
 		 * Used in aggro checks
 		 */
 		if (mob_close_scan_timer.Check()) {
-			entity_list.ScanCloseMobs(close_mobs, this);
+			close_mobs.clear();
+
+			float scan_range = RuleI(Range, MobCloseScanDistance) * RuleI(Range, MobCloseScanDistance);
+			auto  &mob_list  = entity_list.GetMobList();
+
+			for (auto itr : mob_list) {
+				Mob   *mob     = itr.second;
+				float distance = DistanceSquared(m_Position, mob->GetPosition());
+
+				if (mob->GetID() <= 0) {
+					continue;
+				}
+
+				if (mob->IsNPC() || mob->IsClient()) {
+					if (distance <= scan_range) {
+						close_mobs.insert(std::pair<uint16, Mob *>(mob->GetID(), mob));
+					}
+					else if ((mob->GetAggroRange() * mob->GetAggroRange()) > scan_range) {
+						close_mobs.insert(std::pair<uint16, Mob *>(mob->GetID(), mob));
+					}
+				}
+			}
 		}
 		
 		bool may_use_attacks = false;

zone/command.cpp

@@ -783,12 +783,6 @@ void command_help(Client *c, const Seperator *sep)
 		commands_shown++;
 		c->Message(Chat::White, "	%c%s %s",  COMMAND_CHAR, cur->first.c_str(), cur->second->desc == nullptr?"":cur->second->desc);
 	}
-	if (parse->PlayerHasQuestSub(EVENT_COMMAND)) {
-		int i = parse->EventPlayer(EVENT_COMMAND, c, sep->msg, 0);
-		if (i >= 1) {
-			commands_shown += i;
-		}
-	}
 	c->Message(Chat::White, "%d command%s listed.",  commands_shown, commands_shown!=1?"s":"");
 
 }
@@ -12530,9 +12524,9 @@ void command_logs(Client *c, const Seperator *sep){
 					StringFormat(
 						"--- %i | %u | %u | %u | %s",
 						i,
-						LogSys.log_settings[i].log_to_console,
+						EQEmuLogSys::Get()->log_settings[i].log_to_console,
-						LogSys.log_settings[i].log_to_file,
+						EQEmuLogSys::Get()->log_settings[i].log_to_file,
-						LogSys.log_settings[i].log_to_gmsay,
+						EQEmuLogSys::Get()->log_settings[i].log_to_gmsay,
 						Logs::LogCategoryName[i]
 					).c_str());
 				redisplay_columns++;
@@ -12541,15 +12535,15 @@ void command_logs(Client *c, const Seperator *sep){
 		/* #logs set */
 		if (strcasecmp(sep->arg[1], "set") == 0){
 			if (strcasecmp(sep->arg[2], "console") == 0){
-				LogSys.log_settings[atoi(sep->arg[3])].log_to_console = atoi(sep->arg[4]);
+				EQEmuLogSys::Get()->log_settings[atoi(sep->arg[3])].log_to_console = atoi(sep->arg[4]);
 				logs_set = 1;
 			}
 			else if (strcasecmp(sep->arg[2], "file") == 0){
-				LogSys.log_settings[atoi(sep->arg[3])].log_to_file = atoi(sep->arg[4]);
+				EQEmuLogSys::Get()->log_settings[atoi(sep->arg[3])].log_to_file = atoi(sep->arg[4]);
 				logs_set = 1;
 			}
 			else if (strcasecmp(sep->arg[2], "gmsay") == 0){
-				LogSys.log_settings[atoi(sep->arg[3])].log_to_gmsay = atoi(sep->arg[4]);
+				EQEmuLogSys::Get()->log_settings[atoi(sep->arg[3])].log_to_gmsay = atoi(sep->arg[4]);
 				logs_set = 1;
 			}
 			else{
@@ -12564,10 +12558,10 @@ void command_logs(Client *c, const Seperator *sep){
 				This is used in hot places of code to check if its enabled in any way before triggering logs
 			*/
 			if (atoi(sep->arg[4]) > 0){
-				LogSys.log_settings[atoi(sep->arg[3])].is_category_enabled = 1;
+				EQEmuLogSys::Get()->log_settings[atoi(sep->arg[3])].is_category_enabled = 1;
 			}
 			else{
-				LogSys.log_settings[atoi(sep->arg[3])].is_category_enabled = 0;
+				EQEmuLogSys::Get()->log_settings[atoi(sep->arg[3])].is_category_enabled = 0;
 			}
 		}
 	}
@@ -13270,8 +13264,8 @@ void command_bot(Client *c, const Seperator *sep)
 	}
 	
 	if (bot_command_dispatch(c, bot_message.c_str()) == -2) {
-		if (parse->PlayerHasQuestSub(EVENT_BOT_COMMAND)) {
+		if (parse->PlayerHasQuestSub(EVENT_COMMAND)) {
-			int i = parse->EventPlayer(EVENT_BOT_COMMAND, c, bot_message, 0);
+			int i = parse->EventPlayer(EVENT_COMMAND, c, bot_message, 0);
 			if (i == 0 && !RuleB(Chat, SuppressCommandErrors)) {
 				c->Message(Chat::Red, "Bot command '%s' not recognized.", bot_message.c_str());
 			}

zone/doors.cpp

@@ -209,8 +209,6 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 	uint8  disable_add_to_key_ring = GetNoKeyring();
 	uint32 player_has_key          = 0;
 	uint32 player_key              = 0;
-	bool   gm_key                  = false;
-	bool   picklock_success        = false;
 
 	const EQEmu::ItemInstance *lock_pick_item = sender->GetInv().GetItem(EQEmu::invslot::slotCursor);
 	player_has_key = static_cast<uint32>(sender->GetInv().HasItem(required_key_item, 1));
@@ -219,8 +217,6 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 		player_key = required_key_item;
 	}
 
-	bool is_teleport_door = (strncmp(destination_zone_name, "NONE", strlen("NONE")) != 0);
-
 	/**
 	 * Object is not triggered
 	 */
@@ -230,7 +226,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 		 * Door is only triggered by an object
 		 */
 		if (trigger == 1) {
-			if ((!this->IsDoorOpen() || (open_type == 58)) && !is_teleport_door) {
+			if (!this->IsDoorOpen() || (open_type == 58)) {
 				move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 			} else {
 				move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
@@ -251,7 +247,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 	bool is_door_open_and_open_able = (this->IsDoorOpen() && (open_type == 58));
 
 	if (is_door_not_locked || is_door_open_and_open_able || is_guild_door) {
-		if ((!this->IsDoorOpen() || (this->GetOpenType() == 58)) && !is_teleport_door) {
+		if (!this->IsDoorOpen() || (this->GetOpenType() == 58)) {
 			move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 		} else {
 			move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
@@ -287,12 +283,12 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 		if (sender->GetGM()) {
 			sender->MessageString(Chat::LightBlue, DOORS_GM);
 
-			if ((!IsDoorOpen() || (open_type == 58)) && !is_teleport_door) {
+			if (!IsDoorOpen() || (open_type == 58)) {
 				move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 			} else {
 				move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
 			}
-			gm_key = true;
+
 		}
 
 		/**
@@ -312,7 +308,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 
 				sender->Message(Chat::LightBlue, "You got it open!");
 
-				if ((!IsDoorOpen() || (open_type == 58)) && !is_teleport_door) {
+				if (!IsDoorOpen() || (open_type == 58)) {
 					move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 				} else {
 					move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
@@ -332,13 +328,12 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 					LogSkills("Client has lockpicks: skill=[{}]", player_pick_lock_skill);
 
 					if (GetLockpick() <= player_pick_lock_skill) {
-						if (!IsDoorOpen() && !is_teleport_door) {
+						if (!IsDoorOpen()) {
 							move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 						} else {
 							move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
 						}
 						sender->MessageString(Chat::LightBlue, DOORS_SUCCESSFUL_PICK);
-						picklock_success = true;
 					} else {
 						sender->MessageString(Chat::LightBlue, DOORS_INSUFFICIENT_SKILL);
 						safe_delete(outapp);
@@ -367,7 +362,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 			if (sender->KeyRingCheck(required_key_item)) {
 				player_key = required_key_item;
 				sender->Message(Chat::LightBlue, "You got it open!"); // more debug spam
-				if ((!IsDoorOpen() || (open_type == 58)) && !is_teleport_door) {
+				if (!IsDoorOpen() || (open_type == 58)) {
 					move_door_packet->action = static_cast<uint8>(invert_state == 0 ? OPEN_DOOR : OPEN_INVDOOR);
 				} else {
 					move_door_packet->action = static_cast<uint8>(invert_state == 0 ? CLOSE_DOOR : CLOSE_INVDOOR);
@@ -381,7 +376,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 	}
 
 	entity_list.QueueClients(sender, outapp, false);
-	if ((!IsDoorOpen() || (open_type == 58)) && !is_teleport_door) {
+	if (!IsDoorOpen() || (open_type == 58)) {
 		if (!disable_timer)
 			close_timer.Start();
 		SetOpenState(true);
@@ -391,6 +386,18 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 			SetOpenState(false);
 	}
 
+	/*
+	 * Everything past this point assumes we opened the door
+	 *  and met all the requirements for opening
+	 *  everything to do with closed doors has already been taken care of
+	 *  we return because we don't want people using teleports on an unlocked door (exploit!)
+	 */
+
+	if ((move_door_packet->action == CLOSE_DOOR && invert_state == 0) || (move_door_packet->action == CLOSE_INVDOOR && invert_state == 1)) {
+		safe_delete(outapp);
+		return;
+	}
+
 	safe_delete(outapp);
 
 	if ((GetTriggerDoorID() != 0) && (GetTriggerType() == 1)) {
@@ -414,22 +421,8 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
 	/**
 	 * Teleport door
 	 */
-	if (((open_type == 57) || (open_type == 58)) && is_teleport_door) {
+	if (((open_type == 57) || (open_type == 58)) &&
-
+	    (strncmp(destination_zone_name, "NONE", strlen("NONE")) != 0)) {
-		if (required_key_item != 0 && player_key == 0 && gm_key != true && picklock_success != true) {
-			LogError(
-				"Teleport door [%s][dbid:%u][eqid:%u][dest:%s] used by [%s] in zone [%s] without proper key [id:%u]",
-				door_name,
-				database_id,
-				door_id,
-				destination_zone_name,
-				sender->GetName(),
-				zone->GetShortName(),
-				required_key_item
-			);
-			sender->Message(Chat::Red, "This door requires a key for teleportation that you do not possess!");
-			return;
-		}
 
 		/**
 		 * If click destination is same zone and doesn't require a key

zone/embparser.cpp

@@ -98,7 +98,7 @@ const char *QuestEventSubroutines[_LargestEventID] = {
 	"EVENT_DUEL_LOSE",
 	"EVENT_ENCOUNTER_LOAD",
 	"EVENT_ENCOUNTER_UNLOAD",
-	"EVENT_COMMAND",
+	"EVENT_SAY",
 	"EVENT_DROP_ITEM",
 	"EVENT_DESTROY_ITEM",
 	"EVENT_FEIGN_DEATH",
@@ -119,7 +119,6 @@ const char *QuestEventSubroutines[_LargestEventID] = {
 	"EVENT_DEATH_ZONE",
 	"EVENT_USE_SKILL",
 	"EVENT_COMBINE_VALIDATE",
-	"EVENT_BOT_COMMAND"
 };
 
 PerlembParser::PerlembParser() : perl(nullptr)
@@ -1543,12 +1542,9 @@ void PerlembParser::ExportEventVariables(
 		}
 
 		case EVENT_COMMAND: {
-			Seperator sep(data);
-			ExportVar(package_name.c_str(), "command", (sep.arg[0] + 1));
-			ExportVar(package_name.c_str(), "args", (sep.argnum >= 1 ? (&data[strlen(sep.arg[0]) + 1]) : "0"));
-			ExportVar(package_name.c_str(), "data", objid);
 			ExportVar(package_name.c_str(), "text", data);
-			ExportVar(package_name.c_str(), "langid", extradata);
+			ExportVar(package_name.c_str(), "data", "0");
+			ExportVar(package_name.c_str(), "langid", "0");
 			break;
 		}
 
@@ -1614,15 +1610,6 @@ void PerlembParser::ExportEventVariables(
 			ExportVar(package_name.c_str(), "tradeskill_id", tradeskill_id.c_str());
 			break;
 		}
-		case EVENT_BOT_COMMAND: {
-			Seperator sep(data);
-			ExportVar(package_name.c_str(), "bot_command", (sep.arg[0] + 1));
-			ExportVar(package_name.c_str(), "args", (sep.argnum >= 1 ? (&data[strlen(sep.arg[0]) + 1]) : "0"));
-			ExportVar(package_name.c_str(), "data", objid);
-			ExportVar(package_name.c_str(), "text", data);
-			ExportVar(package_name.c_str(), "langid", extradata);
-			break;
-		}
 
 		default: {
 			break;

zone/entity.cpp

@@ -2654,12 +2654,7 @@ void EntityList::ScanCloseMobs(std::unordered_map<uint16, Mob *> &close_mobs, Mo
 		}
 	}
 
-	LogAIScanClose(
+	LogAIScanClose("Close List Size [{}] for mob [{}]", close_mobs.size(), scanning_mob->GetCleanName());
-		"[{}] Scanning Close List | list_size [{}] moving [{}]",
-		scanning_mob->GetCleanName(),
-		close_mobs.size(),
-		scanning_mob->IsMoving() ? "true" : "false"
-	);
 }
 
 bool EntityList::RemoveMerc(uint16 delete_id)

zone/event_codes.h

@@ -87,7 +87,6 @@ typedef enum {
 	EVENT_DEATH_ZONE,
 	EVENT_USE_SKILL,
 	EVENT_COMBINE_VALIDATE,
-	EVENT_BOT_COMMAND,
 	_LargestEventID
 } QuestEventID;
 

zone/inventory.cpp

@@ -593,7 +593,7 @@ void Client::DropItem(int16 slot_id, bool recurse)
 			LogInventory("Error in InventoryProfile::CheckNoDrop() - returned 'true' for empty slot");
 		}
 		else {
-			if (LogSys.log_settings[Logs::Inventory].is_category_enabled) {
+			if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled) {
 				LogInventory("DropItem() Hack detected - full item parse:");
 				LogInventory("depth: 0, Item: [{}] (id: [{}]), IsDroppable: [{}]",
 					(invalid_drop->GetItem() ? invalid_drop->GetItem()->Name : "null data"), invalid_drop->GetID(), (invalid_drop->IsDroppable(false) ? "true" : "false"));
@@ -619,7 +619,7 @@ void Client::DropItem(int16 slot_id, bool recurse)
 	// Take control of item in client inventory
 	EQEmu::ItemInstance *inst = m_inv.PopItem(slot_id);
 	if(inst) {
-		if (LogSys.log_settings[Logs::Inventory].is_category_enabled) {
+		if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled) {
 			LogInventory("DropItem() Processing - full item parse:");
 			LogInventory("depth: 0, Item: [{}] (id: [{}]), IsDroppable: [{}]",
 				(inst->GetItem() ? inst->GetItem()->Name : "null data"), inst->GetID(), (inst->IsDroppable(false) ? "true" : "false"));

zone/lua_parser.cpp

@@ -124,8 +124,7 @@ const char *LuaEvents[_LargestEventID] = {
 	"event_spawn_zone",
 	"event_death_zone",
 	"event_use_skill",
-	"event_combine_validate",
+	"event_combine_validate"
-	"event_bot_command"
 };
 
 extern Zone *zone;
@@ -209,7 +208,6 @@ LuaParser::LuaParser() {
 	PlayerArgumentDispatch[EVENT_UNHANDLED_OPCODE] = handle_player_packet;
 	PlayerArgumentDispatch[EVENT_USE_SKILL] = handle_player_use_skill;
 	PlayerArgumentDispatch[EVENT_COMBINE_VALIDATE] = handle_player_combine_validate;
-	PlayerArgumentDispatch[EVENT_BOT_COMMAND] = handle_player_bot_command;
 
 	ItemArgumentDispatch[EVENT_ITEM_CLICK] = handle_item_click;
 	ItemArgumentDispatch[EVENT_ITEM_CLICK_CAST] = handle_item_click;

zone/lua_parser_events.cpp

@@ -539,25 +539,6 @@ void handle_player_combine_validate(QuestInterface* parse, lua_State* L, Client*
 	lua_setfield(L, -2, "tradeskill_id");
 }
 
-void handle_player_bot_command(QuestInterface* parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
-	std::vector<EQEmu::Any>* extra_pointers) {
-	Seperator sep(data.c_str(), ' ', 10, 100, true);
-	std::string bot_command(sep.arg[0] + 1);
-	lua_pushstring(L, bot_command.c_str());
-	lua_setfield(L, -2, "bot_command");
-
-	luabind::adl::object args = luabind::newtable(L);
-	int max_args = sep.GetMaxArgNum();
-	for (int i = 1; i < max_args; ++i) {
-		if (strlen(sep.arg[i]) > 0) {
-			args[i] = std::string(sep.arg[i]);
-		}
-	}
-
-	args.push(L);
-	lua_setfield(L, -2, "args");
-}
-
 //Item
 void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
 					   std::vector<EQEmu::Any> *extra_pointers) {

zone/lua_parser_events.h

@@ -99,8 +99,6 @@ void handle_player_use_skill(QuestInterface *parse, lua_State* L, Client* client
 		std::vector<EQEmu::Any> *extra_pointers);
 void handle_player_combine_validate(QuestInterface* parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
 		std::vector<EQEmu::Any>* extra_pointers);
-void handle_player_bot_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
-		std::vector<EQEmu::Any> *extra_pointers);
 
 //Item
 void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,

zone/main.cpp

@@ -35,7 +35,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "../common/profanity_manager.h"
 #include "../common/misc_functions.h"
 #include "../common/string_util.h"
-#include "../common/platform.h"
 #include "../common/crash.h"
 #include "../common/ipc_mutex.h"
 #include "../common/memory_mapped_file.h"
@@ -106,7 +105,6 @@ QueryServ *QServ = 0;
 TaskManager *taskmanager = 0;
 NpcScaleManager *npc_scale_manager;
 QuestParserCollection *parse = 0;
-EQEmuLogSys LogSys;
 const SPDat_Spell_Struct* spells;
 int32 SPDAT_RECORDS = -1;
 const ZoneConfig *Config;
@@ -119,8 +117,7 @@ void CatchSignal(int sig_num);
 extern void MapOpcodes();
 
 int main(int argc, char** argv) {
-	RegisterExecutablePlatform(ExePlatformZone);
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("zone");
-	LogSys.LoadLogSettingsDefaults();
 
 	set_exception_handler();
 
@@ -238,9 +235,9 @@ int main(int argc, char** argv) {
 	}
 
 	/* Register Log System and Settings */
-	LogSys.SetGMSayHandler(&Zone::GMSayHookCallBackProcess);
+	EQEmuLogSys::Get()->SetGMSayHandler(&Zone::GMSayHookCallBackProcess);
-	database.LoadLogSettings(LogSys.log_settings);
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
-	LogSys.StartFileLogs();
+	EQEmuLogSys::Get()->StartFileLogs();
 
 	/* Guilds */
 	guild_mgr.SetDatabase(&database);
@@ -573,7 +570,7 @@ int main(int argc, char** argv) {
 #endif
 	safe_delete(parse);
 	LogInfo("Proper zone shutdown complete.");
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 	return 0;
 }
 
@@ -589,7 +586,7 @@ void Shutdown()
 	Zone::Shutdown(true);
 	RunLoops = false;
 	LogInfo("Shutting down...");
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 }
 
 /* Update Window Title with relevant information */

zone/mob.cpp

@@ -459,8 +459,6 @@ Mob::Mob(
 #ifdef BOTS
 	m_manual_follow = false;
 #endif
-
-	mob_scan_close.Trigger();
 }
 
 Mob::~Mob()

zone/npc.cpp

@@ -705,6 +705,12 @@ bool NPC::Process()
 	SpellProcess();
 
 	if (mob_scan_close.Check()) {
+		LogAIScanClose(
+			"is_moving [{}] npc [{}] timer [{}]",
+			moving ? "true" : "false",
+			GetCleanName(),
+			mob_scan_close.GetDuration()
+		);
 
 		entity_list.ScanCloseMobs(close_mobs, this);
 

zone/npc_scale_manager.cpp

@@ -143,7 +143,7 @@ void NpcScaleManager::ScaleNPC(NPC *npc)
 		npc->ModifyNPCStat("special_abilities", scale_data.special_abilities.c_str());
 	}
 
-	if (LogSys.log_settings[Logs::NPCScaling].is_category_enabled == 1) {
+	if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1) {
 		std::string scale_log;
 
 		for (const auto &stat : scaling_stats) {

zone/worldserver.cpp

@@ -1813,7 +1813,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 		break;
 	}
 	case ServerOP_ReloadLogs: {
-		database.LoadLogSettings(LogSys.log_settings);
+		database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
 		break;
 	}
 	case ServerOP_ReloadPerlExportSettings: {

zone/zone.cpp

@@ -161,7 +161,7 @@ bool Zone::Bootup(uint32 iZoneID, uint32 iInstanceID, bool iStaticZone) {
 	/*
 	 * Set Logging
 	 */
-	LogSys.StartFileLogs(StringFormat("%s_version_%u_inst_id_%u_port_%u", zone->GetShortName(), zone->GetInstanceVersion(), zone->GetInstanceID(), ZoneConfig::get()->ZonePort));
+	EQEmuLogSys::Get()->StartFileLogs(StringFormat("%s_version_%u_inst_id_%u_port_%u", zone->GetShortName(), zone->GetInstanceVersion(), zone->GetInstanceID(), ZoneConfig::get()->ZonePort));
 
 	return true;
 }
@@ -729,7 +729,7 @@ void Zone::Shutdown(bool quiet)
 	parse->ReloadQuests(true);
 	UpdateWindowTitle(nullptr);
 
-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 
 	if (RuleB(Zone, KillProcessOnDynamicShutdown)) {
 		LogInfo("[KillProcessOnDynamicShutdown] Shutting down");

zone/zone.h

@@ -299,7 +299,7 @@ public:
 			entity_list.MessageStatus(
 				0,
 				80,
-				LogSys.GetGMSayColorFromCategory(log_category),
+				EQEmuLogSys::Get()->GetGMSayColorFromCategory(log_category),
 				"%s",
 				message_split[0].c_str()
 			);
@@ -308,14 +308,14 @@ public:
 				entity_list.MessageStatus(
 					0,
 					80,
-					LogSys.GetGMSayColorFromCategory(log_category),
+					EQEmuLogSys::Get()->GetGMSayColorFromCategory(log_category),
 					"--- %s",
 					message_split[iter].c_str()
 				);
 			}
 		}
 		else {
-			entity_list.MessageStatus(0, 80, LogSys.GetGMSayColorFromCategory(log_category), "%s", message.c_str());
+			entity_list.MessageStatus(0, 80, EQEmuLogSys::Get()->GetGMSayColorFromCategory(log_category), "%s", message.c_str());
 		}
 	}