.

Update zone.h
2026-05-22 16:28:28 +00:00 · 2025-06-14 00:03:28 -05:00 · 2025-06-13 23:52:34 -05:00
250 changed files with 3835 additions and 7716 deletions
@@ -1,109 +1,3 @@
-## [23.8.1] 6/28/2025
-
-### Crash Fix
-
-* Fix Possible Crashes with Raid Methods ([#4955](https://github.com/EQEmu/Server/pull/4955)) @Kinglykrab 2025-06-26
-
-### Databuckets
-
-* Revert Caching Changes of #4917 ([#4957](https://github.com/EQEmu/Server/pull/4957)) @Akkadius 2025-06-28
-
-### Fixes
-
-* Fix FindCharacter Using content_db ([#4956](https://github.com/EQEmu/Server/pull/4956)) @Kinglykrab 2025-06-26
-* Fix Hero Forge on Character Select ([#4954](https://github.com/EQEmu/Server/pull/4954)) @Kinglykrab 2025-06-26
-
-## [23.8.0] 6/25/2025
-
-### API
-
-* Add wwmarquee <type> <message> ([#4919](https://github.com/EQEmu/Server/pull/4919)) @Akkadius 2025-06-23
-
-### Build
-
-* Significantly Improve Build Times Using Unity Builds ([#4948](https://github.com/EQEmu/Server/pull/4948)) @Akkadius 2025-06-22
-
-### Code
-
-* AdventureManager Global to Singleton Cleanup ([#4931](https://github.com/EQEmu/Server/pull/4931)) @Kinglykrab 2025-06-25
-* Cleanup Strings Header ([#4950](https://github.com/EQEmu/Server/pull/4950)) @Akkadius 2025-06-22
-* ClientList Global to Singleton Cleanup ([#4942](https://github.com/EQEmu/Server/pull/4942)) @Kinglykrab 2025-06-25
-* DatabaseUpdate Global to Singleton Cleanup ([#4943](https://github.com/EQEmu/Server/pull/4943)) @Kinglykrab 2025-06-25
-* DiscordManager Global to Singleton Cleanup ([#4926](https://github.com/EQEmu/Server/pull/4926)) @Kinglykrab 2025-06-25
-* EQ::Random Global to Singleton Cleanup ([#4936](https://github.com/EQEmu/Server/pull/4936)) @Kinglykrab 2025-06-22
-* EQEmuLogSys Global to Singleton Cleanup ([#4925](https://github.com/EQEmu/Server/pull/4925)) @Akkadius 2025-06-25
-* EvolvingItemsManager Global to Singleton Cleanup ([#4929](https://github.com/EQEmu/Server/pull/4929)) @Kinglykrab 2025-06-25
-* LFGuildManager Global to Singleton Cleanup ([#4927](https://github.com/EQEmu/Server/pull/4927)) @Kinglykrab 2025-06-25
-* LoginServerList Global to Singleton Cleanup ([#4941](https://github.com/EQEmu/Server/pull/4941)) @Kinglykrab 2025-06-25
-* Optimize PCH Config (Faster Builds) ([#4951](https://github.com/EQEmu/Server/pull/4951)) @Akkadius 2025-06-22
-* PCH Cleanup ([#4952](https://github.com/EQEmu/Server/pull/4952)) @Akkadius 2025-06-25
-* PathManager Global to Singleton Cleanup ([#4924](https://github.com/EQEmu/Server/pull/4924)) @Akkadius 2025-06-22
-* PetitionList Global to Singleton Cleanup ([#4944](https://github.com/EQEmu/Server/pull/4944)) @Kinglykrab 2025-06-25
-* PlayerEventLogs Global to Singleton Cleanup ([#4928](https://github.com/EQEmu/Server/pull/4928)) @Kinglykrab 2025-06-25
-* QueryServConnection Global to Singleton Cleanup ([#4938](https://github.com/EQEmu/Server/pull/4938)) @Kinglykrab 2025-06-25
-* Remove Lua Rule Constants ([#4949](https://github.com/EQEmu/Server/pull/4949)) @Akkadius 2025-06-22
-* Remove Regex Compile Bloat ([#4947](https://github.com/EQEmu/Server/pull/4947)) @Akkadius 2025-06-22
-* Remove Unused MZoneShutdown Mutex ([#4946](https://github.com/EQEmu/Server/pull/4946)) @Kinglykrab 2025-06-22
-* SharedTaskManager Global to Singleton Cleanup ([#4930](https://github.com/EQEmu/Server/pull/4930)) @Kinglykrab 2025-06-25
-* SkillCaps Global to Singleton Cleanup ([#4933](https://github.com/EQEmu/Server/pull/4933)) @Kinglykrab 2025-06-22
-* TaskManager Global to Singleton Cleanup ([#4945](https://github.com/EQEmu/Server/pull/4945)) @Kinglykrab 2025-06-22
-* UCSConnection Global to Singleton Cleanup ([#4937](https://github.com/EQEmu/Server/pull/4937)) @Kinglykrab 2025-06-25
-* WebInterfaceList Global to Singleton Cleanup ([#4935](https://github.com/EQEmu/Server/pull/4935)) @Kinglykrab 2025-06-25
-* WorldContentServer Global to Singleton Cleanup ([#4939](https://github.com/EQEmu/Server/pull/4939)) @Kinglykrab 2025-06-25
-* WorldEventScheduler and ZoneEventScheduler Global to Singleton Cleanup ([#4932](https://github.com/EQEmu/Server/pull/4932)) @Kinglykrab 2025-06-25
-* ZSList Global to Singleton Cleanup ([#4940](https://github.com/EQEmu/Server/pull/4940)) @Kinglykrab 2025-06-25
-* ZoneStore Global to Singleton Cleanup ([#4934](https://github.com/EQEmu/Server/pull/4934)) @Kinglykrab 2025-06-23
-
-### Corpses
-
-* Add corpse entity variables to DB ([#4911](https://github.com/EQEmu/Server/pull/4911)) @fryguy503 2025-06-25
-
-### Databuckets
-
-* Move Databuckets to Common ([#4918](https://github.com/EQEmu/Server/pull/4918)) @Akkadius 2025-06-16
-* Nested Caching ([#4917](https://github.com/EQEmu/Server/pull/4917)) @Akkadius 2025-06-25
-
-### Doors
-
-* Fix door saving for versions ([#4905](https://github.com/EQEmu/Server/pull/4905)) @nytmyr 2025-06-09
-
-### Fixes
-
-* Bulk Send Corpses after Idle State ([#4910](https://github.com/EQEmu/Server/pull/4910)) @Akkadius 2025-06-09
-* Fix ClientList Singleton Shortcomings of #4942  @Akkadius 2025-06-25
-* Fix breaking changes to Titanium, SoF, SoD patches causes by big bags update ([#4922](https://github.com/EQEmu/Server/pull/4922)) @regneq 2025-06-25
-
-### Logs
-
-* Fix output for tasks in logs ([#4907](https://github.com/EQEmu/Server/pull/4907)) @joligario 2025-06-09
-
-### Performance
-
-* Auto Idle / AFK ([#4903](https://github.com/EQEmu/Server/pull/4903)) @Akkadius 2025-05-22
-* Wearchange Packet Send Deduplication ([#4916](https://github.com/EQEmu/Server/pull/4916)) @Akkadius 2025-06-25
-
-### Player Event Logs
-
-* Don't Clear Event Data on ETL Events ([#4913](https://github.com/EQEmu/Server/pull/4913)) @Akkadius 2025-06-25
-
-### Player Events
-
-* Don't Write Empty Data ([#4912](https://github.com/EQEmu/Server/pull/4912)) @Akkadius 2025-06-25
-* Zone Fetch Settings from QS if Enabled ([#4915](https://github.com/EQEmu/Server/pull/4915)) @Akkadius 2025-06-25
-
-### Quest API
-
-* Add CompleteTask and UncompleteTask methods to Perl/Lua ([#4921](https://github.com/EQEmu/Server/pull/4921)) @Barathos 2025-06-25
-* Lua Client Scoped EnableTitleSets ([#4914](https://github.com/EQEmu/Server/pull/4914)) @fryguy503 2025-06-25
-
-### Quests
-
-* Support Multiple Quest, Plugin, and Lua Module Paths ([#4906](https://github.com/EQEmu/Server/pull/4906)) @Akkadius 2025-06-09
-
-### World API
-
-* Input Validation ([#4904](https://github.com/EQEmu/Server/pull/4904)) @Akkadius 2025-05-22
-
 ## [23.7.0] 5/19/2025

 ### CLI
@@ -42,7 +42,6 @@ IF(USE_MAP_MMFS)
 ENDIF (USE_MAP_MMFS)

 IF(MSVC)
-	add_compile_options(/bigobj)
 	ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-DNOMINMAX)
 	ADD_DEFINITIONS(-DCRASH_LOGGING)
@@ -363,8 +362,6 @@ MESSAGE(STATUS "**************************************************")
 #setup server libs and headers
 SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)

-set(FMT_HEADER_ONLY OFF)
-
 INCLUDE_DIRECTORIES(SYSTEM "${DATABASE_LIBRARY_INCLUDE}")
 INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_LIBRARY_INCLUDE}")
 INCLUDE_DIRECTORIES(SYSTEM "${Boost_INCLUDE_DIRS}")
@@ -5,7 +5,7 @@
 </p>

 <p align="center">
-<b>EQEmulator - A Fan-Made Project Honoring a Legendary MMORPG</b>
+<b>EverQuest Emulator (EQEmu) - A Fan-Made Project Honoring the Legendary MMORPG</b>
 </p>

 <p align="center">
@@ -26,19 +26,19 @@
 ***

 <p align="center">
-EQEmulator is a <b>passion-driven</b>, <b>open source server emulator</b> project dedicated to preserving and celebrating the legacy of a groundbreaking classic MMORPG.
+EQEmulator is a <b>passion-driven</b>, <b>open source server emulator</b> project dedicated to preserving and celebrating the groundbreaking world of <b>EverQuest</b>, the massively multiplayer online role-playing game originally developed by <b>Verant Interactive</b> and <b>Sony Online Entertainment (now Daybreak Game Company)</b>.
 </p>

 <p align="center">
-For over two decades and continuing, EQEmulator has served as a <strong>fan tribute</strong>, providing tools and technology that allow players to explore, customize, and experience the legendary game's iconic gameplay in new ways. This project exists solely out of <strong>deep admiration</strong> for the original developers, artists, designers, and visionaries who created one of the most influential online worlds of all time.
+For over two decades and continuing, EQEmulator has served as a <strong>fan tribute</strong>, providing tools and technology that allow players to explore, customize, and experience EverQuest’s iconic gameplay in new ways. This project exists solely out of <strong>deep admiration</strong> for the original developers, artists, designers, and visionaries who created one of the most influential online worlds of all time.
 </p>

 <p align="center">
-We do not claim ownership of the original game or its assets. <strong>All credit and respect belong to the original creators and Daybreak Game Company</strong>, whose work continues to inspire generations of players and developers alike.
+We do not claim ownership of EverQuest or its assets. <strong>All credit and respect belong to the original creators and Daybreak Game Company</strong>, whose work continues to inspire generations of players and developers alike.
 </p>

 <p align="center">
-EQEmulator has for over 20 years and always will be a <strong>fan-based, non-commercial open-source effort</strong> made by players, for players—preserving the legacy of the game while empowering community-driven creativity, learning and joy that the game and its creators has so strongly inspired in us all.
+EQEmulator has for over 20 years and always will be a <strong>fan-based, non-commercial open-source effort</strong> made by players, for players—preserving the legacy of EverQuest while empowering community-driven creativity, learning and joy that the game and its creators has so strongly inspired in us all.
 </p>

 ***
@@ -47,7 +47,7 @@ EQEmulator has for over 20 years and always will be a <strong>fan-based, non-com
 Technical Overview & Reverse Engineering Effort
 </h1>

-<p align="center">EQEmulator represents <strong>over two decades of collaborative reverse engineering</strong>, building the server from the ground up without access to the original source code. This effort was achieved entirely through <strong>community-driven analysis, network protocol decoding, and in-game behavioral research</strong>.</p>
+<p align="center">EQEmulator represents <strong>over two decades of collaborative reverse engineering</strong>, rebuilding the EverQuest server from the ground up without access to the original source code. This effort was achieved entirely through <strong>community-driven analysis, network protocol decoding, and in-game behavioral research</strong>.</p>

 <h1 align="center">
 💡 How We Did It
@@ -104,10 +104,10 @@ Every system, packet, opcode, and game mechanic has been reconstructed through c
 🚀 Why It Matters
 </h1>

-<p align="center">🧬 EQEmulator stands as a <strong>technical preservation project</strong>, ensuring that the magic of classic and custom servers lives on for future generations of players, tinkerers, and game designers.
+<p align="center">🧬 EQEmulator stands as a <strong>technical preservation project</strong>, ensuring that the magic of classic and custom EverQuest servers lives on for future generations of players, tinkerers, and game designers.
 </p>

-> We humbly acknowledge and thank the original developers for creating one of the most influential online experiences in gaming history.
+> We humbly acknowledge and thank the original developers at **Verant Interactive** and **Sony Online Entertainment (now Daybreak Game Company)** for creating one of the most influential online experiences in gaming history.

 <h1 align="center">
 🧑‍💻🖥️ Supported Clients
@@ -148,3 +148,4 @@ If you want to set up your own EQEmulator server, please refer to the current [s
 <a href="https://github.com/EQEmu/server/graphs/contributors">
  <img src="https://contributors-img.firebaseapp.com/image?repo=EQEmu/server" />
 </a>
+
@@ -38,6 +38,13 @@
 #include "../../common/skill_caps.h"
 #include "../../common/evolving_items.h"

+EQEmuLogSys          LogSys;
+WorldContentService  content_service;
+ZoneStore            zone_store;
+PathManager          path;
+PlayerEventLogs      player_event_logs;
+EvolvingItemsManager evolving_items_manager;
+
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
@@ -46,10 +53,10 @@ void ExportDBStrings(SharedDatabase *db);
 int main(int argc, char **argv)
 {
 	RegisterExecutablePlatform(ExePlatformClientExport);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	LogInfo("Client Files Export Utility");
 	if (!EQEmuConfig::LoadConfig()) {
@@ -92,8 +99,8 @@ int main(int argc, char **argv)
 		content_db.SetMySQL(database);
 	}

-	EQEmuLogSys::Instance()->SetDatabase(&database)
-		->SetLogPath(PathManager::Instance()->GetLogPath())
+	LogSys.SetDatabase(&database)
+		->SetLogPath(path.GetLogPath())
 		->LoadLogDatabaseSettings()
 		->StartFileLogs();

@@ -122,14 +129,14 @@ int main(int argc, char **argv)
 	ExportBaseData(&content_db);
 	ExportDBStrings(&database);

-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();

 	return 0;
 }

 void ExportSpells(SharedDatabase* db)
 {
-	std::ofstream file(fmt::format("{}/export/spells_us.txt", PathManager::Instance()->GetServerPath()));
+	std::ofstream file(fmt::format("{}/export/spells_us.txt", path.GetServerPath()));
 	if (!file || !file.is_open()) {
 		LogError("Unable to open export/spells_us.txt to write, skipping.");
 		return;
@@ -148,7 +155,7 @@ void ExportSpells(SharedDatabase* db)

 void ExportSkillCaps(SharedDatabase* db)
 {
-	std::ofstream file(fmt::format("{}/export/SkillCaps.txt", PathManager::Instance()->GetServerPath()));
+	std::ofstream file(fmt::format("{}/export/SkillCaps.txt", path.GetServerPath()));
 	if (!file || !file.is_open()) {
 		LogError("Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
@@ -167,7 +174,7 @@ void ExportSkillCaps(SharedDatabase* db)

 void ExportBaseData(SharedDatabase *db)
 {
-	std::ofstream file(fmt::format("{}/export/BaseData.txt", PathManager::Instance()->GetServerPath()));
+	std::ofstream file(fmt::format("{}/export/BaseData.txt", path.GetServerPath()));
 	if (!file || !file.is_open()) {
 		LogError("Unable to open export/BaseData.txt to write, skipping.");
 		return;
@@ -186,7 +193,7 @@ void ExportBaseData(SharedDatabase *db)

 void ExportDBStrings(SharedDatabase *db)
 {
-	std::ofstream file(fmt::format("{}/export/dbstr_us.txt", PathManager::Instance()->GetServerPath()));
+	std::ofstream file(fmt::format("{}/export/dbstr_us.txt", path.GetServerPath()));
 	if (!file || !file.is_open()) {
 		LogError("Unable to open export/dbstr_us.txt to write, skipping.");
 		return;
@@ -32,6 +32,13 @@
 #include "../../common/events/player_event_logs.h"
 #include "../../common/evolving_items.h"

+EQEmuLogSys          LogSys;
+WorldContentService  content_service;
+ZoneStore            zone_store;
+PathManager          path;
+PlayerEventLogs      player_event_logs;
+EvolvingItemsManager evolving_items_manager;
+
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
@@ -39,10 +46,10 @@ void ImportDBStrings(SharedDatabase *db);

 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	LogInfo("Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
@@ -85,8 +92,8 @@ int main(int argc, char **argv) {
 		content_db.SetMySQL(database);
 	}

-	EQEmuLogSys::Instance()->SetDatabase(&database)
-		->SetLogPath(PathManager::Instance()->GetLogPath())
+	LogSys.SetDatabase(&database)
+		->SetLogPath(path.GetLogPath())
 		->LoadLogDatabaseSettings()
 		->StartFileLogs();

@@ -95,7 +102,7 @@ int main(int argc, char **argv) {
 	ImportBaseData(&content_db);
 	ImportDBStrings(&database);

-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();

 	return 0;
 }
@@ -131,7 +138,7 @@ bool IsStringField(int i) {

 void ImportSpells(SharedDatabase *db) {
 	LogInfo("Importing Spells");
-	std::string file = fmt::format("{}/import/spells_us.txt", PathManager::Instance()->GetServerPath());
+	std::string file = fmt::format("{}/import/spells_us.txt", path.GetServerPath());
 	FILE *f = fopen(file.c_str(), "r");
 	if(!f) {
 		LogError("Unable to open {} to read, skipping.", file);
@@ -221,7 +228,7 @@ void ImportSpells(SharedDatabase *db) {
 void ImportSkillCaps(SharedDatabase *db) {
 	LogInfo("Importing Skill Caps");

-	std::string file = fmt::format("{}/import/SkillCaps.txt", PathManager::Instance()->GetServerPath());
+	std::string file = fmt::format("{}/import/SkillCaps.txt", path.GetServerPath());
 	FILE *f = fopen(file.c_str(), "r");
 	if(!f) {
 		LogError("Unable to open {} to read, skipping.", file);
@@ -258,7 +265,7 @@ void ImportBaseData(SharedDatabase *db)
 {
 	LogInfo("Importing Base Data");

-	const std::string& file_name = fmt::format("{}/import/BaseData.txt", PathManager::Instance()->GetServerPath());
+	const std::string& file_name = fmt::format("{}/import/BaseData.txt", path.GetServerPath());

 	const auto& file_contents = File::GetContents(file_name);
 	if (!file_contents.error.empty()) {
@@ -298,7 +305,7 @@ void ImportBaseData(SharedDatabase *db)
 void ImportDBStrings(SharedDatabase *db) {
 	LogInfo("Importing DB Strings");

-	std::string file = fmt::format("{}/import/dbstr_us.txt", PathManager::Instance()->GetServerPath());
+	std::string file = fmt::format("{}/import/dbstr_us.txt", path.GetServerPath());
 	FILE *f = fopen(file.c_str(), "r");
 	if(!f) {
 		LogError("Unable to open {} to read, skipping.", file);
@@ -9,7 +9,6 @@ SET(common_sources
    compression.cpp
    condition.cpp
    content/world_content_service.cpp
-    content/world_content_service_rulesets.cpp
    discord/discord.cpp
    crash.cpp
    crc16.cpp
@@ -842,8 +841,8 @@ IF (UNIX)
    SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp" "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF (UNIX)

-IF (EQEMU_BUILD_PCH)
-    TARGET_PRECOMPILE_HEADERS(common PRIVATE pch/std-pch.h)
+IF (WIN32 AND EQEMU_BUILD_PCH)
+    TARGET_PRECOMPILE_HEADERS(common PRIVATE pch/pch.h)
 ENDIF ()

 SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -1,14 +1,19 @@
 #include "world_content_service.h"

+#include <utility>
 #include <glm/vec3.hpp>
 #include "../database.h"
 #include "../rulesys.h"
 #include "../eqemu_logsys.h"
 #include "../repositories/instance_list_repository.h"
-#include "../repositories/rule_sets_repository.h"
-#include "../repositories/rule_values_repository.h"
 #include "../zone_store.h"

+
+WorldContentService::WorldContentService()
+{
+	SetCurrentExpansion(Expansion::EXPANSION_ALL);
+}
+
 int WorldContentService::GetCurrentExpansion() const
 {
 	return current_expansion;
@@ -22,7 +27,7 @@ WorldContentService *WorldContentService::SetExpansionContext()
 	// pull expansion from rules
 	int expansion = RuleI(Expansion, CurrentExpansion);
 	if (expansion >= Expansion::Classic && expansion <= Expansion::MaxId) {
-		SetCurrentExpansion(expansion);
+		content_service.SetCurrentExpansion(expansion);
 	}

 	LogInfo(
@@ -36,27 +41,36 @@ WorldContentService *WorldContentService::SetExpansionContext()

 std::string WorldContentService::GetCurrentExpansionName()
 {
-	if (GetCurrentExpansion() == Expansion::EXPANSION_ALL) {
+	if (content_service.GetCurrentExpansion() == Expansion::EXPANSION_ALL) {
 		return "All Expansions";
 	}

 	if (current_expansion >= Expansion::Classic && current_expansion <= Expansion::MaxId) {
-		return Expansion::ExpansionName[GetCurrentExpansion()];
+		return Expansion::ExpansionName[content_service.GetCurrentExpansion()];
 	}

 	return "Unknown Expansion";
 }

+/**
+ * @param current_expansion
+ */
 void WorldContentService::SetCurrentExpansion(int current_expansion)
 {
 	WorldContentService::current_expansion = current_expansion;
 }

+/**
+ * @return
+ */
 const std::vector<ContentFlagsRepository::ContentFlags> &WorldContentService::GetContentFlags() const
 {
 	return content_flags;
 }

+/**
+ * @return
+ */
 std::vector<std::string> WorldContentService::GetContentFlagsEnabled()
 {
 	std::vector<std::string> enabled_flags;
@@ -70,6 +84,9 @@ std::vector<std::string> WorldContentService::GetContentFlagsEnabled()
 	return enabled_flags;
 }

+/**
+ * @return
+ */
 std::vector<std::string> WorldContentService::GetContentFlagsDisabled()
 {
 	std::vector<std::string> disabled_flags;
@@ -83,11 +100,18 @@ std::vector<std::string> WorldContentService::GetContentFlagsDisabled()
 	return disabled_flags;
 }

+/**
+ * @param content_flags
+ */
 void WorldContentService::SetContentFlags(const std::vector<ContentFlagsRepository::ContentFlags> &content_flags)
 {
 	WorldContentService::content_flags = content_flags;
 }

+/**
+ * @param content_flag
+ * @return
+ */
 bool WorldContentService::IsContentFlagEnabled(const std::string &content_flag)
 {
 	for (auto &f: GetContentFlags()) {
@@ -99,6 +123,10 @@ bool WorldContentService::IsContentFlagEnabled(const std::string &content_flag)
 	return false;
 }

+/**
+ * @param content_flag
+ * @return
+ */
 bool WorldContentService::IsContentFlagDisabled(const std::string &content_flag)
 {
 	for (auto &f: GetContentFlags()) {
@@ -157,7 +185,7 @@ void WorldContentService::ReloadContentFlags()

 	SetContentFlags(set_content_flags);
 	LoadStaticGlobalZoneInstances();
-	ZoneStore::Instance()->LoadZones(*m_content_database);
+	zone_store.LoadZones(*m_content_database);
 }

 Database *WorldContentService::GetDatabase() const
@@ -167,7 +195,7 @@ Database *WorldContentService::GetDatabase() const

 WorldContentService *WorldContentService::SetDatabase(Database *database)
 {
-	m_database = database;
+	WorldContentService::m_database = database;

 	return this;
 }
@@ -263,7 +291,7 @@ WorldContentService *WorldContentService::LoadStaticGlobalZoneInstances()
 //   instance_list table entry for lavastorm has version = 1, is_global = 1, never_expires = 1
 WorldContentService::FindZoneResult WorldContentService::FindZone(uint32 zone_id, uint32 instance_id)
 {
-	for (const auto &z: ZoneStore::Instance()->GetZones()) {
+	for (const auto &z: zone_store.GetZones()) {
 		for (auto &i: m_zone_static_instances) {
 			if (
 				z.zoneidnumber == zone_id &&
@@ -285,7 +313,7 @@ WorldContentService::FindZoneResult WorldContentService::FindZone(uint32 zone_id
 					i.notes
 				);

-				return FindZoneResult{
+				return WorldContentService::FindZoneResult{
 					.zone_id = static_cast<uint32>(z.zoneidnumber),
 					.instance = i,
 					.zone = z
@@ -294,7 +322,7 @@ WorldContentService::FindZoneResult WorldContentService::FindZone(uint32 zone_id
 		}
 	}

-	return FindZoneResult{.zone_id = 0};
+	return WorldContentService::FindZoneResult{.zone_id = 0};
 }

 bool WorldContentService::IsInPublicStaticInstance(uint32 instance_id)
@@ -319,4 +347,3 @@ bool WorldContentService::DoesZonePassContentFiltering(const ZoneRepository::Zon

 	return DoesPassContentFiltering(f);
 }
-
@@ -3,7 +3,6 @@

 #include <string>
 #include <vector>
-#include "../rulesys.h"
 #include "../repositories/content_flags_repository.h"
 #include "../repositories/zone_repository.h"
 #include "../repositories/instance_list_repository.h"
@@ -18,10 +17,8 @@ struct ContentFlags {
 };

 namespace Expansion {
-	static constexpr int8 EXPANSION_ZERO_VALUE = -2;
-	static constexpr int8 EXPANSION_MAX        = 98;
-	static const int      EXPANSION_ALL        = -1;
-	static const int      EXPANSION_FILTER_MAX = 99;
+	static const int EXPANSION_ALL        = -1;
+	static const int EXPANSION_FILTER_MAX = 99;

 	enum ExpansionNumber {
 		Classic = 0,
@@ -84,25 +81,14 @@ namespace Expansion {
 		"Empires of Kunark",
 		"Ring of Scale",
 		"The Burning Lands",
-		"Torment of Velious"
+		"Torment of Velious",
 	};
 }

 class WorldContentService {
 public:

-	// Constructor can initialize from singleton
-	WorldContentService()
-		: m_rule_manager(RuleManager::Instance())
-	{
-		SetCurrentExpansion(Expansion::EXPANSION_ALL);
-	}
-
-	static WorldContentService* Instance()
-	{
-		static WorldContentService instance;
-		return &instance;
-	}
+	WorldContentService();

 	std::string GetCurrentExpansionName();
 	int GetCurrentExpansion() const;
@@ -195,12 +181,6 @@ public:
 	FindZoneResult FindZone(uint32 zone_id, uint32 instance_id);
 	bool IsInPublicStaticInstance(uint32 instance_id);

-	// targeted rulesets
-	void        SeedDefaultRulesets() const;
-	void        LoadTargetedRulesets();
-	inline void SetZoneId(int zone_id) { m_zone_id = zone_id; }
-	inline void SetInstanceVersion(int instance_version) { m_instance_version = instance_version; }
-
 private:
 	int current_expansion{};
 	std::vector<ContentFlagsRepository::ContentFlags> content_flags;
@@ -208,14 +188,12 @@ private:
 	// reference to database
 	Database *m_database;
 	Database *m_content_database;
-	RuleManager* m_rule_manager;
-
-	int m_zone_id = 0;
-	int m_instance_version = 0;

 	// holds a record of the zone table from the database
 	WorldContentService *LoadStaticGlobalZoneInstances();
 	std::vector<InstanceListRepository::InstanceList> m_zone_static_instances;
 };

+extern WorldContentService content_service;
+
 #endif //EQEMU_WORLD_CONTENT_SERVICE_H
@@ -1,981 +0,0 @@
-#include "world_content_service.h"
-#include "../repositories/rule_sets_repository.h"
-#include "../repositories/rule_values_repository.h"
-
-// RuleSet is a struct that contains a ruleset and its associated rules.
-struct RuleSet {
-	RuleSetsRepository::RuleSets                  rule_set;
-	std::vector<RuleValuesRepository::RuleValues> rules;
-};
-
-inline RuleSet GetClassicRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 100,
-			.name = "Original (Classic)",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::Classic,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "Classic client-based ruleset",
-		},
-		.rules = {
-			{
-				.rule_name = "Character:EnableXTargetting",
-				.rule_value = "false",
-				.notes = "Added in Call of the Forsaken"
-			},
-			{
-				.rule_name = "Character:LeaveCorpses",
-				.rule_value = "true",
-				.notes = "Leave corpses behind"
-			},
-			{
-				.rule_name = "Character:LeaveNakedCorpses",
-				.rule_value = "false",
-				.notes = "Gear left on corpses until SoD"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "50",
-				.notes = "Level 50 cap until Kunark"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "50",
-				.notes = "Level 50 cap until Kunark"
-			},
-			{
-				.rule_name = "Character:RestRegenEnabled",
-				.rule_value = "false",
-				.notes = "OoC regen not added until TSS"
-			},
-			{
-				.rule_name = "Character:SharedBankPlat",
-				.rule_value = "false",
-				.notes = "No shared bank until LoY"
-			},
-			{
-				.rule_name = "Character:StatCap",
-				.rule_value = "255",
-				.notes = "Classic stat cap is 255"
-			},
-			{
-				.rule_name = "Character:UseOldBindWound",
-				.rule_value = "true",
-				.notes = ""
-			},
-			{
-				.rule_name = "Character:UseOldClassExpPenalties",
-				.rule_value = "true",
-				.notes = "Exp penalties removed in SoF"
-			},
-			{
-				.rule_name = "Character:UseOldConSystem",
-				.rule_value = "true",
-				.notes = "Con system changed in SoF"
-			},
-			{
-				.rule_name = "Character:UseOldRaceExpPenalties",
-				.rule_value = "true",
-				.notes = "Exp penalties removed in SoF"
-			},
-			{
-				.rule_name = "Character:UseOldRaceRezEffects",
-				.rule_value = "true",
-				.notes = "May need testing to ensure it can't be dispelled"
-			},
-			{
-				.rule_name = "Character:UseRaceClassExpBonuses",
-				.rule_value = "true",
-				.notes = ""
-			},
-			{
-				.rule_name = "Chat:EnableVoiceMacros",
-				.rule_value = "false",
-				.notes = "Introduced in GoD"
-			},
-			{
-				.rule_name = "Chat:ServerWideAuction",
-				.rule_value = "false",
-				.notes = "Disable Server-Wide Auction Chat"
-			},
-			{
-				.rule_name = "Chat:ServerWideOOC",
-				.rule_value = "false",
-				.notes = "Disable Server-Wide OOC Chat"
-			},
-			{
-				.rule_name = "Combat:ClassicNPCBackstab",
-				.rule_value = "true",
-				.notes = "Disables front backstab"
-			},
-			{
-				.rule_name = "Mail:EnableMailSystem",
-				.rule_value = "false",
-				.notes = "Mail system added in DoN"
-			},
-			{
-				.rule_name = "Spells:PreNerfBardAEDoT",
-				.rule_value = "true",
-				.notes = "Bard AE nerf not added until OoW"
-			},
-			{
-				.rule_name = "Spells:WizCritLevel",
-				.rule_value = "65",
-				.notes = "Wiz non-AA crits not until Luclin"
-			},
-			{
-				.rule_name = "TaskSystem:EnableTaskSystem",
-				.rule_value = "false",
-				.notes = "Task system added in OoW"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "0",
-				.notes = "Classic Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:EnableReturnHomeButton",
-				.rule_value = "false",
-				.notes = "Return Home added in DoN"
-			},
-			{
-				.rule_name = "World:EnableTutorialButton",
-				.rule_value = "false",
-				.notes = "Tutorial added in DoN"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "0",
-				.notes = "Classic Client-Based Expansion Setting"
-			},
-		}
-	};
-}
-
-inline RuleSet GetKunarkRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 101,
-			.name = "Ruins of Kunark",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheRuinsOfKunark,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "Kunark client-based ruleset. Level 60 cap until PoP.",
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "1",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "1",
-				.notes = "Kunark Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "1",
-				.notes = "Kunark Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "60",
-				.notes = "Level 60 cap until PoP"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "60",
-				.notes = "Level 60 cap until PoP"
-			},
-		}
-	};
-}
-
-inline RuleSet GetVeliousRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 102,
-			.name = "Scars of Velious",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheScarsOfVelious,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "Velious client-based ruleset. Level 60 cap until PoP."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "2",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "3",
-				.notes = "Velious Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "3",
-				.notes = "Velious Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "60",
-				.notes = "Level 60 cap until PoP"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "60",
-				.notes = "Level 60 cap until PoP"
-			},
-		}
-	};
-}
-
-inline RuleSet GetLuclinRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 103,
-			.name = "Shadows of Luclin",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheShadowsOfLuclin,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "Luclin client-based ruleset. Level 60 cap. Added Wiz crits."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "3",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "7",
-				.notes = "Luclin Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "7",
-				.notes = "Luclin Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Spells:WizCritLevel",
-				.rule_value = "12",
-				.notes = "Wizard non-AA Criticals Not added until Luclin"
-			},
-		}
-	};
-}
-
-inline RuleSet GetPlanesRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 104,
-			.name = "Planes of Power",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::ThePlanesOfPower,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "PoP client-based ruleset. Level 65 cap. Stat cap increased. Bind Wound changed."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "4",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "15",
-				.notes = "Planes of Power Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "15",
-				.notes = "Planes of Power Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "65",
-				.notes = "Level 65 cap until Omens of War"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "65",
-				.notes = "Level 65 cap until Omens of War"
-			},
-			{
-				.rule_name = "Character:StatCap",
-				.rule_value = "305",
-				.notes = "Stat cap raised from 255 to 305 with PoP"
-			},
-			{
-				.rule_name = "Character:UseOldBindWound",
-				.rule_value = "false",
-				.notes = "PoP introduced a more effective bind wound system"
-			},
-		}
-	};
-}
-
-// Returns a RuleSet for the Legacy of Ykesha ruleset.
-inline RuleSet GetLegacyOfYkeshaRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 105,
-			.name = "Legacy of Ykesha",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheLegacyOfYkesha,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "LoY client-based ruleset. Shared bank introduced. Stat cap raised to 350."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "5",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "31",
-				.notes = "Legacy of Ykesha Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "31",
-				.notes = "Legacy of Ykesha Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "65",
-				.notes = "Level 65 cap until Omens of War"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "65",
-				.notes = "Level 65 cap until Omens of War"
-			},
-			{
-				.rule_name = "Character:SharedBankPlat",
-				.rule_value = "true",
-				.notes = "Shared bank enabled in Legacy of Ykesha"
-			},
-			{
-				.rule_name = "Character:StatCap",
-				.rule_value = "350",
-				.notes = "Stat cap increased to 350 with LoY (was 305 in PoP)"
-			},
-		}
-	};
-}
-
-inline RuleSet GetLDoNRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 106,
-			.name = "Lost Dungeons of Norrath",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::LostDungeonsOfNorrath,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "LDoN client-based ruleset. Stat cap raised to 400."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "6",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "63",
-				.notes = "Lost Dungeons of Norrath Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "63",
-				.notes = "Lost Dungeons of Norrath Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Character:StatCap",
-				.rule_value = "400",
-				.notes = "Stat cap increased to 400 with LDoN (was 350 in LoY)"
-			},
-		}
-	};
-}
-
-inline RuleSet GetGatesOfDiscordRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 107,
-			.name = "Gates of Discord",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::GatesOfDiscord,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "GoD client-based ruleset. Voice macros introduced."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "7",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "127",
-				.notes = "Gates of Discord Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "127",
-				.notes = "Gates of Discord Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Chat:EnableVoiceMacros",
-				.rule_value = "true",
-				.notes = "Enable Voice Macros - Introduced in Gates of Discord"
-			},
-		}
-	};
-}
-
-inline RuleSet GetOmensOfWarRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 108,
-			.name = "Omens of War",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::OmensOfWar,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "OoW client-based ruleset. Level cap raised to 70. Bard AE nerfed. Task system enabled."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "8",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "255",
-				.notes = "Omens of War Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "255",
-				.notes = "Omens of War Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Spells:PreNerfBardAEDoT",
-				.rule_value = "false",
-				.notes = "Bard AE Nerf"
-			},
-			{
-				.rule_name = "TaskSystem:EnableTaskSystem",
-				.rule_value = "true",
-				.notes = "Task system was introduced in Omens of War"
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "70",
-				.notes = "Level 70 cap until The Serpent's Spine"
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "70",
-				.notes = "Level 70 cap until The Serpent's Spine"
-			},
-		}
-	};
-}
-
-inline RuleSet GetDragonsOfNorrathRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 109,
-			.name = "Dragons of Norrath",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::DragonsOfNorrath,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "DoN client-based ruleset. Mail system introduced. Accursed Nest unlockable."
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "9",
-				.notes = "Current Expansion"
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "511",
-				.notes = "Dragons of Norrath Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "511",
-				.notes = "Dragons of Norrath Client-Based Expansion Setting"
-			},
-			{
-				.rule_name = "Mail:EnableMailSystem",
-				.rule_value = "true",
-				.notes = "Mail System not added until Dragons of Norrath"
-			},
-		}
-	};
-}
-
-inline RuleSet GetEraOverridesRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 200,
-			.name = "Era Overrides",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::EXPANSION_ALL,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "If you want to override any rules for era specific rulesets, use this ruleset. It will not be used by default.",
-		},
-		.rules = {
-			// users will add their own dynamically
-		}
-	};
-}
-
-inline RuleSet GetDepthsOfDarkhollowRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 110,
-			.name = "Depths of Darkhollow",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::DepthsOfDarkhollow,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "DoD client-based ruleset. Introduced Shroud system.",
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "10",
-				.notes = "Current Expansion",
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "1023",
-				.notes = "Depths of Darkhollow Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "1023",
-				.notes = "Depths of Darkhollow Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "Character:EnableShroudSystem",
-				.rule_value = "true",
-				.notes = "Shroud system was introduced in Depths of Darkhollow",
-			},
-		}
-	};
-}
-
-inline RuleSet GetProphecyOfRoRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 111,
-			.name = "Prophecy of Ro",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::ProphecyOfRo,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "PoR client-based ruleset. Introduced aura system.",
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "11",
-				.notes = "Current Expansion",
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "2047",
-				.notes = "Prophecy of Ro Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "2047",
-				.notes = "Prophecy of Ro Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "Character:EnableAuraSystem",
-				.rule_value = "true",
-				.notes = "Aura system introduced in Prophecy of Ro",
-			},
-		}
-	};
-}
-
-inline RuleSet GetTheSerpentsSpineRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 112,
-			.name = "The Serpent's Spine",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheSerpentsSpine,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "TSS client-based ruleset. Level cap raised to 75. Out-of-combat regen enabled.",
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "12",
-				.notes = "Current Expansion",
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "4095",
-				.notes = "The Serpent's Spine Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "4095",
-				.notes = "The Serpent's Spine Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "Character:MaxExpLevel",
-				.rule_value = "75",
-				.notes = "Level 75 cap until The Buried Sea",
-			},
-			{
-				.rule_name = "Character:MaxLevel",
-				.rule_value = "75",
-				.notes = "Level 75 cap until The Buried Sea",
-			},
-			{
-				.rule_name = "Character:RestRegenEnabled",
-				.rule_value = "true",
-				.notes = "Out of combat regeneration enabled in The Serpent's Spine",
-			},
-		}
-	};
-}
-
-inline RuleSet GetTheBuriedSeaRuleset()
-{
-	return {
-		.rule_set = {
-			.ruleset_id = 113,
-			.name = "The Buried Sea",
-			.zone_ids = "",
-			.instance_versions = "",
-			.content_flags = "",
-			.content_flags_disabled = "",
-			.min_expansion = Expansion::TheBuriedSea,
-			.max_expansion = Expansion::EXPANSION_MAX,
-			.notes = "TBS client-based ruleset. Fellowship and item aug system added.",
-		},
-		.rules = {
-			{
-				.rule_name = "Expansion:CurrentExpansion",
-				.rule_value = "13",
-				.notes = "Current Expansion",
-			},
-			{
-				.rule_name = "World:CharacterSelectExpansionSettings",
-				.rule_value = "8191",
-				.notes = "The Buried Sea Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "World:ExpansionSettings",
-				.rule_value = "8191",
-				.notes = "The Buried Sea Client-Based Expansion Setting",
-			},
-			{
-				.rule_name = "Fellowship:Enabled",
-				.rule_value = "true",
-				.notes = "Fellowships were introduced in The Buried Sea",
-			},
-			{
-				.rule_name = "Items:AllowItemAugmenting",
-				.rule_value = "true",
-				.notes = "Item augmenting system introduced in The Buried Sea",
-			},
-		}
-	};
-}
-
-inline std::vector<RuleSet> GetCustomRulesets()
-{
-	return {
-		{
-			.rule_set = {
-				.ruleset_id = 300,
-				.name = "Double Experience",
-				.zone_ids = "",
-				.instance_versions = "",
-				.content_flags = "",
-				.content_flags_disabled = "",
-				.min_expansion = Expansion::EXPANSION_ZERO_VALUE,
-				.max_expansion = Expansion::EXPANSION_ZERO_VALUE,
-				.notes = "Doubles EXP globally",
-			},
-			.rules = {
-				{
-					.rule_name = "Character:FinalExpMultiplier",
-					.rule_value = "2"
-				}
-			}
-		},
-		{
-			.rule_set = {
-				.ruleset_id = 1000,
-				.name = "Custom Boundary (Put your custom rulesets after here)",
-				.zone_ids = "",
-				.instance_versions = "",
-				.content_flags = "",
-				.content_flags_disabled = "",
-				.min_expansion = Expansion::EXPANSION_ZERO_VALUE,
-				.max_expansion = Expansion::EXPANSION_ZERO_VALUE,
-				.notes = "You may add your own rulesets above 1000+"
-			},
-		},
-	};
-}
-
-inline std::vector<RuleSet> GetDefaultRulesets()
-{
-	std::vector<RuleSet> sets = {
-		GetClassicRuleset(),
-		GetKunarkRuleset(),
-		GetVeliousRuleset(),
-		GetLuclinRuleset(),
-		GetPlanesRuleset(),
-		GetLegacyOfYkeshaRuleset(),
-		GetLDoNRuleset(),
-		GetGatesOfDiscordRuleset(),
-		GetOmensOfWarRuleset(),
-		GetDragonsOfNorrathRuleset(),
-		GetDepthsOfDarkhollowRuleset(),
-		GetProphecyOfRoRuleset(),
-		GetTheSerpentsSpineRuleset(),
-		GetTheBuriedSeaRuleset(),
-		GetEraOverridesRuleset()
-	};
-
-	// Append custom rulesets
-	const auto custom = GetCustomRulesets();
-	sets.insert(sets.end(), custom.begin(), custom.end());
-
-	return sets;
-}
-
-void WorldContentService::SeedDefaultRulesets() const
-{
-	LogInfo("Seeding default rulesets");
-
-	// Load existing rule_sets into a map
-	std::unordered_map<uint32_t, RuleSetsRepository::RuleSets> existing_rulesets;
-	for (const auto& r : RuleSetsRepository::All(*m_database)) {
-		existing_rulesets[r.ruleset_id] = r;
-	}
-
-	// Load existing rule_values into a map<ruleset_id, map<rule_name, RuleValues>>
-	std::unordered_map<uint32_t, std::unordered_map<std::string, RuleValuesRepository::RuleValues>> existing_rule_values;
-	for (const auto& r : RuleValuesRepository::All(*m_database)) {
-		existing_rule_values[r.ruleset_id][r.rule_name] = r;
-	}
-
-	std::vector<RuleSetsRepository::RuleSets> rule_sets_to_insert;
-	std::vector<RuleSetsRepository::RuleSets> rule_sets_to_update;
-	std::vector<RuleValuesRepository::RuleValues> rule_values_to_insert;
-	std::unordered_map<uint32_t, std::vector<std::string>> rule_values_to_delete;
-
-	for (const auto& entry : GetDefaultRulesets()) {
-		const auto& rs = entry.rule_set;
-		const auto existing_it = existing_rulesets.find(rs.ruleset_id);
-
-		if (existing_it == existing_rulesets.end()) {
-			rule_sets_to_insert.push_back(rs);
-		}
-		else {
-			const auto& existing = existing_it->second;
-			if (rs.name != existing.name ||
-			    rs.zone_ids != existing.zone_ids ||
-			    rs.instance_versions != existing.instance_versions ||
-			    rs.content_flags != existing.content_flags ||
-			    rs.content_flags_disabled != existing.content_flags_disabled ||
-			    rs.min_expansion != existing.min_expansion ||
-			    rs.max_expansion != existing.max_expansion ||
-			    rs.notes != existing.notes) {
-				rule_sets_to_update.push_back(rs);
-			}
-		}
-
-		std::unordered_set<std::string> defined_rule_names;
-
-		for (auto rule : entry.rules) {
-			rule.ruleset_id = rs.ruleset_id;
-
-			if (rule.notes.empty()) {
-				rule.notes = m_rule_manager->GetRuleNotesByName(rule.rule_name);
-			}
-
-			defined_rule_names.insert(rule.rule_name);
-
-			auto& existing_rules = existing_rule_values[rs.ruleset_id];
-			if (existing_rules.find(rule.rule_name) == existing_rules.end()) {
-				rule_values_to_insert.push_back(rule);
-			}
-		}
-
-		for (const auto& [rule_name, _] : existing_rule_values[rs.ruleset_id]) {
-			if (!defined_rule_names.count(rule_name)) {
-				rule_values_to_delete[rs.ruleset_id].push_back(rule_name);
-			}
-		}
-	}
-
-	// Insert new rule sets
-	for (const auto& rs : rule_sets_to_insert) {
-		RuleSetsRepository::InsertOne(*m_database, rs);
-		LogInfo("Inserted ruleset [{}] {}", rs.ruleset_id, rs.name);
-	}
-
-	// Update modified rule sets
-	for (const auto& rs : rule_sets_to_update) {
-		RuleSetsRepository::UpdateOne(*m_database, rs);
-		LogInfo("Updated ruleset metadata [{}] {}", rs.ruleset_id, rs.name);
-	}
-
-	// Insert new rule values
-	if (!rule_values_to_insert.empty()) {
-		RuleValuesRepository::InsertMany(*m_database, rule_values_to_insert);
-		LogInfo("Inserted [{}] new rule(s)]", rule_values_to_insert.size());
-	}
-
-	// Delete obsolete rule values in batches
-	for (const auto& [ruleset_id, rule_names] : rule_values_to_delete) {
-		if (rule_names.empty()) continue;
-
-		std::string in_clause = "'" + Strings::Join(rule_names, "','") + "'";
-		std::string where = fmt::format("ruleset_id = {} AND rule_name IN ({})", ruleset_id, in_clause);
-
-		int removed = RuleValuesRepository::DeleteWhere(*m_database, where);
-		LogInfo("Deleted [{}] obsolete rule(s) from ruleset [{}]: [{}]", removed, ruleset_id, Strings::Join(rule_names, ", "));
-	}
-}
-
-void WorldContentService::LoadTargetedRulesets()
-{
-	if (!m_zone_id) {
-		LogError("Zone ID is not set. Cannot load targeted rulesets.");
-		return;
-	}
-
-	SeedDefaultRulesets();
-
-	LogInfo("Zone ID [{}] Instance Version [{}] - Loading targeted rulesets", m_zone_id, m_instance_version);
-
-	auto rules = RuleValuesRepository::GetWhere(*m_database, "TRUE ORDER BY ruleset_id, rule_name");
-	auto sets  = RuleSetsRepository::GetWhere(*m_database, "TRUE ORDER BY ruleset_id");
-	for (auto& e : sets) {
-		bool has_filters =
-			!e.zone_ids.empty() ||
-			!e.instance_versions.empty() ||
-			!e.content_flags.empty() ||
-			!e.content_flags_disabled.empty() ||
-			e.min_expansion != Expansion::EXPANSION_ZERO_VALUE ||
-			e.max_expansion != Expansion::EXPANSION_ZERO_VALUE;
-		if (!has_filters) {
-			continue; // not a targeted ruleset
-		}
-
-		auto zone_id = std::to_string(m_zone_id);
-		if (!e.zone_ids.empty() && !Strings::Contains(e.zone_ids, zone_id)) {
-			continue;
-		}
-
-		auto instance_id = std::to_string(m_instance_version);
-		if (!e.instance_versions.empty() && !Strings::Contains(e.instance_versions, instance_id)) {
-			continue;
-		}
-
-		if (!DoesPassContentFiltering(
-			ContentFlags{
-				.min_expansion = e.min_expansion,
-				.max_expansion = e.max_expansion,
-				.content_flags = e.content_flags,
-				.content_flags_disabled = e.content_flags_disabled
-			}
-		)) {
-			continue;
-		}
-
-		for (auto& r : rules) {
-			if (r.ruleset_id != e.ruleset_id) {
-				continue;
-			}
-
-			m_rule_manager->SetRule(r.rule_name, r.rule_value);
-
-			LogInfo(
-				"Loaded [{}] ruleset [{}] name [{}] value [{}]",
-				e.ruleset_id,
-				e.name,
-				r.rule_name,
-				r.rule_value
-			);
-		}
-	}
-}
@@ -27,8 +27,6 @@ void SendCrashReport(const std::string &crash_report)
 //		"http://localhost:3010/api/v1/analytics/server-crash-report", // development
 	};

-	EQEmuLogSys* log = EQEmuLogSys::Instance();
-
 	auto      config = EQEmuConfig::get();
 	for (auto &e: endpoints) {
 		uri u(e);
@@ -70,12 +68,12 @@ void SendCrashReport(const std::string &crash_report)
 		p["cpus"]              = cpus.size();
 		p["origination_info"]  = "";

-		if (!log->origination_info.zone_short_name.empty()) {
+		if (!LogSys.origination_info.zone_short_name.empty()) {
 			p["origination_info"] = fmt::format(
 				"{} ({}) instance_id [{}]",
-				log->origination_info.zone_short_name,
-				log->origination_info.zone_long_name,
-				log->origination_info.instance_id
+				LogSys.origination_info.zone_short_name,
+				LogSys.origination_info.zone_long_name,
+				LogSys.origination_info.instance_id
 			);
 		}

@@ -296,7 +294,7 @@ void print_trace()
 		SendCrashReport(crash_report);
 	}

-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();

 	exit(1);
 }
@@ -708,20 +708,6 @@ const std::string Database::GetNPCNameByID(uint32 npc_id)
 	return e.id ? e.name : std::string();
 }

-template<typename InputIterator, typename OutputIterator>
-inline auto CleanMobName(InputIterator first, InputIterator last, OutputIterator result)
-{
-	for (; first != last; ++first) {
-		if (*first == '_') {
-			*result = ' ';
-		}
-		else if (isalpha(*first) || *first == '`') {
-			*result = *first;
-		}
-	}
-	return result;
-}
-
 const std::string Database::GetCleanNPCNameByID(uint32 npc_id)
 {
 	const auto& e = NpcTypesRepository::FindOne(*this, npc_id);
@@ -2244,7 +2230,7 @@ void Database::PurgeCharacterParcels()
 		pel.event_data = ss.str();
 		pel.created_at = std::time(nullptr);

-		PlayerEventLogs::Instance()->AddToQueue(pel);
+		player_event_logs.AddToQueue(pel);

 		ss.str("");
 		ss.clear();
@@ -204,7 +204,7 @@ void DatabaseDumpService::DatabaseDump()
 	}

 	if (IsDumpOutputToConsole()) {
-		EQEmuLogSys::Instance()->SilenceConsoleLogging();
+		LogSys.SilenceConsoleLogging();
 	}

 	LogInfo("MySQL installed [{}]", GetMySQLVersion());
@@ -324,7 +324,7 @@ void DatabaseDumpService::DatabaseDump()
 	}

 	if (!IsDumpOutputToConsole()) {
-		EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+		LogSys.LoadLogSettingsDefaults();
 	}

 	if (!pipe_file.empty()) {
@@ -55,7 +55,7 @@ void DatabaseUpdate::CheckDbUpdates()
 	}

 	if (UpdateManifest(manifest_entries, v.server_database_version, b.server_database_version)) {
-		LogInfoNoFn(
+		LogInfo(
 			"Updates ran successfully, setting database version to [{}] from [{}]",
 			b.server_database_version,
 			v.server_database_version
@@ -64,7 +64,7 @@ void DatabaseUpdate::CheckDbUpdates()
 	}

 	if (UpdateManifest(manifest_entries_custom, v.custom_database_version, b.custom_database_version)) {
-		LogInfoNoFn(
+		LogInfo(
 			"Updates ran successfully, setting database version to [{}] from [{}]",
 			b.custom_database_version,
 			v.custom_database_version
@@ -154,7 +154,7 @@ bool DatabaseUpdate::UpdateManifest(
 	std::vector<int> missing_migrations = {};
 	if (version_low != version_high) {

-		EQEmuLogSys::Instance()->DisableMySQLErrorLogs();
+		LogSys.DisableMySQLErrorLogs();
 		bool force_interactive = false;
 		for (int version = version_low + 1; version <= version_high; ++version) {
 			for (auto &e: entries) {
@@ -184,7 +184,7 @@ bool DatabaseUpdate::UpdateManifest(
 				}
 			}
 		}
-		EQEmuLogSys::Instance()->EnableMySQLErrorLogs();
+		LogSys.EnableMySQLErrorLogs();
 		LogInfo("{}", Strings::Repeat("-", BREAK_LENGTH));

 		if (!missing_migrations.empty() && m_skip_backup) {
@@ -337,9 +337,9 @@ DatabaseUpdate *DatabaseUpdate::SetSkipBackup(bool skip)

 bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 {
-	LogInfoNoFn("{}", Strings::Repeat("-", BREAK_LENGTH));
+	LogInfo("{}", Strings::Repeat("-", BREAK_LENGTH));

-	LogInfoNoFn(
+	LogInfo(
 		"{:>8} | database [{}] binary [{}] {}",
 		"Server",
 		v.server_database_version,
@@ -348,7 +348,7 @@ bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 	);

 	if (RuleB(Bots, Enabled) && b.bots_database_version > 0) {
-		LogInfoNoFn(
+		LogInfo(
 			"{:>8} | database [{}] binary [{}] {}",
 			"Bots",
 			v.bots_database_version,
@@ -358,7 +358,7 @@ bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 	}

 	if (b.custom_database_version > 0) {
-		LogInfoNoFn(
+		LogInfo(
 			"{:>8} | database [{}] binary [{}] {}",
 			"Custom",
 			v.custom_database_version,
@@ -367,9 +367,9 @@ bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 		);
 	}

-	LogInfoNoFn("{:>8} | [server.auto_database_updates] [<green>true]", "Config");
+	LogInfo("{:>8} | [server.auto_database_updates] [<green>true]", "Config");

-	LogInfoNoFn("{}", Strings::Repeat("-", BREAK_LENGTH));
+	LogInfo("{}", Strings::Repeat("-", BREAK_LENGTH));

 	// server database version is required
 	bool server_up_to_date = v.server_database_version >= b.server_database_version;
@@ -33,13 +33,6 @@ public:
 	DatabaseUpdate *SetContentDatabase(Database *db);
 	DatabaseUpdate *SetSkipBackup(bool skip);
 	bool HasPendingUpdates();
-
-	static DatabaseUpdate* Instance()
-	{
-		static DatabaseUpdate instance;
-		return &instance;
-	}
-
 private:
 	bool m_skip_backup = false;
 	Database *m_database;
@@ -7109,52 +7109,6 @@ ALTER TABLE `npc_types`
 ALTER TABLE `character_data`
 CHANGE COLUMN `firstlogon` `ingame` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 AFTER `xtargets`,
 ADD COLUMN `first_login` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `xtargets`;
-)",
-		.content_schema_update = false
-	},
-	ManifestEntry{
-		.version = 9324,
-		.description = "2025_06_11_player_event_logs_table.sql",
-		.check = "SHOW CREATE TABLE `player_event_logs`",
-		.condition = "missing",
-		.match = "COMPRESS",
-		.sql = R"(
-ALTER TABLE player_event_logs ROW_FORMAT=COMPRESSED;
-CREATE INDEX idx_event_type_char_id ON player_event_logs (event_type_id, character_id);
-)",
-		.content_schema_update = false
-	},
-	ManifestEntry{
-		.version = 9325,
-		.description = "2025_06_10_character_corpses_entity_variables.sql",
-		.check = "SHOW COLUMNS FROM `character_corpses` LIKE 'entity_variables'",
-		.condition = "empty",
-		.match = "",
-		.sql = R"(
-ALTER TABLE `character_corpses`
-ADD COLUMN `entity_variables` TEXT DEFAULT NULL AFTER `rezzable`;
-)",
-		.content_schema_update = false
-	},
-	ManifestEntry{
-		.version = 9326,
-		.description = "2025_06_16_rule_set_expansion.sql",
-		.check = "SHOW COLUMNS FROM `rule_sets` LIKE 'zone_ids'",
-		.condition = "empty",
-		.match = "",
-		.sql = R"(
-ALTER TABLE `rule_sets`
-  ADD COLUMN `zone_ids` TEXT NOT NULL DEFAULT '',
-  ADD COLUMN `instance_versions` TEXT NOT NULL DEFAULT '',
-  ADD COLUMN `content_flags` TEXT NOT NULL DEFAULT '',
-  ADD COLUMN `content_flags_disabled` TEXT NOT NULL DEFAULT '',
-  ADD COLUMN `min_expansion` TINYINT NOT NULL DEFAULT -2,
-  ADD COLUMN `max_expansion` TINYINT NOT NULL DEFAULT -2,
-  ADD COLUMN `notes` VARCHAR(255) NOT NULL DEFAULT '';
-ALTER TABLE `rule_sets`
-	CHANGE `ruleset_id` `ruleset_id` int NOT NULL auto_increment;
-ALTER TABLE `rule_values`
-	CHANGE `ruleset_id` `ruleset_id` int NOT NULL DEFAULT 0;
 )",
 		.content_schema_update = false
 	},
@@ -160,7 +160,7 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 		(uint32) mysql_insert_id(mysql)
 	);

-	if (EQEmuLogSys::Instance()->log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
+	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
 		if ((strncasecmp(query, "select", 6) == 0)) {
 			LogMySQLQuery(
 				"{0} -- ({1} row{2} returned) ({3}s)",
@@ -4,6 +4,7 @@

 #include <string>
 #include "../types.h"
+#include "../http/httplib.h"
 #include "../repositories/player_event_logs_repository.h"
 #include "../events/player_events.h"

@@ -26,7 +26,7 @@ void DiscordManager::ProcessMessageQueue()
 			continue;
 		}

-		auto        webhook  = EQEmuLogSys::Instance()->GetDiscordWebhooks()[q.first];
+		auto        webhook  = LogSys.GetDiscordWebhooks()[q.first];
 		std::string message;

 		for (auto &m: q.second) {
@@ -68,7 +68,7 @@ void DiscordManager::ProcessMessageQueue()

 void DiscordManager::QueuePlayerEventMessage(const PlayerEvent::PlayerEventContainer& e)
 {
-	auto w = PlayerEventLogs::Instance()->GetDiscordWebhookUrlFromEventType(e.player_event_log.event_type_id);
+	auto w = player_event_logs.GetDiscordWebhookUrlFromEventType(e.player_event_log.event_type_id);
 	if (!w.empty()) {
 		Discord::SendPlayerEventMessage(e, w);
 	}
@@ -13,12 +13,6 @@ public:
 	void QueueWebhookMessage(uint32 webhook_id, const std::string& message);
 	void ProcessMessageQueue();
 	void QueuePlayerEventMessage(const PlayerEvent::PlayerEventContainer& e);
-
-	static DiscordManager* Instance()
-	{
-		static DiscordManager instance;
-		return &instance;
-	}
 private:
 	std::mutex webhook_queue_lock{};
 	std::map<uint32, std::vector<std::string>> webhook_message_queue{};
@@ -988,8 +988,7 @@ enum StartZoneIndex {
    Felwithe,
    Akanon,
    Cabilis,
-    SharVahl,
-    RatheMtn
+    SharVahl
 };

 enum FVNoDropFlagRule
@@ -545,13 +545,13 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 	uint32 chunksize, used;
 	uint32 length;

-	if (EQEmuLogSys::Instance()->log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
 			Log(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
 		}
 	}

-	if (EQEmuLogSys::Instance()->log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
 			Log(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
 		}
@@ -436,11 +436,11 @@ void EQEmuConfig::CheckUcsConfigConversion()
 		LogInfo("Migrating old [eqemu_config] UCS configuration to new configuration");

 		std::string config_file_path = std::filesystem::path{
-			PathManager::Instance()->GetServerPath() + "/eqemu_config.json"
+			path.GetServerPath() + "/eqemu_config.json"
 		}.string();

 		std::string config_file_bak_path = std::filesystem::path{
-			PathManager::Instance()->GetServerPath() + "/eqemu_config.ucs-migrate-json.bak"
+			path.GetServerPath() + "/eqemu_config.ucs-migrate-json.bak"
 		}.string();

 		// copy eqemu_config.json to eqemu_config.json.bak
@@ -191,7 +191,7 @@ class EQEmuConfig

 			std::string file = fmt::format(
 				"{}/{}",
-				(file_path.empty() ? PathManager::Instance()->GetServerPath() : file_path),
+				(file_path.empty() ? path.GetServerPath() : file_path),
 				EQEmuConfig::ConfigFile
 			);

@@ -224,22 +224,48 @@ void EQEmuLogSys::ProcessConsoleMessage(
 	const char *file,
 	const char *func,
 	int line
-) {
+)
+{
 	bool is_error   = (
 		log_category == Logs::LogCategory::Error ||
 		log_category == Logs::LogCategory::MySQLError ||
 		log_category == Logs::LogCategory::Crash ||
 		log_category == Logs::LogCategory::QuestErrors
 	);
-	bool is_warning = (log_category == Logs::LogCategory::Warning);
+	bool is_warning = (
+		log_category == Logs::LogCategory::Warning
+	);

-	std::ostream &out = (!is_error ? std::cout : std::cerr);
+	(!is_error ? std::cout : std::cerr)
+		<< ""
+		<< rang::fgB::black
+		<< rang::style::bold
+		<< fmt::format("{:>6}", GetPlatformName().substr(0, 6))
+		<< rang::style::reset
+		<< rang::fgB::gray
+		<< " | "
+		<< ((is_error || is_warning) ? rang::fgB::red : rang::fgB::gray)
+		<< rang::style::bold
+		<< fmt::format("{:^10}", fmt::format("{}", Logs::LogCategoryName[log_category]).substr(0, 10))
+		<< rang::style::reset
+		<< rang::fgB::gray
+		<< " | "
+		<< rang::fgB::gray
+		<< rang::style::bold
+		<< fmt::format("{}", func)
+		<< rang::style::reset
+		<< rang::fgB::gray
+		<< " ";

-	out
-		<< rang::style::bold << rang::fgB::gray << GetPlatformName() << " › "
-		<< rang::fgB::gray << Logs::LogCategoryName[log_category] << " › "
-		// << rang::fgB::gray << func << " › "
-		<< rang::style::reset;
+	if (RuleB(Logging, PrintFileFunctionAndLine)) {
+		(!is_error ? std::cout : std::cerr)
+			<< ""
+			<< rang::fgB::green
+			<< rang::style::bold
+			<< fmt::format("{:}", fmt::format("{}:{}:{}", std::filesystem::path(file).filename().string(), func, line))
+			<< rang::style::reset
+			<< " | ";
+	}

 	if (log_category == Logs::LogCategory::MySQLQuery) {
 		auto s = Strings::Split(message, "--");
@@ -247,84 +273,132 @@ void EQEmuLogSys::ProcessConsoleMessage(
 			std::string query = Strings::Trim(s[0]);
 			std::string meta  = Strings::Trim(s[1]);

-			out << rang::fgB::green << query << rang::style::reset;
-			out << rang::fgB::black << " -- " << meta << rang::style::reset;
+			std::cout <<
+					  rang::fgB::green
+					  <<
+					  query
+					  <<
+					  rang::style::reset;
+
+			std::cout <<
+					  rang::fgB::black
+					  <<
+					  " -- "
+					  <<
+					  meta
+					  <<
+					  rang::style::reset;
 		}
-	} else {
-		std::vector<std::string> tokens = Strings::Split(message, " ");
+	}
+	else if (Strings::Contains(message, "[")) {
+		for (auto &e: Strings::Split(message, " ")) {
+			if (Strings::Contains(e, "[") && Strings::Contains(e, "]")) {
+				e = Strings::Replace(e, "[", "");
+				e = Strings::Replace(e, "]", "");

-		for (auto &token : tokens) {
-			bool has_brackets = Strings::Contains(token, "[") && Strings::Contains(token, "]");
-			std::string clean_token = Strings::Replace(Strings::Replace(token, "[", ""), "]", "");
+				bool is_upper = false;

-			// Bracket formatting
-			if (has_brackets) {
-				static std::map<std::string, rang::fgB> color_tags = {
-					{"<black>", rang::fgB::black},
-					{"<green>", rang::fgB::green},
-					{"<yellow>", rang::fgB::yellow},
-					{"<blue>", rang::fgB::blue},
+				for (int i = 0; i < strlen(e.c_str()); i++) {
+					if (isupper(e[i])) {
+						is_upper = true;
+					}
+				}
+
+				// color matching in []
+				// ex: [<red>variable] would produce [variable] with red inside brackets
+				std::map<std::string, rang::fgB> colors = {
+					{"<black>",   rang::fgB::black},
+					{"<green>",   rang::fgB::green},
+					{"<yellow>",  rang::fgB::yellow},
+					{"<blue>",    rang::fgB::blue},
 					{"<magenta>", rang::fgB::magenta},
-					{"<cyan>", rang::fgB::cyan},
-					{"<gray>", rang::fgB::gray},
-					{"<red>", rang::fgB::red},
+					{"<cyan>",    rang::fgB::cyan},
+					{"<gray>",    rang::fgB::gray},
+					{"<red>",     rang::fgB::red},
 				};

-				static std::map<std::string, rang::fgB> keyword_matches = {
+				bool      match_color = false;
+				for (auto &c: colors) {
+					if (Strings::Contains(e, c.first)) {
+						e = Strings::Replace(e, c.first, "");
+						(!is_error ? std::cout : std::cerr)
+							<< rang::fgB::gray
+							<< "["
+							<< rang::style::bold
+							<< c.second
+							<< e
+							<< rang::style::reset
+							<< rang::fgB::gray
+							<< "] ";
+						match_color = true;
+					}
+				}
+
+				// string match to colors
+				std::map<std::string, rang::fgB> matches = {
 					{"missing", rang::fgB::red},
 					{"error",   rang::fgB::red},
 					{"ok",      rang::fgB::green},
 				};

-				bool matched = false;
-
-				for (auto &[tag, color] : color_tags) {
-					if (Strings::Contains(clean_token, tag)) {
-						clean_token = Strings::Replace(clean_token, tag, "");
-						out << rang::fgB::gray << "["
-							<< rang::style::bold << color << clean_token
-							<< rang::style::reset << rang::fgB::gray << "] ";
-						matched = true;
-						break;
+				for (auto &c: matches) {
+					if (Strings::Contains(e, c.first)) {
+						(!is_error ? std::cout : std::cerr)
+							<< rang::fgB::gray
+							<< "["
+							<< rang::style::bold
+							<< c.second
+							<< e
+							<< rang::style::reset
+							<< rang::fgB::gray
+							<< "] ";
+						match_color = true;
 					}
 				}

-				if (!matched) {
-					for (auto &[keyword, color] : keyword_matches) {
-						if (Strings::Contains(clean_token, keyword)) {
-							out << rang::fgB::gray << "["
-								<< rang::style::bold << color << clean_token
-								<< rang::style::reset << rang::fgB::gray << "] ";
-							matched = true;
-							break;
-						}
-					}
-				}
-
-				if (!matched) {
-					bool is_upper = std::any_of(clean_token.begin(), clean_token.end(), ::isupper);
+				// if we don't match a color in either the string matching or
+				// the color tag matching, we default to yellow inside brackets
+				// if uppercase, does not get colored
+				if (!match_color) {
 					if (!is_upper) {
-						out << rang::fgB::gray << "["
-							<< rang::style::bold << "\033[92m" << clean_token
-							<< rang::style::reset << rang::fgB::gray << "] ";
-					} else {
-						out << rang::fgB::gray << "[" << clean_token << "] ";
+						(!is_error ? std::cout : std::cerr)
+							<< rang::fgB::gray
+							<< "["
+							<< rang::style::bold
+							<< rang::fgB::yellow
+							<< e
+							<< rang::style::reset
+							<< rang::fgB::gray
+							<< "] ";
+					}
+					else {
+						(!is_error ? std::cout : std::cerr) << rang::fgB::gray << "[" << e << "] ";
 					}
 				}
-			} else {
-				out << (is_error ? rang::fgB::red : rang::fgB::gray) << token << " ";
+			}
+			else {
+				(!is_error ? std::cout : std::cerr)
+					<< (is_error ? rang::fgB::red : rang::fgB::gray)
+					<< e
+					<< " ";
 			}
 		}
 	}
-
-	// check if func is not empty
-	if (func && *func) {
-		out << rang::fgB::black << "#" << func << " ";
+	else {
+		(!is_error ? std::cout : std::cerr)
+			<< (is_error ? rang::fgB::red : rang::fgB::gray)
+			<< message
+			<< " ";
 	}

 	if (!origination_info.zone_short_name.empty()) {
-		out << rang::fgB::black << "-- "
-			<< fmt::format(
+		(!is_error ? std::cout : std::cerr)
+			<<
+			rang::fgB::black
+			<<
+			"-- "
+			<<
+			fmt::format(
 				"[{}] ({}) inst_id [{}]",
 				origination_info.zone_short_name,
 				origination_info.zone_long_name,
@@ -332,12 +406,11 @@ void EQEmuLogSys::ProcessConsoleMessage(
 			);
 	}

-	out << rang::style::reset << std::endl;
+	(!is_error ? std::cout : std::cerr) << rang::style::reset << std::endl;

 	m_on_log_console_hook(log_category, message);
 }

-
 /**
 * @param str
 * @return
@@ -464,9 +537,9 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 {
 	EQEmuLogSys::CloseFileLogs();

-	if (!File::Exists(PathManager::Instance()->GetLogPath())) {
-		LogInfo("Logs directory not found, creating [{}]", PathManager::Instance()->GetLogPath());
-		File::Makedir(PathManager::Instance()->GetLogPath());
+	if (!File::Exists(path.GetLogPath())) {
+		LogInfo("Logs directory not found, creating [{}]", path.GetLogPath());
+		File::Makedir(path.GetLogPath());
 	}

 	/**
@@ -583,7 +656,7 @@ EQEmuLogSys *EQEmuLogSys::LoadLogDatabaseSettings(bool silent_load)
 		// 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[c.log_category_id].log_to_file > 0) {
-			m_file_logs_enabled = true;
+			LogSys.m_file_logs_enabled = true;
 		}

 		db_categories.emplace_back(c.log_category_id);
@@ -266,6 +266,8 @@ namespace Logs {
 	};
 }

+#include "eqemu_logsys_log_aliases.h"
+
 class Database;

 constexpr uint16 MAX_DISCORD_WEBHOOK_ID = 300;
@@ -283,12 +285,6 @@ public:
 	EQEmuLogSys *LoadLogSettingsDefaults();
 	EQEmuLogSys *LoadLogDatabaseSettings(bool silent_load = false);

-	static EQEmuLogSys *Instance()
-	{
-		static EQEmuLogSys instance;
-		return &instance;
-	}
-
 	/**
 	 * @param directory_name
 	 */
@@ -354,7 +350,7 @@ public:
 	/**
 	 * Internally used memory reference for all log settings per category
 	 * These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults
-	 * Database loaded via EQEmuLogSys::Instance()->SetDatabase(&database)->LoadLogDatabaseSettings();
+	 * Database loaded via LogSys.SetDatabase(&database)->LoadLogDatabaseSettings();
 	*/
 	LogSettings log_settings[Logs::LogCategory::MaxCategoryID]{};

@@ -438,7 +434,7 @@ private:
 	void InjectTablesIfNotExist();
 };

-#include "eqemu_logsys_log_aliases.h"
+extern EQEmuLogSys LogSys;

 /**
 template<typename... Args>
@@ -460,7 +456,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
@@ -716,7 +716,7 @@ std::string PlayerEventDiscordFormatter::FormatNPCHandinEvent(
 			);

 			for (int i = 0; i < h.augment_ids.size(); i++) {
-				if (!h.augment_names[i].empty()) {
+				if (!Strings::EqualFold(h.augment_names[i], "None")) {
 					const uint8 slot_id = (i + 1);
 					handin_items_info += fmt::format(
 						"Augment {}: {} ({})\n",
@@ -741,7 +741,7 @@ std::string PlayerEventDiscordFormatter::FormatNPCHandinEvent(
 			);

 			for (int i = 0; i < r.augment_ids.size(); i++) {
-				if (!r.augment_names[i].empty()) {
+				if (!Strings::EqualFold(r.augment_names[i], "None")) {
 					const uint8 slot_id = (i + 1);
 					return_items_info += fmt::format(
 						"Augment {}: {} ({})\n",
@@ -195,12 +195,10 @@ void PlayerEventLogs::ProcessBatchQueue()
 	};

 	// Helper to assign ETL table ID
-
-	auto AssignEtlId = [&](
-		PlayerEventLogsRepository::PlayerEventLogs& r,
-		PlayerEvent::EventType                      type
-	)
-	{
+	auto                                                                                                          AssignEtlId      = [&](
+		PlayerEventLogsRepository::PlayerEventLogs &r,
+		PlayerEvent::EventType type
+	) {
 		if (m_etl_settings.contains(type)) {
 			r.etl_table_id = m_etl_settings.at(type).next_id++;
 		}
@@ -408,6 +406,7 @@ void PlayerEventLogs::ProcessBatchQueue()
 			auto it = event_processors.find(static_cast<PlayerEvent::EventType>(r.event_type_id));
 			if (it != event_processors.end()) {
 				it->second(r);  // Call the appropriate lambda
+				r.event_data = "{}"; // Clear event data
 			}
 			else {
 				LogPlayerEventsDetail("Non-Implemented ETL routing [{}]", r.event_type_id);
@@ -509,7 +508,7 @@ bool PlayerEventLogs::IsEventDiscordEnabled(int32_t event_type_id)
 	}

 	// ensure there is a matching webhook to begin with
-	if (!EQEmuLogSys::Instance()->GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url.empty()) {
+	if (!LogSys.GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url.empty()) {
 		return true;
 	}

@@ -529,27 +528,13 @@ std::string PlayerEventLogs::GetDiscordWebhookUrlFromEventType(int32_t event_typ
 	}

 	// ensure there is a matching webhook to begin with
-	if (!EQEmuLogSys::Instance()->GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url.empty()) {
-		return EQEmuLogSys::Instance()->GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url;
+	if (!LogSys.GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url.empty()) {
+		return LogSys.GetDiscordWebhooks()[m_settings[event_type_id].discord_webhook_id].webhook_url;
 	}

 	return "";
 }

-void PlayerEventLogs::LoadPlayerEventSettingsFromQS(
-	const std::vector<PlayerEventLogSettingsRepository::PlayerEventLogSettings> &settings
-)
-{
-	for (const auto &e : settings) {
-		if (e.id >= PlayerEvent::MAX || e.id < 0) {
-			continue;
-		}
-		m_settings[e.id] = e;
-	}
-
-	LogInfo("Applied [{}] player event log settings from QS", settings.size());
-}
-
 // GM_COMMAND           | [x] Implemented Formatter
 // ZONING               | [x] Implemented Formatter
 // AA_GAIN              | [x] Implemented Formatter
@@ -73,11 +73,9 @@ public:
 		return BuildPlayerEventPacket(c);
 	}

-	[[nodiscard]] const PlayerEventLogSettingsRepository::PlayerEventLogSettings * GetSettings() const;
-	bool                                                                           IsEventDiscordEnabled(int32_t event_type_id);
-	std::string                                                                    GetDiscordWebhookUrlFromEventType(int32_t event_type_id);
-
-	void LoadPlayerEventSettingsFromQS(const std::vector<PlayerEventLogSettingsRepository::PlayerEventLogSettings>& settings);
+	[[nodiscard]] const PlayerEventLogSettingsRepository::PlayerEventLogSettings *GetSettings() const;
+	bool IsEventDiscordEnabled(int32_t event_type_id);
+	std::string GetDiscordWebhookUrlFromEventType(int32_t event_type_id);

 	static std::string GetDiscordPayloadFromEvent(const PlayerEvent::PlayerEventContainer &e);

@@ -96,12 +94,6 @@ public:
 		std::vector<PlayerEventAaPurchaseRepository::PlayerEventAaPurchase>             aa_purchase;
 	};

-	static PlayerEventLogs* Instance()
-	{
-		static PlayerEventLogs instance;
-		return &instance;
-	}
-
 private:
 	struct EtlSettings {
 		bool        enabled;
@@ -135,4 +127,6 @@ public:
 	std::map<PlayerEvent::EventType, EtlSettings> &GetEtlSettings() { return m_etl_settings;}
 };

+extern PlayerEventLogs player_event_logs;
+
 #endif //EQEMU_PLAYER_EVENT_LOGS_H
@@ -21,8 +21,8 @@ void EvolvingItemsManager::LoadEvolvingItems() const
 		results.begin(),
 		results.end(),
 		std::inserter(
-			EvolvingItemsManager::Instance()->GetEvolvingItemsCache(),
-			EvolvingItemsManager::Instance()->GetEvolvingItemsCache().end()
+			evolving_items_manager.GetEvolvingItemsCache(),
+			evolving_items_manager.GetEvolvingItemsCache().end()
 		),
 		[](const ItemsEvolvingDetailsRepository::ItemsEvolvingDetails &x) {
 			return std::make_pair(x.item_id, x);
@@ -42,13 +42,13 @@ void EvolvingItemsManager::SetContentDatabase(Database *db)

 double EvolvingItemsManager::CalculateProgression(const uint64 current_amount, const uint32 item_id)
 {
-	if (!EvolvingItemsManager::Instance()->GetEvolvingItemsCache().contains(item_id)) {
+	if (!evolving_items_manager.GetEvolvingItemsCache().contains(item_id)) {
 		return 0;
 	}

-	return EvolvingItemsManager::Instance()->GetEvolvingItemsCache().at(item_id).required_amount > 0
+	return evolving_items_manager.GetEvolvingItemsCache().at(item_id).required_amount > 0
 		? static_cast<double>(current_amount)
-		  / static_cast<double>(EvolvingItemsManager::Instance()->GetEvolvingItemsCache().at(item_id).required_amount) * 100
+		  / static_cast<double>(evolving_items_manager.GetEvolvingItemsCache().at(item_id).required_amount) * 100
 		: 0;
 }

@@ -73,7 +73,7 @@ void EvolvingItemsManager::DoLootChecks(const uint32 char_id, const uint16 slot_
 		e.character_id  = char_id;
 		e.item_id       = inst.GetID();
 		e.equipped      = inst.GetEvolveEquipped();
-		e.final_item_id = EvolvingItemsManager::Instance()->GetFinalItemID(inst);
+		e.final_item_id = evolving_items_manager.GetFinalItemID(inst);

 		auto r = CharacterEvolvingItemsRepository::InsertOne(*m_db, e);
 		e.id   = r.id;
@@ -96,20 +96,20 @@ uint32 EvolvingItemsManager::GetFinalItemID(const EQ::ItemInstance &inst) const
 	}

 	const auto start_iterator = std::ranges::find_if(
-		EvolvingItemsManager::Instance()->GetEvolvingItemsCache().cbegin(),
-		EvolvingItemsManager::Instance()->GetEvolvingItemsCache().cend(),
+		evolving_items_manager.GetEvolvingItemsCache().cbegin(),
+		evolving_items_manager.GetEvolvingItemsCache().cend(),
 		[&](const std::pair<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> &a) {
 			return a.second.item_evo_id == inst.GetEvolveLoreID();
 		}
 	);

-	if (start_iterator == std::end(EvolvingItemsManager::Instance()->GetEvolvingItemsCache())) {
+	if (start_iterator == std::end(evolving_items_manager.GetEvolvingItemsCache())) {
 		return 0;
 	}

 	const auto final_id = std::ranges::max_element(
 		start_iterator,
-		EvolvingItemsManager::Instance()->GetEvolvingItemsCache().cend(),
+		evolving_items_manager.GetEvolvingItemsCache().cend(),
 		[&](
 		const std::pair<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> &a,
 		const std::pair<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> &b
@@ -131,15 +131,15 @@ uint32 EvolvingItemsManager::GetNextEvolveItemID(const EQ::ItemInstance &inst) c
 	int8 const current_level = inst.GetEvolveLvl();

 	const auto iterator = std::ranges::find_if(
-		EvolvingItemsManager::Instance()->GetEvolvingItemsCache().cbegin(),
-		EvolvingItemsManager::Instance()->GetEvolvingItemsCache().cend(),
+		evolving_items_manager.GetEvolvingItemsCache().cbegin(),
+		evolving_items_manager.GetEvolvingItemsCache().cend(),
 		[&](const std::pair<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> &a) {
 			return a.second.item_evo_id == inst.GetEvolveLoreID() &&
 			       a.second.item_evolve_level == current_level + 1;
 		}
 	);

-	if (iterator == std::end(EvolvingItemsManager::Instance()->GetEvolvingItemsCache())) {
+	if (iterator == std::end(evolving_items_manager.GetEvolvingItemsCache())) {
 		return 0;
 	}

@@ -255,8 +255,8 @@ EvolveTransfer EvolvingItemsManager::DetermineTransferResults(
 		return ets;
 	}

-	auto evolving_details_inst_from = EvolvingItemsManager::Instance()->GetEvolveItemDetails(inst_from.GetID());
-	auto evolving_details_inst_to   = EvolvingItemsManager::Instance()->GetEvolveItemDetails(inst_to.GetID());
+	auto evolving_details_inst_from = evolving_items_manager.GetEvolveItemDetails(inst_from.GetID());
+	auto evolving_details_inst_to   = evolving_items_manager.GetEvolveItemDetails(inst_to.GetID());

 	if (!evolving_details_inst_from.id || !evolving_details_inst_to.id) {
 		return ets;
@@ -272,10 +272,10 @@ EvolveTransfer EvolvingItemsManager::DetermineTransferResults(
 			compatibility = 30;
 		}

-		xp           = EvolvingItemsManager::Instance()->GetTotalEarnedXP(inst_from) * compatibility / 100;
-		auto results = EvolvingItemsManager::Instance()->GetNextItemByXP(inst_to, xp);
+		xp           = evolving_items_manager.GetTotalEarnedXP(inst_from) * compatibility / 100;
+		auto results = evolving_items_manager.GetNextItemByXP(inst_to, xp);

-		ets.item_from_id             = EvolvingItemsManager::Instance()->GetFirstItemInLoreGroup(inst_from.GetEvolveLoreID());
+		ets.item_from_id             = evolving_items_manager.GetFirstItemInLoreGroup(inst_from.GetEvolveLoreID());
 		ets.item_from_current_amount = results.from_current_amount;
 		ets.item_to_id               = results.new_item_id;
 		ets.item_to_current_amount   = results.new_current_amount;
@@ -56,15 +56,12 @@ public:
 	std::map<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails>& GetEvolvingItemsCache() { return m_evolving_items_cache; }
 	std::vector<ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> GetEvolveIDItems(uint32 evolve_id);

-	static EvolvingItemsManager* Instance()
-	{
-		static EvolvingItemsManager instance;
-		return &instance;
-	}
 private:
 	std::map<uint32, ItemsEvolvingDetailsRepository::ItemsEvolvingDetails> m_evolving_items_cache;
 	Database *                                                             m_db;
 	Database *                                                             m_content_db;
 };

+extern EvolvingItemsManager evolving_items_manager;
+
 #endif //EVOLVING_H
@@ -55,7 +55,7 @@ namespace EQ {
 			EQ_EXCEPT("IPC Mutex", "Could not create mutex.");
 		}
 #else
-		std::string final_name = fmt::format("{}/{}.lock", PathManager::Instance()->GetSharedMemoryPath(), name);
+		std::string final_name = fmt::format("{}/{}.lock", path.GetSharedMemoryPath(), name);

 #ifdef __DARWIN
 #if __DARWIN_C_LEVEL < 200809L
@@ -574,7 +574,7 @@ EQ::ItemInstance* EQ::ItemInstance::GetOrnamentationAugment() const
 uint32 EQ::ItemInstance::GetOrnamentHeroModel(int32 material_slot) const
 {
 	// Not a Hero Forge item.
-	if (m_ornament_hero_model == 0) {
+	if (m_ornament_hero_model == 0 || material_slot < 0) {
 		return 0;
 	}

@@ -1799,7 +1799,7 @@ std::vector<std::string> EQ::ItemInstance::GetAugmentNames() const

 	for (uint8 slot_id = invaug::SOCKET_BEGIN; slot_id <= invaug::SOCKET_END; slot_id++) {
 		const auto augment = GetAugment(slot_id);
-		augment_names.push_back(augment ? augment->GetItem()->Name : "");
+		augment_names.push_back(augment ? augment->GetItem()->Name : "None");
 	}

 	return augment_names;
@@ -335,7 +335,7 @@ namespace EQ
 		void             SetEvolveAddToCurrentAmount(const uint64 in) const { m_evolving_details.current_amount += in; }
 		void             SetEvolveFinalItemID(const uint32 in) const { m_evolving_details.final_item_id = in; }
 		bool             TransferOwnership(Database& db, const uint32 to_char_id) const;
-		void             CalculateEvolveProgression() const { m_evolving_details.progression = EvolvingItemsManager::Instance()->CalculateProgression(GetEvolveCurrentAmount(), GetID()); }
+		void             CalculateEvolveProgression() const { m_evolving_details.progression = evolving_items_manager.CalculateProgression(GetEvolveCurrentAmount(), GetID()); }

 	protected:
 		//////////////////////////
@@ -1167,7 +1167,7 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream)
 		}
 	}

-	if (EQEmuLogSys::Instance()->IsLogEnabled(Logs::General, Logs::NetClient)) {
+	if (LogSys.IsLogEnabled(Logs::General, Logs::NetClient)) {
 		size_t    total_size = 0;
 		for (auto &e: s->sent_packets) {
 			total_size += e.second.packet.Length();
@@ -71,7 +71,7 @@ void EQ::Net::EQStream::QueuePacket(const EQApplicationPacket *p, bool ack_req)
 		OpcodeManager::EmuToName(p->GetOpcode()),
 		(*m_opcode_manager)->EmuToEQ(p->GetOpcode()),
 		p->Size(),
-		(EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::PacketServerClient) ? DumpPacketToString(p) : "")
+		(LogSys.IsLogEnabled(Logs::Detail, Logs::PacketServerClient) ? DumpPacketToString(p) : "")
 	);

 	if (m_opcode_manager && *m_opcode_manager) {
@@ -319,7 +319,7 @@ void EQ::Net::ServertalkServerConnection::ProcessMessage(EQ::Net::Packet &p)
 			size_t message_len = length;
 			EQ::Net::StaticPacket packet(&data[0], message_len);

-			const auto is_detail_enabled = EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::PacketServerToServer);
+			const auto is_detail_enabled = LogSys.IsLogEnabled(Logs::Detail, Logs::PacketServerToServer);
 			if (opcode != ServerOP_KeepAlive || is_detail_enabled) {
 				LogPacketServerToServer(
 					"[{:#06x}] Size [{}] {}",
@@ -78,7 +78,7 @@ namespace RoF
 	{
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);

 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
@@ -117,7 +117,7 @@ namespace RoF
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -81,7 +81,7 @@ namespace RoF2
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {

-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);

 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
@@ -123,7 +123,7 @@ namespace RoF2
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -72,7 +72,7 @@ namespace SoD
 	{
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
@@ -113,7 +113,7 @@ namespace SoD
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -3966,12 +3966,12 @@ namespace SoD
 			SoDSlot = serverSlot - 2;
 		}

-		else if (serverSlot <= EQ::invbag::GENERAL_BAGS_END && serverSlot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-			SoDSlot = serverSlot - (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((serverSlot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));;
+		else if (serverSlot <= EQ::invbag::GENERAL_BAGS_8_END && serverSlot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
+			SoDSlot = serverSlot + 11;
 		}

 		else if (serverSlot <= EQ::invbag::CURSOR_BAG_END && serverSlot >= EQ::invbag::CURSOR_BAG_BEGIN) {
-			SoDSlot = serverSlot - (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			SoDSlot = serverSlot - 9;
 		}

 		else if (serverSlot <= EQ::invslot::TRIBUTE_END && serverSlot >= EQ::invslot::TRIBUTE_BEGIN) {
@@ -3991,7 +3991,7 @@ namespace SoD
 		}

 		else if (serverSlot <= EQ::invbag::BANK_BAGS_END && serverSlot >= EQ::invbag::BANK_BAGS_BEGIN) {
-			SoDSlot = serverSlot - (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((serverSlot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));;
+			SoDSlot = serverSlot + 1;
 		}

 		else if (serverSlot <= EQ::invslot::SHARED_BANK_END && serverSlot >= EQ::invslot::SHARED_BANK_BEGIN) {
@@ -3999,7 +3999,7 @@ namespace SoD
 		}

 		else if (serverSlot <= EQ::invbag::SHARED_BANK_BAGS_END && serverSlot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN) {
-			SoDSlot = serverSlot - (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((serverSlot - EQ::invbag::SHARED_BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			SoDSlot = serverSlot + 1;
 		}

 		else if (serverSlot <= EQ::invslot::TRADE_END && serverSlot >= EQ::invslot::TRADE_BEGIN) {
@@ -4007,7 +4007,7 @@ namespace SoD
 		}

 		else if (serverSlot <= EQ::invbag::TRADE_BAGS_END && serverSlot >= EQ::invbag::TRADE_BAGS_BEGIN) {
-			SoDSlot = serverSlot - (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((serverSlot - EQ::invbag::TRADE_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			SoDSlot = serverSlot;
 		}

 		else if (serverSlot <= EQ::invslot::WORLD_END && serverSlot >= EQ::invslot::WORLD_BEGIN) {
@@ -4049,11 +4049,11 @@ namespace SoD
 		}

 		else if (sod_slot <= invbag::GENERAL_BAGS_END && sod_slot >= invbag::GENERAL_BAGS_BEGIN) {
-			server_slot = sod_slot + (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sod_slot - invbag::GENERAL_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = sod_slot - 11;
 		}

 		else if (sod_slot <= invbag::CURSOR_BAG_END && sod_slot >= invbag::CURSOR_BAG_BEGIN) {
-			server_slot = sod_slot + (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			server_slot = sod_slot + 9;
 		}

 		else if (sod_slot <= invslot::TRIBUTE_END && sod_slot >= invslot::TRIBUTE_BEGIN) {
@@ -4073,7 +4073,7 @@ namespace SoD
 		}

 		else if (sod_slot <= invbag::BANK_BAGS_END && sod_slot >= invbag::BANK_BAGS_BEGIN) {
-			server_slot = sod_slot + (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sod_slot - invbag::BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = sod_slot - 1;
 		}

 		else if (sod_slot <= invslot::SHARED_BANK_END && sod_slot >= invslot::SHARED_BANK_BEGIN) {
@@ -4081,7 +4081,7 @@ namespace SoD
 		}

 		else if (sod_slot <= invbag::SHARED_BANK_BAGS_END && sod_slot >= invbag::SHARED_BANK_BAGS_BEGIN) {
-			server_slot = sod_slot + (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sod_slot - invbag::SHARED_BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = sod_slot - 1;
 		}

 		else if (sod_slot <= invslot::TRADE_END && sod_slot >= invslot::TRADE_BEGIN) {
@@ -4089,7 +4089,7 @@ namespace SoD
 		}

 		else if (sod_slot <= invbag::TRADE_BAGS_END && sod_slot >= invbag::TRADE_BAGS_BEGIN) {
-			server_slot = sod_slot + (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sod_slot - invbag::TRADE_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = sod_slot;
 		}

 		else if (sod_slot <= invslot::WORLD_END && sod_slot >= invslot::WORLD_BEGIN) {
@@ -71,7 +71,7 @@ namespace SoF
 	{
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
@@ -110,7 +110,7 @@ namespace SoF
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -3355,12 +3355,12 @@ namespace SoF
 			sof_slot = server_slot - 2;
 		}

-		else if (server_slot <= EQ::invbag::GENERAL_BAGS_END && server_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-			sof_slot = server_slot - (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));;
+		else if (server_slot <= EQ::invbag::GENERAL_BAGS_8_END && server_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
+			sof_slot = server_slot + 11;
 		}

 		else if (server_slot <= EQ::invbag::CURSOR_BAG_END && server_slot >= EQ::invbag::CURSOR_BAG_BEGIN) {
-			sof_slot = server_slot - (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			sof_slot = server_slot - 9;
 		}

 		else if (server_slot <= EQ::invslot::TRIBUTE_END && server_slot >= EQ::invslot::TRIBUTE_BEGIN) {
@@ -3380,7 +3380,7 @@ namespace SoF
 		}

 		else if (server_slot <= EQ::invbag::BANK_BAGS_END && server_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
-			sof_slot = server_slot - (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			sof_slot = server_slot + 1;
 		}

 		else if (server_slot <= EQ::invslot::SHARED_BANK_END && server_slot >= EQ::invslot::SHARED_BANK_BEGIN) {
@@ -3388,7 +3388,7 @@ namespace SoF
 		}

 		else if (server_slot <= EQ::invbag::SHARED_BANK_BAGS_END && server_slot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN) {
-			sof_slot = server_slot - (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::SHARED_BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			sof_slot = server_slot + 1;
 		}

 		else if (server_slot <= EQ::invslot::TRADE_END && server_slot >= EQ::invslot::TRADE_BEGIN) {
@@ -3396,7 +3396,7 @@ namespace SoF
 		}

 		else if (server_slot <= EQ::invbag::TRADE_BAGS_END && server_slot >= EQ::invbag::TRADE_BAGS_BEGIN) {
-			sof_slot = server_slot - (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::TRADE_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			sof_slot = server_slot;
 		}

 		else if (server_slot <= EQ::invslot::WORLD_END && server_slot >= EQ::invslot::WORLD_BEGIN) {
@@ -3442,11 +3442,11 @@ namespace SoF
 		}

 		else if (sof_slot <= invbag::GENERAL_BAGS_END && sof_slot >= invbag::GENERAL_BAGS_BEGIN) {
-			server_slot = sof_slot + (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sof_slot - invbag::GENERAL_BAGS_BEGIN) / invbag::SLOT_COUNT));;
+			server_slot = sof_slot - 11;
 		}

 		else if (sof_slot <= invbag::CURSOR_BAG_END && sof_slot >= invbag::CURSOR_BAG_BEGIN) {
-			server_slot = sof_slot + (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			server_slot = sof_slot + 9;
 		}

 		else if (sof_slot <= invslot::TRIBUTE_END && sof_slot >= invslot::TRIBUTE_BEGIN) {
@@ -3466,7 +3466,7 @@ namespace SoF
 		}

 		else if (sof_slot <= invbag::BANK_BAGS_END && sof_slot >= invbag::BANK_BAGS_BEGIN) {
-			server_slot = sof_slot + (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sof_slot - invbag::BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));;
+			server_slot = sof_slot - 1;
 		}

 		else if (sof_slot <= invslot::SHARED_BANK_END && sof_slot >= invslot::SHARED_BANK_BEGIN) {
@@ -3474,7 +3474,7 @@ namespace SoF
 		}

 		else if (sof_slot <= invbag::SHARED_BANK_BAGS_END && sof_slot >= invbag::SHARED_BANK_BAGS_BEGIN) {
-			server_slot = sof_slot + (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sof_slot - invbag::SHARED_BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));;
+			server_slot = sof_slot - 1;
 		}

 		else if (sof_slot <= invslot::TRADE_END && sof_slot >= invslot::TRADE_BEGIN) {
@@ -3482,7 +3482,7 @@ namespace SoF
 		}

 		else if (sof_slot <= invbag::TRADE_BAGS_END && sof_slot >= invbag::TRADE_BAGS_BEGIN) {
-			server_slot = sof_slot + (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((sof_slot - invbag::TRADE_BAGS_BEGIN) / invbag::SLOT_COUNT));;
+			server_slot = sof_slot;
 		}

 		else if (sof_slot <= invslot::WORLD_END && sof_slot >= invslot::WORLD_BEGIN) {
@@ -73,7 +73,7 @@ namespace Titanium
 		auto Config = EQEmuConfig::get();
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
@@ -114,7 +114,7 @@ namespace Titanium
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -3596,12 +3596,12 @@ namespace Titanium
 		else if (server_slot == (EQ::invslot::POSSESSIONS_COUNT + EQ::invslot::slotAmmo)) {
 			titanium_slot = server_slot - 4;
 		}
-		else if (server_slot <= EQ::invbag::GENERAL_BAGS_END &&
+		else if (server_slot <= EQ::invbag::GENERAL_BAGS_8_END &&
 				 server_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-			titanium_slot = server_slot - (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invbag::CURSOR_BAG_END && server_slot >= EQ::invbag::CURSOR_BAG_BEGIN) {
-			titanium_slot = server_slot - (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			titanium_slot = server_slot - 20;
 		}
 		else if (server_slot <= EQ::invslot::TRIBUTE_END && server_slot >= EQ::invslot::TRIBUTE_BEGIN) {
 			titanium_slot = server_slot;
@@ -3616,21 +3616,21 @@ namespace Titanium
 		else if (server_slot <= EQ::invslot::BANK_END && server_slot >= EQ::invslot::BANK_BEGIN) {
 			titanium_slot = server_slot;
 		}
-		else if (server_slot <= EQ::invbag::BANK_BAGS_END && server_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
-			titanium_slot = server_slot - (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+		else if (server_slot <= EQ::invbag::BANK_BAGS_16_END && server_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
+			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invslot::SHARED_BANK_END && server_slot >= EQ::invslot::SHARED_BANK_BEGIN) {
 			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invbag::SHARED_BANK_BAGS_END &&
 				 server_slot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN) {
-			titanium_slot = server_slot - (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::SHARED_BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invslot::TRADE_END && server_slot >= EQ::invslot::TRADE_BEGIN) {
 			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invbag::TRADE_BAGS_END && server_slot >= EQ::invbag::TRADE_BAGS_BEGIN) {
-			titanium_slot = server_slot - (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) - ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((server_slot - EQ::invbag::TRADE_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT));
+			titanium_slot = server_slot;
 		}
 		else if (server_slot <= EQ::invslot::WORLD_END && server_slot >= EQ::invslot::WORLD_BEGIN) {
 			titanium_slot = server_slot;
@@ -3687,10 +3687,10 @@ namespace Titanium
 			server_slot = titanium_slot + 4;
 		}
 		else if (titanium_slot <= invbag::GENERAL_BAGS_END && titanium_slot >= invbag::GENERAL_BAGS_BEGIN) {
-			server_slot = titanium_slot + (EQ::invbag::GENERAL_BAGS_BEGIN - invbag::GENERAL_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((titanium_slot - invbag::GENERAL_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invbag::CURSOR_BAG_END && titanium_slot >= invbag::CURSOR_BAG_BEGIN) {
-			server_slot = titanium_slot + (EQ::invbag::CURSOR_BAG_BEGIN - invbag::CURSOR_BAG_BEGIN);
+			server_slot = titanium_slot + 20;
 		}
 		else if (titanium_slot <= invslot::TRIBUTE_END && titanium_slot >= invslot::TRIBUTE_BEGIN) {
 			server_slot = titanium_slot;
@@ -3705,19 +3705,19 @@ namespace Titanium
 			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invbag::BANK_BAGS_END && titanium_slot >= invbag::BANK_BAGS_BEGIN) {
-			server_slot = titanium_slot + (EQ::invbag::BANK_BAGS_BEGIN - invbag::BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((titanium_slot - invbag::BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invslot::SHARED_BANK_END && titanium_slot >= invslot::SHARED_BANK_BEGIN) {
 			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invbag::SHARED_BANK_BAGS_END && titanium_slot >= invbag::SHARED_BANK_BAGS_BEGIN) {
-			server_slot = titanium_slot + (EQ::invbag::SHARED_BANK_BAGS_BEGIN - invbag::SHARED_BANK_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((titanium_slot - invbag::SHARED_BANK_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invslot::TRADE_END && titanium_slot >= invslot::TRADE_BEGIN) {
 			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invbag::TRADE_BAGS_END && titanium_slot >= invbag::TRADE_BAGS_BEGIN) {
-			server_slot = titanium_slot + (EQ::invbag::TRADE_BAGS_BEGIN - invbag::TRADE_BAGS_BEGIN) + ((EQ::invbag::SLOT_COUNT - invbag::SLOT_COUNT) * ((titanium_slot - invbag::TRADE_BAGS_BEGIN) / invbag::SLOT_COUNT));
+			server_slot = titanium_slot;
 		}
 		else if (titanium_slot <= invslot::WORLD_END && titanium_slot >= invslot::WORLD_BEGIN) {
 			server_slot = titanium_slot;
@@ -76,7 +76,7 @@ namespace UF
 	{
 		//create our opcode manager if we havent already
 		if (opcodes == nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			//load up the opcode manager.
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
@@ -117,7 +117,7 @@ namespace UF
 		//we need to go to every stream and replace it's manager.

 		if (opcodes != nullptr) {
-			std::string opfile = fmt::format("{}/patch_{}.conf", PathManager::Instance()->GetPatchPath(), name);
+			std::string opfile = fmt::format("{}/patch_{}.conf", path.GetPatchPath(), name);
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
 				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
@@ -8,7 +8,7 @@

 namespace fs = std::filesystem;

-void PathManager::Init()
+void PathManager::LoadPaths()
 {
 	m_server_path = File::FindEqemuConfigPath();

@@ -87,16 +87,16 @@ void PathManager::Init()
 	constexpr int break_length = 70;

 	LogInfo("Loading server paths");
-	LogInfoNoFn("{}", Strings::Repeat("-", break_length));
+	LogInfo("{}", Strings::Repeat("-", break_length));
 	for (const auto& [name, in_path] : paths) {
 		if (!in_path.empty()) {
-			LogInfoNoFn("{:>{}} > {:<{}}", name, name_width, in_path, path_width);
+			LogInfo("{:>{}} > [{:<{}}]", name, name_width, in_path, path_width);
 		}
 	}

 	auto log_paths = [&](const std::string& label, const std::vector<std::string>& paths) {
 		if (!paths.empty()) {
-			LogInfoNoFn("{:>{}} > {:<{}}", label, name_width, Strings::Join(paths, ";"), path_width);
+			LogInfo("{:>{}} > [{:<{}}]", label, name_width - 1, Strings::Join(paths, ";"), path_width);
 		}
 	};

@@ -104,7 +104,7 @@ void PathManager::Init()
 	log_paths("plugins", m_plugin_paths);
 	log_paths("lua_modules", m_lua_module_paths);

-	LogInfoNoFn("{}", Strings::Repeat("-", break_length));
+	LogInfo("{}", Strings::Repeat("-", break_length));
 }

 const std::string &PathManager::GetServerPath() const
@@ -7,13 +7,7 @@

 class PathManager {
 public:
-	void Init();
-
-	static PathManager *Instance()
-	{
-		static PathManager instance;
-		return &instance;
-	}
+	void LoadPaths();

 	[[nodiscard]] const std::string &GetLogPath() const;
 	[[nodiscard]] const std::string &GetLuaModsPath() const;
@@ -44,4 +38,6 @@ private:
 	std::string              m_shared_memory_path;
 };

+extern PathManager path;
+
 #endif //EQEMU_PATH_MANAGER_H
@@ -1,9 +0,0 @@
-#pragma once
-
-#include "../types.h"
-#include "../database.h"
-#include "../strings.h"
-#include "../eqemu_logsys.h"
-#include "../eqemu_logsys_log_aliases.h"
-#include "../features.h"
-#include "../global_define.h"
@@ -0,0 +1,34 @@
+// types
+#include <limits>
+#include <string>
+#include <cctype>
+#include <sstream>
+
+// containers
+#include <iterator>
+#include <set>
+#include <unordered_set>
+#include <map>
+#include <unordered_map>
+#include <list>
+#include <vector>
+
+// utilities
+#include <iostream>
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <functional>
+#include <algorithm>
+#include <utility>
+#include <tuple>
+#include <fstream>
+#include <cstdio>
+
+// fmt
+#include <fmt/format.h>
+
+// lua
+#include "lua.hpp"
+#include <luabind/luabind.hpp>
+#include <luabind/object.hpp>
@@ -1,14 +0,0 @@
-#pragma once
-
-// Lightweight, widely used
-#include <string>
-#include <vector>
-#include <map>
-#include <unordered_map>
-#include <memory>
-#include <limits>
-#include <cstdint>
-#include <cassert>
-
-// fmt
-#include <fmt/format.h>
@@ -1,7 +1,6 @@
 #include <string>
 #include <memory>
 #include "process.h"
-#include <fmt/format.h>

 std::string Process::execute(const std::string &cmd)
 {
@@ -116,12 +116,6 @@ namespace EQ {
 			Reseed();
 		}

-		static Random* Instance()
-		{
-			static Random instance;
-			return &instance;
-		}
-
 	private:
 #ifndef BIASED_INT_DIST
 		typedef std::uniform_int_distribution<int>::param_type int_param_t;
@@ -70,7 +70,6 @@ public:
 		uint32_t    gm_exp;
 		uint32_t    killed_by;
 		uint8_t     rezzable;
-		std::string entity_variables;
 	};

 	static std::string PrimaryKey()
@@ -132,7 +131,6 @@ public:
 			"gm_exp",
 			"killed_by",
 			"rezzable",
-			"entity_variables",
 		};
 	}

@@ -190,7 +188,6 @@ public:
 			"gm_exp",
 			"killed_by",
 			"rezzable",
-			"entity_variables",
 		};
 	}

@@ -282,7 +279,6 @@ public:
 		e.gm_exp           = 0;
 		e.killed_by        = 0;
 		e.rezzable         = 0;
-		e.entity_variables = "";

 		return e;
 	}
@@ -370,7 +366,6 @@ public:
 			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
 			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
 			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;
-			e.entity_variables = row[51] ? row[51] : "";

 			return e;
 		}
@@ -454,7 +449,6 @@ public:
 		v.push_back(columns[48] + " = " + std::to_string(e.gm_exp));
 		v.push_back(columns[49] + " = " + std::to_string(e.killed_by));
 		v.push_back(columns[50] + " = " + std::to_string(e.rezzable));
-		v.push_back(columns[51] + " = '" + Strings::Escape(e.entity_variables) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -527,7 +521,6 @@ public:
 		v.push_back(std::to_string(e.gm_exp));
 		v.push_back(std::to_string(e.killed_by));
 		v.push_back(std::to_string(e.rezzable));
-		v.push_back("'" + Strings::Escape(e.entity_variables) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -608,7 +601,6 @@ public:
 			v.push_back(std::to_string(e.gm_exp));
 			v.push_back(std::to_string(e.killed_by));
 			v.push_back(std::to_string(e.rezzable));
-			v.push_back("'" + Strings::Escape(e.entity_variables) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -693,7 +685,6 @@ public:
 			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
 			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
 			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;
-			e.entity_variables = row[51] ? row[51] : "";

 			all_entries.push_back(e);
 		}
@@ -769,7 +760,6 @@ public:
 			e.gm_exp           = row[48] ? static_cast<uint32_t>(strtoul(row[48], nullptr, 10)) : 0;
 			e.killed_by        = row[49] ? static_cast<uint32_t>(strtoul(row[49], nullptr, 10)) : 0;
 			e.rezzable         = row[50] ? static_cast<uint8_t>(strtoul(row[50], nullptr, 10)) : 0;
-			e.entity_variables = row[51] ? row[51] : "";

 			all_entries.push_back(e);
 		}
@@ -895,7 +885,6 @@ public:
 		v.push_back(std::to_string(e.gm_exp));
 		v.push_back(std::to_string(e.killed_by));
 		v.push_back(std::to_string(e.rezzable));
-		v.push_back("'" + Strings::Escape(e.entity_variables) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -969,7 +958,6 @@ public:
 			v.push_back(std::to_string(e.gm_exp));
 			v.push_back(std::to_string(e.killed_by));
 			v.push_back(std::to_string(e.rezzable));
-			v.push_back("'" + Strings::Escape(e.entity_variables) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -15,7 +15,7 @@
 #include "../../database.h"
 #include "../../strings.h"
 #include <ctime>
-#include <cereal/cereal.hpp>
+
 class BasePlayerEventLogSettingsRepository {
 public:
 	struct PlayerEventLogSettings {
@@ -25,20 +25,6 @@ public:
 		int32_t     retention_days;
 		int32_t     discord_webhook_id;
 		uint8_t     etl_enabled;
-
-		// cereal
-		template<class Archive>
-		void serialize(Archive &ar)
-		{
-			ar(
-				CEREAL_NVP(id),
-				CEREAL_NVP(event_name),
-				CEREAL_NVP(event_enabled),
-				CEREAL_NVP(retention_days),
-				CEREAL_NVP(discord_webhook_id),
-				CEREAL_NVP(etl_enabled)
-			);
-		}
 	};

 	static std::string PrimaryKey()
@@ -19,15 +19,8 @@
 class BaseRuleSetsRepository {
 public:
 	struct RuleSets {
-		int32_t     ruleset_id;
+		uint8_t     ruleset_id;
 		std::string name;
-		std::string zone_ids;
-		std::string instance_versions;
-		std::string content_flags;
-		std::string content_flags_disabled;
-		int8_t      min_expansion;
-		int8_t      max_expansion;
-		std::string notes;
 	};

 	static std::string PrimaryKey()
@@ -40,13 +33,6 @@ public:
 		return {
 			"ruleset_id",
 			"name",
-			"zone_ids",
-			"instance_versions",
-			"content_flags",
-			"content_flags_disabled",
-			"min_expansion",
-			"max_expansion",
-			"notes",
 		};
 	}

@@ -55,13 +41,6 @@ public:
 		return {
 			"ruleset_id",
 			"name",
-			"zone_ids",
-			"instance_versions",
-			"content_flags",
-			"content_flags_disabled",
-			"min_expansion",
-			"max_expansion",
-			"notes",
 		};
 	}

@@ -102,15 +81,8 @@ public:
 	{
 		RuleSets e{};

-		e.ruleset_id             = 0;
-		e.name                   = "";
-		e.zone_ids               = "";
-		e.instance_versions      = "";
-		e.content_flags          = "";
-		e.content_flags_disabled = "";
-		e.min_expansion          = -2;
-		e.max_expansion          = -2;
-		e.notes                  = "";
+		e.ruleset_id = 0;
+		e.name       = "";

 		return e;
 	}
@@ -147,15 +119,8 @@ public:
 		if (results.RowCount() == 1) {
 			RuleSets e{};

-			e.ruleset_id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
-			e.name                   = row[1] ? row[1] : "";
-			e.zone_ids               = row[2] ? row[2] : "";
-			e.instance_versions      = row[3] ? row[3] : "";
-			e.content_flags          = row[4] ? row[4] : "";
-			e.content_flags_disabled = row[5] ? row[5] : "";
-			e.min_expansion          = row[6] ? static_cast<int8_t>(atoi(row[6])) : -2;
-			e.max_expansion          = row[7] ? static_cast<int8_t>(atoi(row[7])) : -2;
-			e.notes                  = row[8] ? row[8] : "";
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name       = row[1] ? row[1] : "";

 			return e;
 		}
@@ -190,13 +155,6 @@ public:
 		auto columns = Columns();

 		v.push_back(columns[1] + " = '" + Strings::Escape(e.name) + "'");
-		v.push_back(columns[2] + " = '" + Strings::Escape(e.zone_ids) + "'");
-		v.push_back(columns[3] + " = '" + Strings::Escape(e.instance_versions) + "'");
-		v.push_back(columns[4] + " = '" + Strings::Escape(e.content_flags) + "'");
-		v.push_back(columns[5] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");
-		v.push_back(columns[6] + " = " + std::to_string(e.min_expansion));
-		v.push_back(columns[7] + " = " + std::to_string(e.max_expansion));
-		v.push_back(columns[8] + " = '" + Strings::Escape(e.notes) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -220,13 +178,6 @@ public:

 		v.push_back(std::to_string(e.ruleset_id));
 		v.push_back("'" + Strings::Escape(e.name) + "'");
-		v.push_back("'" + Strings::Escape(e.zone_ids) + "'");
-		v.push_back("'" + Strings::Escape(e.instance_versions) + "'");
-		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
-		v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
-		v.push_back(std::to_string(e.min_expansion));
-		v.push_back(std::to_string(e.max_expansion));
-		v.push_back("'" + Strings::Escape(e.notes) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -258,13 +209,6 @@ public:

 			v.push_back(std::to_string(e.ruleset_id));
 			v.push_back("'" + Strings::Escape(e.name) + "'");
-			v.push_back("'" + Strings::Escape(e.zone_ids) + "'");
-			v.push_back("'" + Strings::Escape(e.instance_versions) + "'");
-			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
-			v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
-			v.push_back(std::to_string(e.min_expansion));
-			v.push_back(std::to_string(e.max_expansion));
-			v.push_back("'" + Strings::Escape(e.notes) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -298,15 +242,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RuleSets e{};

-			e.ruleset_id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
-			e.name                   = row[1] ? row[1] : "";
-			e.zone_ids               = row[2] ? row[2] : "";
-			e.instance_versions      = row[3] ? row[3] : "";
-			e.content_flags          = row[4] ? row[4] : "";
-			e.content_flags_disabled = row[5] ? row[5] : "";
-			e.min_expansion          = row[6] ? static_cast<int8_t>(atoi(row[6])) : -2;
-			e.max_expansion          = row[7] ? static_cast<int8_t>(atoi(row[7])) : -2;
-			e.notes                  = row[8] ? row[8] : "";
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name       = row[1] ? row[1] : "";

 			all_entries.push_back(e);
 		}
@@ -331,15 +268,8 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RuleSets e{};

-			e.ruleset_id             = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
-			e.name                   = row[1] ? row[1] : "";
-			e.zone_ids               = row[2] ? row[2] : "";
-			e.instance_versions      = row[3] ? row[3] : "";
-			e.content_flags          = row[4] ? row[4] : "";
-			e.content_flags_disabled = row[5] ? row[5] : "";
-			e.min_expansion          = row[6] ? static_cast<int8_t>(atoi(row[6])) : -2;
-			e.max_expansion          = row[7] ? static_cast<int8_t>(atoi(row[7])) : -2;
-			e.notes                  = row[8] ? row[8] : "";
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
+			e.name       = row[1] ? row[1] : "";

 			all_entries.push_back(e);
 		}
@@ -416,13 +346,6 @@ public:

 		v.push_back(std::to_string(e.ruleset_id));
 		v.push_back("'" + Strings::Escape(e.name) + "'");
-		v.push_back("'" + Strings::Escape(e.zone_ids) + "'");
-		v.push_back("'" + Strings::Escape(e.instance_versions) + "'");
-		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
-		v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
-		v.push_back(std::to_string(e.min_expansion));
-		v.push_back(std::to_string(e.max_expansion));
-		v.push_back("'" + Strings::Escape(e.notes) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -447,13 +370,6 @@ public:

 			v.push_back(std::to_string(e.ruleset_id));
 			v.push_back("'" + Strings::Escape(e.name) + "'");
-			v.push_back("'" + Strings::Escape(e.zone_ids) + "'");
-			v.push_back("'" + Strings::Escape(e.instance_versions) + "'");
-			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
-			v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
-			v.push_back(std::to_string(e.min_expansion));
-			v.push_back(std::to_string(e.max_expansion));
-			v.push_back("'" + Strings::Escape(e.notes) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -19,7 +19,7 @@
 class BaseRuleValuesRepository {
 public:
 	struct RuleValues {
-		int32_t     ruleset_id;
+		uint8_t     ruleset_id;
 		std::string rule_name;
 		std::string rule_value;
 		std::string notes;
@@ -127,7 +127,7 @@ public:
 		if (results.RowCount() == 1) {
 			RuleValues e{};

-			e.ruleset_id = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.rule_name  = row[1] ? row[1] : "";
 			e.rule_value = row[2] ? row[2] : "";
 			e.notes      = row[3] ? row[3] : "";
@@ -259,7 +259,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RuleValues e{};

-			e.ruleset_id = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.rule_name  = row[1] ? row[1] : "";
 			e.rule_value = row[2] ? row[2] : "";
 			e.notes      = row[3] ? row[3] : "";
@@ -287,7 +287,7 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RuleValues e{};

-			e.ruleset_id = row[0] ? static_cast<int32_t>(atoi(row[0])) : 0;
+			e.ruleset_id = row[0] ? static_cast<uint8_t>(strtoul(row[0], nullptr, 10)) : 0;
 			e.rule_name  = row[1] ? row[1] : "";
 			e.rule_value = row[2] ? row[2] : "";
 			e.notes      = row[3] ? row[3] : "";
@@ -231,21 +231,6 @@ public:

 		return UpdateOne(db, corpse);
 	}
-
-	static int UpdateEntityVariables(Database& db, uint32 corpse_id, const std::string& json_string)
-	{
-		auto results = db.QueryDatabase(
-			fmt::format(
-				"UPDATE `{}` SET `entity_variables` = '{}' WHERE `{}` = {}",
-				TableName(),
-				Strings::Escape(json_string),
-				PrimaryKey(),
-				corpse_id
-			)
-		);
-
-		return results.Success() ? results.RowsAffected() : 0;
-	}
 };

 #endif //EQEMU_CHARACTER_CORPSES_REPOSITORY_H
@@ -167,30 +167,6 @@ public:

 		return zone_player_counts;
 	}
-
-	static std::vector<uint32_t> GetCharacterIDsByAccountID(
-		Database& db,
-		uint32_t  account_id
-	)
-	{
-		std::vector<uint32_t> character_ids;
-
-		auto query = fmt::format(
-			"SELECT id FROM character_data WHERE account_id = {} AND deleted_at IS NULL",
-			account_id
-		);
-
-		auto results = db.QueryDatabase(query);
-		if (results.Success()) {
-			for (auto row : results) {
-				if (row[0]) {
-					character_ids.push_back(static_cast<uint32_t>(std::stoul(row[0])));
-				}
-			}
-		}
-
-		return character_ids;
-	}
 };

 #endif //EQEMU_CHARACTER_DATA_REPOSITORY_H
@@ -14,7 +14,7 @@ namespace ContentFilterCriteria {
 			table_prefix = table_prefix + ".";
 		}

-		int current_expansion_filter_criteria = WorldContentService::Instance()->GetCurrentExpansion();
+		int current_expansion_filter_criteria = content_service.GetCurrentExpansion();
 		if (current_expansion_filter_criteria == Expansion::EXPANSION_ALL) {
 			current_expansion_filter_criteria = Expansion::EXPANSION_FILTER_MAX;
 		}
@@ -33,8 +33,8 @@ namespace ContentFilterCriteria {
 			table_prefix
 		);

-		std::vector<std::string> flags_disabled = WorldContentService::Instance()->GetContentFlagsDisabled();
-		std::vector<std::string> flags_enabled  = WorldContentService::Instance()->GetContentFlagsEnabled();
+		std::vector<std::string> flags_disabled = content_service.GetContentFlagsDisabled();
+		std::vector<std::string> flags_enabled  = content_service.GetContentFlagsEnabled();
 		std::string              flags_in_filter_enabled;
 		std::string              flags_in_filter_disabled;
 		if (!flags_enabled.empty()) {
@@ -43,47 +43,6 @@ public:
     * method and encapsulate filters there
     */

-	template<typename T1, typename T2, typename T3, typename T4>
-	static std::vector<std::string> join_tuple(
-		const std::string &glue,
-		const std::pair<char, char> &encapsulation,
-		const std::vector<std::tuple<T1, T2, T3, T4>> &src
-	)
-	{
-		if (src.empty()) {
-			return {};
-		}
-
-		std::vector<std::string> output;
-
-		for (const std::tuple<T1, T2, T3, T4> &src_iter: src) {
-
-			output.emplace_back(
-
-				fmt::format(
-					"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
-					encapsulation.first,
-					std::get<0>(src_iter),
-					encapsulation.second,
-					glue,
-					encapsulation.first,
-					std::get<1>(src_iter),
-					encapsulation.second,
-					glue,
-					encapsulation.first,
-					std::get<2>(src_iter),
-					encapsulation.second,
-					glue,
-					encapsulation.first,
-					std::get<3>(src_iter),
-					encapsulation.second
-				)
-			);
-		}
-
-		return output;
-	}
-
 	// Custom extended repository methods here
 	static std::vector<std::string> GetRuleNames(Database &db, int rule_set_id)
 	{
@@ -128,28 +87,12 @@ public:
 		return v;
 	}

-	template<typename T>
-	static std::string
-	ImplodePair(const std::string &glue, const std::pair<char, char> &encapsulation, const std::vector<T> &src)
-	{
-		if (src.empty()) {
-			return {};
-		}
-		std::ostringstream oss;
-		for (const T &src_iter: src) {
-			oss << encapsulation.first << src_iter << encapsulation.second << glue;
-		}
-		std::string output(oss.str());
-		output.resize(output.size() - glue.size());
-		return output;
-	}
-
 	static bool DeleteOrphanedRules(Database& db, std::vector<std::string>& v)
 	{
 		const auto query = fmt::format(
 			"DELETE FROM {} WHERE rule_name IN ({})",
 			TableName(),
-			ImplodePair(",", std::pair<char, char>('\'', '\''), v)
+			Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), v)
 		);

 		return db.QueryDatabase(query).Success();
@@ -160,7 +103,7 @@ public:
 		const auto query = fmt::format(
 			"REPLACE INTO {} (`ruleset_id`, `rule_name`, `rule_value`, `notes`) VALUES {}",
 			TableName(),
-			ImplodePair(
+			Strings::ImplodePair(
 				",",
 				std::pair<char, char>('(', ')'),
 				join_tuple(",", std::pair<char, char>('\'', '\''), v)
@@ -26,7 +26,6 @@

 #include "../common/repositories/rule_sets_repository.h"
 #include "../common/repositories/rule_values_repository.h"
-#include "../common/content/world_content_service.h"

 const char *RuleManager::s_categoryNames[_CatCount + 1] = {
 	#define RULE_CATEGORY(category_name) \
@@ -269,6 +268,7 @@ bool RuleManager::LoadRules(Database *db, const std::string &rule_set_name, bool

 	const std::string default_ruleset_name = "default";
 	bool is_default = rule_set_name == default_ruleset_name;
+
 	if (!is_default) {
 		const auto default_rule_set_id = RuleSetsRepository::GetRuleSetID(*db, default_ruleset_name);

@@ -327,10 +327,6 @@ bool RuleManager::LoadRules(Database *db, const std::string &rule_set_name, bool
 		rule_set_id
 	);

-	if (m_post_load_callback) {
-		m_post_load_callback();
-	}
-
 	return true;
 }

@@ -666,15 +662,3 @@ std::string RuleManager::GetStringRule(RuleManager::StringType t) const
 {
 	return m_RuleStringValues[t];
 }
-
-std::string RuleManager::GetRuleNotesByName(std::string rule_name) const
-{
-	for (const auto &r : s_RuleInfo) {
-		if (Strings::EqualFold(r.name, rule_name)) {
-			return r.notes;
-		}
-	}
-
-	LogRulesDetail("Unable to find rule notes for '{}'.", rule_name);
-	return "";
-}
@@ -40,7 +40,6 @@
    RuleManager::Instance()->GetStringRule( RuleManager::String__##rule_name )


-#include <functional>
 #include <vector>
 #include <string>
 #include <map>
@@ -120,9 +119,9 @@ public:
 	static const uint32 RulesCount = IntRuleCount + RealRuleCount + BoolRuleCount + StringRuleCount;

 	//fetch routines, you should generally use the Rule* macros instead of this
-	int         GetIntRule(IntType t) const;
-	float       GetRealRule(RealType t) const;
-	bool        GetBoolRule(BoolType t) const;
+	int GetIntRule(IntType t) const;
+	float GetRealRule(RealType t) const;
+	bool GetBoolRule(BoolType t) const;
 	std::string GetStringRule(StringType t) const;

 	//management routines
@@ -134,8 +133,6 @@ public:
 	static const std::string& GetRuleNotes(RealType t) { return s_RuleInfo[static_cast<int>(t) + IntRuleCount].notes; }
 	static const std::string& GetRuleNotes(BoolType t) { return s_RuleInfo[static_cast<int>(t) + IntRuleCount + RealRuleCount].notes; }
 	static const std::string& GetRuleNotes(StringType t) { return s_RuleInfo[static_cast<int>(t) + IntRuleCount + RealRuleCount + StringRuleCount].notes; }
-	std::string GetRuleNotesByName(std::string rule_name) const;
-
 	static uint32 CountRules() { return RulesCount; }
 	static CategoryType FindCategory(const std::string& category_name);
 	bool ListRules(const std::string& category_name, std::vector<std::string>& l);
@@ -159,9 +156,6 @@ public:
 	bool UpdateInjectedRules(Database* db, const std::string& rule_set_name, bool quiet_update = false);
 	bool UpdateOrphanedRules(Database* db, bool quiet_update = false);
 	bool RestoreRuleNotes(Database* db);
-	void SetPostLoadCallback(std::function<void()> cb) {
-		m_post_load_callback = std::move(cb);
-	}

 private:
 	RuleManager();
@@ -176,8 +170,6 @@ private:
 	uint32      m_RuleBoolValues[BoolRuleCount];
 	std::string m_RuleStringValues[StringRuleCount];

-	std::function<void()> m_post_load_callback;
-
 	typedef enum {
 		IntRule,
 		RealRule,
@@ -233,7 +233,7 @@ RULE_BOOL(Character, SneakAlwaysSucceedOver100, false, "When sneak skill is over
 RULE_INT(Character, BandolierSwapDelay, 0, "Bandolier swap delay in milliseconds, default is 0")
 RULE_BOOL(Character, EnableHackedFastCampForGM, false, "Enables hacked fast camp for GM clients, if the GM doesn't have a hacked client they'll camp like normal")
 RULE_BOOL(Character, AlwaysAllowNameChange, false, "Enable this option to allow /changename to work without enabling a name change via scripts.")
-RULE_BOOL(Character, EnableAutoAFK, false, "Enable or disable the auto AFK feature, cuts down on packet spam")
+RULE_BOOL(Character, EnableAutoAFK, true, "Enable or disable the auto AFK feature, cuts down on packet spam")
 RULE_BOOL(Character, AutoIdleFilterPackets, true, "Enable or disable filtering packets when auto AFK is enabled, heavily cuts down on packet spam in zones with lots of players")
 RULE_INT(Character, SecondsBeforeIdleCombatZone, 600, "Seconds before a player is considered idle in combat zones (600 = 10 minutes)")
 RULE_INT(Character, SecondsBeforeIdleNonCombatZone, 60, "Seconds before a player is considered idle in non-combat zones (60 = 1 minute)")
@@ -273,9 +273,8 @@
 #define ServerOP_WWTaskUpdate 0x4758

 // player events
-#define ServerOP_QSSendQuery 0x5000
+#define ServerOP_QSSendQuery		0x5000
 #define ServerOP_PlayerEvent 0x5100
-#define ServerOP_SendPlayerEventSettings 0x5101

 enum {
 	CZUpdateType_Character,
@@ -1779,7 +1778,6 @@ struct BazaarPurchaseMessaging_Struct {
 	uint32           id;
 };

-
 #pragma pack()

 #endif
@@ -824,7 +824,7 @@ bool SharedDatabase::GetInventory(Client *c)
 				e.character_id  = char_id;
 				e.item_id       = item_id;
 				e.equipped      = inst->GetEvolveEquipped();
-				e.final_item_id = EvolvingItemsManager::Instance()->GetFinalItemID(*inst);
+				e.final_item_id = evolving_items_manager.GetFinalItemID(*inst);

 				auto r = CharacterEvolvingItemsRepository::InsertOne(*this, e);
 				e.id = r.id;
@@ -974,7 +974,7 @@ bool SharedDatabase::LoadItems(const std::string &prefix) {
 		const auto Config = EQEmuConfig::get();
 		EQ::IPCMutex mutex("items");
 		mutex.Lock();
-		std::string file_name = fmt::format("{}/{}{}", PathManager::Instance()->GetSharedMemoryPath(), prefix, std::string("items"));
+		std::string file_name = fmt::format("{}/{}{}", path.GetSharedMemoryPath(), prefix, std::string("items"));
 		items_mmf = std::make_unique<EQ::MemoryMappedFile>(file_name);
 		items_hash = std::make_unique<EQ::FixedMemoryHashSet<EQ::ItemData>>(static_cast<uint8*>(items_mmf->Get()), items_mmf->Size());
 		mutex.Unlock();
@@ -1544,60 +1544,12 @@ bool SharedDatabase::GetCommandSettings(std::map<std::string, std::pair<uint8, s
 	return true;
 }

-template<typename T1, typename T2>
-inline std::vector<std::string> join_pair(
-	const std::string &glue,
-	const std::pair<char, char> &encapsulation,
-	const std::vector<std::pair<T1, T2>> &src
-)
-{
-	if (src.empty()) {
-		return {};
-	}
-
-	std::vector<std::string> output;
-
-	for (const std::pair<T1, T2> &src_iter: src) {
-		output.emplace_back(
-
-			fmt::format(
-				"{}{}{}{}{}{}{}",
-				encapsulation.first,
-				src_iter.first,
-				encapsulation.second,
-				glue,
-				encapsulation.first,
-				src_iter.second,
-				encapsulation.second
-			)
-		);
-	}
-
-	return output;
-}
-
-template<typename T>
-inline std::string
-ImplodePair(const std::string &glue, const std::pair<char, char> &encapsulation, const std::vector<T> &src)
-{
-	if (src.empty()) {
-		return {};
-	}
-	std::ostringstream oss;
-	for (const T &src_iter: src) {
-		oss << encapsulation.first << src_iter << encapsulation.second << glue;
-	}
-	std::string output(oss.str());
-	output.resize(output.size() - glue.size());
-	return output;
-}
-
 bool SharedDatabase::UpdateInjectedCommandSettings(const std::vector<std::pair<std::string, uint8>> &injected)
 {
 	if (injected.size()) {
 		const std::string query = fmt::format(
 			"REPLACE INTO `command_settings`(`command`, `access`) VALUES {}",
-			ImplodePair(
+			Strings::ImplodePair(
 				",",
 				std::pair<char, char>('(', ')'),
 				join_pair(",", std::pair<char, char>('\'', '\''), injected)
@@ -1624,7 +1576,7 @@ bool SharedDatabase::UpdateOrphanedCommandSettings(const std::vector<std::string
 	if (orphaned.size()) {
 		std::string query = fmt::format(
 			"DELETE FROM `command_settings` WHERE `command` IN ({})",
-			ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
+			Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
 		);

 		auto results = QueryDatabase(query);
@@ -1634,7 +1586,7 @@ bool SharedDatabase::UpdateOrphanedCommandSettings(const std::vector<std::string

 		query = fmt::format(
 			"DELETE FROM `command_subsettings` WHERE `parent_command` IN ({})",
-			ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
+			Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
 		);

 		auto results_two = QueryDatabase(query);
@@ -1713,7 +1665,7 @@ bool SharedDatabase::LoadSpells(const std::string &prefix, int32 *records, const
 		EQ::IPCMutex mutex("spells");
 		mutex.Lock();

-		std::string file_name = fmt::format("{}/{}{}", PathManager::Instance()->GetSharedMemoryPath(), prefix, std::string("spells"));
+		std::string file_name = fmt::format("{}/{}{}", path.GetSharedMemoryPath(), prefix, std::string("spells"));
 		spells_mmf = std::make_unique<EQ::MemoryMappedFile>(file_name);
 		LogInfo("Loading [{}]", file_name);
 		*records = *static_cast<uint32*>(spells_mmf->Get());
@@ -16,16 +16,12 @@ public:
 	static int32_t GetSkillCapMaxLevel(uint8 class_id, EQ::skills::SkillType skill_id);

 	SkillCaps *SetContentDatabase(Database *db);
-
-	static SkillCaps* Instance()
-	{
-		static SkillCaps instance;
-		return &instance;
-	}
 private:
 	Database                                    *m_content_database{};
 	std::map<uint64, SkillCapsRepository::SkillCaps> m_skill_caps = {};
 };

+extern SkillCaps skill_caps;
+

 #endif //CODE_SKILL_CAPS_H
@@ -358,7 +358,6 @@ bool RequiresStackCheck(uint16 spell_type) {
 		case BotSpellTypes::CompleteHeal:
 		case BotSpellTypes::PetCompleteHeals:
 		case BotSpellTypes::GroupCompleteHeals:
-		case BotSpellTypes::Resurrect:
 			return false;
 		default:
 			return true;
@@ -34,7 +34,6 @@
 */

 #include "strings.h"
-#include <cereal/external/rapidjson/document.h>
 #include <fmt/format.h>
 #include <algorithm>
 #include <cctype>
@@ -42,7 +41,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <iostream>
-#include <sstream>

 #include <random>
 #include <string>
@@ -51,12 +49,6 @@
 #include "strings_legacy.cpp" // legacy c functions
 #include "strings_misc.cpp" // anything non "Strings" scoped

-#ifdef _WINDOWS
-#include <ctype.h>
-#include <functional>
-#include <algorithm>
-#endif
-
 std::string Strings::Random(size_t length)
 {
 	static auto &chrs = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -709,18 +701,6 @@ std::string &Strings::Trim(std::string &str, const std::string &chars)
 	return LTrim(RTrim(str, chars), chars);
 }

-const std::string NUM_TO_ENGLISH_X[] = {
-	"", "One ", "Two ", "Three ", "Four ",
-	"Five ", "Six ", "Seven ", "Eight ", "Nine ", "Ten ", "Eleven ",
-	"Twelve ", "Thirteen ", "Fourteen ", "Fifteen ",
-	"Sixteen ", "Seventeen ", "Eighteen ", "Nineteen "
-};
-
-const std::string NUM_TO_ENGLISH_Y[] = {
-	"", "", "Twenty ", "Thirty ", "Forty ",
-	"Fifty ", "Sixty ", "Seventy ", "Eighty ", "Ninety "
-};
-
 // Function to convert single digit or two digit number into words
 std::string Strings::ConvertToDigit(int n, const std::string& suffix)
 {
@@ -36,19 +36,53 @@
 #define _STRINGUTIL_H_

 #include <charconv>
-#include <cstring>
+#include <sstream>
+#include <string.h>
 #include <string_view>
-#include <string>
 #include <vector>
 #include <cstdarg>
+#include <tuple>
 #include <type_traits>

-#ifdef _WIN32
+#include <fmt/format.h>
+#include <cereal/external/rapidjson/document.h>
+
+#ifndef _WIN32
+// this doesn't appear to affect linux-based systems..need feedback for _WIN64
+
+#endif
+
+#ifdef _WINDOWS
 #include <ctype.h>
+#include <functional>
+#include <algorithm>
 #endif

 #include "types.h"

+namespace detail {
+	// template magic to check if std::from_chars floating point functions exist
+	template <typename T, typename = void>
+	struct has_from_chars_float : std::false_type { };
+
+	// basically it "uses" this template if they do exist because reasons
+	template <typename T>
+	struct has_from_chars_float < T,
+	std::void_t<decltype(std::from_chars(std::declval<const char *>(), std::declval<const char *>(),
+						 std::declval<T &>()))>> : std::true_type { };
+}; // namespace detail
+
+namespace EQ {
+// lame -- older GCC's didn't define this, clang's libc++ however does, even though they lack FP support
+#if defined(__GNUC__) && (__GNUC__ < 11) && !defined(__clang__)
+	enum class chars_format {
+		scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
+	};
+#else
+	using chars_format = std::chars_format;
+#endif
+}; // namespace EQ
+
 class Strings {
 public:
 	static bool Contains(std::vector<std::string> container, const std::string& element);
@@ -99,6 +133,61 @@ public:
 	static bool BeginsWith(const std::string& subject, const std::string& search);
 	static bool EndsWith(const std::string& subject, const std::string& search);
 	static std::string ZoneTime(const uint8 hours, const uint8 minutes);
+
+	template<typename T>
+	static std::string
+	ImplodePair(const std::string &glue, const std::pair<char, char> &encapsulation, const std::vector<T> &src)
+	{
+		if (src.empty()) {
+			return {};
+		}
+		std::ostringstream oss;
+		for (const T &src_iter: src) {
+			oss << encapsulation.first << src_iter << encapsulation.second << glue;
+		}
+		std::string output(oss.str());
+		output.resize(output.size() - glue.size());
+		return output;
+	}
+
+	// basic string_view overloads that just use std stuff since they work!
+	template <typename T>
+	std::enable_if_t<std::is_floating_point_v<T> && detail::has_from_chars_float<T>::value, std::from_chars_result>
+	static from_chars(std::string_view str, T& value, EQ::chars_format fmt = EQ::chars_format::general)
+	{
+		return std::from_chars(str.data(), str.data() + str.size(), value, fmt);
+	}
+
+	template <typename T>
+	std::enable_if_t<std::is_integral_v<T>, std::from_chars_result>
+	static from_chars(std::string_view str, T& value, int base = 10)
+	{
+		return std::from_chars(str.data(), str.data() + str.size(), value, base);
+	}
+
+	// fallback versions of floating point in case they're not implemented
+	// TODO: add error handling ...
+	// This does have to allocate since from_chars doesn't need a null terminated string and neither does string_view
+	template <typename T>
+	std::enable_if_t<std::is_floating_point_v<T> && !detail::has_from_chars_float<T>::value && std::is_same_v<T, float>, std::from_chars_result>
+	static from_chars(std::string_view str, T& value, EQ::chars_format fmt = EQ::chars_format::general)
+	{
+		std::from_chars_result res{};
+		std::string tmp_str(str.data(), str.size());
+		value = strtof(tmp_str.data(), nullptr);
+		return res;
+	}
+
+	template <typename T>
+	std::enable_if_t<std::is_floating_point_v<T> && !detail::has_from_chars_float<T>::value && std::is_same_v<T, double>, std::from_chars_result>
+	static from_chars(std::string_view str, T& value, EQ::chars_format fmt = EQ::chars_format::general)
+	{
+		std::from_chars_result res{};
+		std::string tmp_str(str.data(), str.size());
+		value = strtod(tmp_str.data(), nullptr);
+		return res;
+	}
+
 	static std::string Slugify(const std::string &input, const std::string &separator = "-");
 	static bool IsValidJson(const std::string& json);
 };
@@ -110,6 +199,93 @@ const std::string vStringFormat(const char *format, va_list args);
 // Used for grid nodes, as NPC names remove numerals.
 // But general purpose

+const std::string NUM_TO_ENGLISH_X[] = {
+	"", "One ", "Two ", "Three ", "Four ",
+	"Five ", "Six ", "Seven ", "Eight ", "Nine ", "Ten ", "Eleven ",
+	"Twelve ", "Thirteen ", "Fourteen ", "Fifteen ",
+	"Sixteen ", "Seventeen ", "Eighteen ", "Nineteen "
+};
+
+const std::string NUM_TO_ENGLISH_Y[] = {
+	"", "", "Twenty ", "Thirty ", "Forty ",
+	"Fifty ", "Sixty ", "Seventy ", "Eighty ", "Ninety "
+};
+
+// _WIN32 builds require that #include<fmt/format.h> be included in whatever code file the invocation is made from (no header files)
+template<typename T1, typename T2>
+std::vector<std::string> join_pair(
+	const std::string &glue,
+	const std::pair<char, char> &encapsulation,
+	const std::vector<std::pair<T1, T2>> &src
+)
+{
+	if (src.empty()) {
+		return {};
+	}
+
+	std::vector<std::string> output;
+
+	for (const std::pair<T1, T2> &src_iter: src) {
+		output.emplace_back(
+
+			fmt::format(
+				"{}{}{}{}{}{}{}",
+				encapsulation.first,
+				src_iter.first,
+				encapsulation.second,
+				glue,
+				encapsulation.first,
+				src_iter.second,
+				encapsulation.second
+			)
+		);
+	}
+
+	return output;
+}
+
+// _WIN32 builds require that #include<fmt/format.h> be included in whatever code file the invocation is made from (no header files)
+template<typename T1, typename T2, typename T3, typename T4>
+std::vector<std::string> join_tuple(
+	const std::string &glue,
+	const std::pair<char, char> &encapsulation,
+	const std::vector<std::tuple<T1, T2, T3, T4>> &src
+)
+{
+	if (src.empty()) {
+		return {};
+	}
+
+	std::vector<std::string> output;
+
+	for (const std::tuple<T1, T2, T3, T4> &src_iter: src) {
+
+		output.emplace_back(
+
+			fmt::format(
+				"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+				encapsulation.first,
+				std::get<0>(src_iter),
+				encapsulation.second,
+				glue,
+				encapsulation.first,
+				std::get<1>(src_iter),
+				encapsulation.second,
+				glue,
+				encapsulation.first,
+				std::get<2>(src_iter),
+				encapsulation.second,
+				glue,
+				encapsulation.first,
+				std::get<3>(src_iter),
+				encapsulation.second
+			)
+		);
+	}
+
+	return output;
+}
+
 // misc functions
 std::string SanitizeWorldServerName(std::string server_long_name);
 std::vector<std::string> GetBadWords();
@@ -134,4 +310,18 @@ std::string FormatName(const std::string &char_name);
 bool IsAllowedWorldServerCharacterList(char c);
 void SanitizeWorldServerName(char *name);

+template<typename InputIterator, typename OutputIterator>
+auto CleanMobName(InputIterator first, InputIterator last, OutputIterator result)
+{
+	for (; first != last; ++first) {
+		if (*first == '_') {
+			*result = ' ';
+		}
+		else if (isalpha(*first) || *first == '`') {
+			*result = *first;
+		}
+	}
+	return result;
+}
+
 #endif
@@ -25,7 +25,7 @@

 // Build variables
 // these get injected during the build pipeline
-#define CURRENT_VERSION "23.8.1-dev" // always append -dev to the current version for custom-builds
+#define CURRENT_VERSION "23.7.0-dev" // always append -dev to the current version for custom-builds
 #define LOGIN_VERSION "0.8.0"
 #define COMPILE_DATE    __DATE__
 #define COMPILE_TIME    __TIME__
@@ -42,7 +42,7 @@
 * Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
 */

-#define CURRENT_BINARY_DATABASE_VERSION 9326
+#define CURRENT_BINARY_DATABASE_VERSION 9323
 #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9054
 #define CUSTOM_BINARY_DATABASE_VERSION 0

@@ -104,39 +104,36 @@ public:
 	uint8 GetZoneIdleWhenEmpty(uint32 zone_id, int version = 0);
 	uint32 GetZoneSecondsBeforeIdle(uint32 zone_id, int version = 0);

-	static ZoneStore* Instance()
-	{
-		static ZoneStore instance;
-		return &instance;
-	}
 private:
 	std::vector<ZoneRepository::Zone> m_zones;
 };

+extern ZoneStore zone_store;
+
 /**
 * Global helpers
 */
-inline uint32 ZoneID(const char *in_zone_name) { return ZoneStore::Instance()->GetZoneID(in_zone_name); }
-inline uint32 ZoneID(const std::string& zone_name) { return ZoneStore::Instance()->GetZoneID(zone_name); }
+inline uint32 ZoneID(const char *in_zone_name) { return zone_store.GetZoneID(in_zone_name); }
+inline uint32 ZoneID(const std::string& zone_name) { return zone_store.GetZoneID(zone_name); }
 inline const char *ZoneName(uint32 zone_id, bool error_unknown = false)
 {
-	return ZoneStore::Instance()->GetZoneName(
+	return zone_store.GetZoneName(
 		zone_id,
 		error_unknown
 	);
 }
 inline const char *ZoneLongName(uint32 zone_id, bool error_unknown = false)
 {
-	return ZoneStore::Instance()->GetZoneLongName(
+	return zone_store.GetZoneLongName(
 		zone_id,
 		error_unknown
 	);
 }
-inline ZoneRepository::Zone *GetZone(uint32 zone_id, int version = 0) { return ZoneStore::Instance()->GetZone(zone_id, version); };
-inline ZoneRepository::Zone *GetZone(const char *in_zone_name) { return ZoneStore::Instance()->GetZone(in_zone_name); };
+inline ZoneRepository::Zone *GetZone(uint32 zone_id, int version = 0) { return zone_store.GetZone(zone_id, version); };
+inline ZoneRepository::Zone *GetZone(const char *in_zone_name) { return zone_store.GetZone(in_zone_name); };
 inline ZoneRepository::Zone *GetZone(const char *in_zone_name, int version = 0)
 {
-	return ZoneStore::Instance()->GetZone(
+	return zone_store.GetZone(
 		ZoneID(
 			in_zone_name
 		), version
@@ -144,7 +141,7 @@ inline ZoneRepository::Zone *GetZone(const char *in_zone_name, int version = 0)
 };
 inline ZoneRepository::Zone *GetZoneVersionWithFallback(uint32 zone_id, int version = 0)
 {
-	return ZoneStore::Instance()->GetZoneWithFallback(
+	return zone_store.GetZoneWithFallback(
 		zone_id,
 		version
 	);
@@ -33,16 +33,19 @@
 #include <signal.h>
 #include <time.h>

+EQEmuLogSys LogSys;
+PathManager path;
+
 bool RunLoops = false;

 void CatchSignal(int sig_num);

 int main(int argc, char *argv[]) {
 	RegisterExecutablePlatform(ExePlatformLaunch);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	std::string launcher_name;
 	if(argc == 2) {
@@ -166,7 +169,7 @@ int main(int argc, char *argv[]) {
 		delete zone->second;
 	}

-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();

 	return 0;
 }
@@ -25,7 +25,7 @@ bool Client::Process()
 			OpcodeManager::EmuToName(app->GetOpcode()),
 			o->EmuToEQ(app->GetOpcode()) == 0 ? app->GetProtocolOpcode() : o->EmuToEQ(app->GetOpcode()),
 			app->Size(),
-			(EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
+			(LogSys.IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
 		);

 		if (m_client_status == cs_failed_to_login) {
@@ -94,7 +94,7 @@ ClientManager::ClientManager()

 	std::string opcodes_path = fmt::format(
 		"{}/{}",
-		PathManager::Instance()->GetOpcodePath(),
+		path.GetOpcodePath(),
 		"login_opcodes.conf"
 	);

@@ -131,7 +131,7 @@ ClientManager::ClientManager()

 	opcodes_path = fmt::format(
 		"{}/{}",
-		PathManager::Instance()->GetOpcodePath(),
+		path.GetOpcodePath(),
 		"login_opcodes_sod.conf"
 	);

@@ -169,7 +169,7 @@ ClientManager::ClientManager()

 	opcodes_path = fmt::format(
 		"{}/{}",
-		PathManager::Instance()->GetOpcodePath(),
+		path.GetOpcodePath(),
 		"login_opcodes_larion.conf"
 	);

@@ -22,8 +22,12 @@
 #include <thread>

 LoginServer     server;
+EQEmuLogSys     LogSys;
 bool            run_server = true;
+PathManager     path;
 Database        database;
+PlayerEventLogs player_event_logs;
+ZoneStore       zone_store;

 void CatchSignal(int sig_num)
 {
@@ -48,7 +52,7 @@ void LoadDatabaseConnection()
 void LoadServerConfig()
 {
 	server.config = EQ::JsonConfigFile::Load(
-		fmt::format("{}/login.json", PathManager::Instance()->GetServerPath())
+		fmt::format("{}/login.json", path.GetServerPath())
 	);
 	LogInfo("Config System Init");

@@ -155,21 +159,21 @@ int main(int argc, char **argv)
 	LogInfo("Logging System Init");

 	if (argc == 1) {
-		EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+		LogSys.LoadLogSettingsDefaults();
 	}

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	// command handler
 	if (argc > 1) {
-		EQEmuLogSys::Instance()->SilenceConsoleLogging();
+		LogSys.SilenceConsoleLogging();

 		LoadServerConfig();
 		LoadDatabaseConnection();

-		EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
-		EQEmuLogSys::Instance()->log_settings[Logs::Debug].log_to_console = static_cast<uint8>(Logs::General);
-		EQEmuLogSys::Instance()->log_settings[Logs::Debug].is_category_enabled = 1;
+		LogSys.LoadLogSettingsDefaults();
+		LogSys.log_settings[Logs::Debug].log_to_console = static_cast<uint8>(Logs::General);
+		LogSys.log_settings[Logs::Debug].is_category_enabled = 1;

 		LoginserverCommandHandler::CommandHandler(argc, argv);
 	}
@@ -178,7 +182,7 @@ int main(int argc, char **argv)
 	LoadDatabaseConnection();

 	if (argc == 1) {
-		EQEmuLogSys::Instance()->SetDatabase(&database)
+		LogSys.SetDatabase(&database)
 			->SetLogPath("logs")
 			->LoadLogDatabaseSettings()
 			->StartFileLogs();
@@ -1,6 +1,6 @@
 {
  "name": "eqemu-server",
-  "version": "23.8.1",
+  "version": "23.7.0",
  "repository": {
    "type": "git",
    "url": "https://github.com/EQEmu/Server.git"
@@ -44,12 +44,6 @@ public:
 	bool LoadDatabase();
 	void HandlePacket(ServerPacket *pack);
 	void ExpireEntries();
-
-	static LFGuildManager* Instance()
-	{
-		static LFGuildManager instance;
-		return &instance;
-	}
 private:
 	void SendPlayerMatches(uint32 FromZoneID, uint32 FromInstanceID, char *From, uint32 FromLevel, uint32 ToLevel, uint32 MinAA, uint32 TimeZone, uint32 Classes);
 	void SendGuildMatches(uint32 FromZoneID, uint32 FromInstanceID, char *From, uint32 Level, uint32 AAPoints, uint32 TimeZone, uint32 Class);
@@ -20,15 +20,23 @@
 #include "../common/net/console_server.h"
 #include "../queryserv/zonelist.h"
 #include "../queryserv/zoneserver.h"
+#include "../common/discord/discord_manager.h"

 volatile bool RunLoops = true;

 QSDatabase            qs_database;
 Database              database;
+LFGuildManager        lfguildmanager;
 std::string           WorldShortName;
 const queryservconfig *Config;
 WorldServer           *worldserver = 0;
+EQEmuLogSys           LogSys;
+PathManager           path;
+ZoneStore             zone_store;
+PlayerEventLogs       player_event_logs;
+ZSList                zs_list;
 uint32                numzones     = 0;
+DiscordManager        discord_manager;

 void CatchSignal(int sig_num)
 {
@@ -38,11 +46,11 @@ void CatchSignal(int sig_num)
 int main()
 {
 	RegisterExecutablePlatform(ExePlatformQueryServ);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 	Timer LFGuildExpireTimer(60000);

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	LogInfo("Starting EQEmu QueryServ");
 	if (!queryservconfig::LoadConfig()) {
@@ -77,8 +85,8 @@ int main()
 		return 1;
 	}

-	EQEmuLogSys::Instance()->SetDatabase(&database)
-		->SetLogPath(PathManager::Instance()->GetLogPath())
+	LogSys.SetDatabase(&database)
+		->SetLogPath(path.GetLogPath())
 		->LoadLogDatabaseSettings()
 		->StartFileLogs();

@@ -121,7 +129,7 @@ int main()
 	server_connection->OnConnectionIdentified(
 		"Zone", [&console](std::shared_ptr<EQ::Net::ServertalkServerConnection> connection) {
 			numzones++;
-			ZSList::Instance()->Add(new ZoneServer(connection, console.get()));
+			zs_list.Add(new ZoneServer(connection, console.get()));

 			LogInfo(
 				"New Zone Server connection from [{}] at [{}:{}] zone_count [{}]",
@@ -136,7 +144,7 @@ int main()
 	server_connection->OnConnectionRemoved(
 		"Zone", [](std::shared_ptr<EQ::Net::ServertalkServerConnection> connection) {
 			numzones--;
-			ZSList::Instance()->Remove(connection->GetUUID());
+			zs_list.Remove(connection->GetUUID());

 			LogInfo(
 				"Removed Zone Server connection from [{}] total zone_count [{}]",
@@ -151,10 +159,10 @@ int main()
 	worldserver->Connect();

 	/* Load Looking For Guild Manager */
-	LFGuildManager::Instance()->LoadDatabase();
+	lfguildmanager.LoadDatabase();

 	Timer player_event_process_timer(1000);
-	PlayerEventLogs::Instance()->SetDatabase(&qs_database)->Init();
+	player_event_logs.SetDatabase(&qs_database)->Init();

 	auto loop_fn = [&](EQ::Timer *t) {
 		Timer::SetCurrentTime();
@@ -165,11 +173,11 @@ int main()
 		}

 		if (LFGuildExpireTimer.Check()) {
-			LFGuildManager::Instance()->ExpireEntries();
+			lfguildmanager.ExpireEntries();
 		}

 		if (player_event_process_timer.Check()) {
-			PlayerEventLogs::Instance()->Process();
+			player_event_logs.Process();
 		}
 	};

@@ -179,7 +187,7 @@ int main()
 	EQ::EventLoop::Get().Run();

 	safe_delete(worldserver);
-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();
 }

 void UpdateWindowTitle(char *iNewTitle)
@@ -21,11 +21,10 @@
 #include <string.h>
 #include <time.h>

-#include "zonelist.h"
-
 extern WorldServer           worldserver;
 extern const queryservconfig *Config;
 extern QSDatabase            qs_database;
+extern LFGuildManager        lfguildmanager;

 WorldServer::WorldServer()
 {
@@ -77,9 +76,8 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 		case ServerOP_ServerReloadRequest: {
 			auto o = (ServerReload::Request*) p.Data();
 			if (o->type == ServerReload::Type::Logs) {
-				EQEmuLogSys::Instance()->LoadLogDatabaseSettings();
-				PlayerEventLogs::Instance()->ReloadSettings();
-				ZSList::Instance()->SendPlayerEventLogSettings();
+				LogSys.LoadLogDatabaseSettings();
+				player_event_logs.ReloadSettings();
 			}

 			break;
@@ -114,7 +112,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 					pack.pBuffer = (uchar *) p.Data();
 					pack.opcode  = opcode;
 					pack.size    = (uint32) p.Length();
-					LFGuildManager::Instance()->HandlePacket(&pack);
+					lfguildmanager.HandlePacket(&pack);
 					pack.pBuffer = nullptr;
 					break;
 				}
@@ -5,8 +5,6 @@
 void ZSList::Add(ZoneServer* zoneserver) {
 	zone_server_list.emplace_back(std::unique_ptr<ZoneServer>(zoneserver));
 	zoneserver->SetIsZoneConnected(true);
-
-	zoneserver->SendPlayerEventLogSettings();
 }

 void ZSList::Remove(const std::string &uuid)
@@ -20,10 +18,3 @@ void ZSList::Remove(const std::string &uuid)
 		iter++;
 	}
 }
-
-void ZSList::SendPlayerEventLogSettings()
-{
-	for (auto &zs : zone_server_list) {
-		zs->SendPlayerEventLogSettings();
-	}
-}
@@ -6,22 +6,15 @@
 #include <vector>
 #include <memory>
 #include <list>
-#include "zoneserver.h"

 class WorldTCPConnection;
+class ZoneServer;

 class ZSList {
 public:
-	std::list<std::unique_ptr<ZoneServer>>& GetZsList() { return zone_server_list; }
-	void                                    Add(ZoneServer* zoneserver);
-	void                                    Remove(const std::string& uuid);
-	void                                    SendPlayerEventLogSettings();
-
-	static ZSList* Instance()
-	{
-		static ZSList instance;
-		return &instance;
-	}
+	std::list<std::unique_ptr<ZoneServer>> &GetZsList() { return zone_server_list; }
+	void Add(ZoneServer *zoneserver);
+	void Remove(const std::string &uuid);

 private:
 	std::list<std::unique_ptr<ZoneServer>> zone_server_list;
@@ -5,6 +5,8 @@
 #include "../common/events/player_event_logs.h"
 #include "../common/discord/discord_manager.h"

+extern DiscordManager discord_manager;
+
 ZoneServer::ZoneServer(
 	std::shared_ptr<EQ::Net::ServertalkServerConnection> in_connection,
 	EQ::Net::ConsoleServer *in_console
@@ -33,9 +35,9 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 			cereal::BinaryInputArchive archive(ss);
 			archive(n);

-			PlayerEventLogs::Instance()->AddToQueue(n.player_event_log);
+			player_event_logs.AddToQueue(n.player_event_log);

-			DiscordManager::Instance()->QueuePlayerEventMessage(n);
+			discord_manager.QueuePlayerEventMessage(n);
 			break;
 		}
 		default: {
@@ -44,27 +46,3 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
 		}
 	}
 }
-
-void ZoneServer::SendPlayerEventLogSettings()
-{
-	EQ::Net::DynamicPacket                                                dyn_pack;
-	std::vector<PlayerEventLogSettingsRepository::PlayerEventLogSettings> settings(
-		PlayerEventLogs::Instance()->GetSettings(),
-		PlayerEventLogs::Instance()->GetSettings() + PlayerEvent::EventType::MAX
-	);
-
-	dyn_pack.PutSerialize(0, settings);
-
-	auto packet_size = sizeof(ServerSendPlayerEvent_Struct) + dyn_pack.Length();
-
-	auto pack = std::make_unique<ServerPacket>(
-		ServerOP_SendPlayerEventSettings,
-		static_cast<uint32_t>(packet_size)
-	);
-
-	auto* buf        = reinterpret_cast<ServerSendPlayerEvent_Struct*>(pack->pBuffer);
-	buf->cereal_size = static_cast<uint32_t>(dyn_pack.Length());
-	memcpy(buf->cereal_data, dyn_pack.Data(), dyn_pack.Length());
-
-	SendPacket(pack.release());
-}
@@ -16,12 +16,11 @@ class ZoneServer : public WorldTCPConnection {
 public:
 	ZoneServer(std::shared_ptr<EQ::Net::ServertalkServerConnection> in_connection, EQ::Net::ConsoleServer *in_console);
 	~ZoneServer();
-	void        SendPacket(ServerPacket *pack) { m_connection->SendPacket(pack); }
-	void        SetIsZoneConnected(bool in) { m_is_zone_connected = in; }
-	bool        GetIsZoneConnected() { return m_is_zone_connected; }
-	void        HandleMessage(uint16 opcode, const EQ::Net::Packet &p);
+	void SendPacket(ServerPacket *pack) { m_connection->SendPacket(pack); }
+	void SetIsZoneConnected(bool in) { m_is_zone_connected = in; }
+	bool GetIsZoneConnected() { return m_is_zone_connected; }
+	void HandleMessage(uint16 opcode, const EQ::Net::Packet &p);
 	std::string GetUUID() const { return m_connection->GetUUID(); }
-	void        SendPlayerEventLogSettings();

 private:
 	std::shared_ptr<EQ::Net::ServertalkServerConnection> m_connection{};
@@ -35,6 +35,13 @@
 #include "../common/events/player_event_logs.h"
 #include "../common/evolving_items.h"

+EQEmuLogSys          LogSys;
+WorldContentService  content_service;
+ZoneStore            zone_store;
+PathManager          path;
+PlayerEventLogs      player_event_logs;
+EvolvingItemsManager evolving_items_manager;
+
 #ifdef _WINDOWS
 #include <direct.h>
 #else
@@ -74,10 +81,10 @@ inline bool MakeDirectory(const std::string &directory_name)
 int main(int argc, char **argv)
 {
 	RegisterExecutablePlatform(ExePlatformSharedMemory);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	LogInfo("Shared Memory Loader Program");
 	if (!EQEmuConfig::LoadConfig()) {
@@ -119,8 +126,8 @@ int main(int argc, char **argv)
 		content_db.SetMySQL(database);
 	}

-	EQEmuLogSys::Instance()->SetDatabase(&database)
-		->SetLogPath(PathManager::Instance()->GetLogPath())
+	LogSys.SetDatabase(&database)
+		->SetLogPath(path.GetLogPath())
 		->LoadLogDatabaseSettings()
 		->StartFileLogs();

@@ -162,16 +169,16 @@ int main(int argc, char **argv)
 	}


-	WorldContentService::Instance()->SetCurrentExpansion(RuleI(Expansion, CurrentExpansion));
-	WorldContentService::Instance()->SetDatabase(&database)
+	content_service.SetCurrentExpansion(RuleI(Expansion, CurrentExpansion));
+	content_service.SetDatabase(&database)
 		->SetContentDatabase(&content_db)
 		->SetExpansionContext()
 		->ReloadContentFlags();

 	LogInfo(
 		"Current expansion is [{}] ({})",
-		WorldContentService::Instance()->GetCurrentExpansion(),
-		WorldContentService::Instance()->GetCurrentExpansionName()
+		content_service.GetCurrentExpansion(),
+		content_service.GetCurrentExpansionName()
 	);

 	std::string hotfix_name = "";
@@ -237,6 +244,6 @@ int main(int argc, char **argv)
 		}
 	}

-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();
 	return 0;
 }
@@ -34,12 +34,14 @@
 #include "task_state_test.h"

 const EQEmuConfig *Config;
+EQEmuLogSys       LogSys;
+PathManager       path;

 int main()
 {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
-	PathManager::Instance()->Init();
+	LogSys.LoadLogSettingsDefaults();
+	path.LoadPaths();

 	auto ConfigLoadResult = EQEmuConfig::LoadConfig();
 	Config = EQEmuConfig::get();
@@ -30,6 +30,7 @@ public:
 		TEST_ADD(StringUtilTest::EscapeStringTest);
 		TEST_ADD(StringUtilTest::SearchDeliminatedStringTest);
 		TEST_ADD(StringUtilTest::SplitStringTest);
+		TEST_ADD(StringUtilTest::FromCharsTest);
 		TEST_ADD(StringUtilTest::TestIsFloat);
 		TEST_ADD(StringUtilTest::TestIsNumber);
 	}
@@ -107,6 +108,21 @@ public:
 		TEST_ASSERT(v[2] == "789");
 	}

+	void FromCharsTest() {
+		char int_chars[] = "123";
+		int int_value = 0;
+
+		char float_chars[] = "3.14";
+		float float_value = 0.0f;
+
+		Strings::from_chars(int_chars, int_value);
+		TEST_ASSERT(int_value == 123);
+
+		Strings::from_chars(float_chars, float_value);
+		TEST_ASSERT(float_value == 3.14f);
+
+	}
+
 	void TestIsFloat() {
 		TEST_ASSERT_EQUALS(Strings::IsFloat("0.23424523"), true);
 		TEST_ASSERT_EQUALS(Strings::IsFloat("12312312313.23424523"), true);
@@ -482,7 +482,7 @@ Clientlist::Clientlist(int ChatPort) {
 	const ucsconfig *Config = ucsconfig::get();


-	std::string opcodes_file = fmt::format("{}/{}", PathManager::Instance()->GetServerPath(), Config->MailOpCodesFile);
+	std::string opcodes_file = fmt::format("{}/{}", path.GetServerPath(), Config->MailOpCodesFile);

 	LogInfo("Loading [{}]", opcodes_file);
 	if (!ChatOpMgr->LoadOpcodes(opcodes_file.c_str()))
@@ -651,7 +651,7 @@ void Clientlist::Process()
 				OpcodeManager::EmuToName(app->GetOpcode()),
 				o->EmuToEQ(app->GetOpcode()) == 0 ? app->GetProtocolOpcode() : o->EmuToEQ(app->GetOpcode()),
 				app->Size(),
-				(EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
+				(LogSys.IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
 			);

 			switch (opcode) {
@@ -44,8 +44,13 @@

 ChatChannelList *ChannelList;
 Clientlist *g_Clientlist;
+EQEmuLogSys LogSys;
 UCSDatabase database;
 WorldServer *worldserver = nullptr;
+DiscordManager discord_manager;
+PathManager path;
+ZoneStore zone_store;
+PlayerEventLogs player_event_logs;

 const ucsconfig *Config;

@@ -70,7 +75,7 @@ void Shutdown() {
 	LogInfo("Shutting down...");
 	ChannelList->RemoveAllChannels();
 	g_Clientlist->CloseAllConnections();
-	EQEmuLogSys::Instance()->CloseFileLogs();
+	LogSys.CloseFileLogs();
 }

 int caught_loop = 0;
@@ -85,24 +90,24 @@ void CatchSignal(int sig_num) {
 		LogInfo("In a signal handler loop and process is incapable of exiting properly, forcefully cleaning up");
 		ChannelList->RemoveAllChannels();
 		g_Clientlist->CloseAllConnections();
-		EQEmuLogSys::Instance()->CloseFileLogs();
+		LogSys.CloseFileLogs();
 		std::exit(0);
 	}
 }

 void PlayerEventQueueListener() {
 	while (caught_loop == 0) {
-		DiscordManager::Instance()->ProcessMessageQueue();
+		discord_manager.ProcessMessageQueue();
 		Sleep(100);
 	}
 }

 int main() {
 	RegisterExecutablePlatform(ExePlatformUCS);
-	EQEmuLogSys::Instance()->LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	PathManager::Instance()->Init();
+	path.LoadPaths();

 	// Check every minute for unused channels we can delete
 	//
@@ -134,13 +139,12 @@ int main() {
 		return 1;
 	}

-	EQEmuLogSys::Instance()
-		->SetDatabase(&database)
-		->SetLogPath(PathManager::Instance()->GetLogPath())
+	LogSys.SetDatabase(&database)
+		->SetLogPath(path.GetLogPath())
 		->LoadLogDatabaseSettings()
 		->StartFileLogs();

-	PlayerEventLogs::Instance()->SetDatabase(&database)->Init();
+	player_event_logs.SetDatabase(&database)->Init();

 	char tmp[64];

@@ -42,6 +42,7 @@ extern WorldServer     worldserver;
 extern Clientlist      *g_Clientlist;
 extern const ucsconfig *Config;
 extern UCSDatabase       database;
+extern DiscordManager  discord_manager;

 void ProcessMailTo(Client *c, const std::string& from, const std::string& subject, const std::string& message);

@@ -78,8 +79,8 @@ void WorldServer::ProcessMessage(uint16 opcode, EQ::Net::Packet &p)
 	case ServerOP_ServerReloadRequest: {
 		auto o = (ServerReload::Request*) pack->pBuffer;
 		if (o->type == ServerReload::Type::Logs) {
-			EQEmuLogSys::Instance()->LoadLogDatabaseSettings();
-			PlayerEventLogs::Instance()->ReloadSettings();
+			LogSys.LoadLogDatabaseSettings();
+			player_event_logs.ReloadSettings();
 		}

 		break;
@@ -91,14 +92,14 @@ void WorldServer::ProcessMessage(uint16 opcode, EQ::Net::Packet &p)
 		cereal::BinaryInputArchive archive(ss);
 		archive(n);

-		DiscordManager::Instance()->QueuePlayerEventMessage(n);
+		discord_manager.QueuePlayerEventMessage(n);

 		break;
 	}
 	case ServerOP_DiscordWebhookMessage: {
 		auto *q = (DiscordWebhookMessage_Struct *) p.Data();

-		DiscordManager::Instance()->QueueWebhookMessage(
+		discord_manager.QueueWebhookMessage(
 			q->webhook_id,
 			q->message
 		);
@@ -14,15 +14,15 @@ perl utils/scripts/build/tag-version.pl

 mkdir -p build && cd build && \
  cmake -DEQEMU_BUILD_TESTS=ON \
-      -DCMAKE_BUILD_TYPE=RelWithDebInfo \
      -DEQEMU_BUILD_STATIC=ON \
      -DEQEMU_BUILD_LOGIN=ON \
      -DEQEMU_BUILD_LUA=ON \
      -DEQEMU_BUILD_PERL=ON \
-      -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING="-g -Wno-everything" \
+      -DCMAKE_CXX_FLAGS:STRING="-O1 -g -Wno-everything" \
+      -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING="-O1 -g -Wno-everything" \
      -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
      -G 'Unix Makefiles' \
-      .. && make -j$((`nproc`-2))
+      .. && make -j$((`nproc`-12))

 curl https://raw.githubusercontent.com/Akkadius/eqemu-install-v2/master/eqemu_config.json --output eqemu_config.json
 ./bin/tests
@@ -1,8 +1,6 @@
 module should-release

-go 1.23.0
-
-toolchain go1.23.5
+go 1.18

 require (
 	github.com/google/go-github/v41 v41.0.0
@@ -35,12 +35,12 @@ if (scalar(@enum) > 0) {

        foreach my $cat (@cats) {
            print "#define Log" . $cat . "(message, ...) do {\\
-    if (EQEmuLogSys::Instance()->IsLogEnabled(Logs::General, Logs::" . $cat . "))\\
+    if (LogSys.IsLogEnabled(Logs::General, Logs::" . $cat . "))\\
        OutF(LogSys, Logs::General, Logs::" . $cat . ", __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\\
 } while (0)

 #define Log" . $cat . "Detail(message, ...) do {\\
-    if (EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::" . $cat . "))\\
+    if (LogSys.IsLogEnabled(Logs::Detail, Logs::" . $cat . "))\\
        OutF(LogSys, Logs::Detail, Logs::" . $cat . ", __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\\
 } while (0)

@@ -114,8 +114,7 @@ if ($requested_table_to_generate ne "all") {

 my @cereal_enabled_tables = (
    "data_buckets",
-    "player_event_logs",
-    "player_event_log_settings"
+    "player_event_logs"
 );

 my $generated_base_repository_files = "";
@@ -7,7 +7,6 @@ SET(world_sources
    cliententry.cpp
    clientlist.cpp
    console.cpp
-    ../common/data_bucket.cpp
    dynamic_zone.cpp
    dynamic_zone_manager.cpp
    eql_config.cpp
@@ -43,7 +42,6 @@ SET(world_headers
    cliententry.h
    clientlist.h
    console.h
-    ../common/data_bucket.h
    dynamic_zone.h
    dynamic_zone_manager.h
    eql_config.h
@@ -77,7 +75,7 @@ ADD_EXECUTABLE(world ${world_sources} ${world_headers})
 INSTALL(TARGETS world RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)

 IF (WIN32 AND EQEMU_BUILD_PCH)
-    TARGET_PRECOMPILE_HEADERS(world PRIVATE ../common/pch/std-pch.h)
+    TARGET_PRECOMPILE_HEADERS(world PRIVATE ../common/pch/pch.h)
 ENDIF ()

 ADD_DEFINITIONS(-DWORLD)
@@ -15,6 +15,9 @@
 #include "../common/zone_store.h"
 #include "../common/repositories/character_corpses_repository.h"

+extern ZSList zoneserver_list;
+extern ClientList client_list;
+extern AdventureManager adventure_manager;
 extern EQ::Random emu_random;

 Adventure::Adventure(AdventureTemplate *t)
@@ -174,7 +177,7 @@ void Adventure::SetStatus(AdventureStatus new_status)
 		ut->instance_id = instance_id;
 		ut->new_duration = adventure_template->duration + 60;

-		ZSList::Instance()->SendPacket(0, instance_id, pack);
+		zoneserver_list.SendPacket(0, instance_id, pack);
 		safe_delete(pack);
 	}
 	else if(new_status == AS_WaitingForSecondaryEndTime)
@@ -188,7 +191,7 @@ void Adventure::SetStatus(AdventureStatus new_status)
 		ut->instance_id = instance_id;
 		ut->new_duration = 1860;

-		ZSList::Instance()->SendPacket(0, instance_id, pack);
+		zoneserver_list.SendPacket(0, instance_id, pack);
 		safe_delete(pack);
 	}
 	else if(new_status == AS_Finished)
@@ -202,7 +205,7 @@ void Adventure::SetStatus(AdventureStatus new_status)
 		ut->instance_id = instance_id;
 		ut->new_duration = 1860;

-		ZSList::Instance()->SendPacket(0, instance_id, pack);
+		zoneserver_list.SendPacket(0, instance_id, pack);
 		safe_delete(pack);
 	}
 	else
@@ -213,7 +216,7 @@ void Adventure::SetStatus(AdventureStatus new_status)
 	auto iter = players.begin();
 	while(iter != players.end())
 	{
-		AdventureManager::Instance()->GetAdventureData((*iter).c_str());
+		adventure_manager.GetAdventureData((*iter).c_str());
 		++iter;
 	}
 }
@@ -227,11 +230,11 @@ void Adventure::SendAdventureMessage(uint32 type, const char *msg)
 	auto iter = players.begin();
 	while(iter != players.end())
 	{
-		ClientListEntry *current = ClientList::Instance()->FindCharacter((*iter).c_str());
+		ClientListEntry *current = client_list.FindCharacter((*iter).c_str());
 		if(current)
 		{
 			strcpy(sms->to, (*iter).c_str());
-			ZSList::Instance()->SendPacket(current->zone(), current->instance(), pack);
+			zoneserver_list.SendPacket(current->zone(), current->instance(), pack);
 		}
 		++iter;
 	}
@@ -280,7 +283,7 @@ void Adventure::Finished(AdventureWinStatus ws)
 {
 	auto iter = players.begin();
 	while (iter != players.end()) {
-		ClientListEntry *current = ClientList::Instance()->FindCharacter((*iter).c_str());
+		ClientListEntry *current = client_list.FindCharacter((*iter).c_str());
 		auto character_id = database.GetCharacterID(*iter);

 		if (character_id == 0) {
@@ -307,7 +310,7 @@ void Adventure::Finished(AdventureWinStatus ws)
 					af->win = false;
 					af->points = 0;
 				}
-				ZSList::Instance()->SendPacket(current->zone(), current->instance(), pack);
+				zoneserver_list.SendPacket(current->zone(), current->instance(), pack);
 				database.UpdateAdventureStatsEntry(character_id, GetTemplate()->theme, (ws != AWS_Lose) ? true : false);
 				delete pack;
 			}
@@ -328,7 +331,7 @@ void Adventure::Finished(AdventureWinStatus ws)
 					afe.win = false;
 					afe.points = 0;
 				}
-				AdventureManager::Instance()->AddFinishedEvent(afe);
+				adventure_manager.AddFinishedEvent(afe);
 				database.UpdateAdventureStatsEntry(character_id, GetTemplate()->theme, (ws != AWS_Lose) ? true : false);
 			}
 		}
@@ -349,12 +352,12 @@ void Adventure::Finished(AdventureWinStatus ws)
 				afe.win = false;
 				afe.points = 0;
 			}
-			AdventureManager::Instance()->AddFinishedEvent(afe);
+			adventure_manager.AddFinishedEvent(afe);
 			database.UpdateAdventureStatsEntry(character_id, GetTemplate()->theme, (ws != AWS_Lose) ? true : false);
 		}
 		++iter;
 	}
-	AdventureManager::Instance()->GetAdventureData(this);
+	adventure_manager.GetAdventureData(this);
 }

 void Adventure::MoveCorpsesToGraveyard()
@@ -365,8 +368,8 @@ void Adventure::MoveCorpsesToGraveyard()

 	glm::vec4 position;

-	float x = GetTemplate()->graveyard_x + EQ::Random::Instance()->Real(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
-	float y = GetTemplate()->graveyard_y + EQ::Random::Instance()->Real(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
+	float x = GetTemplate()->graveyard_x + emu_random.Real(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
+	float y = GetTemplate()->graveyard_y + emu_random.Real(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
 	float z = GetTemplate()->graveyard_z;

 	position.x = x;
@@ -393,7 +396,7 @@ void Adventure::MoveCorpsesToGraveyard()
 		d->InstanceID  = 0;
 		d->ZoneID      = GetTemplate()->graveyard_zone_id;

-		ZSList::Instance()->SendPacket(0, GetInstanceID(), pack);
+		zoneserver_list.SendPacket(0, GetInstanceID(), pack);

 		delete pack;

@@ -404,7 +407,7 @@ void Adventure::MoveCorpsesToGraveyard()
 		spc->player_corpse_id = e.id;
 		spc->zone_id          = GetTemplate()->graveyard_zone_id;

-		ZSList::Instance()->SendPacket(spc->zone_id, 0, pack);
+		zoneserver_list.SendPacket(spc->zone_id, 0, pack);

 		delete pack;
 	}
@@ -14,6 +14,10 @@
 #include <sstream>
 #include <stdio.h>

+extern ZSList zoneserver_list;
+extern ClientList client_list;
+extern EQ::Random emu_random;
+
 AdventureManager::AdventureManager()
 {
 	process_timer = new Timer(500);
@@ -64,7 +68,7 @@ void AdventureManager::Process()
 void AdventureManager::CalculateAdventureRequestReply(const char *data)
 {
 	ServerAdventureRequest_Struct *sar = (ServerAdventureRequest_Struct*)data;
-	ClientListEntry *leader = ClientList::Instance()->FindCharacter(sar->leader);
+	ClientListEntry *leader = client_list.FindCharacter(sar->leader);
 	if(!leader)
 	{
 		return;
@@ -80,7 +84,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 		ServerAdventureRequestDeny_Struct *deny = (ServerAdventureRequestDeny_Struct*)pack->pBuffer;
 		strcpy(deny->leader, sar->leader);
 		strcpy(deny->reason, "There are currently no adventures set for this theme.");
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -109,7 +113,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 					ss << (data + sizeof(ServerAdventureRequest_Struct) + (64 * i)) << " is already apart of an active adventure.";

 					strcpy(deny->reason, ss.str().c_str());
-					ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+					zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 					delete pack;
 					return;
 				}
@@ -181,7 +185,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)

 	for(int i = 0; i < sar->member_count; ++i)
 	{
-		ClientListEntry *current = ClientList::Instance()->FindCharacter((data + sizeof(ServerAdventureRequest_Struct) + (64 * i)));
+		ClientListEntry *current = client_list.FindCharacter((data + sizeof(ServerAdventureRequest_Struct) + (64 * i)));
 		if(current)
 		{
 			int lvl = current->level();
@@ -240,7 +244,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 		ServerAdventureRequestDeny_Struct *deny = (ServerAdventureRequestDeny_Struct*)pack->pBuffer;
 		strcpy(deny->leader, sar->leader);
 		strcpy(deny->reason, "The number of found players for this adventure was zero.");
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -257,7 +261,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 		ss << "The maximum level range for this adventure is " << RuleI(Adventure, MaxLevelRange);
 		ss << " but the level range calculated was " << (max_level - min_level) << ".";
 		strcpy(deny->reason, ss.str().c_str());
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -320,7 +324,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 	if(eligible_adventures.size() > 0)
 	{
 		ea_iter = eligible_adventures.begin();
-		int c_index = EQ::Random::Instance()->Int(0, (eligible_adventures.size()-1));
+		int c_index = emu_random.Int(0, (eligible_adventures.size()-1));
 		for(int i = 0; i < c_index; ++i)
 		{
 			++ea_iter;
@@ -334,7 +338,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 		sra->id = (*ea_iter)->id;
 		sra->member_count = sar->member_count;
 		memcpy((pack->pBuffer + sizeof(ServerAdventureRequestAccept_Struct)), (data + sizeof(ServerAdventureRequest_Struct)), (sar->member_count * 64));
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -344,7 +348,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 		ServerAdventureRequestDeny_Struct *deny = (ServerAdventureRequestDeny_Struct*)pack->pBuffer;
 		strcpy(deny->leader, sar->leader);
 		strcpy(deny->reason, "The number of adventures returned was zero.");
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -353,7 +357,7 @@ void AdventureManager::CalculateAdventureRequestReply(const char *data)
 void AdventureManager::TryAdventureCreate(const char *data)
 {
 	ServerAdventureRequestCreate_Struct *src = (ServerAdventureRequestCreate_Struct*)data;
-	ClientListEntry *leader = ClientList::Instance()->FindCharacter(src->leader);
+	ClientListEntry *leader = client_list.FindCharacter(src->leader);
 	if(!leader)
 	{
 		return;
@@ -364,7 +368,7 @@ void AdventureManager::TryAdventureCreate(const char *data)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureCreateDeny, 64);
 		strcpy((char*)pack->pBuffer, src->leader);
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		return;
 	}
@@ -374,7 +378,7 @@ void AdventureManager::TryAdventureCreate(const char *data)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureCreateDeny, 64);
 		strcpy((char*)pack->pBuffer, src->leader);
-		ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+		zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 		delete pack;
 		delete adv;
 		return;
@@ -387,7 +391,7 @@ void AdventureManager::TryAdventureCreate(const char *data)
 		{
 			auto pack = new ServerPacket(ServerOP_AdventureCreateDeny, 64);
 			strcpy((char*)pack->pBuffer, src->leader);
-			ZSList::Instance()->SendPacket(leader->zone(), leader->instance(), pack);
+			zoneserver_list.SendPacket(leader->zone(), leader->instance(), pack);
 			delete pack;
 			delete adv;
 			return;
@@ -400,7 +404,7 @@ void AdventureManager::TryAdventureCreate(const char *data)
 	for(int i = 0; i < src->member_count; ++i)
 	{

-		ClientListEntry *player = ClientList::Instance()->FindCharacter((data + sizeof(ServerAdventureRequestCreate_Struct) + (64 * i)));
+		ClientListEntry *player = client_list.FindCharacter((data + sizeof(ServerAdventureRequestCreate_Struct) + (64 * i)));
 		if(player)
 		{
 			int f_count = 0;
@@ -432,7 +436,7 @@ void AdventureManager::TryAdventureCreate(const char *data)
 				sfa->zone_in_object = finished_adventures[f]->GetTemplate()->zone_in_object_id;
 			}

-			ZSList::Instance()->SendPacket(player->zone(), player->instance(), pack);
+			zoneserver_list.SendPacket(player->zone(), player->instance(), pack);
 			safe_delete_array(finished_adventures);
 			delete pack;
 		}
@@ -454,7 +458,7 @@ void AdventureManager::GetAdventureData(Adventure *adv)

 void AdventureManager::GetAdventureData(const char *name)
 {
-	ClientListEntry *player = ClientList::Instance()->FindCharacter(name);
+	ClientListEntry *player = client_list.FindCharacter(name);
 	if(player)
 	{
 		int f_count = 0;
@@ -493,7 +497,7 @@ void AdventureManager::GetAdventureData(const char *name)
 				delete pack;
 				auto pack = new ServerPacket(ServerOP_AdventureDataClear, 64);
 				strcpy((char*)pack->pBuffer, name);
-				ZSList::Instance()->SendPacket(player->zone(), player->instance(), pack);
+				zoneserver_list.SendPacket(player->zone(), player->instance(), pack);

 				delete pack;
 				delete[] finished_adventures;
@@ -511,7 +515,7 @@ void AdventureManager::GetAdventureData(const char *name)
 			sfa->zone_in_object = finished_adventures[i]->GetTemplate()->zone_in_object_id;
 		}

-		ZSList::Instance()->SendPacket(player->zone(), player->instance(), pack);
+		zoneserver_list.SendPacket(player->zone(), player->instance(), pack);
 		safe_delete_array(finished_adventures);
 		delete pack;
 		delete[] finished_adventures;
@@ -760,7 +764,7 @@ void AdventureManager::PlayerClickedDoor(const char *player, int zone_id, int do
 		{
 			if((*iter)->PlayerExists(player))
 			{
-				ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+				ClientListEntry *pc = client_list.FindCharacter(player);
 				if(pc)
 				{
 					auto pack =
@@ -779,7 +783,7 @@ void AdventureManager::PlayerClickedDoor(const char *player, int zone_id, int do
 						(*iter)->SetStatus(AS_WaitingForPrimaryEndTime);
 					}

-					ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+					zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 					safe_delete(pack);
 				}
 				return;
@@ -788,19 +792,19 @@ void AdventureManager::PlayerClickedDoor(const char *player, int zone_id, int do
 		++iter;
 	}

-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureClickDoorError, 64);
 		strcpy((char*)pack->pBuffer, player);
-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		safe_delete(pack);
 	}
 }

 void AdventureManager::LeaveAdventure(const char *name)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(name);
+	ClientListEntry *pc = client_list.FindCharacter(name);
 	if(pc)
 	{
 		Adventure *current = GetActiveAdventure(name);
@@ -810,7 +814,7 @@ void AdventureManager::LeaveAdventure(const char *name)
 			{
 				auto pack = new ServerPacket(ServerOP_AdventureLeaveDeny, 64);
 				strcpy((char*)pack->pBuffer, name);
-				ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+				zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 				safe_delete(pack);
 			}
 			else
@@ -823,7 +827,7 @@ void AdventureManager::LeaveAdventure(const char *name)
 				current->RemovePlayer(name);
 				auto pack = new ServerPacket(ServerOP_AdventureLeaveReply, 64);
 				strcpy((char*)pack->pBuffer, name);
-				ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+				zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 				safe_delete(pack);
 			}
 		}
@@ -831,7 +835,7 @@ void AdventureManager::LeaveAdventure(const char *name)
 		{
 			auto pack = new ServerPacket(ServerOP_AdventureLeaveReply, 64);
 			strcpy((char*)pack->pBuffer, name);
-			ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+			zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 			safe_delete(pack);
 		}
 	}
@@ -863,12 +867,12 @@ void AdventureManager::IncrementCount(uint16 instance_id)

 		while(siter != slist.end())
 		{
-			ClientListEntry *pc = ClientList::Instance()->FindCharacter((*siter).c_str());
+			ClientListEntry *pc = client_list.FindCharacter((*siter).c_str());
 			if(pc)
 			{
 				memset(ac->player, 0, 64);
 				strcpy(ac->player, (*siter).c_str());
-				ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+				zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 			}
 			++siter;
 		}
@@ -932,7 +936,7 @@ void AdventureManager::GetZoneData(uint16 instance_id)
 		zd->dest_y = temp->dest_y;
 		zd->dest_z = temp->dest_z;
 		zd->dest_h = temp->dest_h;
-		ZSList::Instance()->SendPacket(0, instance_id, pack);
+		zoneserver_list.SendPacket(0, instance_id, pack);
 		delete pack;
 	}
 }
@@ -1258,7 +1262,7 @@ void AdventureManager::DoLeaderboardRequest(const char* player, uint8 type)

 void AdventureManager::DoLeaderboardRequestWins(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1317,14 +1321,14 @@ void AdventureManager::DoLeaderboardRequestWins(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentage(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1383,14 +1387,14 @@ void AdventureManager::DoLeaderboardRequestPercentage(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestWinsGuk(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1449,14 +1453,14 @@ void AdventureManager::DoLeaderboardRequestWinsGuk(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentageGuk(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1515,14 +1519,14 @@ void AdventureManager::DoLeaderboardRequestPercentageGuk(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestWinsMir(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1581,14 +1585,14 @@ void AdventureManager::DoLeaderboardRequestWinsMir(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentageMir(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1647,14 +1651,14 @@ void AdventureManager::DoLeaderboardRequestPercentageMir(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestWinsMmc(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1713,14 +1717,14 @@ void AdventureManager::DoLeaderboardRequestWinsMmc(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentageMmc(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1779,14 +1783,14 @@ void AdventureManager::DoLeaderboardRequestPercentageMmc(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestWinsRuj(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1845,14 +1849,14 @@ void AdventureManager::DoLeaderboardRequestWinsRuj(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentageRuj(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1911,14 +1915,14 @@ void AdventureManager::DoLeaderboardRequestPercentageRuj(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestWinsTak(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -1977,14 +1981,14 @@ void AdventureManager::DoLeaderboardRequestWinsTak(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }

 void AdventureManager::DoLeaderboardRequestPercentageTak(const char* player)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(player);
+	ClientListEntry *pc = client_list.FindCharacter(player);
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureLeaderboard, 64 + sizeof(AdventureLeaderboard_Struct));
@@ -2043,7 +2047,7 @@ void AdventureManager::DoLeaderboardRequestPercentageTak(const char* player)
 			al->failure = our_failures;
 		}

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }
@@ -2070,7 +2074,7 @@ bool AdventureManager::PopFinishedEvent(const char *name, AdventureFinishEvent &

 void AdventureManager::SendAdventureFinish(AdventureFinishEvent fe)
 {
-	ClientListEntry *pc = ClientList::Instance()->FindCharacter(fe.name.c_str());
+	ClientListEntry *pc = client_list.FindCharacter(fe.name.c_str());
 	if(pc)
 	{
 		auto pack = new ServerPacket(ServerOP_AdventureFinish, sizeof(ServerAdventureFinish_Struct));
@@ -2080,7 +2084,7 @@ void AdventureManager::SendAdventureFinish(AdventureFinishEvent fe)
 		af->win = fe.win;
 		af->points = fe.points;

-		ZSList::Instance()->SendPacket(pc->zone(), pc->instance(), pack);
+		zoneserver_list.SendPacket(pc->zone(), pc->instance(), pack);
 		delete pack;
 	}
 }
@@ -40,12 +40,6 @@ public:
 	AdventureTemplate *GetAdventureTemplate(int theme, int id);
 	AdventureTemplate *GetAdventureTemplate(int id);
 	void GetZoneData(uint16 instance_id);
-
-	static AdventureManager* Instance()
-	{
-		static AdventureManager instance;
-		return &instance;
-	}
 protected:
 	bool IsInExcludedZoneList(std::list<AdventureZones> excluded_zones, std::string zone_name, int version);
 	bool IsInExcludedZoneInList(std::list<AdventureZoneIn> excluded_zone_ins, int zone_id, int door_object);
@@ -12,9 +12,9 @@ void WorldserverCLI::EtlGetSettings(int argc, char **argv, argh::parser &cmd, st
 	Json::Value etl_settings;
 	Json::Value player_events;

-	PlayerEventLogs::Instance()->SetDatabase(&database)->Init();
-	auto event_settings = PlayerEventLogs::Instance()->GetSettings();
-	auto etl_details    = PlayerEventLogs::Instance()->GetEtlSettings();
+	player_event_logs.SetDatabase(&database)->Init();
+	auto event_settings = player_event_logs.GetSettings();
+	auto etl_details    = player_event_logs.GetEtlSettings();

 	for (int i = PlayerEvent::GM_COMMAND; i < PlayerEvent::EventType::MAX; i++) {
 		player_events["event_id"]    = event_settings[i].id;
@@ -16,7 +16,7 @@ void WorldserverCLI::ExpansionTestCommand(int argc, char **argv, argh::parser &c
 		LogInfo("No rule set configured, using default rules");
 	}

-	WorldContentService::Instance()->SetCurrentExpansion(RuleI(Expansion, CurrentExpansion));
+	content_service.SetCurrentExpansion(RuleI(Expansion, CurrentExpansion));

 	std::vector<ContentFlagsRepository::ContentFlags> flags = {};
 	auto                                              f     = ContentFlagsRepository::NewEntity();
@@ -32,13 +32,13 @@ void WorldserverCLI::ExpansionTestCommand(int argc, char **argv, argh::parser &c
 		flags.push_back(f);
 	}

-	WorldContentService::Instance()->SetContentFlags(flags);
+	content_service.SetContentFlags(flags);

 	LogInfo(
 		"Current expansion is [{}] ({}) is Velious Enabled [{}] Criteria [{}]",
-		WorldContentService::Instance()->GetCurrentExpansion(),
-		WorldContentService::Instance()->GetCurrentExpansionName(),
-		WorldContentService::Instance()->IsTheScarsOfVeliousEnabled() ? "true" : "false",
+		content_service.GetCurrentExpansion(),
+		content_service.GetCurrentExpansionName(),
+		content_service.IsTheScarsOfVeliousEnabled() ? "true" : "false",
 		ContentFilterCriteria::apply()
 	);
 }
@@ -36,7 +36,6 @@
 #include "../common/shareddb.h"
 #include "../common/opcodemgr.h"
 #include "../common/data_verification.h"
-#include "../common/data_bucket.h"

 #include "client.h"
 #include "worlddb.h"
@@ -89,6 +88,10 @@
 std::vector<RaceClassAllocation> character_create_allocations;
 std::vector<RaceClassCombos> character_create_race_class_combos;

+extern ZSList zoneserver_list;
+extern LoginServerList loginserverlist;
+extern ClientList client_list;
+extern EQ::Random emu_random;
 extern uint32 numclients;
 extern volatile bool RunLoops;
 extern volatile bool UCSServerAvailable_;
@@ -132,8 +135,6 @@ Client::Client(EQStreamInterface* ieqs)
 }

 Client::~Client() {
-	ClearDataBucketsCache();
-
 	if (RunLoops && cle && zone_id == 0)
 		cle->SetOnline(CLE_Status::Offline);

@@ -475,9 +476,7 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)

 	LogClientLogin("Checking authentication id [{}]", id);

-	if ((cle = ClientList::Instance()->CheckAuth(id, password))) {
-		LoadDataBucketsCache();
-
+	if ((cle = client_list.CheckAuth(id, password))) {
 		LogClientLogin("Checking authentication id [{}] passed", id);
 		if (!is_player_zoning) {
 			// Track who is in and who is out of the game
@@ -515,7 +514,7 @@ bool Client::HandleSendLoginInfoPacket(const EQApplicationPacket *app)
 			ServerLSPlayerJoinWorld_Struct* join =(ServerLSPlayerJoinWorld_Struct*)pack->pBuffer;
 			strcpy(join->key,GetLSKey());
 			join->lsaccount_id = GetLSID();
-			LoginServerList::Instance()->SendPacket(pack);
+			loginserverlist.SendPacket(pack);
 			safe_delete(pack);
 		}

@@ -798,7 +797,7 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
 		RuleB(World, EnableIPExemptions) ||
 		RuleI(World, MaxClientsPerIP) > 0
 	) {
-		ClientList::Instance()->GetCLEIP(GetIP()); //Check current CLE Entry IPs against incoming connection
+		client_list.GetCLEIP(GetIP()); //Check current CLE Entry IPs against incoming connection
 	}

 	auto ew = (EnterWorld_Struct *) app->pBuffer;
@@ -818,7 +817,7 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
 		return true;
 	}

-	auto r = WorldContentService::Instance()->FindZone(zone_id, instance_id);
+	auto r = content_service.FindZone(zone_id, instance_id);
 	if (r.zone_id && r.instance.id != instance_id) {
 		LogInfo(
 			"Zone [{}] has been remapped to instance_id [{}] from instance_id [{}] for client [{}]",
@@ -985,7 +984,7 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
 	safe_delete(outapp);

 	// set mailkey - used for duration of character session
-	int mail_key = EQ::Random::Instance()->Int(1, INT_MAX);
+	int mail_key = emu_random.Int(1, INT_MAX);

 	database.SetMailKey(charid, GetIP(), mail_key);
 	if (UCSServerAvailable_) {
@@ -1098,7 +1097,7 @@ bool Client::HandlePacket(const EQApplicationPacket *app) {
 		OpcodeManager::EmuToName(app->GetOpcode()),
 		o->EmuToEQ(app->GetOpcode()) == 0 ? app->GetProtocolOpcode() : o->EmuToEQ(app->GetOpcode()),
 		app->Size(),
-		(EQEmuLogSys::Instance()->IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
+		(LogSys.IsLogEnabled(Logs::Detail, Logs::PacketClientServer) ? DumpPacketToString(app) : "")
 	);

 	if (!eqs->CheckState(ESTABLISHED)) {
@@ -1247,7 +1246,7 @@ bool Client::Process() {
 			ServerLSPlayerLeftWorld_Struct* logout =(ServerLSPlayerLeftWorld_Struct*)pack->pBuffer;
 			strcpy(logout->key,GetLSKey());
 			logout->lsaccount_id = GetLSID();
-			LoginServerList::Instance()->SendPacket(pack);
+			loginserverlist.SendPacket(pack);
 			safe_delete(pack);
 		}
 		LogInfo("Client disconnected (not active in process)");
@@ -1413,18 +1412,18 @@ void Client::EnterWorld(bool TryBootup) {
 			return;
 		}

-		zone_server = ZSList::Instance()->FindByInstanceID(instance_id);
+		zone_server = zoneserver_list.FindByInstanceID(instance_id);
 	}
 	else
 	{
-		zone_server = ZSList::Instance()->FindByZoneID(zone_id);
+		zone_server = zoneserver_list.FindByZoneID(zone_id);
 	}

 	const char *zone_name = ZoneName(zone_id, true);
 	if (zone_server) {
 		if (false == enter_world_triggered) {
 			//Drop any clients we own in other zones.
-			ZSList::Instance()->DropClient(GetLSID(), zone_server);
+			zoneserver_list.DropClient(GetLSID(), zone_server);

 			// warn the zone we're coming
 			zone_server->IncomingClient(this);
@@ -1437,7 +1436,7 @@ void Client::EnterWorld(bool TryBootup) {
 		if (TryBootup) {
 			LogInfo("Attempting autobootup of [{}] [{}] [{}]", zone_name, zone_id, instance_id);
 			autobootup_timeout.Start();
-			zone_waiting_for_bootup = ZSList::Instance()->TriggerBootup(zone_id, instance_id);
+			zone_waiting_for_bootup = zoneserver_list.TriggerBootup(zone_id, instance_id);
 			if (zone_waiting_for_bootup == 0) {
 				LogInfo("No zoneserver available to boot up");
 				TellClientZoneUnavailable();
@@ -1453,7 +1452,7 @@ void Client::EnterWorld(bool TryBootup) {

 	zone_waiting_for_bootup = 0;

-	if (GetAdmin() < 80 && ZSList::Instance()->IsZoneLocked(zone_id)) {
+	if (GetAdmin() < 80 && zoneserver_list.IsZoneLocked(zone_id)) {
 		LogInfo("Enter world failed. Zone is locked");
 		TellClientZoneUnavailable();
 		return;
@@ -1499,11 +1498,11 @@ void Client::Clearance(int8 response)
 	ZoneServer* zs = nullptr;
 	if(instance_id > 0)
 	{
-		zs = ZSList::Instance()->FindByInstanceID(instance_id);
+		zs = zoneserver_list.FindByInstanceID(instance_id);
 	}
 	else
 	{
-		zs = ZSList::Instance()->FindByZoneID(zone_id);
+		zs = zoneserver_list.FindByZoneID(zone_id);
 	}

 	if(zs == 0 || response == -1 || response == 0)
@@ -2172,7 +2171,7 @@ void Client::SetClassStartingSkills(PlayerProfile_Struct *pp)
 				i == EQ::skills::SkillAlcoholTolerance || i == EQ::skills::SkillBindWound)
 				continue;

-			pp->skills[i] = SkillCaps::Instance()->GetSkillCap(pp->class_, (EQ::skills::SkillType)i, 1).cap;
+			pp->skills[i] = skill_caps.GetSkillCap(pp->class_, (EQ::skills::SkillType)i, 1).cap;
 		}
 	}

@@ -2370,7 +2369,7 @@ bool Client::StoreCharacter(
 		return false;
 	}

-	const std::string& zone_name = ZoneStore::Instance()->GetZoneName(p_player_profile_struct->zone_id, true);
+	const std::string& zone_name = zone_store.GetZoneName(p_player_profile_struct->zone_id, true);
 	if (Strings::EqualFold(zone_name, "UNKNOWN")) {
 		p_player_profile_struct->zone_id = Zones::QEYNOS;
 	}
@@ -2428,7 +2427,7 @@ bool Client::StoreCharacter(

 void Client::RecordPossibleHack(const std::string& message)
 {
-	if (PlayerEventLogs::Instance()->IsEventEnabled(PlayerEvent::POSSIBLE_HACK)) {
+	if (player_event_logs.IsEventEnabled(PlayerEvent::POSSIBLE_HACK)) {
 		auto event = PlayerEvent::PossibleHackEvent{.message = message};
 		std::stringstream ss;
 		{
@@ -2519,19 +2518,3 @@ void Client::SendUnsupportedClientPacket(const std::string& message)

 	QueuePacket(&packet);
 }
-
-void Client::LoadDataBucketsCache()
-{
-	DataBucket::BulkLoadEntitiesToCache(DataBucketLoadType::Account, {GetAccountID()});
-	const auto ids = CharacterDataRepository::GetCharacterIDsByAccountID(database, GetAccountID());
-	DataBucket::BulkLoadEntitiesToCache(DataBucketLoadType::Client, ids);
-}
-
-void Client::ClearDataBucketsCache()
-{
-	DataBucket::DeleteFromCache(GetAccountID(), DataBucketLoadType::Account);
-	auto ids = CharacterDataRepository::GetCharacterIDsByAccountID(database, GetAccountID());
-	for (const auto& id : ids) {
-		DataBucket::DeleteFromCache(id, DataBucketLoadType::Client);
-	}
-}
@@ -121,9 +121,6 @@ private:
 	bool CanTradeFVNoDropItem();
 	void RecordPossibleHack(const std::string& message);
 	void SendUnsupportedClientPacket(const std::string& message);
-
-	void LoadDataBucketsCache();
-	void ClearDataBucketsCache();
 };

 bool CheckCharCreateInfoSoF(CharCreate_Struct *cc);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chris Miles	faa6819f80	.	2025-06-14 00:03:28 -05:00
Chris Miles	4cc1d99322	Update zone.h	2025-06-13 23:52:34 -05:00