[Release] 22.22.1

[Doors] Add door blacklist (#3516 )
* [Doors] Add door blacklist * Renaming to simplify
2026-05-27 13:02:28 +00:00 · 2023-07-30 01:36:49 -05:00 · 2023-07-30 01:35:44 -05:00 · 2023-07-28 22:22:43 -05:00 · 2023-07-28 11:35:40 -05:00 · 2023-07-27 23:16:41 -05:00
372 changed files with 17513 additions and 10080 deletions
@@ -1,3 +1,266 @@
+## [22.22.1] - 07/30/2023
+
+### Database
+
+* Hotfix: Add command_subsettings to server tables  @Akkadius 2023-07-29
+
+### Doors
+
+* Add door blacklist ([#3516](https://github.com/EQEmu/Server/pull/3516)) @Akkadius 2023-07-30
+
+## [22.22.0] - 07/27/2023
+
+### Code
+
+* Fix casing in corpse money and decay time. ([#3511](https://github.com/EQEmu/Server/pull/3511)) @Kinglykrab 2023-07-23
+
+### Crash Fix
+
+* Guard against Spells:MaxTotalSlotsPET being set above client allowed maximum. ([#3507](https://github.com/EQEmu/Server/pull/3507)) @Valorith 2023-07-22
+
+### Data Buckets
+
+* Distributed Databucket Caching ([#3500](https://github.com/EQEmu/Server/pull/3500)) @Kinglykrab 2023-07-24
+
+### Database
+
+* Fix console output in database:dump --dump-output-to-console  @Akkadius 2023-07-25
+
+### Fixes
+
+* Escape search string in #find item ([#3510](https://github.com/EQEmu/Server/pull/3510)) @Kinglykrab 2023-07-22
+
+### Quest API
+
+* Add GetMobTypeIdentifier() to Perl/Lua ([#3512](https://github.com/EQEmu/Server/pull/3512)) @Kinglykrab 2023-07-28
+
+### Saylink
+
+* Fix cases where saylinks were not being cached ([#3508](https://github.com/EQEmu/Server/pull/3508)) @Akkadius 2023-07-20
+
+## [22.21.2] - 07/19/2023
+
+### Databuckets
+
+* Fix rarer same bucket name scoping overlap issue ([#3509](https://github.com/EQEmu/Server/pull/3509)) @Akkadius 2023-07-20
+
+## [22.21.1] - 07/18/2023
+
+### Bug
+
+* Show Petition and Show Petition_Info fix ([#3503](https://github.com/EQEmu/Server/pull/3503)) @fryguy503 2023-07-18
+
+### Code
+
+* Remove arbitrary teleport blocking in Tutorial and Load zones ([#3506](https://github.com/EQEmu/Server/pull/3506)) @Valorith 2023-07-19
+
+### Databuckets
+
+* Fix issue with expired databuckets not being expired and returned properly ([#3504](https://github.com/EQEmu/Server/pull/3504)) @Akkadius 2023-07-18
+
+### Fixes
+
+* #set title_suffix Argument Position ([#3505](https://github.com/EQEmu/Server/pull/3505)) @Kinglykrab 2023-07-18
+
+## [22.21.0] - 07/18/2023
+
+### Data Buckets
+
+* Implement scoped data buckets ([#3498](https://github.com/EQEmu/Server/pull/3498)) @Akkadius 2023-07-16
+
+### Fixes
+
+* Fix rule check and add rule for pickpocket command ([#3492](https://github.com/EQEmu/Server/pull/3492)) @tuday2 2023-07-16
+
+### Pathing
+
+* Improvements to roambox logic, pathing ([#3502](https://github.com/EQEmu/Server/pull/3502)) @Akkadius 2023-07-18
+
+### Quest API
+
+* Add SetLDoNPoints() to Perl/Lua ([#3496](https://github.com/EQEmu/Server/pull/3496)) @Kinglykrab 2023-07-16
+
+### Z Clipping
+
+* Don't issue zclip adjustments when NPC is not moving ([#3499](https://github.com/EQEmu/Server/pull/3499)) @Akkadius 2023-07-16
+
+## [22.20.1] - 07/15/2023
+
+### Database
+
+* Fix database manifest entry for #3443  @neckkola 2023-07-15
+
+## [22.20.0] - 07/15/2023
+
+### Bots
+
+* Remove orphaned commands related to botgroup ([#3489](https://github.com/EQEmu/Server/pull/3489)) @tuday2 2023-07-09
+
+### Commands
+
+* Consolidate #set-like commands into a singular #set command ([#3486](https://github.com/EQEmu/Server/pull/3486)) @Kinglykrab 2023-07-15
+
+### Feature
+
+* Add Support for item textures higher than 65,535 ([#3494](https://github.com/EQEmu/Server/pull/3494)) @Kinglykrab 2023-07-14
+* Update raid features ([#3443](https://github.com/EQEmu/Server/pull/3443)) @neckkola 2023-07-13
+
+### Fixes
+
+* Fix Tradeskill Combines with augmented items ([#3490](https://github.com/EQEmu/Server/pull/3490)) @Kinglykrab 2023-07-15
+* Fix charmed pets to follow when charmed. ([#3488](https://github.com/EQEmu/Server/pull/3488)) @noudess 2023-07-08
+* Update bot naming check and add more explanation ([#3491](https://github.com/EQEmu/Server/pull/3491)) @tuday2 2023-07-13
+
+### Quest API
+
+* Add Mob/Entity type check methods to Perl/Lua ([#3493](https://github.com/EQEmu/Server/pull/3493)) @Kinglykrab 2023-07-13
+
+## [22.19.0] - 07/08/2023
+
+### Bots
+
+* Add Pickpocket Command ([#3484](https://github.com/EQEmu/Server/pull/3484)) @tuday2 2023-07-08
+
+### Code
+
+* Move #find item summon links to front ([#3483](https://github.com/EQEmu/Server/pull/3483)) @Kinglykrab 2023-07-05
+* Remove LoadItemDBFieldNames() from common/misc.cpp and common/misc.h ([#3473](https://github.com/EQEmu/Server/pull/3473)) @Kinglykrab 2023-07-04
+
+### Commands
+
+* Add #itemsearch alias to #find aliases ([#3485](https://github.com/EQEmu/Server/pull/3485)) @Kinglykrab 2023-07-08
+* Consolidate #show commands into a singular #show command ([#3478](https://github.com/EQEmu/Server/pull/3478)) @Kinglykrab 2023-07-08
+
+### Fixes
+
+* Fix _PutItem having a slot_id of -1 on mobs with no items ([#3474](https://github.com/EQEmu/Server/pull/3474)) @Kinglykrab 2023-07-04
+
+### Rules
+
+* Add Skills:TrivialTradeskillCombinesNoFail Rule ([#3481](https://github.com/EQEmu/Server/pull/3481)) @JasXSL 2023-07-05
+
+## [22.18.0] - 07/04/2023
+
+### Commands
+
+* Add #emotesearch to #find command ([#3480](https://github.com/EQEmu/Server/pull/3480)) @Kinglykrab 2023-07-04
+* Cleanup #copycharacter Command ([#3479](https://github.com/EQEmu/Server/pull/3479)) @Kinglykrab 2023-07-04
+
+### Fixes
+
+* Add chatchannel_reserved_names to a new manifest ([#3482](https://github.com/EQEmu/Server/pull/3482)) @Kinglykrab 2023-07-04
+* Fix issue in zone store of returning reference to local variable ([#3477](https://github.com/EQEmu/Server/pull/3477)) @Kinglykrab 2023-07-04
+
+## [22.17.0] - 07/03/2023
+
+### Cleanup/Feature
+
+* Add support for bots to #showstats/#mystats ([#3427](https://github.com/EQEmu/Server/pull/3427)) @Kinglykrab 2023-07-01
+
+### Code
+
+* Remove LoadItemDBFieldNames() from common/misc.cpp and common/misc.h ([#3473](https://github.com/EQEmu/Server/pull/3473)) @Kinglykrab 2023-07-04
+* Remove handle_npc_single_npc from zone/lua_parser_events.cpp and zone/lua_parser_events.h ([#3467](https://github.com/EQEmu/Server/pull/3467)) @Kinglykrab 2023-07-03
+
+### Database
+
+* Set multi statements off when returning early ([#3462](https://github.com/EQEmu/Server/pull/3462)) @Akkadius 2023-07-01
+
+### Feature
+
+* Add Strings::BeginsWith() and Strings::EndsWith() ([#3471](https://github.com/EQEmu/Server/pull/3471)) @Kinglykrab 2023-07-03
+
+### Fixes
+
+* Add check for underscores in botcreate command ([#3458](https://github.com/EQEmu/Server/pull/3458)) @tuday2 2023-06-29
+* EVENT_LANGUAGE_SKILL_UP in Lua was using EVENT_SKILL_UP logic ([#3466](https://github.com/EQEmu/Server/pull/3466)) @Kinglykrab 2023-07-03
+* Fix _PutItem having a slot_id of -1 on mobs with no items ([#3474](https://github.com/EQEmu/Server/pull/3474)) @Kinglykrab 2023-07-04
+* Fix data type of GetAggroCount() ([#3470](https://github.com/EQEmu/Server/pull/3470)) @Kinglykrab 2023-07-03
+
+### Logging
+
+* Fix logging crash when % are sent through query logs ([#3461](https://github.com/EQEmu/Server/pull/3461)) @Akkadius 2023-07-01
+
+### Quest API
+
+* Add ClearAccountFlag() and GetAccountFlags() to Perl/Lua ([#3469](https://github.com/EQEmu/Server/pull/3469)) @Kinglykrab 2023-07-03
+* Add GetClassAbbreviation() and GetRaceAbbreviation() to Perl/Lua ([#3463](https://github.com/EQEmu/Server/pull/3463)) @Kinglykrab 2023-07-02
+* Add GetClassPlural() and GetRacePlural() to Perl/Lua ([#3468](https://github.com/EQEmu/Server/pull/3468)) @Kinglykrab 2023-07-03
+* Add GetCloseMobList() and CalculateDistance() overload to Perl/Lua ([#3455](https://github.com/EQEmu/Server/pull/3455)) @Kinglykrab 2023-07-02
+* Add Hate Entry Methods to Perl ([#3459](https://github.com/EQEmu/Server/pull/3459)) @Kinglykrab 2023-07-02
+* Add ItemData Class to Perl ([#3465](https://github.com/EQEmu/Server/pull/3465)) @Kinglykrab 2023-07-02
+* Add Spawn2 Class to Perl ([#3456](https://github.com/EQEmu/Server/pull/3456)) @Kinglykrab 2023-07-02
+* Add StatBonuses Class to Perl ([#3460](https://github.com/EQEmu/Server/pull/3460)) @Kinglykrab 2023-07-02
+* Add missing Item Methods to Perl/Lua. ([#3464](https://github.com/EQEmu/Server/pull/3464)) @Kinglykrab 2023-07-02
+
+## [22.16.0] - 06/27/2023
+
+### Code
+
+* Default skill type to Hand to Hand in #npcedit meleetype ([#3422](https://github.com/EQEmu/Server/pull/3422)) @Kinglykrab 2023-06-19
+* Delete common/worldconn.cpp ([#3436](https://github.com/EQEmu/Server/pull/3436)) @Kinglykrab 2023-06-24
+* Remove DatabaseCastAccepted() from zone/npc.cpp and zone/npc.h ([#3449](https://github.com/EQEmu/Server/pull/3449)) @Kinglykrab 2023-06-24
+* Remove GetACAvoid() from zone/merc.h ([#3447](https://github.com/EQEmu/Server/pull/3447)) @Kinglykrab 2023-06-25
+* Remove GetACMit() from zone/merc.h ([#3446](https://github.com/EQEmu/Server/pull/3446)) @Kinglykrab 2023-06-24
+* Remove _ClearWaypints() from zone/npc.h ([#3445](https://github.com/EQEmu/Server/pull/3445)) @Kinglykrab 2023-06-24
+* Remove acmod() from zone/merc.h ([#3448](https://github.com/EQEmu/Server/pull/3448)) @Kinglykrab 2023-06-24
+* Remove command_packetprofile from zone/command.h ([#3432](https://github.com/EQEmu/Server/pull/3432)) @Kinglykrab 2023-06-24
+* Remove command_showpetspell in zone/command.h ([#3430](https://github.com/EQEmu/Server/pull/3430)) @Kinglykrab 2023-06-24
+* Remove command_unlock from zone/command.h ([#3431](https://github.com/EQEmu/Server/pull/3431)) @Kinglykrab 2023-06-24
+
+### Commands
+
+* Add #finddeity Command ([#3435](https://github.com/EQEmu/Server/pull/3435)) @Kinglykrab 2023-06-26
+* Add #findlanguage Command ([#3434](https://github.com/EQEmu/Server/pull/3434)) @Kinglykrab 2023-06-25
+* Add #showspells Command ([#3429](https://github.com/EQEmu/Server/pull/3429)) @Kinglykrab 2023-06-24
+* Add missing subcommands to #npcedit ([#3423](https://github.com/EQEmu/Server/pull/3423)) @Kinglykrab 2023-06-19
+* Cleanup #showbuffs Command ([#3439](https://github.com/EQEmu/Server/pull/3439)) @Kinglykrab 2023-06-26
+* Cleanup #shownpcgloballoot and #showzonegloballoot Commands ([#3440](https://github.com/EQEmu/Server/pull/3440)) @Kinglykrab 2023-06-24
+* Cleanup #viewcurrencies Command ([#3441](https://github.com/EQEmu/Server/pull/3441)) @Kinglykrab 2023-06-25
+* Consolidate #findX commands to a singular #find Command ([#3452](https://github.com/EQEmu/Server/pull/3452)) @Kinglykrab 2023-06-28
+* Consolidate #merchant_close_shop and #merchant_open_shop to #merchantshop ([#3433](https://github.com/EQEmu/Server/pull/3433)) @Kinglykrab 2023-06-24
+* Delete #showbonusstats Command ([#3437](https://github.com/EQEmu/Server/pull/3437)) @Kinglykrab 2023-06-24
+* Delete #spellinfo Command ([#3438](https://github.com/EQEmu/Server/pull/3438)) @Kinglykrab 2023-06-24
+
+### Database
+
+* Fix database version checking edge case issue ([#3428](https://github.com/EQEmu/Server/pull/3428)) @Akkadius 2023-06-22
+* Fix multi-statement error reporting ([#3425](https://github.com/EQEmu/Server/pull/3425)) @Akkadius 2023-06-19
+* Implement native database migrations in server ([#2857](https://github.com/EQEmu/Server/pull/2857)) @Akkadius 2023-06-19
+
+### Fixes
+
+* Fix NPC Item Stat Bonuses ([#3444](https://github.com/EQEmu/Server/pull/3444)) @Kinglykrab 2023-06-26
+* Fix error in 023_01_21_bots_raid_members.sql ([#3453](https://github.com/EQEmu/Server/pull/3453)) @mibastian 2023-06-28
+* Fix possible crash with #npcedit weapon ([#3421](https://github.com/EQEmu/Server/pull/3421)) @Kinglykrab 2023-06-19
+* Merchant Open Flag set only for regular Merchants ([#3454](https://github.com/EQEmu/Server/pull/3454)) @Kinglykrab 2023-06-27
+
+### Readme
+
+* Update new location of database updates ([#3424](https://github.com/EQEmu/Server/pull/3424)) @joligario 2023-06-19
+
+### Rules
+
+* Add ClientPetsUserOwnerNameInLastName rule ([#3442](https://github.com/EQEmu/Server/pull/3442)) @Kinglykrab 2023-06-25
+
+## [22.15.3] - 06/19/2023
+
+### Fixes
+
+* Fix improper condition in Water LOS checks ([#3426](https://github.com/EQEmu/Server/pull/3426)) @Kinglykrab 2023-06-19
+
+## [22.15.2] - 06/19/2023
+
+### Database
+
+* Fix multi-statement error reporting ([#3425](https://github.com/EQEmu/Server/pull/3425)) @Akkadius 2023-06-19
+
+## [22.15.1] - 06/19/2023
+
+### Schema
+
+* Add `chatchannel_reserved_names` table to `database_schema.h`
+
 ## [22.15.0] - 06/19/2023

 ### Code
@@ -17,6 +17,7 @@
 	*/
 #include "../common/global_define.h"
 #include "../common/classes.h"
+#include "data_verification.h"

 const char *GetClassIDName(uint8 class_id, uint8 level)
 {
@@ -750,3 +751,51 @@ uint8 ClassArmorType(uint8 class_id)
 			return ARMOR_TYPE_UNKNOWN;
 	}
 }
+
+const std::string GetPlayerClassAbbreviation(uint8 class_id)
+{
+	if (!EQ::ValueWithin(class_id, WARRIOR, BERSERKER)) {
+		return std::string("UNK");
+	}
+
+	switch (class_id) {
+		case WARRIOR:
+			return "WAR";
+		case CLERIC:
+			return "CLR";
+		case PALADIN:
+			return "PAL";
+		case RANGER:
+			return "RNG";
+		case SHADOWKNIGHT:
+			return "SHD";
+		case DRUID:
+			return "DRU";
+		case MONK:
+			return "MNK";
+		case BARD:
+			return "BRD";
+		case ROGUE:
+			return "ROG";
+		case SHAMAN:
+			return "SHM";
+		case NECROMANCER:
+			return "NEC";
+		case WIZARD:
+			return "WIZ";
+		case MAGICIAN:
+			return "MAG";
+		case ENCHANTER:
+			return "ENC";
+		case BEASTLORD:
+			return "BST";
+		case BERSERKER:
+			return "BER";
+	}
+
+	return std::string("UNK");
+}
+
+bool IsPlayerClass(uint8 class_id) {
+	return EQ::ValueWithin(class_id, WARRIOR, BERSERKER);
+}
@@ -19,6 +19,7 @@
 #define CLASSES_CH

 #include "../common/types.h"
+#include <string>

 #define NO_CLASS 0
 #define WARRIOR 1
@@ -127,6 +128,9 @@
 const char* GetClassIDName(uint8 class_id, uint8 level = 0);
 const char* GetPlayerClassName(uint32 player_class_value, uint8 level = 0);

+bool IsPlayerClass(uint8 class_id);
+const std::string GetPlayerClassAbbreviation(uint8 class_id);
+
 uint32 GetPlayerClassValue(uint8 class_id);
 uint32 GetPlayerClassBit(uint8 class_id);

@@ -324,7 +324,9 @@ void DatabaseDumpService::DatabaseDump()
 		}
 	}

-	LogSys.LoadLogSettingsDefaults();
+	if (!IsDumpOutputToConsole()) {
+		LogSys.LoadLogSettingsDefaults();
+	}

 	if (!pipe_file.empty()) {
 		std::string file = fmt::format("{}.sql", GetDumpFileNameWithPath());
@@ -46,7 +46,7 @@ void DatabaseUpdate::CheckDbUpdates()
 	InjectBotsVersionColumn();
 	auto v = GetDatabaseVersions();
 	auto b = GetBinaryDatabaseVersions();
-	if (CheckVersions(v, b)) {
+	if (CheckVersionsUpToDate(v, b)) {
 		return;
 	}

@@ -183,7 +183,7 @@ bool DatabaseUpdate::UpdateManifest(

 					// ignore empty query result "errors"
 					if (r.ErrorNumber() != 1065 && !r.ErrorMessage().empty()) {
-						LogError("[{}]", r.ErrorMessage());
+						LogError("(#{}) [{}]", r.ErrorNumber(), r.ErrorMessage());
 						errored_migration = true;

 						LogInfo("Required database update failed. This could be a problem");
@@ -247,7 +247,7 @@ DatabaseUpdate *DatabaseUpdate::SetDatabase(Database *db)
 	return this;
 }

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

@@ -259,7 +259,7 @@ bool DatabaseUpdate::CheckVersions(DatabaseVersion v, DatabaseVersion b)
 		(v.server_database_version == b.server_database_version) ? "up to date" : "checking updates"
 	);

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

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

-	return (v.server_database_version == b.server_database_version) &&
-		   (v.bots_database_version == b.bots_database_version);
+	// server database version is required
+	bool server_up_to_date = v.server_database_version == b.server_database_version;
+	// bots database version is optional, if not enabled then it is always up-to-date
+	bool bots_up_to_date   = RuleB(Bots, Enabled) ? v.bots_database_version == b.bots_database_version : true;
+
+	return server_up_to_date && bots_up_to_date;
 }

 // checks to see if there are pending updates
@@ -284,7 +288,7 @@ bool DatabaseUpdate::HasPendingUpdates()
 	auto v = GetDatabaseVersions();
 	auto b = GetBinaryDatabaseVersions();

-	return !CheckVersions(v, b);
+	return !CheckVersionsUpToDate(v, b);
 }

 void DatabaseUpdate::InjectBotsVersionColumn()
@@ -30,7 +30,7 @@ public:
 	bool HasPendingUpdates();
 private:
 	Database *m_database;
-	static bool CheckVersions(DatabaseVersion v, DatabaseVersion b);
+	static bool CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b);
 	void InjectBotsVersionColumn();
 };

@@ -4642,11 +4642,10 @@ ADD COLUMN `avoidance` int(11) unsigned NOT NULL DEFAULT 0 AFTER `heal_scale`;
 		.condition = "empty",
 		.match = "",
 		.sql = R"(
-ALTER TABLE `npc_scale_global_base`
-MODIFY COLUMN `hp` bigint(20) NOT NULL DEFAULT 0 AFTER `ac`,
-MODIFY COLUMN `hp_regen_rate` bigint(20) NOT NULL DEFAULT 0 AFTER `max_dmg`,
-ADD COLUMN `hp_regen_per_second` bigint(20) NOT NULL DEFAULT 0 AFTER `hp_regen_rate`,
-ADD COLUMN `avoidance` int(11) unsigned NOT NULL DEFAULT 0 AFTER `heal_scale`;
+DROP INDEX `PRIMARY` ON `raid_members`;
+CREATE UNIQUE INDEX `UNIQUE` ON `raid_members`(`name`);
+ALTER TABLE `raid_members` ADD COLUMN `bot_id` int(4) NOT NULL DEFAULT 0 AFTER `charid`;
+ALTER TABLE `raid_members` ADD COLUMN `id` BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT FIRST;

 )"
 	},
@@ -4745,6 +4744,89 @@ ADD COLUMN `id` int(11) NOT NULL AUTO_INCREMENT FIRST,
 ADD PRIMARY KEY (`id`);
 )",
 	},
+	ManifestEntry{
+		.version = 9229,
+		.description = "2023_07_04_chatchannel_reserved_names_fix.sql",
+		.check = "SHOW TABLES LIKE 'chatchannel_reserved_names'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+CREATE TABLE `chatchannel_reserved_names`
+(
+`id`   int(11) NOT NULL AUTO_INCREMENT,
+`name` varchar(64) NOT NULL,
+PRIMARY KEY (`id`) USING BTREE,
+UNIQUE KEY `name` (`name`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+)"
+	},
+	ManifestEntry{
+		.version = 9230,
+		.description = "2023_06_23_raid_feature_updates",
+		.check = "SHOW COLUMNS FROM `raid_members` LIKE 'is_assister'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+	ALTER TABLE `raid_members`
+	ADD COLUMN `is_marker` TINYINT UNSIGNED DEFAULT 0 NOT NULL AFTER `islooter`,
+	ADD COLUMN `is_assister` TINYINT UNSIGNED DEFAULT 0 NOT NULL AFTER `is_marker`,
+	ADD COLUMN `note` VARCHAR(64) DEFAULT '' NOT NULL AFTER `is_assister`;
+
+	ALTER TABLE `raid_details`
+	ADD COLUMN `marked_npc_1` SMALLINT UNSIGNED DEFAULT 0 NOT NULL AFTER `motd`,
+	ADD COLUMN `marked_npc_2` SMALLINT UNSIGNED DEFAULT 0 NOT NULL AFTER `marked_npc_1`,
+	ADD COLUMN `marked_npc_3` SMALLINT UNSIGNED DEFAULT 0 NOT NULL AFTER `marked_npc_2`;
+	)",
+	},
+	ManifestEntry{
+		.version = 9231,
+		.description = "2023_07_14_npc_unsigned_melee_texture.sql",
+		.check = "SHOW COLUMNS FROM `npc_types` LIKE 'd_melee_texture1'",
+		.condition = "contains",
+		.match = "int(11) signed",
+		.sql = R"(ALTER TABLE `npc_types`
+	MODIFY COLUMN `d_melee_texture1` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `armortint_blue`,
+	MODIFY COLUMN `d_melee_texture2` int(11) UNSIGNED NOT NULL DEFAULT 0 AFTER `d_melee_texture1`;
+	)",
+	},
+	ManifestEntry{
+		.version = 9232,
+		.description = "2023_07_11_command_subsettings.sql",
+		.check = "SHOW TABLES LIKE 'command_subsettings'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(CREATE TABLE `command_subsettings` (
+`id` int UNSIGNED NOT NULL AUTO_INCREMENT,
+`parent_command` varchar(32) NOT NULL,
+`sub_command` varchar(32) NOT NULL,
+`access_level` int(11) UNSIGNED NOT NULL DEFAULT 0,
+`top_level_aliases` varchar(255) NOT NULL,
+PRIMARY KEY (`id`),
+UNIQUE INDEX `command`(`parent_command`, `sub_command`)
+)
+)"
+	},
+	ManifestEntry{
+		.version = 9233,
+		.description = "2023_07_16_scoped_data_buckets.sql",
+		.check = "SHOW COLUMNS FROM `data_buckets` LIKE 'character_id'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+
+ALTER TABLE `data_buckets`
+ADD COLUMN `character_id` bigint(11) NOT NULL DEFAULT 0 AFTER `expires`,
+ADD COLUMN `npc_id` bigint(11) NOT NULL DEFAULT 0 AFTER `character_id`,
+ADD COLUMN `bot_id` bigint(11) NOT NULL DEFAULT 0 AFTER `npc_id`,
+DROP INDEX `key_index`,
+ADD UNIQUE INDEX `keys`(`key`,`character_id`,`npc_id`,`bot_id`);
+
+UPDATE data_buckets SET character_id = SUBSTRING_INDEX(SUBSTRING_INDEX( `key`, '-', 2 ), '-', -1), `key` = SUBSTR(SUBSTRING_INDEX(`key`, SUBSTRING_INDEX( `key`, '-', 2 ), -1), 2) WHERE `key` LIKE 'character-%';
+UPDATE data_buckets SET npc_id = SUBSTRING_INDEX(SUBSTRING_INDEX( `key`, '-', 2 ), '-', -1), `key` = SUBSTR(SUBSTRING_INDEX(`key`, SUBSTRING_INDEX( `key`, '-', 2 ), -1), 2) WHERE `key` LIKE 'npc-%';
+UPDATE data_buckets SET bot_id = SUBSTRING_INDEX(SUBSTRING_INDEX( `key`, '-', 2 ), '-', -1), `key` = SUBSTR(SUBSTRING_INDEX(`key`, SUBSTRING_INDEX( `key`, '-', 2 ), -1), 2) WHERE `key` LIKE 'bot-%';
+
+)"
+	},

 // -- template; copy/paste this when you need to create a new entry
 //	ManifestEntry{
@@ -256,7 +256,9 @@ namespace DatabaseSchema {
 	{
 		return {
 			"chatchannels",
+			"chatchannel_reserved_names",
 			"command_settings",
+			"command_subsettings",
 			"content_flags",
 			"db_str",
 			"eqtime",
@@ -323,8 +323,11 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 	if (pStatus != Connected) {
 		Open();
 	}
+	auto r = MySQLRequestResult{};

 	int status = mysql_real_query(mysql, query.c_str(), query.length());
+
+	// process single result
 	if (status != 0) {
 		unsigned int error_number = mysql_errno(mysql);

@@ -337,11 +340,37 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 			std::string error_raw   = fmt::format("{}", mysql_error(mysql));
 			std::string mysql_err   = Strings::Trim(error_raw);
 			std::string clean_query = Strings::Replace(query, "\n", "");
-			LogMySQLQuery("[{}] ({}) query [{}]", mysql_err, mysql_errno(mysql), clean_query);
+			LogMySQLError("[{}] ({}) query [{}]", mysql_err, mysql_errno(mysql), clean_query);
+
+			MYSQL_RES *res = mysql_store_result(mysql);
+
+			uint32 row_count = 0;
+			if (res) {
+				row_count = (uint32) mysql_num_rows(res);
+			}
+
+			r = MySQLRequestResult(
+				res,
+				(uint32) mysql_affected_rows(mysql),
+				row_count,
+				(uint32) mysql_field_count(mysql),
+				(uint32) mysql_insert_id(mysql)
+			);
+
+			std::string error_message = mysql_error(mysql);
+			r.SetErrorMessage(error_message);
+			r.SetErrorNumber(mysql_errno(mysql));
+
+			if (res) {
+				mysql_free_result(res);
+			}
+
+			SetMultiStatementsOff();
+
+			return r;
 		}
 	}

-	auto result = MySQLRequestResult{};

 	int index = 0;

@@ -355,7 +384,7 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 		uint32    row_count = 0;
 		MYSQL_RES *res      = mysql_store_result(mysql);

-		result = MySQLRequestResult(
+		r = MySQLRequestResult(
 			res,
 			(uint32) mysql_affected_rows(mysql),
 			row_count,
@@ -368,15 +397,14 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 			LogMySQLQuery(
 				"{} -- ({} row{} affected) ({}s)",
 				piece,
-				result.RowsAffected(),
-				result.RowsAffected() == 1 ? "" : "s",
+				r.RowsAffected(),
+				r.RowsAffected() == 1 ? "" : "s",
 				std::to_string(timer.elapsed())
 			);
 		}

 		if (res) {
 			row_count = (uint32) mysql_num_rows(res);
-			mysql_free_result(res);
 		}

 		// more results? -1 = no, >0 = error, 0 = yes (keep looping)
@@ -385,13 +413,27 @@ MySQLRequestResult DBcore::QueryDatabaseMulti(const std::string &query)
 				LogMySQLError("[{}] [{}]", mysql_errno(mysql), mysql_error(mysql));
 			}

+			mysql_free_result(res);
+
+			// error logging
+			std::string error_message = mysql_error(mysql);
+			r.SetErrorMessage(error_message);
+			r.SetErrorNumber(mysql_errno(mysql));
+
+			SetMultiStatementsOff();
+
 			// we handle errors elsewhere
-			return result;
+			return r;
 		}
+
+		if (res) {
+			mysql_free_result(res);
+		}
+
 		index++;
 	} while (status == 0);

 	SetMultiStatementsOff();

-	return result;
+	return r;
 }
@@ -11,7 +11,7 @@
 	are required to give you total support for your newly bought product;
 	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
+
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
@@ -19,131 +19,81 @@

 #include "deity.h"

-
-EQ::deity::DeityTypeBit EQ::deity::ConvertDeityTypeToDeityTypeBit(DeityType deity_type)
+EQ::deity::DeityTypeBit EQ::deity::GetDeityBitmask(DeityType deity_type)
 {
 	switch (deity_type) {
-	case DeityBertoxxulous:
-		return bit_DeityBertoxxulous;
-	case DeityBrellSirilis:
-		return bit_DeityBrellSirilis;
-	case DeityCazicThule:
-		return bit_DeityCazicThule;
-	case DeityErollisiMarr:
-		return bit_DeityErollisiMarr;
-	case DeityBristlebane:
-		return bit_DeityBristlebane;
-	case DeityInnoruuk:
-		return bit_DeityInnoruuk;
-	case DeityKarana:
-		return bit_DeityKarana;
-	case DeityMithanielMarr:
-		return bit_DeityMithanielMarr;
-	case DeityPrexus:
-		return bit_DeityPrexus;
-	case DeityQuellious:
-		return bit_DeityQuellious;
-	case DeityRallosZek:
-		return bit_DeityRallosZek;
-	case DeityRodcetNife:
-		return bit_DeityRodcetNife;
-	case DeitySolusekRo:
-		return bit_DeitySolusekRo;
-	case DeityTheTribunal:
-		return bit_DeityTheTribunal;
-	case DeityTunare:
-		return bit_DeityTunare;
-	case DeityVeeshan:
-		return bit_DeityVeeshan;
-	case DeityAgnostic_LB:
-	case DeityAgnostic:
-		return bit_DeityAgnostic;
-	default:
-		return bit_DeityAll;
-	};
+		case DeityBertoxxulous:
+			return bit_DeityBertoxxulous;
+		case DeityBrellSirilis:
+			return bit_DeityBrellSirilis;
+		case DeityCazicThule:
+			return bit_DeityCazicThule;
+		case DeityErollisiMarr:
+			return bit_DeityErollisiMarr;
+		case DeityBristlebane:
+			return bit_DeityBristlebane;
+		case DeityInnoruuk:
+			return bit_DeityInnoruuk;
+		case DeityKarana:
+			return bit_DeityKarana;
+		case DeityMithanielMarr:
+			return bit_DeityMithanielMarr;
+		case DeityPrexus:
+			return bit_DeityPrexus;
+		case DeityQuellious:
+			return bit_DeityQuellious;
+		case DeityRallosZek:
+			return bit_DeityRallosZek;
+		case DeityRodcetNife:
+			return bit_DeityRodcetNife;
+		case DeitySolusekRo:
+			return bit_DeitySolusekRo;
+		case DeityTheTribunal:
+			return bit_DeityTheTribunal;
+		case DeityTunare:
+			return bit_DeityTunare;
+		case DeityVeeshan:
+			return bit_DeityVeeshan;
+		case DeityAgnostic_LB:
+		case DeityAgnostic:
+			return bit_DeityAgnostic;
+		default:
+			return bit_DeityAll;
+	}
 }

-EQ::deity::DeityType EQ::deity::ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit)
+const std::map<EQ::deity::DeityType, std::string>& EQ::deity::GetDeityMap()
 {
-	switch (deity_type_bit) {
-	case bit_DeityAgnostic:
-		return DeityAgnostic;
-	case bit_DeityBertoxxulous:
-		return DeityBertoxxulous;
-	case bit_DeityBrellSirilis:
-		return DeityBrellSirilis;
-	case bit_DeityCazicThule:
-		return DeityCazicThule;
-	case bit_DeityErollisiMarr:
-		return DeityErollisiMarr;
-	case bit_DeityBristlebane:
-		return DeityBristlebane;
-	case bit_DeityInnoruuk:
-		return DeityInnoruuk;
-	case bit_DeityKarana:
-		return DeityKarana;
-	case bit_DeityMithanielMarr:
-		return DeityMithanielMarr;
-	case bit_DeityPrexus:
-		return DeityPrexus;
-	case bit_DeityQuellious:
-		return DeityQuellious;
-	case bit_DeityRallosZek:
-		return DeityRallosZek;
-	case bit_DeityRodcetNife:
-		return DeityRodcetNife;
-	case bit_DeitySolusekRo:
-		return DeitySolusekRo;
-	case bit_DeityTheTribunal:
-		return DeityTheTribunal;
-	case bit_DeityTunare:
-		return DeityTunare;
-	case bit_DeityVeeshan:
-		return DeityVeeshan;
-	default:
-		return DeityUnknown;
+	static const std::map<EQ::deity::DeityType, std::string> deity_map = {
+		{ DeityAgnostic, "Agnostic" },
+		{ DeityAgnostic_LB, "Agnostic" },
+		{ DeityBertoxxulous, "Bertoxxulous" },
+		{ DeityBrellSirilis, "Brell Serilis" },
+		{ DeityBristlebane, "Bristlebane" },
+		{ DeityCazicThule, "Cazic-Thule" },
+		{ DeityErollisiMarr, "Erollisi Marr" },
+		{ DeityInnoruuk, "Innoruuk" },
+		{ DeityKarana, "Karana" },
+		{ DeityMithanielMarr, "Mithaniel Marr" },
+		{ DeityPrexus, "Prexus" },
+		{ DeityQuellious, "Quellious" },
+		{ DeityRallosZek, "Rallos Zek" },
+		{ DeityRodcetNife, "Rodcet Nife" },
+		{ DeitySolusekRo, "Solusek Ro" },
+		{ DeityTheTribunal, "The Tribunal" },
+		{ DeityTunare, "Tunare" },
+		{ DeityVeeshan, "Veeshan" }
 	};
+
+	return deity_map;
 }

-const char* EQ::deity::DeityName(DeityType deity_type)
+std::string EQ::deity::GetDeityName(DeityType deity_type)
 {
-	switch (deity_type) {
-	case DeityBertoxxulous:
-		return "Bertoxxulous";
-	case DeityBrellSirilis:
-		return "Brell Serilis";
-	case DeityCazicThule:
-		return "Cazic-Thule";
-	case DeityErollisiMarr:
-		return "Erollisi Marr";
-	case DeityBristlebane:
-		return "Bristlebane";
-	case DeityInnoruuk:
-		return "Innoruuk";
-	case DeityKarana:
-		return "Karana";
-	case DeityMithanielMarr:
-		return "Mithaniel Marr";
-	case DeityPrexus:
-		return "Prexus";
-	case DeityQuellious:
-		return "Quellious";
-	case DeityRallosZek:
-		return "Rallos Zek";
-	case DeityRodcetNife:
-		return "Rodcet Nife";
-	case DeitySolusekRo:
-		return "Solusek Ro";
-	case DeityTheTribunal:
-		return "The Tribunal";
-	case DeityTunare:
-		return "Tunare";
-	case DeityVeeshan:
-		return "Veeshan";
-	case DeityAgnostic_LB:
-	case DeityAgnostic:
-		return "Agnostic";
-	default:
-		return "Unknown";
-	};
+
+	if (EQ::deity::GetDeityMap().find(deity_type) != EQ::deity::GetDeityMap().end()) {
+		return EQ::deity::GetDeityMap().find(deity_type)->second;
+	}
+
+	return std::string();
 }
@@ -21,6 +21,8 @@
 #define COMMON_DEITY_H

 #include "types.h"
+#include <map>
+#include <string>


 namespace EQ
@@ -49,30 +51,29 @@ namespace EQ
 		};

 		enum DeityTypeBit : uint32 {
-			bit_DeityNone = 0x00000000,
-			bit_DeityAgnostic = 0x00000001,
-			bit_DeityBertoxxulous = 0x00000002,
-			bit_DeityBrellSirilis = 0x00000004,
-			bit_DeityCazicThule = 0x00000008,
-			bit_DeityErollisiMarr = 0x00000010,
-			bit_DeityBristlebane = 0x00000020,
-			bit_DeityInnoruuk = 0x00000040,
-			bit_DeityKarana = 0x00000080,
+			bit_DeityAgnostic      = 0x00000001,
+			bit_DeityBertoxxulous  = 0x00000002,
+			bit_DeityBrellSirilis  = 0x00000004,
+			bit_DeityCazicThule    = 0x00000008,
+			bit_DeityErollisiMarr  = 0x00000010,
+			bit_DeityBristlebane   = 0x00000020,
+			bit_DeityInnoruuk      = 0x00000040,
+			bit_DeityKarana        = 0x00000080,
 			bit_DeityMithanielMarr = 0x00000100,
-			bit_DeityPrexus = 0x00000200,
-			bit_DeityQuellious = 0x00000400,
-			bit_DeityRallosZek = 0x00000800,
-			bit_DeityRodcetNife = 0x00001000,
-			bit_DeitySolusekRo = 0x00002000,
-			bit_DeityTheTribunal = 0x00004000,
-			bit_DeityTunare = 0x00008000,
-			bit_DeityVeeshan = 0x00010000,
-			bit_DeityAll = 0xFFFFFFFF
+			bit_DeityPrexus        = 0x00000200,
+			bit_DeityQuellious     = 0x00000400,
+			bit_DeityRallosZek     = 0x00000800,
+			bit_DeityRodcetNife    = 0x00001000,
+			bit_DeitySolusekRo     = 0x00002000,
+			bit_DeityTheTribunal   = 0x00004000,
+			bit_DeityTunare        = 0x00008000,
+			bit_DeityVeeshan       = 0x00010000,
+			bit_DeityAll           = UINT32_MAX
 		};

-		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);
-		extern DeityType ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit);
-		extern const char* DeityName(DeityType deity_type);
+		extern DeityTypeBit GetDeityBitmask(DeityType deity_type);
+		extern std::string GetDeityName(DeityType deity_type);
+		extern const std::map<DeityType, std::string>& GetDeityMap();

 	} /*deity*/

@@ -316,6 +316,7 @@ N(OP_LootRequest),
 N(OP_ManaChange),
 N(OP_ManaUpdate),
 N(OP_MarkNPC),
+N(OP_MarkRaidNPC),
 N(OP_Marquee),
 N(OP_MemorizeSpell),
 N(OP_Mend),
@@ -398,6 +399,8 @@ N(OP_PVPLeaderBoardRequest),
 N(OP_PVPStats),
 N(OP_QueryResponseThing),
 N(OP_QueryUCSServerStatus),
+N(OP_RaidDelegateAbility),
+N(OP_RaidClearNPCMarks),
 N(OP_RaidInvite),
 N(OP_RaidJoin),
 N(OP_RaidUpdate),
@@ -4105,7 +4105,9 @@ struct UpdateLeadershipAA_Struct {

 enum
 {
-	GroupLeadershipAbility_MarkNPC = 0
+	GroupLeadershipAbility_MarkNPC = 0,
+	RaidLeadershipAbility_MarkNPC = 16,
+	RaidLeadershipAbility_MainAssist = 19
 };

 struct DoGroupLeadershipAbility_Struct
@@ -4149,8 +4151,10 @@ struct InspectBuffs_Struct {
 struct RaidGeneral_Struct {
 /*00*/	uint32		action;	//=10
 /*04*/	char		player_name[64];	//should both be the player's name
-/*64*/	char		leader_name[64];
-/*132*/	uint32		parameter;
+/*68*/	uint32		unknown1;
+/*72*/	char		leader_name[64];
+/*136*/	uint32		parameter;
+/*200*/	char		note[64];
 };

 struct RaidAddMember_Struct {
@@ -446,6 +446,8 @@ void EQEmuLogSys::Out(
 	// remove this when we remove all legacy logs
 	bool ignore_log_legacy_format = (
 		log_category == Logs::Netcode ||
+		log_category == Logs::MySQLQuery ||
+		log_category == Logs::MySQLError ||
 		log_category == Logs::PacketServerClient ||
 		log_category == Logs::PacketClientServer ||
 		log_category == Logs::PacketServerToServer
@@ -137,6 +137,7 @@ namespace Logs {
 		Bugs,
 		QuestErrors,
 		PlayerEvents,
+		DataBuckets,
 		MaxCategoryID /* Don't Remove this */
 	};

@@ -233,6 +234,7 @@ namespace Logs {
 		"Bugs",
 		"QuestErrors",
 		"PlayerEvents",
+		"DataBuckets",
 	};
 }

@@ -794,6 +794,16 @@
        OutF(LogSys, Logs::Detail, Logs::PlayerEvents, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)

+#define LogDataBuckets(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::General, Logs::DataBuckets))\
+        OutF(LogSys, Logs::General, Logs::DataBuckets, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogDataBucketsDetail(message, ...) do {\
+    if (LogSys.IsLogEnabled(Logs::Detail, Logs::DataBuckets))\
+        OutF(LogSys, Logs::Detail, Logs::DataBuckets, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
 #define Log(debug_level, log_category, message, ...) do {\
    if (LogSys.IsLogEnabled(debug_level, log_category))\
        LogSys.Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
@@ -240,36 +240,22 @@ enum {	//some random constants

 //Some hard coded statuses from commands and other places:
 enum {
-	minStatusToBeGM = 40,
-	minStatusToUseGMCommands = 80,
-	minStatusToKick = 150,
-	minStatusToAvoidFalling = 100,
-	minStatusToHaveInvalidSpells = 80,
-	minStatusToHaveInvalidSkills = 80,
-	minStatusToIgnoreZoneFlags = 80,
+	minStatusToBeGM               = 40,
+	minStatusToUseGMCommands      = 80,
+	minStatusToKick               = 150,
+	minStatusToAvoidFalling       = 100,
+	minStatusToIgnoreZoneFlags    = 80,
 	minStatusToSeeOthersZoneFlags = 80,
-	minStatusToEditOtherGuilds = 80,
-	commandMovecharSelfOnly = 80,	//below this == only self move allowed
-	commandMovecharToSpecials = 200,	//ability to send people to cshom/load zones
-	commandZoneToSpecials = 80,		//zone to cshome, out of load zones
-	commandToggleAI = 250,			//can turn NPC AI on and off
-	commandCastSpecials = 100,		//can cast special spells
-	commandInstacast = 100,			//insta-cast all #casted spells
-	commandLevelAboveCap = 100,		//can #level players above level cap
-	commandLevelNPCAboveCap = 100,	//can #level NPCs above level cap
-	commandSetSkillsOther = 100,	//ability to setskills on others
-	commandRaceOthers = 100,	//ability to #race on others
-	commandGenderOthers = 100,	//ability to #gender on others
-	commandTextureOthers = 100,	//ability to #texture on others
-	commandDoAnimOthers = 100,	//can #doanim on others
-	commandLockZones = 101,		//can lock or unlock zones
-	commandEditPlayerCorpses = 150,	//can Edit Player Corpses
-	commandChangeFlags = 200,		//ability to set/refresh flags
-	commandBanPlayers = 100,		//can set bans on players
-	commandChangeDatarate = 201,	//edit client's data rate
-	commandZoneToCoords = 0,		//can #zone with coords
-	commandInterrogateInv = 100,	//below this == only log on error state and self-only target dump
-	commandInvSnapshot = 150		//ability to clear/restore snapshots
+	minStatusToEditOtherGuilds    = 80,
+	commandMovecharSelfOnly       = 80,  //below this == only self move allowed
+	commandMovecharToSpecials     = 200, //ability to send people to cshom/load zones
+	commandCastSpecials           = 100, //can cast special spells
+	commandInstacast              = 100, //insta-cast all #casted spells
+	commandDoAnimOthers           = 100, //can #doanim on others
+	commandLockZones              = 101, //can lock or unlock zones
+	commandEditPlayerCorpses      = 150, //can Edit Player Corpses
+	commandInterrogateInv         = 100, //below this == only log on error state and self-only target dump
+	commandInvSnapshot            = 150  //ability to clear/restore snapshots
 };


@@ -353,7 +353,7 @@ bool EQ::InventoryProfile::SwapItem(
 				fail_state = swapRaceClass;
 				return false;
 			}
-			if (deity_id && source_item->Deity && !(deity::ConvertDeityTypeToDeityTypeBit((deity::DeityType)deity_id) & source_item->Deity)) {
+			if (deity_id && source_item->Deity && !(deity::GetDeityBitmask((deity::DeityType)deity_id) & source_item->Deity)) {
 				fail_state = swapDeity;
 				return false;
 			}
@@ -379,7 +379,7 @@ bool EQ::InventoryProfile::SwapItem(
 				fail_state = swapRaceClass;
 				return false;
 			}
-			if (deity_id && destination_item->Deity && !(deity::ConvertDeityTypeToDeityTypeBit((deity::DeityType)deity_id) & destination_item->Deity)) {
+			if (deity_id && destination_item->Deity && !(deity::GetDeityBitmask((deity::DeityType)deity_id) & destination_item->Deity)) {
 				fail_state = swapDeity;
 				return false;
 			}
@@ -1444,7 +1444,7 @@ int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 	}

 	if (result == INVALID_INDEX) {
-		LogError("InventoryProfile::_PutItem: Invalid slot_id specified ({}) with parent slot id ({})", slot_id, parentSlot);
+		LogError("Invalid slot_id specified ({}) with parent slot id ({})", slot_id, parentSlot);
 		InventoryProfile::MarkDirty(inst); // Slot not found, clean up
 	}

@@ -720,12 +720,14 @@ EQ::ItemInstance* EQ::ItemInstance::RemoveAugment(uint8 index)

 bool EQ::ItemInstance::IsAugmented()
 {
-	if (!m_item || !m_item->IsClassCommon())
+	if (!m_item || !m_item->IsClassCommon()) {
 		return false;
+	}

-	for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
-		if (GetAugmentItemID(index))
+	for (uint8 slot_id = invaug::SOCKET_BEGIN; slot_id <= invaug::SOCKET_END; ++slot_id) {
+		if (GetAugmentItemID(slot_id)) {
 			return true;
+		}
 	}

 	return false;
@@ -48,5 +48,7 @@
 #define LANG_HADAL			26
 #define LANG_UNKNOWN	27

+#define MAX_LANGUAGE_SKILL 100
+
 #endif

@@ -214,123 +214,6 @@ std::string x;
 	return i;
 }

-void LoadItemDBFieldNames() {
-	DBFieldNames[0]="N/A";			// Charges
-	DBFieldNames[1]="unknown002";		// ?
-	DBFieldNames[2]="N/A";			// Current Equip Slot
-	DBFieldNames[3]="unknown004";
-	DBFieldNames[4]="unknown005";		// ?
-	DBFieldNames[5]="itemclass";		// "Item Type (0=common, 1=container, 2=book)"
-	DBFieldNames[6]="name";			// Name
-	DBFieldNames[7]="lore";			// "Lore Name (*=lore, &=summoned, #=artifact)"
-	DBFieldNames[8]="idfile";		// IDFile
-	DBFieldNames[9]="id";			// ItemNumber
-	DBFieldNames[10]="weight";		// Weight
-	DBFieldNames[11]="norent";		// "NoRent (0=norent, 255=not norent)"
-	DBFieldNames[12]="nodrop";		// "NoDrop (0=nodrop, 255=not nodrop)"
-	DBFieldNames[13]="size";		// "Size (0=tiny, 1=small, 2=medium, 3=large, 4=giant)"
-	DBFieldNames[14]="slots";		// EquipSlots
-	DBFieldNames[15]="cost";		// Cost
-	DBFieldNames[16]="icon";		// IconNumber
-	DBFieldNames[17]="unknown018";
-	DBFieldNames[18]="unknown019";
-	DBFieldNames[19]="unknown020";		// ?
-	DBFieldNames[20]="tradeskills";		// "Tradeskill Item (1=is a tradeskill item, 0=not)"
-	DBFieldNames[21]="cr";			// SvCold
-	DBFieldNames[22]="dr";			// SvDisease
-	DBFieldNames[23]="pr";			// SvPoison
-	DBFieldNames[24]="mr";			// SvMagic
-	DBFieldNames[25]="fr";			// SvFire
-	DBFieldNames[26]="astr";		// STR
-	DBFieldNames[27]="asta";		// STA
-	DBFieldNames[28]="aagi";		// AGI
-	DBFieldNames[29]="adex";		// DEX
-	DBFieldNames[30]="acha";		// CHA
-	DBFieldNames[31]="aint";		// INT
-	DBFieldNames[32]="awis";		// WIS
-	DBFieldNames[33]="hp";			// HP
-	DBFieldNames[34]="mana";		// Mana
-	DBFieldNames[35]="ac";			// AC
-	DBFieldNames[36]="deity";		// Deity
-	DBFieldNames[37]="skillmodvalue";	// Skill Mod Value
-	DBFieldNames[38]="skillmodtype";	// Skill Mod Type
-	DBFieldNames[39]="banedmgrace";		// Bane Dmg Race
-	DBFieldNames[40]="banedmgamt";		// Band Dmg
-	DBFieldNames[41]="banedmgbody";		// Band Dmg Body
-	DBFieldNames[42]="magic";		// "Magic (0=not magic, 1=magic)"
-	DBFieldNames[43]="casttime2";		// Casttime appears twice
-	DBFieldNames[44]="hasteproclvl";	// "Level (Haste value, rather)"
-	DBFieldNames[45]="reqlevel";		// Required Level
-	DBFieldNames[46]="bardtype";		// Bard Type
-	DBFieldNames[47]="bardvalue";		// Bard Type Amount
-	DBFieldNames[48]="light";		// Light
-	DBFieldNames[49]="delay";		// Attack Delay
-	DBFieldNames[50]="reclevel";		// Recommended Level
-	DBFieldNames[51]="recskill";		// Recommended Skill
-	DBFieldNames[52]="elemdmgamt";		// "Elemental Dmg Type (1=magic, 2=fire, 3=cold, 4=poison, 5=disease)"
-	DBFieldNames[53]="elemdmgtype";		// Elemental Dmg
-	DBFieldNames[54]="effecttype";		// "Effect Type (0=combat, 1=clicky, 2=Worn, 3=Expendable charges, 4=Must Equip Clicky, 5=clicky)"
-	DBFieldNames[55]="range";		// Range
-	DBFieldNames[56]="damage";		// Damage
-	DBFieldNames[57]="color";		// Color
-	DBFieldNames[58]="classes";		// Classes
-	DBFieldNames[59]="races";		// Races
-	DBFieldNames[60]="unknown061";
-	DBFieldNames[61]="spellid";		// SpellId
-	DBFieldNames[62]="maxcharges";		// MaxCharges
-	DBFieldNames[63]="itemtype";		// "Skill (ItemType: 1hs, etc)"
-	DBFieldNames[64]="material";		// Material
-	DBFieldNames[65]="sellrate";		// ** Sell Rate
-	DBFieldNames[66]="unknown067";
-	DBFieldNames[67]="casttime";		// CastTime (milliseconds)
-	DBFieldNames[68]="unknown069";
-	DBFieldNames[69]="unknown070";		// ?
-	DBFieldNames[70]="focusid";		// Focus Effect Spell Id
-	DBFieldNames[71]="combateffects";	// CombatEffects
-	DBFieldNames[72]="shielding";		// Shielding
-	DBFieldNames[73]="stunresist";		// StunResist
-	DBFieldNames[74]="strikethrough";	// StrikeThrough
-	DBFieldNames[75]="unknown076";
-	DBFieldNames[76]="unknown077";		// ?
-	DBFieldNames[77]="spellshield";		// Spell Shield
-	DBFieldNames[78]="avoidance";		// Avoidance
-	DBFieldNames[79]="accuracy";		// Accuracy
-	DBFieldNames[80]="factionmod1";		// Faction Mod Index 1
-	DBFieldNames[81]="factionmod2";		// Faction Mod Index 2
-	DBFieldNames[82]="factionmod3";		// Faction Mod Index 3
-	DBFieldNames[83]="factionmod4";		// Faction Mod Index 4
-	DBFieldNames[84]="factionamt1";		// Faction Mod Value 1
-	DBFieldNames[85]="factionamt2";		// Faction Mod Value 2
-	DBFieldNames[86]="factionamt3";		// Faction Mod Value 3
-	DBFieldNames[87]="factionamt4";		// Faction Mod Value 4
-	DBFieldNames[88]="unknown089";
-	DBFieldNames[89]="charmfile";		// ** Charm File
-	DBFieldNames[90]="unknown091";
-	DBFieldNames[91]="augslot1type";	// Slot1Type
-	DBFieldNames[92]="augslot2type";	// Slot2Type
-	DBFieldNames[93]="augslot3type";	// Slot3Type
-	DBFieldNames[94]="augslot4type";	// Slot4Type
-	DBFieldNames[95]="augslot5type";	// Slot5Type
-	DBFieldNames[96]="ldonpointtheme";
-	DBFieldNames[97]="ldonpointcost";		// ?
-	DBFieldNames[98]="unknown099";
-	DBFieldNames[99]="bagtype";		// bag type
-	DBFieldNames[100]="bagslots";		// bag slots
-	DBFieldNames[101]="bagsize";		// bag size capacity
-	DBFieldNames[102]="bagwr";		// bag weight reduction
-	DBFieldNames[103]="booktype";		// "book type (0=rolled up note, 1=book)"
-	DBFieldNames[104]="unknown105";
-	DBFieldNames[105]="filename";		// Book Filename
-	DBFieldNames[106]="unknown107";
-	DBFieldNames[107]="unknown108";
-	DBFieldNames[108]="loreflag";
-	DBFieldNames[109]="unknown111";
-	DBFieldNames[110]="unknown112";
-	DBFieldNames[111]="unknown113";
-	DBFieldNames[112]="unknown114";
-	DBFieldNames[113]="unknown115";		// ? (end quote)
-}
-
 void dump_message_column(unsigned char *buffer, unsigned long length, std::string leader, FILE *to)
 {
 unsigned long i,j;
@@ -15,8 +15,6 @@ bool ItemParse(const char *data, int length, std::map<int,std::map<int,std::stri

 int Tokenize(std::string s, std::map<int,std::string> & tokens, char delim='|');

-void LoadItemDBFieldNames();
-
 #ifndef WIN32
 int print_stacktrace();
 #endif
@@ -51,6 +51,7 @@ void MySQLRequestResult::ZeroOut()
 	m_RowCount = 0;
 	m_RowsAffected = 0;
 	m_LastInsertedID = 0;
+	m_error_message = "";
 }

 MySQLRequestResult::~MySQLRequestResult()
@@ -137,3 +138,23 @@ MySQLRequestResult& MySQLRequestResult::operator=(MySQLRequestResult&& other)
 	other.ZeroOut();
 	return *this;
 }
+
+uint32 MySQLRequestResult::GetErrorNumber() const
+{
+	return m_ErrorNumber;
+}
+
+void MySQLRequestResult::SetErrorNumber(uint32 m_error_number)
+{
+	m_ErrorNumber = m_error_number;
+}
+
+const std::string &MySQLRequestResult::GetErrorMessage() const
+{
+	return m_error_message;
+}
+
+void MySQLRequestResult::SetErrorMessage(const std::string &m_error_message)
+{
+	MySQLRequestResult::m_error_message = m_error_message;
+}
@@ -33,30 +33,42 @@ private:
 	uint32 m_LastInsertedID;
 	uint32 m_ErrorNumber;

+	std::string m_error_message;

 public:

 	MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected = 0, uint32 rowCount = 0, uint32 columnCount = 0, uint32 lastInsertedID = 0, uint32 errorNumber = 0, char *errorBuffer = nullptr);
-	MySQLRequestResult();	
+	MySQLRequestResult();
 	MySQLRequestResult(MySQLRequestResult&& moveItem);
 	~MySQLRequestResult();

 	MySQLRequestResult& operator=(MySQLRequestResult&& other);

 	bool Success() const { return m_Success;}
-	std::string ErrorMessage() const {return m_ErrorBuffer ? std::string(m_ErrorBuffer) : std::string("");}
+	std::string ErrorMessage() const {
+		if (!m_error_message.empty()) {
+			return m_error_message;
+		}
+
+		return m_ErrorBuffer ? std::string(m_ErrorBuffer) : std::string("");
+	}
 	uint32 ErrorNumber() const {return m_ErrorNumber;}
 	uint32 RowsAffected() const {return m_RowsAffected;}
 	uint32 RowCount() const {return m_RowCount;}
 	uint32 ColumnCount() const {return m_ColumnCount;}
 	uint32 LastInsertedID() const {return m_LastInsertedID;}
 	// default to 0 index since we mostly use it that way anyways.
-	uint32 LengthOfColumn(int columnIndex = 0); 
+	uint32 LengthOfColumn(int columnIndex = 0);
 	const std::string FieldName(int columnIndex);

 	MySQLRequestRow& begin() { return m_CurrentRow; }
 	MySQLRequestRow& end() { return m_OneBeyondRow; }

+	uint32 GetErrorNumber() const;
+	void SetErrorNumber(uint32 m_error_number);
+	const std::string &GetErrorMessage() const;
+	void SetErrorMessage(const std::string &m_error_message);
+
 private:
 	void FreeInternals();
 	void ZeroOut();
@@ -35,6 +35,7 @@
 #include "../path_manager.h"
 #include "../classes.h"
 #include "../races.h"
+#include "../../zone/raids.h"

 #include <iostream>
 #include <sstream>
@@ -2737,7 +2738,7 @@ namespace RoF2
 		{
 			RaidLeadershipUpdate_Struct *inlaa = (RaidLeadershipUpdate_Struct *)__emu_buffer;
 			auto outapp =
-			    new EQApplicationPacket(OP_RaidUpdate, sizeof(structs::RaidLeadershipUpdate_Struct));
+				new EQApplicationPacket(OP_RaidUpdate, sizeof(structs::RaidLeadershipUpdate_Struct));
 			structs::RaidLeadershipUpdate_Struct *outlaa = (structs::RaidLeadershipUpdate_Struct *)outapp->pBuffer;

 			outlaa->action = inlaa->action;
@@ -2746,6 +2747,18 @@ namespace RoF2
 			memcpy(&outlaa->raid, &inlaa->raid, sizeof(RaidLeadershipAA_Struct));
 			dest->FastQueuePacket(&outapp);
 		}
+		else if (raid_gen->action == raidSetNote)
+		{
+			auto in_note = (RaidGeneral_Struct*)__emu_buffer;
+			auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
+			auto note = (RaidGeneral_Struct*)outapp->pBuffer;
+			note->action = raidSetNote;
+			strn0cpy(note->leader_name, in_note->leader_name, sizeof(note->leader_name));
+			strn0cpy(note->player_name, in_note->player_name, sizeof(note->leader_name));
+			strn0cpy(note->note, in_note->note, sizeof(note->note));
+			dest->QueuePacket(outapp);
+			safe_delete(outapp);
+		}
 		else
 		{
 			RaidGeneral_Struct* in_raid_general = (RaidGeneral_Struct*)__emu_buffer;
@@ -17,6 +17,7 @@
 */

 #include "../common/races.h"
+#include "data_verification.h"

 const char* GetRaceIDName(uint16 race_id)
 {
@@ -67,7 +68,7 @@ const char* GetRaceIDName(uint16 race_id)
 	//	return "Froglok";
 	//case DRAKKIN:
 	//	return "Drakkin";
-	
+
 	// RoF2 Race Labels
 	case RT_ABHORRENT:
 		return "Abhorrent";
@@ -1696,7 +1697,7 @@ bool PlayerAppearance::IsValidBeardColor(uint16 race_id, uint8 gender_id, uint8
 {
 	if (beard_color_value == 0xFF)
 	return true;
-	
+
 	switch (BINDRG(race_id, gender_id)) {
 	case GNOME_MALE:
 		if (beard_color_value <= 24)
@@ -1783,7 +1784,7 @@ bool PlayerAppearance::IsValidEyeColor(uint16 race_id, uint8 gender_id, uint8 ey
 	case VAHSHIR_FEMALE:
 		if (eye_color_value <= 9)
 			return true;
-		break;	
+		break;
 	case TROLL_MALE:
 	case TROLL_FEMALE:
 		if (eye_color_value <= 10)
@@ -2109,7 +2110,7 @@ bool PlayerAppearance::IsValidTexture(uint16 race_id, uint8 gender_id, uint8 tex
 {
 	if (texture_value == 0xFF)
 		return true;
-	
+
 	if (use_luclin) {
 		switch (BINDRG(race_id, gender_id)) {
 		case HUMAN_MALE:
@@ -2243,4 +2244,58 @@ const char* GetGenderName(uint32 gender_id) {
 		gender_name = "Neuter";
 	}
 	return gender_name;
-}
+}
+
+const std::string GetPlayerRaceAbbreviation(uint16 race_id)
+{
+	if (!IsPlayerRace(race_id)) {
+		return std::string("UNK");
+	}
+
+	switch (race_id) {
+		case RACE_HUMAN_1:
+			return "HUM";
+		case RACE_BARBARIAN_2:
+			return "BAR";
+		case RACE_ERUDITE_3:
+			return "ERU";
+		case RACE_WOOD_ELF_4:
+			return "ELF";
+		case RACE_HIGH_ELF_5:
+			return "HIE";
+		case RACE_DARK_ELF_6:
+			return "DEF";
+		case RACE_HALF_ELF_7:
+			return "HEF";
+		case RACE_DWARF_8:
+			return "DWF";
+		case RACE_TROLL_9:
+			return "TRL";
+		case RACE_OGRE_10:
+			return "OGR";
+		case RACE_HALFLING_11:
+			return "HFL";
+		case RACE_GNOME_12:
+			return "GNM";
+		case RACE_IKSAR_128:
+			return "IKS";
+		case RACE_VAH_SHIR_130:
+			return "VAH";
+		case RACE_FROGLOK_330:
+			return "FRG";
+		case RACE_DRAKKIN_522:
+			return "DRK";
+	}
+
+	return std::string("UNK");
+}
+
+bool IsPlayerRace(uint16 race_id) {
+	return (
+		EQ::ValueWithin(race_id, RACE_HUMAN_1, RACE_GNOME_12) ||
+		race_id == RACE_IKSAR_128 ||
+		race_id == RACE_VAH_SHIR_130 ||
+		race_id == RACE_FROGLOK_330 ||
+		race_id == RACE_DRAKKIN_522
+	);
+}
@@ -19,6 +19,7 @@
 #ifndef RACES_H
 #define RACES_H
 #include "../common/types.h"
+#include <string>

 #define MALE 0
 #define FEMALE 1
@@ -853,6 +854,9 @@ const char* GetRaceIDName(uint16 race_id);
 const char* GetPlayerRaceName(uint32 player_race_value);
 const char* GetGenderName(uint32 gender_id);

+bool IsPlayerRace(uint16 race_id);
+const std::string GetPlayerRaceAbbreviation(uint16 race_id);
+
 uint32 GetPlayerRaceValue(uint16 race_id);
 uint32 GetPlayerRaceBit(uint16 race_id);

@@ -44,7 +44,35 @@ public:
     */

 	// Custom extended repository methods here
+	static void ClearFlag(
+		Database& db,
+		AccountFlagsRepository::AccountFlags e
+	) {
+		AccountFlagsRepository::DeleteWhere(
+			database,
+			fmt::format(
+				"p_accid = {} AND p_flag = '{}'",
+				e.p_accid,
+				Strings::Escape(e.p_flag)
+			)
+		);
+	}

+	static void ReplaceFlag(
+		Database& db,
+		AccountFlagsRepository::AccountFlags e
+	) {
+		db.QueryDatabase(
+			fmt::format(
+				"REPLACE INTO {} ({}) VALUES ({}, '{}', '{}')",
+				TableName(),
+				ColumnsRaw(),
+				e.p_accid,
+				Strings::Escape(e.p_flag),
+				Strings::Escape(e.p_value)
+			)
+		);
+	}
 };

 #endif //EQEMU_ACCOUNT_FLAGS_REPOSITORY_H
@@ -0,0 +1,364 @@
+/**
+ * DO NOT MODIFY THIS FILE
+ *
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to the repository extending the base.
+ * Any modifications to base repositories are to be made by the generator only
+ *
+ * @generator ./utils/scripts/generators/repository-generator.pl
+ * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories
+ */
+
+#ifndef EQEMU_BASE_COMMAND_SUBSETTINGS_REPOSITORY_H
+#define EQEMU_BASE_COMMAND_SUBSETTINGS_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+
+class BaseCommandSubsettingsRepository {
+public:
+	struct CommandSubsettings {
+		uint32_t    id;
+		std::string parent_command;
+		std::string sub_command;
+		uint32_t    access_level;
+		std::string top_level_aliases;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"parent_command",
+			"sub_command",
+			"access_level",
+			"top_level_aliases",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"id",
+			"parent_command",
+			"sub_command",
+			"access_level",
+			"top_level_aliases",
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", Columns()));
+	}
+
+	static std::string SelectColumnsRaw()
+	{
+		return std::string(Strings::Implode(", ", SelectColumns()));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("command_subsettings");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static CommandSubsettings NewEntity()
+	{
+		CommandSubsettings e{};
+
+		e.id                = 0;
+		e.parent_command    = "";
+		e.sub_command       = "";
+		e.access_level      = 0;
+		e.top_level_aliases = "";
+
+		return e;
+	}
+
+	static CommandSubsettings GetCommandSubsettings(
+		const std::vector<CommandSubsettings> &command_subsettingss,
+		int command_subsettings_id
+	)
+	{
+		for (auto &command_subsettings : command_subsettingss) {
+			if (command_subsettings.id == command_subsettings_id) {
+				return command_subsettings;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static CommandSubsettings FindOne(
+		Database& db,
+		int command_subsettings_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				command_subsettings_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			CommandSubsettings e{};
+
+			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.parent_command    = row[1] ? row[1] : "";
+			e.sub_command       = row[2] ? row[2] : "";
+			e.access_level      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.top_level_aliases = row[4] ? row[4] : "";
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int command_subsettings_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				command_subsettings_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const CommandSubsettings &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[1] + " = '" + Strings::Escape(e.parent_command) + "'");
+		v.push_back(columns[2] + " = '" + Strings::Escape(e.sub_command) + "'");
+		v.push_back(columns[3] + " = " + std::to_string(e.access_level));
+		v.push_back(columns[4] + " = '" + Strings::Escape(e.top_level_aliases) + "'");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static CommandSubsettings InsertOne(
+		Database& db,
+		CommandSubsettings e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back("'" + Strings::Escape(e.parent_command) + "'");
+		v.push_back("'" + Strings::Escape(e.sub_command) + "'");
+		v.push_back(std::to_string(e.access_level));
+		v.push_back("'" + Strings::Escape(e.top_level_aliases) + "'");
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				Strings::Implode(",", v)
+			)
+		);
+
+		if (results.Success()) {
+			e.id = results.LastInsertedID();
+			return e;
+		}
+
+		e = NewEntity();
+
+		return e;
+	}
+
+	static int InsertMany(
+		Database& db,
+		const std::vector<CommandSubsettings> &entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &e: entries) {
+			std::vector<std::string> v;
+
+			v.push_back(std::to_string(e.id));
+			v.push_back("'" + Strings::Escape(e.parent_command) + "'");
+			v.push_back("'" + Strings::Escape(e.sub_command) + "'");
+			v.push_back(std::to_string(e.access_level));
+			v.push_back("'" + Strings::Escape(e.top_level_aliases) + "'");
+
+			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
+		}
+
+		std::vector<std::string> v;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				Strings::Implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<CommandSubsettings> All(Database& db)
+	{
+		std::vector<CommandSubsettings> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			CommandSubsettings e{};
+
+			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.parent_command    = row[1] ? row[1] : "";
+			e.sub_command       = row[2] ? row[2] : "";
+			e.access_level      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.top_level_aliases = row[4] ? row[4] : "";
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<CommandSubsettings> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<CommandSubsettings> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			CommandSubsettings e{};
+
+			e.id                = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.parent_command    = row[1] ? row[1] : "";
+			e.sub_command       = row[2] ? row[2] : "";
+			e.access_level      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.top_level_aliases = row[4] ? row[4] : "";
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(Database& db, const std::string &where_filter)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int Truncate(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"TRUNCATE TABLE {}",
+				TableName()
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int64 GetMaxId(Database& db)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COALESCE(MAX({}), 0) FROM {}",
+				PrimaryKey(),
+				TableName()
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+	static int64 Count(Database& db, const std::string &where_filter = "")
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"SELECT COUNT(*) FROM {} {}",
+				TableName(),
+				(where_filter.empty() ? "" : "WHERE " + where_filter)
+			)
+		);
+
+		return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0);
+	}
+
+};
+
+#endif //EQEMU_BASE_COMMAND_SUBSETTINGS_REPOSITORY_H
@@ -15,7 +15,7 @@
 #include "../../database.h"
 #include "../../strings.h"
 #include <ctime>
-
+#include <cereal/cereal.hpp>

 class BaseDataBucketsRepository {
 public:
@@ -24,6 +24,24 @@ public:
 		std::string key_;
 		std::string value;
 		uint32_t    expires;
+		int64_t     character_id;
+		int64_t     npc_id;
+		int64_t     bot_id;
+
+		// cereal
+		template<class Archive>
+		void serialize(Archive &ar)
+		{
+			ar(
+				CEREAL_NVP(id),
+				CEREAL_NVP(key_),
+				CEREAL_NVP(value),
+				CEREAL_NVP(expires),
+				CEREAL_NVP(character_id),
+				CEREAL_NVP(npc_id),
+				CEREAL_NVP(bot_id)
+			);
+		}
 	};

 	static std::string PrimaryKey()
@@ -38,6 +56,9 @@ public:
 			"`key`",
 			"value",
 			"expires",
+			"character_id",
+			"npc_id",
+			"bot_id",
 		};
 	}

@@ -48,6 +69,9 @@ public:
 			"`key`",
 			"value",
 			"expires",
+			"character_id",
+			"npc_id",
+			"bot_id",
 		};
 	}

@@ -88,10 +112,13 @@ public:
 	{
 		DataBuckets e{};

-		e.id      = 0;
-		e.key_    = "";
-		e.value   = "";
-		e.expires = 0;
+		e.id           = 0;
+		e.key_         = "";
+		e.value        = "";
+		e.expires      = 0;
+		e.character_id = 0;
+		e.npc_id       = 0;
+		e.bot_id       = 0;

 		return e;
 	}
@@ -128,10 +155,13 @@ public:
 		if (results.RowCount() == 1) {
 			DataBuckets e{};

-			e.id      = strtoull(row[0], nullptr, 10);
-			e.key_    = row[1] ? row[1] : "";
-			e.value   = row[2] ? row[2] : "";
-			e.expires = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.id           = strtoull(row[0], nullptr, 10);
+			e.key_         = row[1] ? row[1] : "";
+			e.value        = row[2] ? row[2] : "";
+			e.expires      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.character_id = strtoll(row[4], nullptr, 10);
+			e.npc_id       = strtoll(row[5], nullptr, 10);
+			e.bot_id       = strtoll(row[6], nullptr, 10);

 			return e;
 		}
@@ -168,6 +198,9 @@ public:
 		v.push_back(columns[1] + " = '" + Strings::Escape(e.key_) + "'");
 		v.push_back(columns[2] + " = '" + Strings::Escape(e.value) + "'");
 		v.push_back(columns[3] + " = " + std::to_string(e.expires));
+		v.push_back(columns[4] + " = " + std::to_string(e.character_id));
+		v.push_back(columns[5] + " = " + std::to_string(e.npc_id));
+		v.push_back(columns[6] + " = " + std::to_string(e.bot_id));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -193,6 +226,9 @@ public:
 		v.push_back("'" + Strings::Escape(e.key_) + "'");
 		v.push_back("'" + Strings::Escape(e.value) + "'");
 		v.push_back(std::to_string(e.expires));
+		v.push_back(std::to_string(e.character_id));
+		v.push_back(std::to_string(e.npc_id));
+		v.push_back(std::to_string(e.bot_id));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -226,6 +262,9 @@ public:
 			v.push_back("'" + Strings::Escape(e.key_) + "'");
 			v.push_back("'" + Strings::Escape(e.value) + "'");
 			v.push_back(std::to_string(e.expires));
+			v.push_back(std::to_string(e.character_id));
+			v.push_back(std::to_string(e.npc_id));
+			v.push_back(std::to_string(e.bot_id));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -259,10 +298,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			DataBuckets e{};

-			e.id      = strtoull(row[0], nullptr, 10);
-			e.key_    = row[1] ? row[1] : "";
-			e.value   = row[2] ? row[2] : "";
-			e.expires = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.id           = strtoull(row[0], nullptr, 10);
+			e.key_         = row[1] ? row[1] : "";
+			e.value        = row[2] ? row[2] : "";
+			e.expires      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.character_id = strtoll(row[4], nullptr, 10);
+			e.npc_id       = strtoll(row[5], nullptr, 10);
+			e.bot_id       = strtoll(row[6], nullptr, 10);

 			all_entries.push_back(e);
 		}
@@ -287,10 +329,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			DataBuckets e{};

-			e.id      = strtoull(row[0], nullptr, 10);
-			e.key_    = row[1] ? row[1] : "";
-			e.value   = row[2] ? row[2] : "";
-			e.expires = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.id           = strtoull(row[0], nullptr, 10);
+			e.key_         = row[1] ? row[1] : "";
+			e.value        = row[2] ? row[2] : "";
+			e.expires      = static_cast<uint32_t>(strtoul(row[3], nullptr, 10));
+			e.character_id = strtoll(row[4], nullptr, 10);
+			e.npc_id       = strtoll(row[5], nullptr, 10);
+			e.bot_id       = strtoll(row[6], nullptr, 10);

 			all_entries.push_back(e);
 		}
@@ -16,6 +16,7 @@
 #include "../../strings.h"
 #include <ctime>

+
 class BaseItemsRepository {
 public:
 	struct Items {
@@ -122,7 +123,7 @@ public:
 		int32_t     pr;
 		int32_t     procrate;
 		int32_t     races;
-		int32_t     range;
+		int32_t     range_;
 		int32_t     reclevel;
 		int32_t     recskill;
 		int32_t     reqlevel;
@@ -417,7 +418,7 @@ public:
 			"pr",
 			"procrate",
 			"races",
-			"range",
+			"`range`",
 			"reclevel",
 			"recskill",
 			"reqlevel",
@@ -708,7 +709,7 @@ public:
 			"pr",
 			"procrate",
 			"races",
-			"range",
+			"`range`",
 			"reclevel",
 			"recskill",
 			"reqlevel",
@@ -1033,7 +1034,7 @@ public:
 		e.pr                  = 0;
 		e.procrate            = 0;
 		e.races               = 0;
-		e.range               = 0;
+		e.range_              = 0;
 		e.reclevel            = 0;
 		e.recskill            = 0;
 		e.reqlevel            = 0;
@@ -1240,8 +1241,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				items_id
 			)
 		);
@@ -1353,7 +1355,7 @@ public:
 			e.pr                  = static_cast<int32_t>(atoi(row[100]));
 			e.procrate            = static_cast<int32_t>(atoi(row[101]));
 			e.races               = static_cast<int32_t>(atoi(row[102]));
-			e.range               = static_cast<int32_t>(atoi(row[103]));
+			e.range_              = static_cast<int32_t>(atoi(row[103]));
 			e.reclevel            = static_cast<int32_t>(atoi(row[104]));
 			e.recskill            = static_cast<int32_t>(atoi(row[105]));
 			e.reqlevel            = static_cast<int32_t>(atoi(row[106]));
@@ -1671,7 +1673,7 @@ public:
 		v.push_back(columns[100] + " = " + std::to_string(e.pr));
 		v.push_back(columns[101] + " = " + std::to_string(e.procrate));
 		v.push_back(columns[102] + " = " + std::to_string(e.races));
-		v.push_back(columns[103] + " = " + std::to_string(e.range));
+		v.push_back(columns[103] + " = " + std::to_string(e.range_));
 		v.push_back(columns[104] + " = " + std::to_string(e.reclevel));
 		v.push_back(columns[105] + " = " + std::to_string(e.recskill));
 		v.push_back(columns[106] + " = " + std::to_string(e.reqlevel));
@@ -1977,7 +1979,7 @@ public:
 		v.push_back(std::to_string(e.pr));
 		v.push_back(std::to_string(e.procrate));
 		v.push_back(std::to_string(e.races));
-		v.push_back(std::to_string(e.range));
+		v.push_back(std::to_string(e.range_));
 		v.push_back(std::to_string(e.reclevel));
 		v.push_back(std::to_string(e.recskill));
 		v.push_back(std::to_string(e.reqlevel));
@@ -2291,7 +2293,7 @@ public:
 			v.push_back(std::to_string(e.pr));
 			v.push_back(std::to_string(e.procrate));
 			v.push_back(std::to_string(e.races));
-			v.push_back(std::to_string(e.range));
+			v.push_back(std::to_string(e.range_));
 			v.push_back(std::to_string(e.reclevel));
 			v.push_back(std::to_string(e.recskill));
 			v.push_back(std::to_string(e.reqlevel));
@@ -2609,7 +2611,7 @@ public:
 			e.pr                  = static_cast<int32_t>(atoi(row[100]));
 			e.procrate            = static_cast<int32_t>(atoi(row[101]));
 			e.races               = static_cast<int32_t>(atoi(row[102]));
-			e.range               = static_cast<int32_t>(atoi(row[103]));
+			e.range_              = static_cast<int32_t>(atoi(row[103]));
 			e.reclevel            = static_cast<int32_t>(atoi(row[104]));
 			e.recskill            = static_cast<int32_t>(atoi(row[105]));
 			e.reqlevel            = static_cast<int32_t>(atoi(row[106]));
@@ -2918,7 +2920,7 @@ public:
 			e.pr                  = static_cast<int32_t>(atoi(row[100]));
 			e.procrate            = static_cast<int32_t>(atoi(row[101]));
 			e.races               = static_cast<int32_t>(atoi(row[102]));
-			e.range               = static_cast<int32_t>(atoi(row[103]));
+			e.range_              = static_cast<int32_t>(atoi(row[103]));
 			e.reclevel            = static_cast<int32_t>(atoi(row[104]));
 			e.recskill            = static_cast<int32_t>(atoi(row[105]));
 			e.reqlevel            = static_cast<int32_t>(atoi(row[106]));
@@ -66,8 +66,8 @@ public:
 		uint8_t     armortint_red;
 		uint8_t     armortint_green;
 		uint8_t     armortint_blue;
-		int32_t     d_melee_texture1;
-		int32_t     d_melee_texture2;
+		uint32_t    d_melee_texture1;
+		uint32_t    d_melee_texture2;
 		std::string ammo_idfile;
 		uint8_t     prim_melee_type;
 		uint8_t     sec_melee_type;
@@ -583,7 +583,7 @@ public:
 		e.exp_mod                = 100;
 		e.heroic_strikethrough   = 0;
 		e.faction_amount         = 0;
-		e.keeps_sold_items       = 0;
+		e.keeps_sold_items       = 1;

 		return e;
 	}
@@ -666,8 +666,8 @@ public:
 			e.armortint_red          = static_cast<uint8_t>(strtoul(row[43], nullptr, 10));
 			e.armortint_green        = static_cast<uint8_t>(strtoul(row[44], nullptr, 10));
 			e.armortint_blue         = static_cast<uint8_t>(strtoul(row[45], nullptr, 10));
-			e.d_melee_texture1       = static_cast<int32_t>(atoi(row[46]));
-			e.d_melee_texture2       = static_cast<int32_t>(atoi(row[47]));
+			e.d_melee_texture1       = static_cast<uint32_t>(strtoul(row[46], nullptr, 10));
+			e.d_melee_texture2       = static_cast<uint32_t>(strtoul(row[47], nullptr, 10));
 			e.ammo_idfile            = row[48] ? row[48] : "";
 			e.prim_melee_type        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
 			e.sec_melee_type         = static_cast<uint8_t>(strtoul(row[50], nullptr, 10));
@@ -1289,8 +1289,8 @@ public:
 			e.armortint_red          = static_cast<uint8_t>(strtoul(row[43], nullptr, 10));
 			e.armortint_green        = static_cast<uint8_t>(strtoul(row[44], nullptr, 10));
 			e.armortint_blue         = static_cast<uint8_t>(strtoul(row[45], nullptr, 10));
-			e.d_melee_texture1       = static_cast<int32_t>(atoi(row[46]));
-			e.d_melee_texture2       = static_cast<int32_t>(atoi(row[47]));
+			e.d_melee_texture1       = static_cast<uint32_t>(strtoul(row[46], nullptr, 10));
+			e.d_melee_texture2       = static_cast<uint32_t>(strtoul(row[47], nullptr, 10));
 			e.ammo_idfile            = row[48] ? row[48] : "";
 			e.prim_melee_type        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
 			e.sec_melee_type         = static_cast<uint8_t>(strtoul(row[50], nullptr, 10));
@@ -1440,8 +1440,8 @@ public:
 			e.armortint_red          = static_cast<uint8_t>(strtoul(row[43], nullptr, 10));
 			e.armortint_green        = static_cast<uint8_t>(strtoul(row[44], nullptr, 10));
 			e.armortint_blue         = static_cast<uint8_t>(strtoul(row[45], nullptr, 10));
-			e.d_melee_texture1       = static_cast<int32_t>(atoi(row[46]));
-			e.d_melee_texture2       = static_cast<int32_t>(atoi(row[47]));
+			e.d_melee_texture1       = static_cast<uint32_t>(strtoul(row[46], nullptr, 10));
+			e.d_melee_texture2       = static_cast<uint32_t>(strtoul(row[47], nullptr, 10));
 			e.ammo_idfile            = row[48] ? row[48] : "";
 			e.prim_melee_type        = static_cast<uint8_t>(strtoul(row[49], nullptr, 10));
 			e.sec_melee_type         = static_cast<uint8_t>(strtoul(row[50], nullptr, 10));
@@ -16,6 +16,7 @@
 #include "../../strings.h"
 #include <ctime>

+
 class BaseRaidDetailsRepository {
 public:
 	struct RaidDetails {
@@ -23,6 +24,9 @@ public:
 		int32_t     loottype;
 		int8_t      locked;
 		std::string motd;
+		uint16_t    marked_npc_1;
+		uint16_t    marked_npc_2;
+		uint16_t    marked_npc_3;
 	};

 	static std::string PrimaryKey()
@@ -37,6 +41,9 @@ public:
 			"loottype",
 			"locked",
 			"motd",
+			"marked_npc_1",
+			"marked_npc_2",
+			"marked_npc_3",
 		};
 	}

@@ -47,6 +54,9 @@ public:
 			"loottype",
 			"locked",
 			"motd",
+			"marked_npc_1",
+			"marked_npc_2",
+			"marked_npc_3",
 		};
 	}

@@ -87,10 +97,13 @@ public:
 	{
 		RaidDetails e{};

-		e.raidid   = 0;
-		e.loottype = 0;
-		e.locked   = 0;
-		e.motd     = "";
+		e.raidid       = 0;
+		e.loottype     = 0;
+		e.locked       = 0;
+		e.motd         = "";
+		e.marked_npc_1 = 0;
+		e.marked_npc_2 = 0;
+		e.marked_npc_3 = 0;

 		return e;
 	}
@@ -116,8 +129,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				raid_details_id
 			)
 		);
@@ -126,10 +140,13 @@ public:
 		if (results.RowCount() == 1) {
 			RaidDetails e{};

-			e.raidid   = static_cast<int32_t>(atoi(row[0]));
-			e.loottype = static_cast<int32_t>(atoi(row[1]));
-			e.locked   = static_cast<int8_t>(atoi(row[2]));
-			e.motd     = row[3] ? row[3] : "";
+			e.raidid       = static_cast<int32_t>(atoi(row[0]));
+			e.loottype     = static_cast<int32_t>(atoi(row[1]));
+			e.locked       = static_cast<int8_t>(atoi(row[2]));
+			e.motd         = row[3] ? row[3] : "";
+			e.marked_npc_1 = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
+			e.marked_npc_2 = static_cast<uint16_t>(strtoul(row[5], nullptr, 10));
+			e.marked_npc_3 = static_cast<uint16_t>(strtoul(row[6], nullptr, 10));

 			return e;
 		}
@@ -167,6 +184,9 @@ public:
 		v.push_back(columns[1] + " = " + std::to_string(e.loottype));
 		v.push_back(columns[2] + " = " + std::to_string(e.locked));
 		v.push_back(columns[3] + " = '" + Strings::Escape(e.motd) + "'");
+		v.push_back(columns[4] + " = " + std::to_string(e.marked_npc_1));
+		v.push_back(columns[5] + " = " + std::to_string(e.marked_npc_2));
+		v.push_back(columns[6] + " = " + std::to_string(e.marked_npc_3));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -192,6 +212,9 @@ public:
 		v.push_back(std::to_string(e.loottype));
 		v.push_back(std::to_string(e.locked));
 		v.push_back("'" + Strings::Escape(e.motd) + "'");
+		v.push_back(std::to_string(e.marked_npc_1));
+		v.push_back(std::to_string(e.marked_npc_2));
+		v.push_back(std::to_string(e.marked_npc_3));

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -225,6 +248,9 @@ public:
 			v.push_back(std::to_string(e.loottype));
 			v.push_back(std::to_string(e.locked));
 			v.push_back("'" + Strings::Escape(e.motd) + "'");
+			v.push_back(std::to_string(e.marked_npc_1));
+			v.push_back(std::to_string(e.marked_npc_2));
+			v.push_back(std::to_string(e.marked_npc_3));

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -258,10 +284,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RaidDetails e{};

-			e.raidid   = static_cast<int32_t>(atoi(row[0]));
-			e.loottype = static_cast<int32_t>(atoi(row[1]));
-			e.locked   = static_cast<int8_t>(atoi(row[2]));
-			e.motd     = row[3] ? row[3] : "";
+			e.raidid       = static_cast<int32_t>(atoi(row[0]));
+			e.loottype     = static_cast<int32_t>(atoi(row[1]));
+			e.locked       = static_cast<int8_t>(atoi(row[2]));
+			e.motd         = row[3] ? row[3] : "";
+			e.marked_npc_1 = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
+			e.marked_npc_2 = static_cast<uint16_t>(strtoul(row[5], nullptr, 10));
+			e.marked_npc_3 = static_cast<uint16_t>(strtoul(row[6], nullptr, 10));

 			all_entries.push_back(e);
 		}
@@ -286,10 +315,13 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			RaidDetails e{};

-			e.raidid   = static_cast<int32_t>(atoi(row[0]));
-			e.loottype = static_cast<int32_t>(atoi(row[1]));
-			e.locked   = static_cast<int8_t>(atoi(row[2]));
-			e.motd     = row[3] ? row[3] : "";
+			e.raidid       = static_cast<int32_t>(atoi(row[0]));
+			e.loottype     = static_cast<int32_t>(atoi(row[1]));
+			e.locked       = static_cast<int8_t>(atoi(row[2]));
+			e.motd         = row[3] ? row[3] : "";
+			e.marked_npc_1 = static_cast<uint16_t>(strtoul(row[4], nullptr, 10));
+			e.marked_npc_2 = static_cast<uint16_t>(strtoul(row[5], nullptr, 10));
+			e.marked_npc_3 = static_cast<uint16_t>(strtoul(row[6], nullptr, 10));

 			all_entries.push_back(e);
 		}
@@ -31,6 +31,9 @@ public:
 		int8_t      isgroupleader;
 		int8_t      israidleader;
 		int8_t      islooter;
+		uint8_t     is_marker;
+		uint8_t     is_assister;
+		std::string note;
 	};

 	static std::string PrimaryKey()
@@ -52,6 +55,9 @@ public:
 			"isgroupleader",
 			"israidleader",
 			"islooter",
+			"is_marker",
+			"is_assister",
+			"note",
 		};
 	}

@@ -69,6 +75,9 @@ public:
 			"isgroupleader",
 			"israidleader",
 			"islooter",
+			"is_marker",
+			"is_assister",
+			"note",
 		};
 	}

@@ -120,6 +129,9 @@ public:
 		e.isgroupleader = 0;
 		e.israidleader  = 0;
 		e.islooter      = 0;
+		e.is_marker     = 0;
+		e.is_assister   = 0;
+		e.note          = "";

 		return e;
 	}
@@ -167,6 +179,9 @@ public:
 			e.isgroupleader = static_cast<int8_t>(atoi(row[8]));
 			e.israidleader  = static_cast<int8_t>(atoi(row[9]));
 			e.islooter      = static_cast<int8_t>(atoi(row[10]));
+			e.is_marker     = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
+			e.is_assister   = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
+			e.note          = row[13] ? row[13] : "";

 			return e;
 		}
@@ -210,6 +225,9 @@ public:
 		v.push_back(columns[8] + " = " + std::to_string(e.isgroupleader));
 		v.push_back(columns[9] + " = " + std::to_string(e.israidleader));
 		v.push_back(columns[10] + " = " + std::to_string(e.islooter));
+		v.push_back(columns[11] + " = " + std::to_string(e.is_marker));
+		v.push_back(columns[12] + " = " + std::to_string(e.is_assister));
+		v.push_back(columns[13] + " = '" + Strings::Escape(e.note) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -242,6 +260,9 @@ public:
 		v.push_back(std::to_string(e.isgroupleader));
 		v.push_back(std::to_string(e.israidleader));
 		v.push_back(std::to_string(e.islooter));
+		v.push_back(std::to_string(e.is_marker));
+		v.push_back(std::to_string(e.is_assister));
+		v.push_back("'" + Strings::Escape(e.note) + "'");

 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -282,6 +303,9 @@ public:
 			v.push_back(std::to_string(e.isgroupleader));
 			v.push_back(std::to_string(e.israidleader));
 			v.push_back(std::to_string(e.islooter));
+			v.push_back(std::to_string(e.is_marker));
+			v.push_back(std::to_string(e.is_assister));
+			v.push_back("'" + Strings::Escape(e.note) + "'");

 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -326,6 +350,9 @@ public:
 			e.isgroupleader = static_cast<int8_t>(atoi(row[8]));
 			e.israidleader  = static_cast<int8_t>(atoi(row[9]));
 			e.islooter      = static_cast<int8_t>(atoi(row[10]));
+			e.is_marker     = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
+			e.is_assister   = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
+			e.note          = row[13] ? row[13] : "";

 			all_entries.push_back(e);
 		}
@@ -361,6 +388,9 @@ public:
 			e.isgroupleader = static_cast<int8_t>(atoi(row[8]));
 			e.israidleader  = static_cast<int8_t>(atoi(row[9]));
 			e.islooter      = static_cast<int8_t>(atoi(row[10]));
+			e.is_marker     = static_cast<uint8_t>(strtoul(row[11], nullptr, 10));
+			e.is_assister   = static_cast<uint8_t>(strtoul(row[12], nullptr, 10));
+			e.note          = row[13] ? row[13] : "";

 			all_entries.push_back(e);
 		}
@@ -0,0 +1,221 @@
+#ifndef EQEMU_COMMAND_SUBSETTINGS_REPOSITORY_H
+#define EQEMU_COMMAND_SUBSETTINGS_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_command_subsettings_repository.h"
+
+class CommandSubsettingsRepository: public BaseCommandSubsettingsRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * CommandSubsettingsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * CommandSubsettingsRepository::GetWhereNeverExpires()
+     * CommandSubsettingsRepository::GetWhereXAndY()
+     * CommandSubsettingsRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+	static std::vector<CommandSubsettingsRepository::CommandSubsettings> GetAll(Database& db)
+	{
+		// these are the base definitions for command_subsettings and can be over-ridden by the database
+		std::vector<CommandSubsettingsRepository::CommandSubsettings> static_records = {
+			{.parent_command = "find", .sub_command = "aa", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findaa"},
+			{.parent_command = "find", .sub_command = "character", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findcharacter"},
+			{.parent_command = "find", .sub_command = "class", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findclass"},
+			{.parent_command = "find", .sub_command = "currency", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findcurrency"},
+			{.parent_command = "find", .sub_command = "deity", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "finddeity"},
+			{.parent_command = "find", .sub_command = "emote", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findemote"},
+			{.parent_command = "find", .sub_command = "faction", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findfaction"},
+			{.parent_command = "find", .sub_command = "item", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "fi|finditem|itemsearch"},
+			{.parent_command = "find", .sub_command = "language", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findlanguage"},
+			{.parent_command = "find", .sub_command = "npc_type", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "fn|findnpc|findnpctype"},
+			{.parent_command = "find", .sub_command = "race", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findrace"},
+			{.parent_command = "find", .sub_command = "recipe", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findrecipe"},
+			{.parent_command = "find", .sub_command = "skill", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findskill"},
+			{.parent_command = "find", .sub_command = "spell", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "fs|findspell"},
+			{.parent_command = "find", .sub_command = "task", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "findtask"},
+			{.parent_command = "find", .sub_command = "zone", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "fz|findzone"},
+			{.parent_command = "set", .sub_command = "aa_exp", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setaaxp|setaaexp"},
+			{.parent_command = "set", .sub_command = "aa_points", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setaapts|setaapoints"},
+			{.parent_command = "set", .sub_command = "adventure_points", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setadventurepoints"},
+			{.parent_command = "set", .sub_command = "alternate_currency", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setaltcurrency"},
+			{.parent_command = "set", .sub_command = "animation", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setanim"},
+			{.parent_command = "set", .sub_command = "anon", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setanon"},
+			{.parent_command = "set", .sub_command = "bind", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "bind"},
+			{.parent_command = "set", .sub_command = "checksum", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "updatechecksum"},
+			{.parent_command = "set", .sub_command = "class_permanent", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "permaclass"},
+			{.parent_command = "set", .sub_command = "crystals", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setcrystals"},
+			{.parent_command = "set", .sub_command = "date", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "date"},
+			{.parent_command = "set", .sub_command = "endurance", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setendurance"},
+			{.parent_command = "set", .sub_command = "endurance_full", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "endurance"},
+			{.parent_command = "set", .sub_command = "exp", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setxp|setexp"},
+			{.parent_command = "set", .sub_command = "faction", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setfaction"},
+			{.parent_command = "set", .sub_command = "flymode", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "flymode"},
+			{.parent_command = "set", .sub_command = "freeze", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "freeze|unfreeze"},
+			{.parent_command = "set", .sub_command = "gender", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "gender"},
+			{.parent_command = "set", .sub_command = "gender_permanent", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "permagender"},
+			{.parent_command = "set", .sub_command = "gm", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "gm"},
+			{.parent_command = "set", .sub_command = "gm_speed", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "gmspeed"},
+			{.parent_command = "set", .sub_command = "gm_status", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "flag"},
+			{.parent_command = "set", .sub_command = "god_mode", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "godmode"},
+			{.parent_command = "set", .sub_command = "haste", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "haste"},
+			{.parent_command = "set", .sub_command = "hero_model", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "heromodel"},
+			{.parent_command = "set", .sub_command = "hide_me", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "hideme"},
+			{.parent_command = "set", .sub_command = "hp", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "sethp"},
+			{.parent_command = "set", .sub_command = "hp_full", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "heal"},
+			{.parent_command = "set", .sub_command = "invulnerable", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "invul|invulnerable"},
+			{.parent_command = "set", .sub_command = "language", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setlanguage"},
+			{.parent_command = "set", .sub_command = "last_name", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "lastname"},
+			{.parent_command = "set", .sub_command = "level", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "level"},
+			{.parent_command = "set", .sub_command = "loginserver_info", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setlsinfo"},
+			{.parent_command = "set", .sub_command = "mana", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setmana"},
+			{.parent_command = "set", .sub_command = "mana_full", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "mana"},
+			{.parent_command = "set", .sub_command = "motd", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "motd"},
+			{.parent_command = "set", .sub_command = "name", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "name"},
+			{.parent_command = "set", .sub_command = "ooc_mute", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "oocmute"},
+			{.parent_command = "set", .sub_command = "password", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setpass"},
+			{.parent_command = "set", .sub_command = "pvp", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "pvp"},
+			{.parent_command = "set", .sub_command = "pvp_points", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setpvppoints"},
+			{.parent_command = "set", .sub_command = "race", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "race"},
+			{.parent_command = "set", .sub_command = "race_permanent", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "permarace"},
+			{.parent_command = "set", .sub_command = "server_locked", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "lock|serverlock|serverunlock|unlock"},
+			{.parent_command = "set", .sub_command = "skill", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setskill"},
+			{.parent_command = "set", .sub_command = "skill_all", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setallskill|setallskills|setskillall"},
+			{.parent_command = "set", .sub_command = "skill_all_max", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "maxskills"},
+			{.parent_command = "set", .sub_command = "start_zone", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "setstartzone"},
+			{.parent_command = "set", .sub_command = "temporary_name", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "tempname"},
+			{.parent_command = "set", .sub_command = "texture", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "texture"},
+			{.parent_command = "set", .sub_command = "time", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "time"},
+			{.parent_command = "set", .sub_command = "time_zone", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "timezone"},
+			{.parent_command = "set", .sub_command = "title", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "title"},
+			{.parent_command = "set", .sub_command = "title_suffix", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "titlesuffix"},
+			{.parent_command = "set", .sub_command = "weather", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "weather"},
+			{.parent_command = "set", .sub_command = "zone", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "zclip|zcolor|zheader|zonelock|zsafecoords|zsky|zunderworld"},
+			{.parent_command = "show", .sub_command = "aggro", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "aggro"},
+			{.parent_command = "show", .sub_command = "buffs", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showbuffs"},
+			{.parent_command = "show", .sub_command = "buried_corpse_count", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "getplayerburiedcorpsecount"},
+			{.parent_command = "show", .sub_command = "client_version_summary", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "cvs"},
+			{.parent_command = "show", .sub_command = "currencies", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "viewcurrencies"},
+			{.parent_command = "show", .sub_command = "distance", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "distance"},
+			{.parent_command = "show", .sub_command = "emote", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "emoteview"},
+			{.parent_command = "show", .sub_command = "field_of_view", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "fov"},
+			{.parent_command = "show", .sub_command = "flags", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "flags"},
+			{.parent_command = "show", .sub_command = "group_info", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "ginfo"},
+			{.parent_command = "show", .sub_command = "hatelist", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "hatelist"},
+			{.parent_command = "show", .sub_command = "inventory", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "peekinv"},
+			{.parent_command = "show", .sub_command = "ip_lookup", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "iplookup"},
+			{.parent_command = "show", .sub_command = "line_of_sight", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "checklos"},
+			{.parent_command = "show", .sub_command = "network", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "network"},
+			{.parent_command = "show", .sub_command = "network_stats", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "netstats"},
+			{.parent_command = "show", .sub_command = "npc_global_loot", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "shownpcgloballoot"},
+			{.parent_command = "show", .sub_command = "npc_stats", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "npcstats"},
+			{.parent_command = "show", .sub_command = "npc_type", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "viewnpctype"},
+			{.parent_command = "show", .sub_command = "peqzone_flags", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "peqzone_flags"},
+			{.parent_command = "show", .sub_command = "petition", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "listpetition|viewpetition"},
+			{.parent_command = "show", .sub_command = "petition_info", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "petitioninfo"},
+			{.parent_command = "show", .sub_command = "proximity", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "proximity"},
+			{.parent_command = "show", .sub_command = "quest_errors", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "questerrors"},
+			{.parent_command = "show", .sub_command = "quest_globals", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "globalview"},
+			{.parent_command = "show", .sub_command = "recipe", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "viewrecipe"},
+			{.parent_command = "show", .sub_command = "server_info", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "serverinfo"},
+			{.parent_command = "show", .sub_command = "skills", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showskills"},
+			{.parent_command = "show", .sub_command = "spawn_status", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "spawnstatus"},
+			{.parent_command = "show", .sub_command = "spells", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showspells"},
+			{.parent_command = "show", .sub_command = "spells_list", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showspellslist"},
+			{.parent_command = "show", .sub_command = "stats", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showstats"},
+			{.parent_command = "show", .sub_command = "timers", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "timers"},
+			{.parent_command = "show", .sub_command = "traps", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "trapinfo"},
+			{.parent_command = "show", .sub_command = "uptime", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "uptime"},
+			{.parent_command = "show", .sub_command = "variable", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "getvariable"},
+			{.parent_command = "show", .sub_command = "version", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "version"},
+			{.parent_command = "show", .sub_command = "waypoints", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "wpinfo"},
+			{.parent_command = "show", .sub_command = "who", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "who"},
+			{.parent_command = "show", .sub_command = "xtargets", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "xtargets"},
+			{.parent_command = "show", .sub_command = "zone_global_loot", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showzonegloballoot"},
+			{.parent_command = "show", .sub_command = "zone_loot", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "viewzoneloot"},
+			{.parent_command = "show", .sub_command = "zone_points", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showzonepoints"},
+			{.parent_command = "show", .sub_command = "zone_stats", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "zstats"},
+			{.parent_command = "show", .sub_command = "zone_status", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "zonestatus"},
+		};
+
+		auto db_sub_settings = All(db);
+
+		// inject commands in the database that are not already there
+		std::vector<CommandSubsettingsRepository::CommandSubsettings> new_records = {};
+		for (const auto &r: static_records) {
+			bool found = false;
+			for (const auto &db_r: db_sub_settings) {
+				if (r.parent_command == db_r.parent_command && r.sub_command == db_r.sub_command) {
+					found = true;
+				}
+			}
+
+			if (!found) {
+				LogInfo("New command [{}] sub-command [{}] added to database table [{}] !", r.parent_command, r.sub_command, TableName());
+				new_records.emplace_back(r);
+			}
+		}
+
+		if (!new_records.empty()) {
+			InsertMany(db, new_records);
+			// if any were added, we need to reload the list
+			db_sub_settings = All(db);
+		}
+
+		// remove commands from the database that are not in the static list
+		bool any_deleted = false;
+		for (const auto &db_r: db_sub_settings) {
+			bool found = false;
+			for (const auto &r: static_records) {
+				if (r.parent_command == db_r.parent_command && r.sub_command == db_r.sub_command) {
+					found = true;
+				}
+			}
+
+			if (!found) {
+				LogInfo("Command [{}] sub-command [{}] removed from database table [{}] !", db_r.parent_command, db_r.sub_command, TableName());
+				DeleteWhere(db, fmt::format("parent_command = '{}' AND sub_command = '{}'", db_r.parent_command, db_r.sub_command));
+				any_deleted = true;
+			}
+		}
+
+		// if any were deleted, re-read the database
+		if (any_deleted) {
+			db_sub_settings = All(db);
+		}
+
+		// return the final list of what's in the database
+		return db_sub_settings;
+	}
+};
+
+#endif //EQEMU_COMMAND_SUBSETTINGS_REPOSITORY_H
@@ -44,7 +44,35 @@ public:
     */

 	// Custom extended repository methods here
+	static std::vector<int32> GetItemIDsBySearchCriteria(
+		Database& db,
+		std::string search_string,
+		int query_limit = 0
+	)
+	{
+		auto query = fmt::format(
+			"SELECT `id` FROM {} WHERE LOWER(`name`) LIKE '%%{}%%' ORDER BY id ASC",
+			TableName(),
+			Strings::Escape(search_string)
+		);

+		if (query_limit >= 1) {
+			query += fmt::format(" LIMIT {}", query_limit);
+		}
+
+		std::vector<int32> item_id_list;
+
+		auto results = db.QueryDatabase(query);
+		if (!results.Success() || !results.RowCount()) {
+			return item_id_list;
+		}
+
+		for (auto row : results) {
+			item_id_list.emplace_back(Strings::ToInt(row[0]));
+		}
+
+		return item_id_list;
+	}
 };

 #endif //EQEMU_ITEMS_REPOSITORY_H
@@ -44,7 +44,24 @@ public:
     */

 	// Custom extended repository methods here
+	static int UpdateRaidMarkedNPC(
+		Database& db,
+		int32_t raid_id,
+		uint8_t marked_npc_number,
+		uint8_t value
+	) {
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `marked_npc_{}` = '{}' WHERE raidid = '{}';",
+				TableName(),
+				marked_npc_number,
+				value,
+				raid_id
+			)
+		);

+		return results.Success() ? results.RowsAffected() : 0;
+	}
 };

 #endif //EQEMU_RAID_DETAILS_REPOSITORY_H
@@ -44,7 +44,59 @@ public:
     */

 	// Custom extended repository methods here
+	static int UpdateRaidNote(
+		Database& db,
+		int32_t raid_id,
+		const std::string& note,
+		const std::string& character_name
+	) {
+		auto results = db.QueryDatabase(
+			fmt::format("UPDATE `{}` SET `note` = '{}' WHERE raidid = '{}' AND name = '{}';",
+				TableName(),
+				Strings::Escape(note),
+				raid_id,
+				Strings::Escape(character_name)
+			)
+		);
+		return results.Success() ? results.RowsAffected() : 0;
+	}
+	
+	static int UpdateRaidAssister(
+		Database& db,
+		int32_t raid_id,
+		const std::string& character_name,
+		uint8_t value
+	) {
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `is_assister` = '{}' WHERE raidid = '{}' AND `name` = '{}';",
+				TableName(),
+				value,
+				raid_id,
+				Strings::Escape(character_name)
+			)
+		);

+		return results.Success() ? results.RowsAffected() : 0;
+	}
+
+	static int UpdateRaidMarker(
+		Database& db,
+		int32_t raid_id,
+		const std::string& character_name,
+		uint8_t value
+	) {
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE `{}` SET `is_marker` = '{}' WHERE raidid = '{}' AND `name` = '{}';",
+				TableName(),
+				value,
+				raid_id,
+				Strings::Escape(character_name)
+			)
+		);
+
+		return results.Success() ? results.RowsAffected() : 0;
+	}
 };
-
 #endif //EQEMU_RAID_MEMBERS_REPOSITORY_H
@@ -241,6 +241,7 @@ RULE_CATEGORY_END()
 RULE_CATEGORY(Skills)
 RULE_INT(Skills, MaxTrainTradeskills, 21, "Highest level for trading skills that can be learnt by the trainer")
 RULE_BOOL(Skills, UseLimitTradeskillSearchSkillDiff, true, "Enables the limit for the maximum difference between trivial and skill for recipe searches and favorites")
+RULE_BOOL(Skills, TrivialTradeskillCombinesNoFail, false, "Enable to make all trivial tradeskill combines unable to fail")
 RULE_INT(Skills, MaxTradeskillSearchSkillDiff, 50, "The maximum difference in skill between the trivial of an item and the skill of the player if the trivial is higher than the skill. Recipes that have not been learnt or made at least once via the Experiment mode will be removed from searches based on this criteria.")
 RULE_INT(Skills, MaxTrainSpecializations, 50, "Maximum level a GM trainer will train casting specializations")
 RULE_INT(Skills, SwimmingStartValue, 100, "Start value of swimming skill")
@@ -256,6 +257,7 @@ RULE_BOOL(Pets, UnTargetableSwarmPet, false, "Setting whether swarm pets should
 RULE_REAL(Pets, PetPowerLevelCap, 10, "Maximum number of levels a player pet can go up with pet power")
 RULE_BOOL(Pets, CanTakeNoDrop, false, "Setting whether anyone can give no-drop items to pets")
 RULE_BOOL(Pets, LivelikeBreakCharmOnInvis, true, "Default: true will break charm on any type of invis (hide/ivu/iva/etc) false will only break if the pet can not see you (ex. you have an undead pet and cast IVU")
+RULE_BOOL(Pets, ClientPetsUseOwnerNameInLastName, true, "Disable this to keep client pet's last names from being owner_name's pet")
 RULE_CATEGORY_END()

 RULE_CATEGORY(GM)
@@ -635,6 +637,7 @@ RULE_BOOL(Bots, OldRaceRezEffects, false, "Older clients had ID 757 for races wi
 RULE_BOOL(Bots, ResurrectionSickness, true, "Use Resurrection Sickness based on Resurrection spell cast, set to false to disable Resurrection Sickness.")
 RULE_INT(Bots, OldResurrectionSicknessSpell, 757, "757 is Default Old Resurrection Sickness Spell")
 RULE_INT(Bots, ResurrectionSicknessSpell, 756, "756 is Default Resurrection Sickness Spell")
+RULE_BOOL(Bots, AllowPickpocketCommand, true, "Allows the use of the bot command 'pickpocket'")
 RULE_CATEGORY_END()

 RULE_CATEGORY(Chat)
@@ -376,7 +376,7 @@ std::string EQ::SayLinkEngine::InjectSaylinksIfNotExist(const char *message)

 void EQ::SayLinkEngine::LoadCachedSaylinks()
 {
-	auto saylinks = SaylinkRepository::GetWhere(database, "phrase not like '%#%'");
+	auto saylinks = SaylinkRepository::GetWhere(database, "phrase not REGEXP BINARY '[A-Z]' and phrase not REGEXP '[0-9]'");
 	LogSaylink("Loaded [{}] saylinks into cache", saylinks.size());
 	g_cached_saylinks = saylinks;
 }
@@ -399,6 +399,7 @@ SaylinkRepository::Saylink EQ::SayLinkEngine::GetOrSaveSaylink(std::string sayli

 	// return if found from the database
 	if (!saylinks.empty()) {
+		g_cached_saylinks.emplace_back(saylinks[0]);
 		return saylinks[0];
 	}

@@ -113,6 +113,7 @@
 #define ServerOP_GroupFollowAck		0x0111
 #define ServerOP_GroupCancelInvite	0x0112
 #define ServerOP_RaidMOTD			0x0113
+#define ServerOP_RaidNote           0x0114

 #define ServerOP_InstanceUpdateTime			0x014F
 #define ServerOP_AdventureRequest			0x0150
@@ -285,6 +286,8 @@
 // player events
 #define ServerOP_PlayerEvent 0x5100

+#define ServerOP_DataBucketCacheUpdate 0x5200
+
 enum {
 	CZUpdateType_Character,
 	CZUpdateType_Group,
@@ -1075,6 +1078,10 @@ struct ServerRaidMOTD_Struct {
 	char motd[0];
 };

+struct ServerRaidNote_Struct {
+	uint32 rid;
+};
+
 struct ServerLFGMatchesRequest_Struct {
 	uint32	FromID;
 	uint8	QuerierLevel;
@@ -1815,6 +1822,11 @@ struct ServerSendPlayerEvent_Struct {
 	char cereal_data[0];
 };

+struct ServerDataBucketCacheUpdate_Struct {
+	uint32_t cereal_size;
+	char cereal_data[0];
+};
+
 struct ServerFlagUpdate_Struct {
 	uint32 account_id;
 	int16 admin;
@@ -1824,6 +1836,11 @@ struct ServerOOCMute_Struct {
 	bool is_muted;
 };

+struct ServerZoneStatus_Struct {
+	char  name[64];
+	int16 admin;
+};
+
 #pragma pack()

 #endif
@@ -1635,25 +1635,29 @@ bool SharedDatabase::GetCommandSettings(std::map<std::string, std::pair<uint8, s
 {
 	command_settings.clear();

-	const std::string query = "SELECT `command`, `access`, `aliases` FROM `command_settings`";
+	const std::string& query = "SELECT `command`, `access`, `aliases` FROM `command_settings`";
 	auto results = QueryDatabase(query);
-	if (!results.Success())
+	if (!results.Success() || !results.RowCount()) {
 		return false;
+	}

-	for (auto& row = results.begin(); row != results.end(); ++row) {
+	for (auto row : results) {
 		command_settings[row[0]].first = Strings::ToUnsignedInt(row[1]);
-		if (row[2][0] == 0)
+		if (row[2][0] == 0) {
 			continue;
+		}

 		std::vector<std::string> aliases = Strings::Split(row[2], '|');
-		for (auto iter = aliases.begin(); iter != aliases.end(); ++iter) {
-			if (iter->empty())
+		for (const auto& e : aliases) {
+			if (e.empty()) {
 				continue;
-			command_settings[row[0]].second.push_back(*iter);
+			}
+
+			command_settings[row[0]].second.push_back(e);
 		}
 	}

-    return true;
+	return true;
 }

 bool SharedDatabase::UpdateInjectedCommandSettings(const std::vector<std::pair<std::string, uint8>> &injected)
@@ -1668,13 +1672,15 @@ bool SharedDatabase::UpdateInjectedCommandSettings(const std::vector<std::pair<s
 			)
 		);

-		if (!QueryDatabase(query).Success()) {
+		auto results = QueryDatabase(query);
+		if (!results.Success()) {
 			return false;
 		}

 		LogInfo(
-			"[{0}] New Command(s) Added",
-			injected.size()
+			"[{}] New Command{} Added",
+			injected.size(),
+			injected.size() != 1 ? "s" : ""
 		);
 	}

@@ -1684,25 +1690,58 @@ bool SharedDatabase::UpdateInjectedCommandSettings(const std::vector<std::pair<s
 bool SharedDatabase::UpdateOrphanedCommandSettings(const std::vector<std::string> &orphaned)
 {
 	if (orphaned.size()) {
-		const std::string query = fmt::format(
+		std::string query = fmt::format(
 			"DELETE FROM `command_settings` WHERE `command` IN ({})",
 			Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
 		);

-		if (!QueryDatabase(query).Success()) {
+		auto results = QueryDatabase(query);
+		if (!results.Success()) {
+			return false;
+		}
+
+		query = fmt::format(
+			"DELETE FROM `command_subsettings` WHERE `parent_command` IN ({})",
+			Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned)
+		);
+
+		auto results_two = QueryDatabase(query);
+		if (!results_two.Success()) {
 			return false;
 		}

 		LogInfo(
-			"{} Orphaned Command{} Deleted",
+			"{} Orphaned Command{} Deleted | {} Orphaned Subcommand{} Deleted",
 			orphaned.size(),
-			(orphaned.size() == 1 ? "" : "s")
+			orphaned.size() != 1 ? "s" : "",
+			results_two.RowsAffected(),
+			results_two.RowsAffected() != 1 ? "s" : ""
 		);
 	}

 	return true;
 }

+bool SharedDatabase::GetCommandSubSettings(std::vector<CommandSubsettingsRepository::CommandSubsettings> &command_subsettings)
+{
+	command_subsettings.clear();
+
+	const auto& l = CommandSubsettingsRepository::GetAll(*this);
+
+	if (l.empty()) {
+		return false;
+	}
+
+	command_subsettings.reserve(l.size());
+
+	for (const auto& e : l) {
+		command_subsettings.emplace_back(e);
+	}
+
+	return true;
+}
+
+
 bool SharedDatabase::LoadSkillCaps(const std::string &prefix) {
 	skill_caps_mmf.reset(nullptr);

@@ -28,6 +28,7 @@
 #include "fixed_memory_hash_set.h"
 #include "fixed_memory_variable_hash_set.h"
 #include "say_link.h"
+#include "repositories/command_subsettings_repository.h"

 #include <list>
 #include <map>
@@ -77,6 +78,7 @@ public:
 	bool GetCommandSettings(std::map<std::string, std::pair<uint8, std::vector<std::string>>> &command_settings);
 	bool UpdateInjectedCommandSettings(const std::vector<std::pair<std::string, uint8>> &injected);
 	bool UpdateOrphanedCommandSettings(const std::vector<std::string> &orphaned);
+	bool GetCommandSubSettings(std::vector<CommandSubsettingsRepository::CommandSubsettings> &command_subsettings);
 	uint32 GetTotalTimeEntitledOnAccount(uint32 AccountID);
 	bool SetGMInvul(uint32 account_id, bool gminvul);
 	bool SetGMFlymode(uint32 account_id, uint8 flymode);
@@ -695,8 +695,31 @@ std::string Strings::ConvertToDigit(int n, const std::string& suffix)
 		return NUM_TO_ENGLISH_X[n] + suffix;
 	}
 }
+
+bool Strings::BeginsWith(const std::string& subject, const std::string& search)
+{
+	if (subject.length() < search.length()) {
+		return false;
+	}
+
+	return subject.starts_with(search);
+}
+
+bool Strings::EndsWith(const std::string& subject, const std::string& search)
+{
+	if (subject.length() < search.length()) {
+		return false;
+	}
+
+	return subject.ends_with(search);
+}
+
 bool Strings::Contains(const std::string& subject, const std::string& search)
 {
+	if (subject.length() < search.length()) {
+		return false;
+	}
+
 	return subject.find(search) != std::string::npos;
 }

@@ -859,3 +882,17 @@ std::string Strings::RemoveNumbers(std::string s)

 	return s.substr(0, current);
 }
+
+std::string Strings::ZoneTime(const uint8 hours, const uint8 minutes)
+{
+	return fmt::format(
+		"{:02}:{:02} {}",
+		(
+			(hours % 12) == 0 ?
+			12 :
+			(hours % 12)
+		),
+		minutes,
+		hours >= 13 ? "PM" : "AM"
+	);
+}
@@ -128,6 +128,9 @@ public:
 	static bool ToBool(const std::string& bool_string);
 	static inline bool EqualFold(const std::string &string_one, const std::string &string_two) { return strcasecmp(string_one.c_str(), string_two.c_str()) == 0; }
 	static std::string Random(size_t length);
+	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
@@ -25,7 +25,7 @@

 // Build variables
 // these get injected during the build pipeline
-#define CURRENT_VERSION "22.15.0-dev" // always append -dev to the current version for custom-builds
+#define CURRENT_VERSION "22.22.1-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 9228
+#define CURRENT_BINARY_DATABASE_VERSION 9233

 #define CURRENT_BINARY_BOTS_DATABASE_VERSION 9039

@@ -1,87 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "../common/global_define.h"
-#include "../common/eqemu_logsys.h"
-#include <iomanip>
-
-#include "worldconn.h"
-#include "eqemu_config.h"
-#include "md5.h"
-#include "servertalk.h"
-
-WorldConnection::WorldConnection(EmuTCPConnection::ePacketMode mode, const char *password)
-: m_password(password)
-{
-	tcpc.SetPacketMode(mode);
-	pTryReconnect = true;
-	pConnected = false;
-}
-
-WorldConnection::~WorldConnection() {
-}
-
-bool WorldConnection::SendPacket(ServerPacket* pack) {
-	if (!Connected())
-		return false;
-	return tcpc.SendPacket(pack);
-}
-
-void WorldConnection::OnConnected() {
-	const EQEmuConfig *Config=EQEmuConfig::get();
-	LogNetcode("[WORLD] Connected to World: [{}]:[{}]", Config->WorldIP.c_str(), Config->WorldTCPPort);
-
-	auto pack = new ServerPacket(ServerOP_ZAAuth, 16);
-	MD5::Generate((const uchar*) m_password.c_str(), m_password.length(), pack->pBuffer);
-	SendPacket(pack);
-	safe_delete(pack);
-}
-
-void WorldConnection::Process() {
-	//persistent connection....
-	if (!Connected()) {
-		pConnected = tcpc.Connected();
-		if (pConnected) {
-			OnConnected();
-		}
-		else
-			return;
-	}
-
-}
-
-void WorldConnection::AsyncConnect() {
-	const EQEmuConfig *Config=EQEmuConfig::get();
-	tcpc.AsyncConnect(Config->WorldIP.c_str(), Config->WorldTCPPort);
-}
-
-bool WorldConnection::Connect() {
-	const EQEmuConfig *Config=EQEmuConfig::get();
-	char errbuf[TCPConnection_ErrorBufferSize];
-	if (tcpc.Connect(Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf)) {
-		return true;
-	} else {
-		LogNetcode("[WORLD] WorldConnection connect: Connecting to the server [{}]:[{}] failed: [{}]", Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf);
-	}
-	return false;
-}
-
-void WorldConnection::Disconnect() {
-	tcpc.Disconnect();
-}
-
@@ -370,7 +370,7 @@ uint32 ZoneStore::GetZoneRuleSet(uint32 zone_id, int version)
 	return 0;
 }

-const std::string& ZoneStore::GetZoneNote(uint32 zone_id, int version)
+const std::string ZoneStore::GetZoneNote(uint32 zone_id, int version)
 {
 	for (auto &z: m_zones) {
 		if (z.zoneidnumber == zone_id && z.version == version) {
@@ -384,8 +384,7 @@ const std::string& ZoneStore::GetZoneNote(uint32 zone_id, int version)
 		}
 	}

-	const auto& note = std::string();
-	return note;
+	return "";
 }

 float ZoneStore::GetZoneUnderworld(uint32 zone_id, int version)
@@ -736,7 +735,7 @@ float ZoneStore::GetZoneFogDensity(uint32 zone_id, int version)
 	return 0.0f;
 }

-const std::string& ZoneStore::GetZoneFlagNeeded(uint32 zone_id, int version)
+const std::string ZoneStore::GetZoneFlagNeeded(uint32 zone_id, int version)
 {
 	for (auto &z: m_zones) {
 		if (z.zoneidnumber == zone_id && z.version == version) {
@@ -750,8 +749,7 @@ const std::string& ZoneStore::GetZoneFlagNeeded(uint32 zone_id, int version)
 		}
 	}

-	const auto& flag_needed = std::string();
-	return flag_needed;
+	return "";
 }

 int8 ZoneStore::GetZoneCanBind(uint32 zone_id, int version)
@@ -1259,7 +1257,7 @@ int8 ZoneStore::GetZoneMaximumExpansion(uint32 zone_id, int version)
 	return DEFAULT_ZONE_MIN_MAX_EXPANSION;
 }

-const std::string& ZoneStore::GetZoneContentFlags(uint32 zone_id, int version)
+const std::string ZoneStore::GetZoneContentFlags(uint32 zone_id, int version)
 {
 	for (auto &z: m_zones) {
 		if (z.zoneidnumber == zone_id && z.version == version) {
@@ -1271,13 +1269,12 @@ const std::string& ZoneStore::GetZoneContentFlags(uint32 zone_id, int version)
 		if (z.zoneidnumber == zone_id && z.version == 0) {
 			return z.content_flags;
 		}
-	}
+	};

-	const auto& content_flags = std::string();
-	return content_flags;
+	return "";
 }

-const std::string& ZoneStore::GetZoneContentFlagsDisabled(uint32 zone_id, int version)
+const std::string ZoneStore::GetZoneContentFlagsDisabled(uint32 zone_id, int version)
 {
 	for (auto &z: m_zones) {
 		if (z.zoneidnumber == zone_id && z.version == version) {
@@ -1291,8 +1288,7 @@ const std::string& ZoneStore::GetZoneContentFlagsDisabled(uint32 zone_id, int ve
 		}
 	}

-	const auto& content_flags_disabled = std::string();
-	return content_flags_disabled;
+	return "";
 }

 int ZoneStore::GetZoneUnderworldTeleportIndex(uint32 zone_id, int version)
@@ -54,7 +54,7 @@ public:
 	int GetZoneTimeZone(uint32 zone_id, int version = 0);
 	int GetZoneMaximumPlayers(uint32 zone_id, int version = 0);
 	uint32 GetZoneRuleSet(uint32 zone_id, int version = 0);
-	const std::string& GetZoneNote(uint32 zone_id, int version = 0);
+	const std::string GetZoneNote(uint32 zone_id, int version = 0);
 	float GetZoneUnderworld(uint32 zone_id, int version = 0);
 	float GetZoneMinimumClip(uint32 zone_id, int version = 0);
 	float GetZoneMaximumClip(uint32 zone_id, int version = 0);
@@ -69,7 +69,7 @@ public:
 	float GetZoneWalkSpeed(uint32 zone_id, int version = 0);
 	uint8 GetZoneTimeType(uint32 zone_id, int version = 0);
 	float GetZoneFogDensity(uint32 zone_id, int version = 0);
-	const std::string& GetZoneFlagNeeded(uint32 zone_id, int version = 0);
+	const std::string GetZoneFlagNeeded(uint32 zone_id, int version = 0);
 	int8 GetZoneCanBind(uint32 zone_id, int version = 0);
 	int8 GetZoneCanCombat(uint32 zone_id, int version = 0);
 	int8 GetZoneCanLevitate(uint32 zone_id, int version = 0);
@@ -95,8 +95,8 @@ public:
 	uint32 GetZoneMaximumMovementUpdateRange(uint32 zone_id, int version = 0);
 	int8 GetZoneMinimumExpansion(uint32 zone_id, int version = 0);
 	int8 GetZoneMaximumExpansion(uint32 zone_id, int version = 0);
-	const std::string& GetZoneContentFlags(uint32 zone_id, int version = 0);
-	const std::string& GetZoneContentFlagsDisabled(uint32 zone_id, int version = 0);
+	const std::string GetZoneContentFlags(uint32 zone_id, int version = 0);
+	const std::string GetZoneContentFlagsDisabled(uint32 zone_id, int version = 0);
 	int GetZoneUnderworldTeleportIndex(uint32 zone_id, int version = 0);
 	int GetZoneLavaDamage(uint32 zone_id, int version = 0);
 	int GetZoneMinimumLavaDamage(uint32 zone_id, int version = 0);
@@ -1,6 +1,6 @@
 {
  "name": "eqemu-server",
-  "version": "22.15.0",
+  "version": "22.22.1",
  "repository": {
    "type": "git",
    "url": "https://github.com/EQEmu/Server.git"
@@ -301,9 +301,7 @@ OP_LeadershipExpUpdate=0x2797
 OP_PurchaseLeadershipAA=0x6c55
 OP_UpdateLeadershipAA=0x0026
 OP_MarkNPC=0x1fb5
-OP_MarkRaidNPC=0x5a58		#unimplemented
 OP_ClearNPCMarks=0x2003
-OP_ClearRaidNPCMarks=0x20d3	#unimplemented
 OP_DelegateAbility=0x76b8
 OP_SetGroupTarget=0x2814
 OP_Charm=0x5d92
@@ -544,6 +542,9 @@ OP_LFGResponse=0x0000
 OP_RaidInvite=0x55ac
 OP_RaidUpdate=0x3973
 OP_RaidJoin=0x0000
+OP_RaidDelegateAbility=0x2b33
+OP_MarkRaidNPC=0x5a58
+OP_RaidClearNPCMarks=0x20d3							 

 # Button-push commands
 OP_Taunt=0x2703
@@ -112,6 +112,7 @@ if ($requested_table_to_generate ne "all") {
 }

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

@@ -586,7 +587,8 @@ sub get_reserved_cpp_variable_names {
    return (
        "class",
        "int",
-        "key"
+        "key",
+        "range"
    );
 }

@@ -1,15 +1,4 @@
-On the move from svn -> git we lost the ability to track revision numbers on the repo.
+Database updates have been migrated into native code as of #2857.

-No big deal!
-
-What we'll do instead as follows:
-
-Optional SQL updates go in optional/
-Required SQL updates go in required/
-All updates will follow a specific format of YYYY_MM_DD_Desc.sql, this is so it's easy to sort.
-
-So the following is a good example of what I expect to see
-2013_02_16_GitConversion.sql
-
-
-The new bots/ folder contains two sub-folders named optional/ and required/ for updates.
+Main updates: https://github.com/EQEmu/Server/tree/master/common/database/database_update_manifest.cpp
+Bot updates: https://github.com/EQEmu/Server/tree/master/common/database/database_update_manifest_bots.cpp
@@ -46,6 +46,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "../common/repositories/player_event_logs_repository.h"
 #include "../common/events/player_event_logs.h"
 #include "../common/patches/patches.h"
+#include "../zone/data_bucket.h"

 extern ClientList client_list;
 extern GroupLFPList LFPGroupList;
@@ -397,6 +398,14 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 			zoneserver_list.SendPacket(pack);
 			break;
 		}
+		case ServerOP_RaidNote: {
+			if (pack->size < sizeof(ServerRaidNote_Struct)) {
+				break;
+			}
+
+			zoneserver_list.SendPacket(pack);
+			break;
+		}
 		case ServerOP_SpawnCondition: {
 			if (pack->size != sizeof(ServerSpawnCondition_Struct)) {
 				break;
@@ -748,7 +757,8 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 		}
 		case ServerOP_ZoneStatus: {
 			if (pack->size >= 1) {
-				zoneserver_list.SendZoneStatus((char *)&pack->pBuffer[1], (uint8)pack->pBuffer[0], this);
+				auto z = (ServerZoneStatus_Struct*) pack->pBuffer;
+				zoneserver_list.SendZoneStatus(z->name, z->admin, this);
 			}

 			break;
@@ -1459,6 +1469,11 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 			DynamicZone::HandleZoneMessage(pack);
 			break;
 		}
+		case ServerOP_DataBucketCacheUpdate: {
+			zoneserver_list.SendPacket(pack);
+
+			break;
+		}
 		default: {
 			LogInfo("Unknown ServerOPcode from zone {:#04x}, size [{}]", pack->opcode, pack->size);
 			DumpPacket(pack->pBuffer, pack->size);
@@ -118,8 +118,11 @@ SET(zone_sources
    perl_perlpacket.cpp
    perl_player_corpse.cpp
    perl_questitem.cpp
+    perl_questitem_data.cpp
    perl_raids.cpp
+    perl_spawn.cpp
    perl_spell.cpp
+    perl_stat_bonuses.cpp
    perlpacket.cpp
    petitions.cpp
    pets.cpp
@@ -146,7 +146,8 @@ void Mob::CalcItemBonuses(StatBonuses* b) {
 	int16 i;

 	for (i = EQ::invslot::BONUS_BEGIN; i <= EQ::invslot::BONUS_SKILL_END; i++) {
-		const EQ::ItemInstance* inst = GetInv().GetItem(i);
+		const auto* inst = GetInv().GetItem(i);
+
 		if (!inst) {
 			continue;
 		}
@@ -6032,14 +6033,10 @@ float Mob::CheckHeroicBonusesDataBuckets(std::string bucket_name)
 {
 	std::string bucket_value;
 	if (!bucket_name.empty()) {
-		const auto full_name = fmt::format(
-			"{}-{}",
-			GetBucketKey(),
-			bucket_name
-		);
-
+		DataBucketKey k = GetScopedBucketKeys();
+		k.key = bucket_name;
 		if (IsOfClientBot()) {
-			bucket_value = DataBucket::CheckBucketKey(this, full_name);
+			bucket_value = DataBucket::GetData(k).value;
 		}

 		if (bucket_value.empty() || !Strings::IsNumber(bucket_value)) {
@@ -427,6 +427,7 @@ Bot::Bot(uint32 botID, uint32 botOwnerCharacterID, uint32 botSpellsID, double to
 Bot::~Bot() {
 	AI_Stop();
 	LeaveHealRotationMemberPool();
+	DataBucket::DeleteCachedBuckets(DataBucketLoadType::Bot, GetBotID());

 	if (HasPet()) {
 		GetPet()->Depop();
@@ -1273,8 +1274,11 @@ bool Bot::IsValidName(std::string& name)
 	if (!isupper(name[0]))
 		return false;

-	for (int i = 1; i < name.length(); ++i) {
-		if ((!RuleB(Bots, AllowCamelCaseNames) && !islower(name[i])) && name[i] != '_') {
+	for (char c : name.substr(1)) {
+		if (!RuleB(Bots, AllowCamelCaseNames) && !islower(c)) {
+			return false;
+		}
+		if (isdigit(c) || ispunct(c)) {
 			return false;
 		}
 	}
@@ -8190,27 +8194,22 @@ void Bot::OwnerMessage(const std::string& message)
 bool Bot::CheckDataBucket(std::string bucket_name, const std::string& bucket_value, uint8 bucket_comparison)
 {
 	if (!bucket_name.empty() && !bucket_value.empty()) {
-		auto full_name = fmt::format(
-			"{}-{}",
-			GetBucketKey(),
-			bucket_name
-		);
+		// try to fetch from bot first
+		DataBucketKey k = GetScopedBucketKeys();
+		k.key = bucket_name;

-		auto player_value = DataBucket::CheckBucketKey(this, full_name);
-		if (player_value.empty() && GetBotOwner()) {
-			full_name = fmt::format(
-				"{}-{}",
-				GetBotOwner()->GetBucketKey(),
-				bucket_name
-			);
+		auto b = DataBucket::GetData(k);
+		if (b.value.empty() && GetBotOwner()) {
+			// fetch from owner
+			k = GetBotOwner()->GetScopedBucketKeys();

-			player_value = DataBucket::CheckBucketKey(GetBotOwner(), full_name);
-			if (player_value.empty()) {
+			b = DataBucket::GetData(k);
+			if (b.value.empty()) {
 				return false;
 			}
 		}

-		if (zone->CompareDataBucket(bucket_comparison, bucket_value, player_value)) {
+		if (zone->CompareDataBucket(bucket_comparison, bucket_value, b.value)) {
 			return true;
 		}
 	}
@@ -1423,6 +1423,7 @@ int bot_command_init(void)
 		bot_command_add("petremove", "Orders a bot to remove its charmed pet", AccountStatus::Player, bot_subcommand_pet_remove) ||
 		bot_command_add("petsettype", "Orders a Magician bot to use a specified pet type", AccountStatus::Player, bot_subcommand_pet_set_type) ||
 		bot_command_add("picklock", "Orders a capable bot to pick the lock of the closest door", AccountStatus::Player, bot_command_pick_lock) ||
+		bot_command_add("pickpocket", "Orders a capable bot to pickpocket a NPC", AccountStatus::Player, bot_command_pickpocket) ||
 		bot_command_add("precombat", "Sets flag used to determine pre-combat behavior", AccountStatus::Player, bot_command_precombat) ||
 		bot_command_add("portal", "Orders a Wizard bot to open a magical doorway to a specified destination", AccountStatus::Player, bot_subcommand_portal) ||
 		bot_command_add("pull", "Orders a designated bot to 'pull' an enemy", AccountStatus::Player, bot_command_pull) ||
@@ -2814,19 +2815,6 @@ void bot_command_bot(Client *c, const Seperator *sep)
 	helper_send_available_subcommands(c, "bot", subcommand_list);
 }

-void bot_command_botgroup(Client *c, const Seperator *sep)
-{
-	const std::list<const char*> subcommand_list = {
-		"botgroupaddmember", "botgroupcreate", "botgroupdelete", "botgrouplist", "botgroupload", "botgroupremovemember"
-	};
-
-	if (helper_command_alias_fail(c, "bot_command_botgroup", sep->arg[0], "botgroup")) {
-		return;
-	}
-
-	helper_send_available_subcommands(c, "bot-group", subcommand_list);
-}
-
 void bot_command_charm(Client *c, const Seperator *sep)
 {
 	auto local_list = &bot_command_spells[BCEnum::SpT_Charm];
@@ -5316,7 +5304,7 @@ void bot_command_view_combos(Client *c, const Seperator *sep)
 	const uint16 bot_race = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
 	const std::string race_name = GetRaceIDName(bot_race);

-	if (!Mob::IsPlayerRace(bot_race)) {
+	if (!IsPlayerRace(bot_race)) {
 		c->Message(
 			Chat::White,
 			fmt::format(
@@ -5512,6 +5500,7 @@ void bot_subcommand_bot_create(Client *c, const Seperator *sep)

 	std::string bot_name = sep->arg[1];
 	bot_name = Strings::UcFirst(bot_name);
+
 	if (arguments < 2 || !sep->IsNumber(2)) {
 		c->Message(Chat::White, "Invalid class!");
 		return;
@@ -8864,8 +8853,8 @@ uint32 helper_bot_create(Client *bot_owner, std::string bot_name, uint8 bot_clas
 		bot_owner->Message(
 			Chat::White,
 			fmt::format(
-				"'{}' is an invalid name. You may only use characters 'A-Z', 'a-z' and '_'.",
-				bot_name
+				"'{}' is an invalid name. You may only use characters 'A-Z' or 'a-z'. Mixed case {} allowed.",
+				bot_name, RuleB(Bots, AllowCamelCaseNames) ? "is" : "is not"
 			).c_str()
 		);
 		return bot_id;
@@ -8894,7 +8883,7 @@ uint32 helper_bot_create(Client *bot_owner, std::string bot_name, uint8 bot_clas
 		return bot_id;
 	}

-	if (!Bot::IsValidRaceClassCombo(bot_race, bot_class) && bot_owner->IsPlayerRace(bot_race)) {
+	if (!Bot::IsValidRaceClassCombo(bot_race, bot_class) && IsPlayerRace(bot_race)) {
 		const std::string bot_race_name = GetRaceIDName(bot_race);
 		const std::string bot_class_name = GetClassIDName(bot_class);
 		const auto view_saylink = Saylink::Silent(
@@ -9181,7 +9170,7 @@ bool helper_cast_standard_spell(Bot* casting_bot, Mob* target_mob, int spell_id,

 bool helper_command_disabled(Client* bot_owner, bool rule_value, const char* command)
 {
-	if (rule_value) {
+	if (!rule_value) {
 		bot_owner->Message(Chat::White, "Bot command %s is not enabled on this server.", command);
 		return true;
 	}
@@ -10007,3 +9996,200 @@ void bot_command_caster_range(Client* c, const Seperator* sep)
 		c->Message(Chat::White, "Incorrect argument, use help for a list of options.");
 	}
 }
+
+void bot_command_pickpocket(Client *c, const Seperator *sep)
+{
+	if (helper_command_disabled(c, RuleB(Bots, AllowPickpocketCommand), "pickpocket")) {
+		return;
+	}
+	
+	if (helper_command_alias_fail(c, "bot_command_pickpocket", sep->arg[0], "pickpocket")) {
+		return;
+	}
+
+	if (helper_is_help_or_usage(sep->arg[1])) {
+		c->Message(Chat::White, "usage: <enemy_target>", sep->arg[0]);
+		return;
+	}
+
+	std::list<Bot *> sbl;
+	MyBots::PopulateSBL_BySpawnedBots(c, sbl);
+
+	// Check for capable rogue
+	ActionableBots::Filter_ByClasses(c, sbl, PLAYER_CLASS_ROGUE_BIT);
+	Bot *my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 7, ROGUE);
+	if (!my_bot) {
+		c->Message(Chat::White, "No bots are capable of performing this action");
+		return;
+	}
+
+	// Make sure a mob is targetted and a valid NPC
+	Mob *target_mob = ActionableTarget::AsSingle_ByAttackable(c);
+	if (!target_mob || !target_mob->IsNPC()) {
+		c->Message(Chat::White, "You must <target> an enemy to use this command");
+		return;
+	}
+
+	NPC *target_npc = ActionableTarget::AsSingle_ByAttackable(c)->CastToNPC();
+
+	// Check if mob is close enough
+	glm::vec4 mob_distance    = (c->GetPosition() - target_mob->GetPosition());
+	float     mob_xy_distance = ((mob_distance.x * mob_distance.x) + (mob_distance.y * mob_distance.y));
+	float     mob_z_distance  = (mob_distance.z * mob_distance.z);
+	float     z_offset_diff   = target_mob->GetZOffset() - c->GetZOffset();
+	
+	if (mob_z_distance >= (35-z_offset_diff) || mob_xy_distance > 250) {
+		c->Message(Chat::White, "You must be closer to an enemy to use this command");
+		return;
+	}
+
+	// Adapted from pickpock skill in npc.cpp
+	// Make sure we are allowed to target them
+	uint8 over_level = target_mob->GetLevel();
+	if (over_level > (my_bot->GetLevel() + THIEF_PICKPOCKET_OVER)) {
+		c->Message(Chat::Red, "You are too inexperienced to pick pocket this target");
+		return;
+	}
+
+	// Random fail roll
+	if (zone->random.Roll(5)) {
+		if (zone->CanDoCombat()) {
+			target_mob->AddToHateList(c, 50);
+		}
+		target_mob->Say("Stop thief!");
+		c->Message(Chat::Red, "You are noticed trying to steal!");
+		return;
+	}
+
+	// Setup variables for calcs
+	bool steal_skill  = my_bot->GetSkill(EQ::skills::SkillPickPockets);
+	bool steal_chance = steal_skill * 100 / (5 * over_level + 5);
+
+	// Determine whether to steal money or an item.
+	uint32 money[6] = {
+		0,
+		((steal_skill >= 125) ? (target_npc->GetPlatinum()) : (0)),
+		((steal_skill >= 60) ? (target_npc->GetGold()) : (0)),
+		target_npc->GetSilver(),
+		target_npc->GetCopper(),
+		0
+	};
+
+	bool   has_coin   = ((money[PickPocketPlatinum] | money[PickPocketGold] | money[PickPocketSilver] | money[PickPocketCopper]) != 0);
+	bool   steal_item = (steal_skill >= steal_chance && (zone->random.Roll(50) || !has_coin));
+
+	// Steal item
+	while (steal_item) {
+		std::vector<std::pair<const EQ::ItemData *, uint16>> loot_selection; // <const ItemData*, charges>
+		for (auto                                            item_iter: target_npc->itemlist) {
+			if (!item_iter || !item_iter->item_id) {
+				continue;
+			}
+			auto item_test = database.GetItem(item_iter->item_id);
+			if (item_test->Magic || !item_test->NoDrop || item_test->IsClassBag() || c->CheckLoreConflict(item_test) ||
+				item_iter->equip_slot != EQ::invslot::SLOT_INVALID) {
+				continue;
+			}
+			loot_selection.emplace_back(
+				std::make_pair(
+					item_test,
+					((item_test->Stackable) ? (1) : (item_iter->charges))
+				)
+			);
+		}
+		if (loot_selection.empty()) {
+			steal_item = false;
+			break;
+		}
+
+		int random = zone->random.Int(0, (loot_selection.size() - 1));
+
+		int16 slot_id = c->GetInv().FindFreeSlot(
+			false,
+			true,
+			(loot_selection[random].first->Size),
+			(loot_selection[random].first->ItemType == EQ::item::ItemTypeArrow)
+		);
+		if (slot_id == INVALID_INDEX) {
+			steal_item = false;
+			break;
+		}
+
+		auto item_inst = database.CreateItem(loot_selection[random].first, loot_selection[random].second);
+		if (item_inst == nullptr) {
+			steal_item = false;
+			break;
+		}
+
+		// Successful item pickpocket
+		if (item_inst->IsStackable() && RuleB(Character, UseStackablePickPocketing)) {
+			if (!c->TryStacking(item_inst, ItemPacketTrade, false, false)) {
+				c->PutItemInInventory(slot_id, *item_inst);
+				c->SendItemPacket(slot_id, item_inst, ItemPacketTrade);
+			}
+		}
+		else {
+			c->PutItemInInventory(slot_id, *item_inst);
+			c->SendItemPacket(slot_id, item_inst, ItemPacketTrade);
+		}
+		target_npc->RemoveItem(item_inst->GetID());
+		c->Message(Chat::White, "You stole an item.");
+		safe_delete(item_inst);
+		return;
+	}
+
+	// no items, try money
+	while (!steal_item && has_coin) {
+		uint32 coin_amount = zone->random.Int(1, (steal_skill / 25) + 1);
+
+		int coin_type = PickPocketPlatinum;
+		while (coin_type <= PickPocketCopper) {
+			if (money[coin_type]) {
+				if (coin_amount > money[coin_type]) {
+					coin_amount = money[coin_type];
+				}
+				break;
+			}
+			++coin_type;
+		}
+		if (coin_type > PickPocketCopper) {
+			break;
+		}
+
+		memset(money, 0, (sizeof(int) * 6));
+		money[coin_type] = coin_amount;
+
+		if (zone->random.Roll(steal_chance)) { // Successful coin pickpocket
+			switch (coin_type) {
+				case PickPocketPlatinum:
+					target_npc->SetPlatinum(target_npc->GetPlatinum() - coin_amount);
+					break;
+				case PickPocketGold:
+					target_npc->SetGold(target_npc->GetGold() - coin_amount);
+					break;
+				case PickPocketSilver:
+					target_npc->SetSilver(target_npc->GetSilver() - coin_amount);
+					break;
+				case PickPocketCopper:
+					target_npc->SetCopper(target_npc->GetCopper() - coin_amount);
+					break;
+				default: // has_coin..but, doesn't have coin?
+					c->Message(Chat::Red, "You failed to pickpocket.");
+					return;
+			}
+			c->Message(Chat::White, "You stole money.");
+			c->AddMoneyToPP(
+				money[PickPocketCopper],
+				money[PickPocketSilver],
+				money[PickPocketGold],
+				money[PickPocketPlatinum],
+				true
+			);
+			return;
+		}
+
+		c->Message(Chat::Red, "You failed to pickpocket.");
+		return;
+	}
+	c->Message(Chat::White, "This target's pockets are empty");
+}
@@ -552,7 +552,6 @@ void bot_command_apply_potion(Client* c, const Seperator* sep);
 void bot_command_attack(Client *c, const Seperator *sep);
 void bot_command_bind_affinity(Client *c, const Seperator *sep);
 void bot_command_bot(Client *c, const Seperator *sep);
-void bot_command_botgroup(Client *c, const Seperator *sep);
 void bot_command_caster_range(Client* c, const Seperator* sep);
 void bot_command_charm(Client *c, const Seperator *sep);
 void bot_command_cure(Client *c, const Seperator *sep);
@@ -576,6 +575,7 @@ void bot_command_movement_speed(Client *c, const Seperator *sep);
 void bot_command_owner_option(Client *c, const Seperator *sep);
 void bot_command_pet(Client *c, const Seperator *sep);
 void bot_command_pick_lock(Client *c, const Seperator *sep);
+void bot_command_pickpocket(Client* c, const Seperator* sep);
 void bot_command_precombat(Client* c, const Seperator* sep);
 void bot_command_pull(Client *c, const Seperator *sep);
 void bot_command_release(Client *c, const Seperator *sep);
@@ -131,6 +131,12 @@ enum {
 	HideCorpseNPC = 5
 };

+typedef enum
+{
+	Disciplines,
+	Spells
+} ShowSpellType;
+
 typedef enum
 {
 	Empty = 0,
@@ -596,6 +602,7 @@ public:
 	inline void SetEXPModifier(uint32 zone_id, double exp_modifier, int16 instance_version = -1) { database.SetEXPModifier(CharacterID(), zone_id, exp_modifier, instance_version); };

 	bool UpdateLDoNPoints(uint32 theme_id, int points);
+	void SetLDoNPoints(uint32 theme_id, uint32 points);
 	void SetPVPPoints(uint32 Points) { m_pp.PVPCurrentPoints = Points; }
 	uint32 GetPVPPoints() { return m_pp.PVPCurrentPoints; }
 	void AddPVPPoints(uint32 Points);
@@ -669,6 +676,8 @@ public:
 	inline const int32 GetInstanceID() const { return zone->GetInstanceID(); }
 	void SetZoning(bool in) { bZoning = in; }

+	void ShowSpells(Client* c, ShowSpellType show_spell_type);
+
 	FACTION_VALUE GetReverseFactionCon(Mob* iOther);
 	FACTION_VALUE GetFactionLevel(uint32 char_id, uint32 npc_id, uint32 p_race, uint32 p_class, uint32 p_deity, int32 pFaction, Mob* tnpc);
 	bool ReloadCharacterFaction(Client *c, uint32 facid, uint32 charid);
@@ -764,7 +773,6 @@ public:
 	void SetLanguageSkill(int langid, int value);
 	void SetHoTT(uint32 mobid);
 	void ShowSkillsWindow();
-	void SendStatsWindow(Client* client, bool use_window);

 	uint16 MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const;
 	inline uint16 MaxSkill(EQ::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
@@ -1087,7 +1095,7 @@ public:
 	uint16 GetMaxSkillAfterSpecializationRules(EQ::skills::SkillType skillid, uint16 maxSkill);
 	void SendPopupToClient(const char *Title, const char *Text, uint32 PopupID = 0, uint32 Buttons = 0, uint32 Duration = 0);
 	void SendFullPopup(const char *Title, const char *Text, uint32 PopupID = 0, uint32 NegativeID = 0, uint32 Buttons = 0, uint32 Duration = 0, const char *ButtonName0 = 0, const char *ButtonName1 = 0, uint32 SoundControls = 0);
-	void SendWindow(uint32 PopupID, uint32 NegativeID, uint32 Buttons, const char *ButtonName0, const char *ButtonName1, uint32 Duration, int title_type, Client* target, const char *Title, const char *Text, ...);
+	void SendWindow(uint32 button_one_id, uint32 button_two_id, uint32 button_type, const char* button_one_text, const char* button_two_text, uint32 duration, int title_type, Mob* target, const char* title, const char* text, ...);
 	bool PendingTranslocate;
 	time_t TranslocateTime;
 	bool PendingSacrifice;
@@ -1340,7 +1348,7 @@ public:

 	bool CanEnterZone(const std::string& zone_short_name = "", int16 instance_version = -1);

-	int GetAggroCount();
+	uint32 GetAggroCount();
 	void IncrementAggroCount(bool raid_target = false);
 	void DecrementAggroCount();
 	void SendPVPStats();
@@ -1353,8 +1361,8 @@ public:
 	uint32 GetLDoNLossesTheme(uint32 t);
 	uint32 GetLDoNPointsTheme(uint32 t);
 	void UpdateLDoNWinLoss(uint32 theme_id, bool win = false, bool remove = false);
-	void CheckLDoNHail(Mob *target);
-	void CheckEmoteHail(Mob *target, const char* message);
+	void CheckLDoNHail(NPC* n);
+	void CheckEmoteHail(NPC* n, const char* message);

 	void HandleLDoNOpen(NPC *target);
 	void HandleLDoNSenseTraps(NPC *target, uint16 skill, uint8 type);
@@ -1552,8 +1560,6 @@ public:
 	Timer* GetMercTimer() { return &merc_timer; };
 	Timer* GetPickLockTimer() { return &pick_lock_timer; };

-	const char* GetRacePlural(Client* client);
-	const char* GetClassPlural(Client* client);
 	void SendWebLink(const char* website);
 	void SendMarqueeMessage(uint32 type, std::string message, uint32 duration = 3000);
 	void SendMarqueeMessage(uint32 type, uint32 priority, uint32 fade_in, uint32 fade_out, uint32 duration, std::string message);
@@ -1576,8 +1582,10 @@ public:
 	int32 GetActWIS() { return( std::min(GetMaxWIS(), GetWIS()) ); }
 	int32 GetActCHA() { return( std::min(GetMaxCHA(), GetCHA()) ); }
 	void LoadAccountFlags();
-	void SetAccountFlag(std::string flag, std::string val);
-	std::string GetAccountFlag(std::string flag);
+	void ClearAccountFlag(const std::string& flag);
+	void SetAccountFlag(const std::string& flag, const std::string& value);
+	std::string GetAccountFlag(const std::string& flag);
+	std::vector<std::string> GetAccountFlags();
 	void SetGMStatus(int16 new_status);
 	void Consume(const EQ::ItemData *item, uint8 type, int16 slot, bool auto_consume);
 	void PlayMP3(const char* fname);
@@ -1589,8 +1597,6 @@ public:
 	void SetInvulnerableEnvironmentDamage(bool val) { invulnerable_environment_damage = val; }
 	void SetIntoxication(int32 in_intoxication);

-	void ShowNumHits(); // work around function for numhits not showing on buffs
-
 	void ApplyWeaponsStance();
 	void TogglePassiveAlternativeAdvancement(const AA::Rank &rank, uint32 ability_id);
 	bool UseTogglePassiveHotkey(const AA::Rank &rank);
@@ -1900,7 +1906,7 @@ private:
 	int8 last_reported_mana_percent;
 	int8 last_reported_endurance_percent;

-	unsigned int AggroCount; // How many mobs are aggro on us.
+	uint32 AggroCount; // How many mobs are aggro on us.

 	bool ooc_regen;
 	float AreaHPRegen;
@@ -1919,6 +1925,7 @@ private:
 public:
 	void SetSharedTaskId(int64 shared_task_id);
 	int64 GetSharedTaskId() const;
+	struct XTarget_Struct XTargets[XTARGET_HARDCAP];
 private:

 	bool m_exp_enabled;
@@ -1971,7 +1978,6 @@ private:
 	bool XTargetAutoAddHaters;
 	bool m_dirtyautohaters;

-	struct XTarget_Struct XTargets[XTARGET_HARDCAP];
 	XTargetAutoHaters m_autohatermgr;
 	XTargetAutoHaters *m_activeautohatermgr;

@@ -649,7 +649,7 @@ int64 Client::CalcBaseMana()
 int64 Client::CalcBaseManaRegen()
 {
 	uint8 clevel = GetLevel();
-	int32 regen = 0;
+	int64 regen = 0;
 	if (IsSitting() || (GetHorseId() != 0)) {
 		if (HasSkill(EQ::skills::SkillMeditate)) {
 			regen = (((GetSkill(EQ::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
@@ -666,7 +666,7 @@ int64 Client::CalcBaseManaRegen()

 int64 Client::CalcManaRegen(bool bCombat)
 {
-	int regen = 0;
+	int64 regen = 0;
 	auto level = GetLevel();
 	// so the new formulas break down with older skill caps where you don't have the skill until 4 or 8
 	// so for servers that want to use the old skill progression they can set this rule so they
@@ -688,9 +688,9 @@ int64 Client::CalcManaRegen(bool bCombat)
 				}
 			}
 			if (old)
-				regen = std::max(regen, 2);
+				regen = std::max(regen, static_cast<int64>(2));
 		} else if (old) {
-			regen = std::max(regen, 1);
+			regen = std::max(regen, static_cast<int64>(1));
 		}
 	}

@@ -328,6 +328,8 @@ void MapOpcodes()
 	ConnectedOpcodes[OP_PVPLeaderBoardRequest] = &Client::Handle_OP_PVPLeaderBoardRequest;
 	ConnectedOpcodes[OP_QueryUCSServerStatus] = &Client::Handle_OP_QueryUCSServerStatus;
 	ConnectedOpcodes[OP_RaidInvite] = &Client::Handle_OP_RaidCommand;
+	ConnectedOpcodes[OP_RaidDelegateAbility] = &Client::Handle_OP_RaidDelegateAbility;
+	ConnectedOpcodes[OP_RaidClearNPCMarks] = &Client::Handle_OP_RaidClearNPCMarks;
 	ConnectedOpcodes[OP_RandomReq] = &Client::Handle_OP_RandomReq;
 	ConnectedOpcodes[OP_ReadBook] = &Client::Handle_OP_ReadBook;
 	ConnectedOpcodes[OP_RecipeAutoCombine] = &Client::Handle_OP_RecipeAutoCombine;
@@ -607,7 +609,6 @@ void Client::CompleteConnect()
 			but not important for now.
 			*/
 			raid->SendRaidCreate(this);
-			raid->SendMakeLeaderPacketTo(raid->leadername, this);
 			raid->SendRaidAdd(GetName(), this);
 			raid->SendBulkRaid(this);
 			raid->SendGroupUpdate(this);
@@ -616,6 +617,7 @@ void Client::CompleteConnect()
 				raid->UpdateRaidAAs();
 				raid->SendAllRaidLeadershipAA();
 			}
+			raid->SendMakeLeaderPacketTo(raid->leadername, this);
 			uint32 grpID = raid->GetGroup(GetName());
 			if (grpID < 12) {
 				raid->SendRaidGroupRemove(GetName(), grpID);
@@ -636,6 +638,8 @@ void Client::CompleteConnect()
 				raid->SendRaidLockTo(this);

 			raid->SendHPManaEndPacketsTo(this);
+			raid->SendAssistTarget(this);
+			raid->SendMarkTargets(this);
 		}
 	}
 	else {
@@ -2120,6 +2124,11 @@ void Client::Handle_OP_AdventureMerchantRequest(const EQApplicationPacket *app)
 		(tmp->GetClass() != DISCORD_MERCHANT) && (tmp->GetClass() != NORRATHS_KEEPERS_MERCHANT) && (tmp->GetClass() != DARK_REIGN_MERCHANT)))
 		return;

+	if (!tmp->CastToNPC()->IsMerchantOpen()) {
+		tmp->SayString(zone->random.Int(MERCHANT_CLOSED_ONE, MERCHANT_CLOSED_THREE));
+		return;
+	}
+
 	//you have to be somewhat close to them to be properly using them
 	if (DistanceSquared(m_Position, tmp->GetPosition()) > USE_NPC_RANGE2)
 		return;
@@ -3038,8 +3047,22 @@ void Client::Handle_OP_AssistGroup(const EQApplicationPacket *app)
 		LogDebug("Size mismatch in OP_AssistGroup expected [{}] got [{}]", sizeof(EntityId_Struct), app->size);
 		return;
 	}
-	QueuePacket(app);
-	return;
+
+	EntityId_Struct* eid = (EntityId_Struct*)app->pBuffer;
+	Entity* entity = entity_list.GetID(eid->entity_id);
+
+	if (entity && entity->IsMob()) {
+		Mob* new_target = entity->CastToMob();
+		if (new_target && (GetGM() ||
+			Distance(m_Position, new_target->GetPosition()) <= TARGETING_RANGE)) {
+			cheat_manager.SetExemptStatus(Assist, true);
+			EQApplicationPacket* outapp = new EQApplicationPacket(OP_Assist, sizeof(EntityId_Struct));
+			eid = (EntityId_Struct*)outapp->pBuffer;
+			eid->entity_id = new_target->GetID();
+			FastQueuePacket(&outapp);
+			safe_delete(outapp);
+		}
+	}
 }

 void Client::Handle_OP_AugmentInfo(const EQApplicationPacket *app)
@@ -5201,12 +5224,12 @@ void Client::Handle_OP_ConsiderCorpse(const EQApplicationPacket *app)

 	uint32 decay_time = t->GetDecayTime();
 	if (decay_time) {
-		auto time_string = Strings::SecondsToTime(decay_time, true);
+		const std::string& time_string = Strings::SecondsToTime(decay_time, true);
 		Message(
 			Chat::NPCQuestSay,
 			fmt::format(
 				"This corpse will decay in {}.",
-				time_string
+				Strings::ToLower(time_string)
 			).c_str()
 		);

@@ -5845,6 +5868,31 @@ void Client::Handle_OP_DoGroupLeadershipAbility(const EQApplicationPacket *app)
 		break;
 	}

+	case RaidLeadershipAbility_MainAssist:
+	{
+		//This is not needed as it executes from opcode 0x2b33 which is sent
+		//with this opcode.
+		//if (GetTarget())
+		//{
+		//	Raid* r = GetRaid();
+		//	if (r)
+		//	{
+		//		r->DelegateAbility(GetTarget()->CastToClient()->GetName());
+		//	}
+		//}
+		break;
+	}
+	case RaidLeadershipAbility_MarkNPC:
+	{
+		if (GetTarget() && GetTarget()->IsMob()) {
+			Raid* r = GetRaid();
+			if (r) {
+				r->RaidMarkNPC(this, dglas->Parameter);
+			}
+		}
+		break;
+
+	}
 	default:
 		LogDebug("Got unhandled OP_DoGroupLeadershipAbility Ability: [{}] Parameter: [{}]", dglas->Ability, dglas->Parameter);
 		break;
@@ -6774,16 +6822,14 @@ void Client::Handle_OP_GMSearchCorpse(const EQApplicationPacket *app)

 void Client::Handle_OP_GMServers(const EQApplicationPacket *app)
 {
-	if (!worldserver.Connected())
-		Message(Chat::Red, "Error: World server disconnected");
-	else {
-		auto pack = new ServerPacket(ServerOP_ZoneStatus, strlen(GetName()) + 2);
-		memset(pack->pBuffer, (uint8)admin, 1);
-		strcpy((char *)&pack->pBuffer[1], GetName());
-		worldserver.SendPacket(pack);
-		safe_delete(pack);
-	}
-	return;
+	auto pack = new ServerPacket(ServerOP_ZoneStatus, sizeof(ServerZoneStatus_Struct));
+
+	auto z = (ServerZoneStatus_Struct *) pack->pBuffer;
+	z->admin = Admin();
+	strn0cpy(z->name, GetName(), sizeof(z->name));
+
+	worldserver.SendPacket(pack);
+	delete pack;
 }

 void Client::Handle_OP_GMSummon(const EQApplicationPacket *app)
@@ -9142,8 +9188,14 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 		}
 		else if (inst->IsClassCommon())
 		{
-			if (!RuleB(Skills, RequireTomeHandin) && item->ItemType == EQ::item::ItemTypeSpell && (strstr((const char*)item->Name, "Tome of ") || strstr((const char*)item->Name, "Skill: ")))
-			{
+			if (
+				!RuleB(Skills, RequireTomeHandin) &&
+				item->ItemType == EQ::item::ItemTypeSpell &&
+				(
+					Strings::BeginsWith(item->Name, "Tome of ") ||
+					Strings::BeginsWith(item->Name, "Skill: ")
+				)
+			) {
 				DeleteItemInInventory(slot_id, 1, true);
 				TrainDiscipline(item->ID);
 			}
@@ -10707,7 +10759,7 @@ void Client::Handle_OP_PetCommands(const EQApplicationPacket *app)
 	case PET_HEALTHREPORT: {
 		if ((mypet->GetPetType() == petAnimation && aabonuses.PetCommands[PetCommand]) || mypet->GetPetType() != petAnimation) {
 			MessageString(Chat::PetResponse, PET_REPORT_HP, ConvertArrayF(mypet->GetHPRatio(), val1));
-			mypet->ShowBuffList(this);
+			mypet->ShowBuffs(this);
 		}
 		break;
 	}
@@ -11457,10 +11509,9 @@ void Client::Handle_OP_PopupResponse(const EQApplicationPacket *app)
 			break;

 		case POPUPID_UPDATE_SHOWSTATSWINDOW:
-			if (GetTarget() && GetTarget()->IsClient()) {
-				GetTarget()->CastToClient()->SendStatsWindow(this, true);
-			}
-			else {
+			if (GetTarget() && GetTarget()->IsOfClientBot()) {
+				GetTarget()->SendStatsWindow(this, true);
+			} else {
 				SendStatsWindow(this, true);
 			}
 			return;
@@ -11926,6 +11977,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 							if (raid->IsLocked()) {
 								raid->SendRaidLockTo(c);
 							}
+							raid->SendAssistTarget(c);
+							raid->SendMarkTargets(c);
 						}
 					}
 					group->JoinRaidXTarget(raid);
@@ -11940,6 +11993,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 					if (raid->IsLocked()) {
 						raid->SendRaidLockTo(this);
 					}
+					raid->SendAssistTarget(this);
+					raid->SendMarkTargets(this);
 				}
 			}
 			else
@@ -11980,6 +12035,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 									if (raid->IsLocked()) {
 										raid->SendRaidLockTo(c);
 									}
+									raid->SendAssistTarget(c);
+									raid->SendMarkTargets(c);
 								}
 								else {
 									Client* c = nullptr;
@@ -11996,6 +12053,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 									if (raid->IsLocked()) {
 										raid->SendRaidLockTo(c);
 									}
+									raid->SendAssistTarget(c);
+									raid->SendMarkTargets(c);
 								}
 							}
 						}
@@ -12035,6 +12094,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 								if (raid->IsLocked()) {
 									raid->SendRaidLockTo(c);
 								}
+								raid->SendAssistTarget(c);
+								raid->SendMarkTargets(c);
 							}
 							else
 							{
@@ -12052,6 +12113,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 								if (raid->IsLocked()) {
 									raid->SendRaidLockTo(c);
 								}
+								raid->SendAssistTarget(c);
+								raid->SendMarkTargets(c);
 							}
 						}
 					}
@@ -12092,6 +12155,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 									if (raid->IsLocked()) {
 										raid->SendRaidLockTo(c);
 									}
+									raid->SendAssistTarget(c);
+									raid->SendMarkTargets(c);
 								}
 								else
 								{
@@ -12108,6 +12173,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 									if (raid->IsLocked()) {
 										raid->SendRaidLockTo(c);
 									}
+									raid->SendAssistTarget(c);
+									raid->SendMarkTargets(c);
 								}
 							}
 						}
@@ -12121,6 +12188,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 						if (raid->IsLocked()) {
 							raid->SendRaidLockTo(this);
 						}
+						raid->SendAssistTarget(this);
+						raid->SendMarkTargets(this);
 					}
 					else { // neither has a group
 						raid = new Raid(player_sending_invite);
@@ -12135,6 +12204,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 						if (raid->IsLocked()) {
 							raid->SendRaidLockTo(this);
 						}
+						raid->SendAssistTarget(this);
+						raid->SendMarkTargets(this);
 					}
 				}
 			}
@@ -12157,6 +12228,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 				//Does not camp the Bots, just removes from the raid
 				if (c_to_disband) {
 					uint32 i = raid->GetPlayerIndex(raid_command_packet->leader_name);
+					raid->RemoveRaidDelegates(raid_command_packet->leader_name);
+					raid->SendRemoveAllRaidXTargets(raid_command_packet->leader_name);
 					raid->SetNewRaidLeader(i);
 					raid->HandleBotGroupDisband(c_to_disband->CharacterID());
 					raid->HandleOfflineBots(c_to_disband->CharacterID());
@@ -12172,11 +12245,13 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)

 					if (gid < 12 && (raid->IsGroupLeader(b_to_disband->GetName()) || raid->GroupCount(gid) < 2)) {
 						uint32 owner_id = b_to_disband->CastToBot()->GetOwner()->CastToClient()->CharacterID();
+						raid->RemoveRaidDelegates(raid_command_packet->leader_name);
+						raid->UpdateRaidXTargets();
 						raid->HandleBotGroupDisband(owner_id, gid);
-
 					} else if (b_to_disband && raid->IsRaidMember(b_to_disband->GetName())) {
+						raid->RemoveRaidDelegates(raid_command_packet->leader_name);
+						raid->UpdateRaidXTargets();
 						Bot::RemoveBotFromRaid(b_to_disband);
-
 					} else if (gid < 12 && raid->GetGroupLeader(gid) && raid->GetGroupLeader(gid)->IsBot()) {
 						c_doing_disband->Message(
 							Chat::Yellow,
@@ -12207,6 +12282,8 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 				}
 			}
 			raid->SetNewRaidLeader(i);
+			raid->RemoveRaidDelegates(raid_command_packet->leader_name);
+			raid->UpdateRaidXTargets();
 			raid->RemoveMember(raid_command_packet->leader_name);
 			Client* c = entity_list.GetClientByName(raid_command_packet->leader_name);
 			if (c) {
@@ -12260,9 +12337,9 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 										if (client_to_update) {
 											raid->SendRaidRemove(raid->members[x].member_name, client_to_update);
 											raid->SendRaidCreate(client_to_update);
-											raid->SendMakeLeaderPacketTo(raid->leadername, client_to_update);
 											raid->SendRaidAdd(raid->members[x].member_name, client_to_update);
 											raid->SendBulkRaid(client_to_update);
+											raid->SendMakeLeaderPacketTo(raid->leadername, client_to_update);
 											if (raid->IsLocked()) {
 												raid->SendRaidLockTo(client_to_update);
 											}
@@ -12310,9 +12387,9 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 					raid->GroupUpdate(raid_command_packet->parameter);

 					/* If our old was a group send update there too */
-					if (old_group < 12)
+					if (old_group < 12) {
 						raid->GroupUpdate(old_group);
-
+					}
 				}
 			}
 			/* Move player to ungrouped bank */
@@ -12373,7 +12450,7 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 				}

 				raid->GroupUpdate(oldgrp);
-			}
+}
 		}

 		Client* client_moved = entity_list.GetClientByName(raid_command_packet->leader_name);
@@ -12471,7 +12548,18 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket* app)
 		raid->SendRaidMOTDToWorld();
 		break;
 	}
+	case RaidCommandSetNote:
+	{

+		Raid* raid = entity_list.GetRaidByClient(this);
+		if (!raid) {
+			break;
+		}
+
+		raid->SaveRaidNote(raid_command_packet->leader_name, raid_command_packet->note);
+		raid->SendRaidNotesToWorld();
+		break;
+	}
 	default: {
 		Message(Chat::Red, "Raid command (%d) NYI", raid_command_packet->action);
 		break;
@@ -14021,9 +14109,8 @@ void Client::Handle_OP_ShopRequest(const EQApplicationPacket *app)
 	if (tmp->Charmed())
 		action = 0;

-	// 1199 I don't have time for that now. etc
 	if (!tmp->CastToNPC()->IsMerchantOpen()) {
-		tmp->SayString(zone->random.Int(1199, 1202));
+		tmp->SayString(zone->random.Int(MERCHANT_CLOSED_ONE, MERCHANT_CLOSED_THREE));
 		action = 0;
 	}

@@ -14428,8 +14515,8 @@ void Client::Handle_OP_TargetCommand(const EQApplicationPacket *app)

 	if (nt) {
 		if (GetGM() || (!nt->IsInvisible(this) && (DistanceSquared(m_Position, nt->GetPosition()) <= TARGETING_RANGE*TARGETING_RANGE))) {
-			if (nt->GetBodyType() == BT_NoTarget2 || 
-				nt->GetBodyType() == BT_Special || 
+			if (nt->GetBodyType() == BT_NoTarget2 ||
+				nt->GetBodyType() == BT_Special ||
 				nt->GetBodyType() == BT_NoTarget) {
 				can_target = false;
 			}
@@ -15792,14 +15879,87 @@ void Client::Handle_OP_XTargetRequest(const EQApplicationPacket *app)
 	case RaidAssist1:
 	case RaidAssist2:
 	case RaidAssist3:
+	{
+		struct AssistType {
+			XTargetType type;
+			int32       assist_slot;
+		};
+
+		std::vector<AssistType> assist_types = {
+			{ RaidAssist1, MAIN_ASSIST_1_SLOT },
+			{ RaidAssist2, MAIN_ASSIST_2_SLOT },
+			{ RaidAssist3, MAIN_ASSIST_3_SLOT }
+		};
+
+		for (auto& t : assist_types) {
+			if (t.type == Type) {
+				Raid* r = GetRaid();
+				if (r) {
+					Client* ma = entity_list.GetClientByName(r->main_assister_pcs[t.assist_slot]);
+					if (ma) {
+						UpdateXTargetType(t.type, ma, ma->GetName());
+					}
+				}
+			}
+		}
+		break;
+	}
+
 	case RaidAssist1Target:
 	case RaidAssist2Target:
 	case RaidAssist3Target:
+	{
+		struct AssistType {
+			XTargetType type;
+			int32       assist_slot;
+		};
+
+		std::vector<AssistType> assist_types = {
+			{ RaidAssist1Target, MAIN_ASSIST_1_SLOT },
+			{ RaidAssist2Target, MAIN_ASSIST_2_SLOT },
+			{ RaidAssist3Target, MAIN_ASSIST_3_SLOT }
+		};
+
+		for (auto& t : assist_types) {
+			if (t.type == Type) {
+				Raid* r = GetRaid();
+				if (r) {
+					Client* ma = entity_list.GetClientByName(r->main_assister_pcs[t.assist_slot]);
+					if (ma && ma->GetTarget()) {
+						UpdateXTargetType(t.type, ma->GetTarget(), ma->GetTarget()->GetName());
+					}
+				}
+			}
+		}
+		break;
+	}
+
 	case RaidMarkTarget1:
 	case RaidMarkTarget2:
 	case RaidMarkTarget3:
 	{
-		// Not implemented yet.
+		struct AssistType {
+			XTargetType type;
+			int32       assist_slot;
+		};
+
+		std::vector<AssistType> assist_types = {
+			{ RaidMarkTarget1, MAIN_MARKER_1_SLOT },
+			{ RaidMarkTarget2, MAIN_MARKER_2_SLOT },
+			{ RaidMarkTarget3, MAIN_MARKER_3_SLOT }
+		};
+
+		for (auto& t : assist_types) {
+			if (t.type == Type) {
+				Raid* r = GetRaid();
+				if (r) {
+					auto mm = entity_list.GetNPCByID(r->marked_npcs[t.assist_slot]);
+					if (mm) {
+						UpdateXTargetType(t.type, mm->CastToMob(), mm->CastToMob()->GetName());
+					}
+				}
+			}
+		}
 		break;
 	}

@@ -16183,3 +16343,52 @@ void Client::RecordKilledNPCEvent(NPC *n)
 		}
 	}
 }
+
+void Client::Handle_OP_RaidDelegateAbility(const EQApplicationPacket *app)
+{
+	if (app->size != sizeof(DelegateAbility_Struct)) {
+		LogDebug(
+			"Size mismatch in OP_RaidDelegateAbility expected [{}] got [{}]",
+			sizeof(DelegateAbility_Struct),
+			app->size
+		);
+		DumpPacket(app);
+		return;
+	}
+
+	DelegateAbility_Struct *das = (DelegateAbility_Struct *) app->pBuffer;
+
+	switch (das->DelegateAbility) {
+		case RaidDelegateMainAssist: {
+			auto r = GetRaid();
+			if (r) {
+				r->DelegateAbilityAssist(this, das->Name);
+			}
+			break;
+		}
+		case RaidDelegateMainMarker: {
+			auto r = GetRaid();
+			if (r) {
+				r->DelegateAbilityMark(this, das->Name);
+			}
+			break;
+		}
+		default:
+			LogDebug("RaidDelegateAbility default case");
+			break;
+	}
+}
+
+void Client::Handle_OP_RaidClearNPCMarks(const EQApplicationPacket* app)
+{
+	if (app->size != 0) {
+		LogDebug("Size mismatch in OP_RaidClearNPCMark expected [{}] got [{}]", 0, app->size);
+		DumpPacket(app);
+		return;
+	}
+
+	auto r = GetRaid();
+	if (r) {
+		r->RaidClearNPCMarks(this);
+	}
+}
@@ -241,7 +241,9 @@
 	void Handle_OP_PVPLeaderBoardRequest(const EQApplicationPacket *app);
 	void Handle_OP_QueryUCSServerStatus(const EQApplicationPacket *app);
 	void Handle_OP_RaidCommand(const EQApplicationPacket *app);
-	void Handle_OP_RandomReq(const EQApplicationPacket *app);
+	void Handle_OP_RaidDelegateAbility(const EQApplicationPacket* app);
+	void Handle_OP_RaidClearNPCMarks(const EQApplicationPacket* app);
+	void Handle_OP_RandomReq(const EQApplicationPacket* app);
 	void Handle_OP_ReadBook(const EQApplicationPacket *app);
 	void Handle_OP_RecipeAutoCombine(const EQApplicationPacket *app);
 	void Handle_OP_RecipeDetails(const EQApplicationPacket *app);
@@ -853,18 +853,16 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 		auto bucket_name = ml.bucket_name;
 		auto const& bucket_value = ml.bucket_value;
 		if (!bucket_name.empty() && !bucket_value.empty()) {
-			auto full_name = fmt::format(
-				"{}-{}",
-				GetBucketKey(),
-				bucket_name
-			);

-			auto const& player_value = DataBucket::CheckBucketKey(this, full_name);
-			if (player_value.empty()) {
+			DataBucketKey k = GetScopedBucketKeys();
+			k.key = bucket_name;
+
+			auto b = DataBucket::GetData(k);
+			if (b.value.empty()) {
 				continue;
 			}

-			if (!zone->CompareDataBucket(ml.bucket_comparison, bucket_value, player_value)) {
+			if (!zone->CompareDataBucket(ml.bucket_comparison, bucket_value, b.value)) {
 				continue;
 			}
 		}
@@ -2413,7 +2411,7 @@ bool Client::CheckWaterAutoFireLoS(Mob* m)
 	}

 	return (
-		zone->watermap->InLiquid(GetPosition()) &&
+		zone->watermap->InLiquid(GetPosition()) ==
 		zone->watermap->InLiquid(m->GetPosition())
 	);
 }
@@ -1,8 +1,8 @@
-
 #include <string.h>
 #include <algorithm>
 #include <thread>
 #include <fmt/format.h>
+#include "../common/repositories/command_subsettings_repository.h"

 #ifdef _WINDOWS
 #define strcasecmp _stricmp
@@ -40,16 +40,17 @@ extern FastMath g_Math;
 void CatchSignal(int sig_num);


-int command_count; // how many commands we have
+int                                                           command_count; // how many commands we have

 // this is the pointer to the dispatch function, updated once
 // init has been performed to point at the real function
 int (*command_dispatch)(Client *, std::string, bool) = command_notavail;

-std::map<std::string, CommandRecord *> commandlist;
-std::map<std::string, std::string> commandaliases;
-std::vector<CommandRecord *> command_delete_list;
-std::map<std::string, uint8> commands_map;
+std::map<std::string, CommandRecord *>                        commandlist;
+std::map<std::string, std::string>                            commandaliases;
+std::vector<CommandRecord *>                                  command_delete_list;
+std::map<std::string, uint8>                                  commands_map;
+std::vector<CommandSubsettingsRepository::CommandSubsettings> command_subsettings;

 /*
 * command_notavail
@@ -86,7 +87,6 @@ int command_init(void)
 	if (
 		command_add("acceptrules", "[acceptrules] - Accept the EQEmu Agreement", AccountStatus::Player, command_acceptrules) ||
 		command_add("advnpcspawn", "[maketype|makegroup|addgroupentry|addgroupspawn][removegroupspawn|movespawn|editgroupbox|cleargroupbox]", AccountStatus::GMLeadAdmin, command_advnpcspawn) ||
-		command_add("aggro", "[Distance] [-v] - Display aggro information for all mobs 'Distance' distance from your target. (-v is verbose Faction Information)", AccountStatus::QuestTroupe, command_aggro) ||
 		command_add("aggrozone", "[aggro] - Aggro every mob in the zone with X aggro. Default is 0. Not recommend if you're not invulnerable.", AccountStatus::GMAdmin, command_aggrozone) ||
 		command_add("ai", "[factionid/spellslist/con/guard/roambox/stop/start] - Modify AI on NPC target", AccountStatus::GMAdmin, command_ai) ||
 		command_add("appearance", "[type] [value] - Send an appearance packet for you or your target", AccountStatus::GMLeadAdmin, command_appearance) ||
@@ -95,21 +95,17 @@ int command_init(void)
 		command_add("attack", "[Entity Name] - Make your NPC target attack an entity by name", AccountStatus::GMLeadAdmin, command_attack) ||
 		command_add("augmentitem", "Force augments an item. Must have the augment item window open.", AccountStatus::GMImpossible, command_augmentitem) ||
 		command_add("ban", "[Character Name] [Reason] - Ban by character name", AccountStatus::GMLeadAdmin, command_ban) ||
-		command_add("bind", "Sets your targets bind spot to their current location", AccountStatus::GMMgmt, command_bind) ||
 		command_add("bugs", "[Close|Delete|Review|Search|View] - Handles player bug reports", AccountStatus::QuestTroupe, command_bugs) ||
 		command_add("bot", "Type \"#bot help\" or \"^help\" to the see the list of available commands for bots.", AccountStatus::Player, command_bot) ||
 		command_add("camerashake", "[Duration (Milliseconds)] [Intensity (1-10)] - Shakes the camera on everyone's screen globally.", AccountStatus::QuestTroupe, command_camerashake) ||
 		command_add("castspell", "[Spell ID] [Instant (0 = False, 1 = True, Default is 1 if Unused)] - Cast a spell", AccountStatus::Guide, command_castspell) ||
 		command_add("chat", "[Channel ID] [Message] - Send a channel message to all zones", AccountStatus::GMMgmt, command_chat) ||
-		command_add("checklos", "Check for line of sight to your target", AccountStatus::Guide, command_checklos) ||
 		command_add("copycharacter", "[source_char_name] [dest_char_name] [dest_account_name] - Copies character to destination account", AccountStatus::GMImpossible, command_copycharacter) ||
 		command_add("corpse", "Manipulate corpses, use with no arguments for help", AccountStatus::Guide, command_corpse) ||
 		command_add("corpsefix", "Attempts to bring corpses from underneath the ground within close proximity of the player", AccountStatus::Player, command_corpsefix) ||
 		command_add("countitem", "[Item ID] - Counts the specified Item ID in your or your target's inventory", AccountStatus::GMLeadAdmin, command_countitem) ||
-		command_add("cvs", "Summary of client versions currently online.", AccountStatus::GMMgmt, command_cvs) ||
 		command_add("damage", "[Amount] - Damage yourself or your target", AccountStatus::GMAdmin, command_damage) ||
 		command_add("databuckets", "View|Delete [key] [limit]- View data buckets, limit 50 default or Delete databucket by key", AccountStatus::QuestTroupe, command_databuckets) ||
-		command_add("date", "[Year] [Month] [Day] [Hour] [Minute] - Set EQ time (Hour and Minute are optional)", AccountStatus::EQSupport, command_date) ||
 		command_add("dbspawn2", "[Spawngroup ID] [Respawn] [Variance] [Condition ID] [Condition Minimum] - Spawn an NPC from a predefined row in the spawn2 table, Respawn and Variance are in Seconds (condition is optional)", AccountStatus::GMAdmin, command_dbspawn2) ||
 		command_add("delacct", "[Account ID|Account Name] - Delete an account by ID or Name", AccountStatus::GMLeadAdmin, command_delacct) ||
 		command_add("delpetition", "[petition number] - Delete a petition", AccountStatus::ApprenticeGuide, command_delpetition) ||
@@ -118,7 +114,6 @@ int command_init(void)
 		command_add("devtools", "[Enable|Disable] - Manages Developer Tools (send no parameter for menu)", AccountStatus::GMMgmt, command_devtools) ||
 		command_add("disablerecipe", "[Recipe ID] - Disables a Recipe", AccountStatus::QuestTroupe, command_disablerecipe) ||
 		command_add("disarmtrap", "Analog for ldon disarm trap for the newer clients since we still don't have it working.", AccountStatus::QuestTroupe, command_disarmtrap) ||
-		command_add("distance", "Reports the distance between you and your target.", AccountStatus::QuestTroupe, command_distance) ||
 		command_add("door", "Door editing command", AccountStatus::QuestTroupe, command_door) ||
 		command_add("doanim", "[Animation ID|Animation Name] [Speed] - Send an animation by ID or name at the specified speed to you or your target (Speed is optional)", AccountStatus::Guide, command_doanim) ||
 		command_add("dye", "[slot|'help'] [red] [green] [blue] [use_tint] - Dyes the specified armor slot to Red, Green, and Blue provided, allows you to bypass darkness limits.", AccountStatus::ApprenticeGuide, command_dye) ||
@@ -126,97 +121,49 @@ int command_init(void)
 		command_add("dzkickplayers", "Removes all players from current expedition. (/kickplayers alternative for pre-RoF clients)", AccountStatus::Player, command_dzkickplayers) ||
 		command_add("editmassrespawn", "[name-search] [second-value] - Mass (Zone wide) NPC respawn timer editing command", AccountStatus::GMAdmin, command_editmassrespawn) ||
 		command_add("emote", "[Name|World|Zone] [type] [message] - Send an emote message by name, to the world, or to your zone (^ separator allows multiple messages to be sent at once)", AccountStatus::QuestTroupe, command_emote) ||
-		command_add("emotesearch", "[Search Criteria] - Search for NPC Emotes", AccountStatus::QuestTroupe, command_emotesearch) ||
-		command_add("emoteview", "Lists all NPC Emotes", AccountStatus::QuestTroupe, command_emoteview) ||
 		command_add("emptyinventory", "Clears your or your target's entire inventory (Equipment, General, Bank, and Shared Bank)", AccountStatus::GMImpossible, command_emptyinventory) ||
 		command_add("enablerecipe", "[Recipe ID] - Enables a Recipe", AccountStatus::QuestTroupe, command_enablerecipe) ||
-		command_add("endurance", "Restores your or your target's endurance.", AccountStatus::Guide, command_endurance) ||
 		command_add("entityvariable", "[clear|delete|set|view] - Modify entity variables for yourself or your target", AccountStatus::GMAdmin, command_entityvariable) ||
 		command_add("exptoggle", "[Toggle] - Toggle your or your target's experience gain.", AccountStatus::QuestTroupe, command_exptoggle) ||
 		command_add("faction", "[Find (criteria | all ) | Review (criteria | all) | Reset (id)] - Resets Player's Faction", AccountStatus::QuestTroupe, command_faction) ||
 		command_add("factionassociation", "[factionid] [amount] - triggers a faction hits via association", AccountStatus::GMLeadAdmin, command_faction_association) ||
 		command_add("feature", "Change your or your target's feature's temporarily", AccountStatus::QuestTroupe, command_feature) ||
 		command_add("size", "Change your targets size (alias of #feature size)", AccountStatus::QuestTroupe, command_feature) ||
-		command_add("findaa", "[Search Criteria] - Search for an AA", AccountStatus::Guide, command_findaa) ||
-		command_add("findaliases", "[Search Criteria]- Searches for available command aliases, by alias or command", AccountStatus::Player, command_findaliases) ||
-		command_add("findcharacter", "[Search Criteria] - Search for a character", AccountStatus::Guide, command_findcharacter) ||
-		command_add("findclass", "[Search Criteria] - Search for a class", AccountStatus::Guide, command_findclass) ||
-		command_add("findcurrency", "[Search Criteria] - Search for an alternate currency", AccountStatus::Guide, command_findcurrency) ||
-		command_add("findfaction", "[Search Criteria] - Search for a faction", AccountStatus::Guide, command_findfaction) ||
-		command_add("findnpctype", "[Search Criteria] - Search database NPC types", AccountStatus::GMAdmin, command_findnpctype) ||
-		command_add("findrace", "[Search Criteria] - Search for a race", AccountStatus::Guide, command_findrace) ||
-		command_add("findrecipe", "[Search Criteria] - Search for a recipe", AccountStatus::Guide, command_findrecipe) ||
-		command_add("findskill", "[Search Criteria] - Search for a skill", AccountStatus::Guide, command_findskill) ||
-		command_add("findspell", "[Search Criteria] - Search for a spell", AccountStatus::Guide, command_findspell) ||
-		command_add("findtask", "[Search Criteria] - Search for a task", AccountStatus::Guide, command_findtask) ||
-		command_add("findzone", "[Search Criteria] - Search database zones", AccountStatus::GMAdmin, command_findzone) ||
+		command_add("find", "Search command used to find various things", AccountStatus::Guide, command_find) ||
 		command_add("fixmob", "[race|gender|texture|helm|face|hair|haircolor|beard|beardcolor|heritage|tattoo|detail] [next|prev] - Manipulate appearance of your target", AccountStatus::QuestTroupe, command_fixmob) ||
-		command_add("flag", "[Status] [Account Name] - Refresh your admin status, or set an account's Admin status if arguments provided", AccountStatus::Player, command_flag) ||
 		command_add("flagedit", "Edit zone flags on your target. Use #flagedit help for more info.", AccountStatus::GMAdmin, command_flagedit) ||
-		command_add("flags", "displays the Zone Flags of you or your target", AccountStatus::Player, command_flags) ||
-		command_add("flymode", "[0/1/2/3/4/5] - Set your or your player target's flymode to ground/flying/levitate/water/floating/levitate_running", AccountStatus::Guide, command_flymode) ||
-		command_add("fov", "Check wether you're behind or in your target's field of view", AccountStatus::QuestTroupe, command_fov) ||
-		command_add("freeze", "Freeze your target", AccountStatus::QuestTroupe, command_freeze) ||
-		command_add("gassign", "[Grid ID] - Assign targetted NPC to predefined wandering grid id", AccountStatus::GMAdmin, command_gassign) ||
 		command_add("gearup", "Developer tool to quickly equip yourself or your target", AccountStatus::GMMgmt, command_gearup) ||
-		command_add("gender", "[0/1/2] - Change your or your target's gender to male/female/neuter", AccountStatus::Guide, command_gender) ||
-		command_add("getplayerburiedcorpsecount", "Get your or your target's total number of buried player corpses.", AccountStatus::GMAdmin, command_getplayerburiedcorpsecount) ||
-		command_add("getvariable", "[Variable Name] - Get the value of a variable from the database", AccountStatus::GMMgmt, command_getvariable) ||
-		command_add("ginfo", "get group info on target.", AccountStatus::ApprenticeGuide, command_ginfo) ||
 		command_add("giveitem", "[itemid] [charges] - Summon an item onto your target's cursor. Charges are optional.", AccountStatus::GMMgmt, command_giveitem) ||
 		command_add("givemoney", "[Platinum] [Gold] [Silver] [Copper] - Gives specified amount of money to you or your player target", AccountStatus::GMMgmt, command_givemoney) ||
-		command_add("globalview", "Lists all qglobals in cache if you were to do a quest with this target.", AccountStatus::QuestTroupe, command_globalview) ||
-		command_add("gm", "[On|Off] - Modify your or your target's GM Flag", AccountStatus::QuestTroupe, command_gm) ||
-		command_add("gmspeed", "[On|Off] - Turn GM Speed On or Off for you or your player target", AccountStatus::GMAdmin, command_gmspeed) ||
 		command_add("gmzone", "[Zone ID|Zone Short Name] [Version] [Instance Identifier] - Zones to a private GM instance (Version defaults to 0 and Instance Identifier defaults to 'gmzone' if not used)", AccountStatus::GMAdmin, command_gmzone) ||
-		command_add("godmode", "[on/off] - Turns on/off hideme, gmspeed, invul, and flymode.", AccountStatus::GMMgmt, command_godmode) ||
 		command_add("goto", "[playername] or [x y z] [h] - Teleport to the provided coordinates or to your target", AccountStatus::Steward, command_goto) ||
 		command_add("grid", "[add/delete] [grid_num] [wandertype] [pausetype] - Create/delete a wandering grid", AccountStatus::GMAreas, command_grid) ||
 		command_add("guild", "Guild manipulation commands. Use argument help for more info.", AccountStatus::Steward, command_guild) ||
-		command_add("haste", "[Percentage] - Set your or your target's GM Bonus Haste (100 is 100% more Attack Speed)", AccountStatus::GMAdmin, command_haste) ||
-		command_add("hatelist", "Display hate list for NPC.", AccountStatus::QuestTroupe, command_hatelist) ||
-		command_add("heal", "Completely heal your target", AccountStatus::Steward, command_heal) ||
 		command_add("help", "[Search Criteria] - List available commands and their description, specify partial command as argument to search", AccountStatus::Player, command_help) ||
-		command_add("heromodel", "[Hero Model] [Slot] - Set your or your target's appearance to a full set of Hero's Forge Armor, if slot is set, sends exact model just to slot.", AccountStatus::GMMgmt, command_heromodel) ||
-		command_add("hideme", "[On|Off] or [0|1] - Hide yourself from players below your status level.", AccountStatus::QuestTroupe, command_hideme) ||
 		command_add("hotfix", "[hotfix_name] - Reloads shared memory into a hotfix, equiv to load_shared_memory followed by apply_shared_memory", AccountStatus::GMImpossible, command_hotfix) ||
 		command_add("hp", "Refresh your HP bar from the server.", AccountStatus::Player, command_hp) ||
-		command_add("incstat", "Increases or Decreases a client's stats permanently.", AccountStatus::GMMgmt, command_incstat) ||
 		command_add("instance", "Modify Instances", AccountStatus::GMMgmt, command_instance) ||
 		command_add("interrogateinv", "use [help] argument for available options", AccountStatus::Player, command_interrogateinv) ||
 		command_add("interrupt", "[Message ID] [Color] - Interrupt your casting. Arguments are optional.", AccountStatus::Guide, command_interrupt) ||
 		command_add("invsnapshot", "Manipulates inventory snapshots for your current target", AccountStatus::QuestTroupe, command_invsnapshot) ||
-		command_add("invul", "[On|Off]] - Turn player target's or your invulnerable flag on or off", AccountStatus::QuestTroupe, command_invul) ||
 		command_add("ipban", "[IP] - Ban IP", AccountStatus::GMMgmt, command_ipban) ||
-		command_add("iplookup", "[charname] - Look up IP address of charname", AccountStatus::GMMgmt, command_iplookup) ||
-		command_add("itemsearch", "[Search Criteria] - Search for an item", AccountStatus::Steward, command_itemsearch) ||
 		command_add("kick", "[Character Name] - Disconnect a player by name", AccountStatus::GMLeadAdmin, command_kick) ||
 		command_add("kill", "Kill your target", AccountStatus::GMAdmin, command_kill) ||
 		command_add("killallnpcs", "[npc_name] - Kills all npcs by search name, leave blank for all attackable NPC's", AccountStatus::GMMgmt, command_killallnpcs) ||
-		command_add("lastname", "[Last Name] - Set your or your player target's last name (use \"-1\" to remove last name)", AccountStatus::Guide, command_lastname) ||
-		command_add("level", "[Level] - Set your or your target's level", AccountStatus::Steward, command_level) ||
 		command_add("list", "[npcs|players|corpses|doors|objects] [search] - Search entities", AccountStatus::ApprenticeGuide, command_list) ||
-		command_add("listpetition", "List petitions", AccountStatus::Guide, command_listpetition) ||
 		command_add("lootsim", "[npc_type_id] [loottable_id] [iterations] - Runs benchmark simulations using real loot logic to report numbers and data", AccountStatus::GMImpossible, command_lootsim) ||
 		command_add("load_shared_memory", "[shared_memory_name] - Reloads shared memory and uses the input as output", AccountStatus::GMImpossible, command_load_shared_memory) ||
 		command_add("loc", "Print out your or your target's current location and heading", AccountStatus::Player, command_loc) ||
 		command_add("logs", "Manage anything to do with logs", AccountStatus::GMImpossible, command_logs) ||
 		command_add("makepet", "[Pet Name] - Make a pet", AccountStatus::Guide, command_makepet) ||
-		command_add("mana", "Fill your or your target's mana", AccountStatus::Guide, command_mana) ||
-		command_add("maxskills", "Maxes skills for you or your player target.", AccountStatus::GMMgmt, command_max_all_skills) ||
 		command_add("memspell", "[Spell ID] [Spell Gem] - Memorize a Spell by ID to the specified Spell Gem for you or your target", AccountStatus::Guide, command_memspell) ||
-		command_add("merchant_close_shop", "Closes a merchant shop", AccountStatus::GMAdmin, command_merchantcloseshop) ||
-		command_add("merchant_open_shop", "Opens a merchants shop", AccountStatus::GMAdmin, command_merchantopenshop) ||
+		command_add("merchantshop", "Closes or opens your target merchant's shop", AccountStatus::GMAdmin, command_merchantshop) ||
 		command_add("modifynpcstat", "[Stat] [Value] - Modifies an NPC's stats temporarily.", AccountStatus::GMLeadAdmin, command_modifynpcstat) ||
-		command_add("motd", "[Message of the Day] - Set Message of the Day (leave empty to have no Message of the Day)", AccountStatus::GMLeadAdmin, command_motd) ||
 		command_add("movechar", "[Character ID|Character Name] [Zone ID|Zone Short Name] - Move an offline character to the specified zone", AccountStatus::Guide, command_movechar) ||
 		command_add("movement", "Various movement commands", AccountStatus::GMMgmt, command_movement) ||
 		command_add("myskills", "Show details about your current skill levels", AccountStatus::Player, command_myskills) ||
 		command_add("mysql", "[Help|Query] [SQL Query] - Mysql CLI, see 'Help' for options.", AccountStatus::GMImpossible, command_mysql) ||
 		command_add("mystats", "Show details about you or your pet", AccountStatus::Guide, command_mystats) ||
-		command_add("name", "[New Name] - Rename your player target", AccountStatus::GMLeadAdmin, command_name) ||
-		command_add("netstats", "Gets the network stats for a stream.", AccountStatus::GMMgmt, command_netstats) ||
-		command_add("network", "Admin commands for the udp network interface.", AccountStatus::GMImpossible, command_network) ||
 		command_add("npccast", "[targetname/entityid] [spellid] - Causes NPC target to cast spellid on targetname/entityid", AccountStatus::QuestTroupe, command_npccast) ||
 		command_add("npcedit", "[column] [value] - Mega NPC editing command", AccountStatus::GMAdmin, command_npcedit) ||
 		command_add("npceditmass", "[name-search] [column] [value] - Mass (Zone wide) NPC data editing command", AccountStatus::GMAdmin, command_npceditmass) ||
@@ -225,31 +172,18 @@ int command_init(void)
 		command_add("npcsay", "[Message] - Make your NPC target say a message.", AccountStatus::GMLeadAdmin, command_npcsay) ||
 		command_add("npcshout", "[Message] - Make your NPC target shout a message.", AccountStatus::GMLeadAdmin, command_npcshout) ||
 		command_add("npcspawn", "[create/add/update/remove/delete] - Manipulate spawn DB", AccountStatus::GMAreas, command_npcspawn) ||
-		command_add("npcstats", "Show stats about target NPC", AccountStatus::QuestTroupe, command_npcstats) ||
 		command_add("npctypespawn", "[NPC ID] [Faction ID] - Spawn an NPC by ID from the database with an option of setting its Faction ID", AccountStatus::Steward, command_npctypespawn) ||
 		command_add("nudge", "Nudge your target's current position by specific values", AccountStatus::QuestTroupe, command_nudge) ||
 		command_add("nukebuffs", "[Beneficial|Detrimental|Help] - Strip all buffs by type on you or your target (no argument to remove all buffs)", AccountStatus::Guide, command_nukebuffs) ||
 		command_add("nukeitem", "[Item ID] - Removes the specified Item ID from you or your player target's inventory", AccountStatus::GMLeadAdmin, command_nukeitem) ||
 		command_add("object", "List|Add|Edit|Move|Rotate|Copy|Save|Undo|Delete - Manipulate static and tradeskill objects within the zone", AccountStatus::GMAdmin, command_object) ||
-		command_add("oocmute", "[0|1] - Enable or Disable Server OOC", AccountStatus::GMMgmt, command_oocmute) ||
 		command_add("opcode", "Reloads all opcodes from server patch files", AccountStatus::GMMgmt, command_reload) ||
 		command_add("path", "view and edit pathing", AccountStatus::GMMgmt, command_path) ||
-		command_add("peekinv", "[equip/gen/cursor/poss/limbo/curlim/trib/bank/shbank/allbank/trade/world/all] - Print out contents of your player target's inventory", AccountStatus::GMAdmin, command_peekinv) ||
 		command_add("peqzone", "[Zone ID|Zone Short Name] - Teleports you to the specified zone if you meet the requirements.", AccountStatus::Player, command_peqzone) ||
-		command_add("peqzone_flags", "displays the PEQZone Flags of you or your target", AccountStatus::Player, command_peqzone_flags) ||
-		command_add("permaclass", "[Class ID] - Change your or your player target's class, changed client is disconnected", AccountStatus::QuestTroupe, command_permaclass) ||
-		command_add("permagender", "[Gender ID] - Change your or your player target's gender", AccountStatus::QuestTroupe, command_permagender) ||
-		command_add("permarace", "[Race ID] - Change your or your player target's race", AccountStatus::QuestTroupe, command_permarace) ||
 		command_add("petitems", "View your pet's items if you have one", AccountStatus::ApprenticeGuide, command_petitems) ||
-		command_add("petitioninfo", "[petition number] - Get info about a petition", AccountStatus::ApprenticeGuide, command_petitioninfo) ||
 		command_add("picklock", "Analog for ldon pick lock for the newer clients since we still don't have it working.", AccountStatus::Player, command_picklock) ||
 		command_add("profanity", "Manage censored language.", AccountStatus::GMLeadAdmin, command_profanity) ||
 		command_add("push", "[Back Push] [Up Push] - Lets you do spell push on an NPC", AccountStatus::GMLeadAdmin, command_push) ||
-		command_add("proximity", "Shows NPC proximity", AccountStatus::GMLeadAdmin, command_proximity) ||
-		command_add("pvp", "[On|Off] - Set you or your player target's PVP status", AccountStatus::GMAdmin, command_pvp) ||
-		command_add("qglobal", "[On|Off|View] - Toggles quest global functionality for your NPC target", AccountStatus::GMAdmin, command_qglobal) ||
-		command_add("questerrors", "Shows quest errors.", AccountStatus::GMAdmin, command_questerrors) ||
-		command_add("race", "[racenum] - Change your or your target's race. Use racenum 0 to return to normal", AccountStatus::Guide, command_race) ||
 		command_add("raidloot", "[All|GroupLeader|RaidLeader|Selected] - Sets your Raid Loot Type if you have permission to do so.", AccountStatus::Player, command_raidloot) ||
 		command_add("randomfeatures", "Temporarily randomizes the Facial Features of your target", AccountStatus::QuestTroupe, command_randomfeatures) ||
 		command_add("refreshgroup", "Refreshes Group for you or your player target.", AccountStatus::Player, command_refreshgroup) ||
@@ -270,44 +204,12 @@ int command_init(void)
 		command_add("scribespells", "[Max level] [Min level] - Scribe all spells for you or your player target that are usable by them, up to level specified. (may freeze client for a few seconds)", AccountStatus::GMLeadAdmin, command_scribespells) ||
 		command_add("sendzonespawns", "Refresh spawn list for all clients in zone", AccountStatus::GMLeadAdmin, command_sendzonespawns) ||
 		command_add("sensetrap", "Analog for ldon sense trap for the newer clients since we still don't have it working.", AccountStatus::Player, command_sensetrap) ||
-		command_add("serverinfo", "Get CPU, Operating System, and Process Information about the server", AccountStatus::GMMgmt, command_serverinfo) ||
-		command_add("serverlock", "[0|1] - Lock or Unlock the World Server (0 = Unlocked, 1 = Locked)", AccountStatus::GMLeadAdmin, command_serverlock) ||
-		command_add("serverrules", "Read this server's rules", AccountStatus::Player, command_serverrules) ||
-		command_add("setaapts", "[AA|Group|Raid] [AA Amount] - Set your or your player target's Available AA Points by Type", AccountStatus::GMAdmin, command_setaapts) ||
-		command_add("setaaxp", "[AA|Group|Raid] [AA Experience] - Set your or your player target's AA Experience by Type", AccountStatus::GMAdmin, command_setaaxp) ||
-		command_add("setadventurepoints", "[Theme] [Points] - Set your or your player target's available Adventure Points by Theme", AccountStatus::GMLeadAdmin, command_set_adventure_points) ||
-		command_add("setaltcurrency", "[Currency ID] [Amount] - Set your or your target's available Alternate Currency by Currency ID", AccountStatus::GMAdmin, command_setaltcurrency) ||
-		command_add("setanim", "[Animation ID (IDs are 0 to 4)] - Set target's appearance to Animation ID", AccountStatus::GMMgmt, command_setanim) ||
-		command_add("setanon", "[Anonymous Flag] - Set you or your target's Anonymous Flag (0 = Not Anonymous, 1 = Anonymous, 2 = Roleplaying)", AccountStatus::QuestTroupe, command_setanon) ||
-		command_add("setcrystals", "[value] - Set your or your player target's available radiant or ebon crystals", AccountStatus::GMAdmin, command_setcrystals) ||
-		command_add("setendurance", "[Endurance] - Set your or your target's Endurance", AccountStatus::GMAdmin, command_setendurance) ||
-		command_add("setfaction", "[Faction ID] - Sets targeted NPC's faction in the database", AccountStatus::GMAreas, command_setfaction) ||
-		command_add("sethp", "[Health] - Set your or your target's Health", AccountStatus::GMAdmin, command_sethp) ||
-		command_add("setlanguage", "[Language ID] [Value] - Set your or your target's Language by ID to Value", AccountStatus::Guide, command_setlanguage) ||
-		command_add("setlsinfo", "[Email] [Password] - Set loginserver email address and password (if supported by loginserver)", AccountStatus::Steward, command_setlsinfo) ||
-		command_add("setmana", "[Mana] - Set your or your target's Mana", AccountStatus::GMAdmin, command_setmana) ||
-		command_add("setpass", "[Account Name] [Password] - Set local password by account name", AccountStatus::GMLeadAdmin, command_setpass) ||
-		command_add("setpvppoints", "[Amount] - Set your or your player target's PVP points", AccountStatus::GMAdmin, command_setpvppoints) ||
-		command_add("setskill", "[skillnum] [value] - Set your target's skill skillnum to value", AccountStatus::Guide, command_setskill) ||
-		command_add("setskillall", "[Skill Level] - Set all of your or your target's skills to the specified skill level", AccountStatus::Guide, command_setskillall) ||
-		command_add("setstartzone", "[Zone ID|Zone Short Name] - Sets your or your target's starting zone (Use '0' or 'Reset' to allow the player use of /setstartcity)", AccountStatus::QuestTroupe, command_setstartzone) ||
-		command_add("setstat", "Sets the stats to a specific value.", AccountStatus::Max, command_setstat) ||
-		command_add("setxp", "[value] - Set your or your player target's experience", AccountStatus::GMAdmin, command_setxp) ||
-		command_add("showbonusstats", "[item|spell|all] Shows bonus stats for target from items or spells. Shows both by default.", AccountStatus::Guide, command_showbonusstats) ||
-		command_add("showbuffs", "List buffs active on your target or you if no target", AccountStatus::Guide, command_showbuffs) ||
-		command_add("shownumhits", "Shows buffs numhits for yourself.", AccountStatus::Player, command_shownumhits) ||
-		command_add("shownpcgloballoot", "Show global loot entries for your target NPC", AccountStatus::Guide, command_shownpcgloballoot) ||
-		command_add("showskills", "[Start Skill ID] [All] - Show the values of your or your player target's skills in a popup 50 at a time, use 'all' as second argument to show non-usable skill's values", AccountStatus::Guide, command_showskills) ||
-		command_add("showspellslist", "Shows spell list of targeted NPC", AccountStatus::GMAdmin, command_showspellslist) ||
-		command_add("showstats", "Show details about you or your target", AccountStatus::Guide, command_showstats) ||
-		command_add("showzonegloballoot", "Show global loot entries for your current zone", AccountStatus::Guide, command_showzonegloballoot) ||
-		command_add("showzonepoints", "Show zone points for current zone", AccountStatus::Guide, command_showzonepoints) ||
+		command_add("set", "Set command used to set various things", AccountStatus::Guide, command_set) ||
+		command_add("show", "Show command used to show various things", AccountStatus::Guide, command_show) ||
 		command_add("shutdown", "Shut this zone process down", AccountStatus::GMLeadAdmin, command_shutdown) ||
 		command_add("spawn", "[name] [race] [level] [material] [hp] [gender] [class] [priweapon] [secweapon] [merchantid] - Spawn an NPC", AccountStatus::Steward, command_spawn) ||
 		command_add("spawneditmass", "[Search Criteria] [Edit Option] [Edit Value] [Apply] Mass editing spawn command (Apply is optional, 0 = False, 1 = True, default is False)", AccountStatus::GMLeadAdmin, command_spawneditmass) ||
 		command_add("spawnfix", "Find targeted NPC in database based on its X/Y/heading and update the database to make it spawn at your current location/heading.", AccountStatus::GMAreas, command_spawnfix) ||
-		command_add("spawnstatus", "[All|Disabled|Enabled|Spawn ID] - Show respawn timer status", AccountStatus::GMAdmin, command_spawnstatus) ||
-		command_add("spellinfo", "[spellid] - Get detailed info about a spell", AccountStatus::Steward, command_spellinfo) ||
 		command_add("stun", "[duration] - Stuns you or your target for duration", AccountStatus::GMAdmin, command_stun) ||
 		command_add("summon", "[Character Name] - Summons your corpse, NPC, or player target, or by character name if specified", AccountStatus::QuestTroupe, command_summon) ||
 		command_add("summonburiedplayercorpse", "Summons the target's oldest buried corpse, if any exist.", AccountStatus::GMAdmin, command_summonburiedplayercorpse) ||
@@ -315,57 +217,27 @@ int command_init(void)
 		command_add("suspend", "[name] [days] [reason] - Suspend by character name and for specificed number of days", AccountStatus::GMLeadAdmin, command_suspend) ||
 		command_add("suspendmulti", "[Character Name One|Character Name Two|etc] [Days] [Reason] - Suspend multiple characters by name for specified number of days", AccountStatus::GMLeadAdmin, command_suspendmulti) ||
 		command_add("task", "(subcommand) - Task system commands", AccountStatus::GMLeadAdmin, command_task) ||
-		command_add("tempname", "[newname] - Temporarily renames your target. Leave name blank to restore the original name.", AccountStatus::GMAdmin, command_tempname) ||
 		command_add("petname", "[newname] - Temporarily renames your pet. Leave name blank to restore the original name.", AccountStatus::GMAdmin, command_petname) ||
-		command_add("texture", "[Texture] [Helmet Texture] - Change your or your target's texture (Helmet Texture defaults to 0 if not used)", AccountStatus::Steward, command_texture) ||
-		command_add("time", "[Hour] [Minute] - Set world time to specified time", AccountStatus::EQSupport, command_time) ||
-		command_add("timers", "Display persistent timers for target", AccountStatus::GMMgmt, command_timers) ||
-		command_add("timezone", "[Hour] [Minutes] - Set timezone (Minutes are optional)", AccountStatus::EQSupport, command_timezone) ||
-		command_add("title", "[Title] - Set your or your player target's title (use \"-1\" to remove title)", AccountStatus::Guide, command_title) ||
-		command_add("titlesuffix", "[Title Suffix] - Set your or your player target's title suffix (use \"-1\" to remove title suffix)", AccountStatus::Guide, command_titlesuffix) ||
 		command_add("traindisc", "[level] - Trains all the disciplines usable by the target, up to level specified. (may freeze client for a few seconds)", AccountStatus::GMLeadAdmin, command_traindisc) ||
-		command_add("trapinfo", "Gets infomation about the traps currently spawned in the zone.", AccountStatus::QuestTroupe, command_trapinfo) ||
 		command_add("tune", "Calculate statistical values related to combat.", AccountStatus::GMAdmin, command_tune) ||
 		command_add("undye", "Remove dye from all of your or your target's armor slots", AccountStatus::GMAdmin, command_undye) ||
-		command_add("unfreeze", "Unfreeze your target", AccountStatus::QuestTroupe, command_unfreeze) ||
 		command_add("unmemspell", "[Spell ID] - Unmemorize a Spell by ID for you or your target", AccountStatus::Guide, command_unmemspell) ||
 		command_add("unmemspells", " Unmemorize all spells for you or your target", AccountStatus::Guide, command_unmemspells) ||
 		command_add("unscribespell", "[Spell ID] - Unscribe a spell from your or your target's spell book by Spell ID", AccountStatus::GMCoder, command_unscribespell) ||
 		command_add("unscribespells", "Clear out your or your player target's spell book.", AccountStatus::GMCoder, command_unscribespells) ||
 		command_add("untraindisc", "[Spell ID] - Untrain your or your target's discipline by Spell ID", AccountStatus::GMCoder, command_untraindisc) ||
 		command_add("untraindiscs", "Untrains all disciplines from your target.", AccountStatus::GMCoder, command_untraindiscs) ||
-		command_add("updatechecksum", "update client checksum", AccountStatus::GMImpossible, command_updatechecksum) ||
-		command_add("uptime", "[zone server id] - Get uptime of worldserver, or zone server if argument provided", AccountStatus::Steward, command_uptime) ||
-		command_add("version", "Display current version of EQEmu server", AccountStatus::Player, command_version) ||
-		command_add("viewcurrencies", "View your or your target's currencies", AccountStatus::GMAdmin, command_viewcurrencies) ||
-		command_add("viewnpctype", "[NPC ID] - Show stats for an NPC by NPC ID", AccountStatus::GMAdmin, command_viewnpctype) ||
-		command_add("viewpetition", "[petition number] - View a petition", AccountStatus::ApprenticeGuide, command_viewpetition) ||
-		command_add("viewrecipe", "[Recipe ID] - Show a recipe's entries", AccountStatus::GMAdmin, command_viewrecipe) ||
-		command_add("viewzoneloot", "[item id] - Allows you to search a zone's loot for a specific item ID. (0 shows all loot in the zone)", AccountStatus::QuestTroupe, command_viewzoneloot) ||
 		command_add("wc", "[Slot ID] [Material] [Hero Forge Model] [Elite Material] - Sets the specified slot for you or your target to a material, Hero Forge Model and Elite Material are optional", AccountStatus::GMMgmt, command_wc) ||
-		command_add("weather", "[0/1/2/3] (Off/Rain/Snow/Manual) - Change the weather", AccountStatus::QuestTroupe, command_weather) ||
-		command_add("who", "[search]", AccountStatus::ApprenticeGuide, command_who) ||
 		command_add("worldshutdown", "Shut down world and all zones", AccountStatus::GMMgmt, command_worldshutdown) ||
 		command_add("wp", "[add|delete] [grid_id] [pause] [waypoint_id] [-h] - Add or delete a waypoint by grid ID. (-h to use current heading)", AccountStatus::GMAreas, command_wp) ||
 		command_add("wpadd", "[pause] [-h] - Add your current location as a waypoint to your NPC target's AI path. (-h to use current heading)", AccountStatus::GMAreas, command_wpadd) ||
-		command_add("wpinfo", "Show waypoint info about your NPC target", AccountStatus::GMAreas, command_wpinfo) ||
 		command_add("worldwide", "Performs world-wide GM functions such as cast (can be extended for other commands). Use caution", AccountStatus::GMImpossible, command_worldwide) ||
-		command_add("xtargets", "[New Max XTargets] - Show your or your target's XTargets and optionally set max XTargets.", AccountStatus::GMImpossible, command_xtargets) ||
-		command_add("zclip", "[Minimum Clip] [Maximum Clip] [Fog Minimum Clip] [Fog Maximum Clip] [Permanent (0 = False, 1 = True)] - Change zone clipping", AccountStatus::QuestTroupe, command_zclip) ||
-		command_add("zcolor", "[Red] [Green] [Blue] [Permanent (0 = False, 1 = True)] - Change sky color", AccountStatus::QuestTroupe, command_zcolor) ||
-		command_add("zheader", "[Zone ID|Zone Short Name] [Version] - Load a zone header from the database", AccountStatus::QuestTroupe, command_zheader) ||
 		command_add("zone", "[Zone ID|Zone Short Name] [X] [Y] [Z] - Teleport to specified Zone by ID or Short Name (coordinates are optional)", AccountStatus::Guide, command_zone) ||
 		command_add("zonebootup", "[ZoneServerID] [shortname] - Make a zone server boot a specific zone", AccountStatus::GMLeadAdmin, command_zonebootup) ||
 		command_add("zoneinstance", "[Instance ID] [X] [Y] [Z] - Teleport to specified Instance by ID (coordinates are optional)", AccountStatus::Guide, command_zone_instance) ||
-		command_add("zonelock", "[List|Lock|Unlock] [Zone ID|Zone Short Name] - Set or get lock status of a Zone by ID or Short Name", AccountStatus::GMAdmin, command_zonelock) ||
 		command_add("zoneshutdown", "[shortname] - Shut down a zone server", AccountStatus::GMLeadAdmin, command_zoneshutdown) ||
-		command_add("zonestatus", "Show connected zoneservers, synonymous with /servers", AccountStatus::GMLeadAdmin, command_zonestatus) ||
 		command_add("zopp", "Troubleshooting command - Sends a fake item packet to you. No server reference is created.", AccountStatus::GMImpossible, command_zopp) ||
-		command_add("zsafecoords", "[X] [Y] [Z] [Heading] [Permanent (0 = False, 1 = True)] - Set the current zone's safe coordinates", AccountStatus::QuestTroupe, command_zsafecoords) ||
-		command_add("zsave", " Saves zheader to the database", AccountStatus::QuestTroupe, command_zsave) ||
-		command_add("zsky", "[Sky Type] [Permanent (0 = False, 1 = True)] - Change zone sky type", AccountStatus::QuestTroupe, command_zsky) ||
-		command_add("zstats", "Show info about zone header", AccountStatus::QuestTroupe, command_zstats) ||
-		command_add("zunderworld", "[Z] [Permanent (0 = False, 1 = True)] - Change zone underworld Z", AccountStatus::QuestTroupe, command_zunderworld)
+		command_add("zsave", " Saves zheader to the database", AccountStatus::QuestTroupe, command_zsave)
 	) {
 		command_deinit();
 		return -1;
@@ -373,22 +245,35 @@ int command_init(void)

 	std::map<std::string, std::pair<uint8, std::vector<std::string>>> command_settings;
 	database.GetCommandSettings(command_settings);
+	database.GetCommandSubSettings(command_subsettings);

 	std::vector<std::pair<std::string, uint8>> injected_command_settings;
 	std::vector<std::string> orphaned_command_settings;

+	// inject static sub command aliases
+	// .e.g old #fi routes to #find item or #itemsearch routes to #find item
+	for (auto& cs : command_settings) {
+		for (const auto& e : command_subsettings) {
+			if (cs.first == e.parent_command) {
+				for (const auto& alias : Strings::Split(e.top_level_aliases, "|")) {
+					cs.second.second.emplace_back(alias);
+				}
+			}
+		}
+	}
+
 	for (const auto& cs : command_settings) {
 		auto cl = commandlist.find(cs.first);
 		if (cl == commandlist.end()) {
 			orphaned_command_settings.push_back(cs.first);
 			LogInfo(
-				"Command [{}] no longer exists... Deleting orphaned entry from `command_settings` table...",
+				"Command [{}] no longer exists. Deleting orphaned entry from `command_settings` table.",
 				cs.first
 			);
 		}
 	}

-	if (orphaned_command_settings.size()) {
+	if (!orphaned_command_settings.empty()) {
 		if (!database.UpdateOrphanedCommandSettings(orphaned_command_settings)) {
 			LogInfo("Failed to process 'Orphaned Commands' update operation.");
 		}
@@ -398,16 +283,16 @@ int command_init(void)
 	for (const auto& w : working_cl) {
 		auto cs = command_settings.find(w.first);
 		if (cs == command_settings.end()) {
-			injected_command_settings.emplace_back(std::pair<std::string, uint8>(w.first, w.second->admin));
+			injected_command_settings.emplace_back(w.first, w.second->admin);
 			LogInfo(
-				"New Command [{}] found... Adding to `command_settings` table with admin [{}]...",
+				"New Command [{}] found. Adding to `command_settings` table with admin status [{}]",
 				w.first,
 				w.second->admin
 			);

 			if (w.second->admin == AccountStatus::Player) {
 				LogCommands(
-					"command_init(): Warning: Command [{}] defaulting to admin level 0!",
+					"Warning: Command [{}] defaulting to admin level 0!",
 					w.first
 				);
 			}
@@ -416,8 +301,9 @@ int command_init(void)
 		}

 		w.second->admin = cs->second.first;
+
 		LogCommands(
-			"command_init(): - Command [{}] set to admin level [{}]",
+			"Command [{}] set to admin level [{}]",
 			w.first,
 			cs->second.first
 		);
@@ -440,7 +326,7 @@ int command_init(void)
 				continue;
 			}

-			commandlist[a] = w.second;
+			commandlist[a]    = w.second;
 			commandaliases[a] = w.first;

 			LogCommands(
@@ -451,7 +337,7 @@ int command_init(void)
 		}
 	}

-	if (injected_command_settings.size()) {
+	if (!injected_command_settings.empty()) {
 		if (!database.UpdateInjectedCommandSettings(injected_command_settings)) {
 			LogInfo("Failed to process 'Injected Commands' update operation.");
 		}
@@ -462,6 +348,7 @@ int command_init(void)
 	return command_count;
 }

+
 /*
 * command_deinit
 * clears the command list, freeing resources
@@ -513,23 +400,24 @@ int command_add(std::string command_name, std::string description, uint8 admin,
 	}

 	auto c = new CommandRecord;
-	c->admin = admin;
+
+	c->admin       = admin;
 	c->description = description;
-	c->function = function;
+	c->function    = function;

-	commands_map[command_name] = admin;
-
-	commandlist[command_name] = c;
+	commands_map[command_name]   = admin;
+	commandlist[command_name]    = c;
 	commandaliases[command_name] = command_name;
+
 	command_delete_list.push_back(c);
 	command_count++;

 	return 0;
 }

-uint8 GetCommandStatus(Client *c, std::string command_name) {
-	auto command_status = commands_map[command_name];
-	return command_status;
+uint8 GetCommandStatus(std::string command_name)
+{
+	return commands_map[command_name];
 }

 /*
@@ -555,9 +443,46 @@ int command_realdispatch(Client *c, std::string message, bool ignore_status)
 	}

 	auto cur = commandlist[cstr];
-	if (!ignore_status && c->Admin() < cur->admin) {
-		c->Message(Chat::White, "Your status is not high enough to use this command.");
-		return -1;
+
+	bool is_subcommand            = false;
+	bool can_use_subcommand       = false;
+	bool found_subcommand_setting = false;
+
+	const auto arguments = sep.argnum;
+
+	if (arguments >= 2) {
+		const std::string& sub_command = sep.arg[1];
+
+		for (const auto &e : command_subsettings) {
+			if (e.sub_command == sub_command) {
+				can_use_subcommand       = c->Admin() >= static_cast<int16>(e.access_level);
+				is_subcommand            = true;
+				found_subcommand_setting = true;
+				break;
+			}
+		}
+
+		if (!found_subcommand_setting) {
+			for (const auto &e: command_subsettings) {
+				if (e.sub_command == sub_command) {
+					can_use_subcommand = c->Admin() >= static_cast<int16>(e.access_level);
+					is_subcommand      = true;
+					break;
+				}
+			}
+		}
+	}
+
+	if (!ignore_status) {
+		if (!is_subcommand && c->Admin() < cur->admin) {
+			c->Message(Chat::White, "Your status is not high enough to use this command.");
+			return -1;
+		}
+
+		if (is_subcommand && !can_use_subcommand) {
+			c->Message(Chat::White, "Your status is not high enough to use this subcommand.");
+			return -1;
+		}
 	}

 	/* QS: Player_Log_Issued_Commands */
@@ -612,7 +537,10 @@ void command_help(Client *c, const Seperator *sep)

 	for (const auto& cur : commandlist) {
 		if (!search_criteria.empty()) {
-			if (!Strings::Contains(cur.first, search_criteria) && !Strings::Contains(cur.second->description, search_criteria)) {
+			if (
+				!Strings::Contains(cur.first, search_criteria) &&
+				!Strings::Contains(cur.second->description, search_criteria)
+			) {
 				continue;
 			}
 		}
@@ -632,10 +560,9 @@ void command_help(Client *c, const Seperator *sep)
 		c->Message(
 			Chat::White,
 			fmt::format(
-				"{} | Status: {} | {}",
+				"{} | {}",
 				command_link,
-				cur.second->admin,
-				!cur.second->description.empty() ? cur.second->description : ""
+				cur.second->description
 			).c_str()
 		);

@@ -667,88 +594,6 @@ void command_help(Client *c, const Seperator *sep)
 	);
 }

-void command_findaliases(Client *c, const Seperator *sep)
-{
-	int arguments = sep->argnum;
-	if (!arguments) {
-		c->Message(Chat::White, "Usage: #findaliases [Search Critera]");
-		return;
-	}
-
-	std::string search_criteria = Strings::ToLower(sep->argplus[1]);
-
-	auto find_iter = commandaliases.find(search_criteria);
-	if (find_iter == commandaliases.end()) {
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"No commands or aliases found matching '{}'.",
-				search_criteria
-			).c_str()
-		);
-		return;
-	}
-
-	auto command_iter = commandlist.find(find_iter->second);
-	if (
-		find_iter->second.empty() ||
-		command_iter == commandlist.end()
-	) {
-		c->Message(Chat::White, "An unknown condition occurred.");
-		return;
-	}
-
-	auto current_commmand_link = Saylink::Silent(
-		fmt::format(
-			"{}{}",
-			COMMAND_CHAR,
-			command_iter->first
-		)
-	);
-
-	int alias_count = 0;
-	int alias_number = 1;
-	std::string alias_link;
-	for (const auto& a : commandaliases) {
-		if (
-			find_iter->second != a.second ||
-			c->Admin() < command_iter->second->admin
-		) {
-			continue;
-		}
-
-		alias_link = Saylink::Silent(
-			fmt::format(
-				"{}{}",
-				COMMAND_CHAR,
-				a.first
-			)
-		);
-
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"Alias {} | {}",
-				alias_number,
-				alias_link
-			).c_str()
-		);
-
-		alias_count++;
-		alias_number++;
-	}
-
-	c->Message(
-		Chat::White,
-		fmt::format(
-			"{} Alias{} listed for {}.",
-			alias_count,
-			alias_count != 1 ? "es" : "",
-			current_commmand_link
-		).c_str()
-	);
-}
-
 void command_hotfix(Client *c, const Seperator *sep)
 {
 	auto items_count = database.GetItemsCount();
@@ -934,7 +779,6 @@ void command_bot(Client *c, const Seperator *sep)

 #include "gm_commands/acceptrules.cpp"
 #include "gm_commands/advnpcspawn.cpp"
-#include "gm_commands/aggro.cpp"
 #include "gm_commands/aggrozone.cpp"
 #include "gm_commands/ai.cpp"
 #include "gm_commands/appearance.cpp"
@@ -942,20 +786,16 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/attack.cpp"
 #include "gm_commands/augmentitem.cpp"
 #include "gm_commands/ban.cpp"
-#include "gm_commands/bind.cpp"
 #include "gm_commands/bugs.cpp"
 #include "gm_commands/camerashake.cpp"
 #include "gm_commands/castspell.cpp"
 #include "gm_commands/chat.cpp"
-#include "gm_commands/checklos.cpp"
 #include "gm_commands/copycharacter.cpp"
 #include "gm_commands/corpse.cpp"
 #include "gm_commands/corpsefix.cpp"
 #include "gm_commands/countitem.cpp"
-#include "gm_commands/cvs.cpp"
 #include "gm_commands/damage.cpp"
 #include "gm_commands/databuckets.cpp"
-#include "gm_commands/date.cpp"
 #include "gm_commands/dbspawn2.cpp"
 #include "gm_commands/delacct.cpp"
 #include "gm_commands/delpetition.cpp"
@@ -964,7 +804,6 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/devtools.cpp"
 #include "gm_commands/disablerecipe.cpp"
 #include "gm_commands/disarmtrap.cpp"
-#include "gm_commands/distance.cpp"
 #include "gm_commands/doanim.cpp"
 #include "gm_commands/door.cpp"
 #include "gm_commands/door_manipulation.cpp"
@@ -973,91 +812,44 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/dzkickplayers.cpp"
 #include "gm_commands/editmassrespawn.cpp"
 #include "gm_commands/emote.cpp"
-#include "gm_commands/emotesearch.cpp"
-#include "gm_commands/emoteview.cpp"
 #include "gm_commands/emptyinventory.cpp"
 #include "gm_commands/enablerecipe.cpp"
-#include "gm_commands/endurance.cpp"
 #include "gm_commands/entityvariable.cpp"
 #include "gm_commands/exptoggle.cpp"
 #include "gm_commands/faction.cpp"
 #include "gm_commands/feature.cpp"
-#include "gm_commands/findaa.cpp"
-#include "gm_commands/findcharacter.cpp"
-#include "gm_commands/findclass.cpp"
-#include "gm_commands/findcurrency.cpp"
-#include "gm_commands/findfaction.cpp"
-#include "gm_commands/findnpctype.cpp"
-#include "gm_commands/findrace.cpp"
-#include "gm_commands/findrecipe.cpp"
-#include "gm_commands/findskill.cpp"
-#include "gm_commands/findspell.cpp"
-#include "gm_commands/findtask.cpp"
-#include "gm_commands/findzone.cpp"
+#include "gm_commands/find.cpp"
 #include "gm_commands/fixmob.cpp"
-#include "gm_commands/flag.cpp"
 #include "gm_commands/flagedit.cpp"
-#include "gm_commands/flags.cpp"
-#include "gm_commands/flymode.cpp"
-#include "gm_commands/fov.cpp"
-#include "gm_commands/freeze.cpp"
-#include "gm_commands/gassign.cpp"
 #include "gm_commands/gearup.cpp"
-#include "gm_commands/gender.cpp"
-#include "gm_commands/getplayerburiedcorpsecount.cpp"
-#include "gm_commands/getvariable.cpp"
-#include "gm_commands/ginfo.cpp"
 #include "gm_commands/giveitem.cpp"
 #include "gm_commands/givemoney.cpp"
-#include "gm_commands/globalview.cpp"
-#include "gm_commands/gm.cpp"
-#include "gm_commands/gmspeed.cpp"
 #include "gm_commands/gmzone.cpp"
-#include "gm_commands/godmode.cpp"
 #include "gm_commands/goto.cpp"
 #include "gm_commands/grid.cpp"
 #include "gm_commands/guild.cpp"
-#include "gm_commands/haste.cpp"
-#include "gm_commands/hatelist.cpp"
-#include "gm_commands/heal.cpp"
-#include "gm_commands/heromodel.cpp"
-#include "gm_commands/hideme.cpp"
 #include "gm_commands/hp.cpp"
-#include "gm_commands/incstat.cpp"
 #include "gm_commands/instance.cpp"
 #include "gm_commands/interrogateinv.cpp"
 #include "gm_commands/interrupt.cpp"
 #include "gm_commands/invsnapshot.cpp"
-#include "gm_commands/invul.cpp"
 #include "gm_commands/ipban.cpp"
-#include "gm_commands/iplookup.cpp"
-#include "gm_commands/itemsearch.cpp"
 #include "gm_commands/kick.cpp"
 #include "gm_commands/kill.cpp"
 #include "gm_commands/killallnpcs.cpp"
-#include "gm_commands/lastname.cpp"
-#include "gm_commands/level.cpp"
 #include "gm_commands/list.cpp"
-#include "gm_commands/listpetition.cpp"
 #include "gm_commands/lootsim.cpp"
 #include "gm_commands/loc.cpp"
 #include "gm_commands/logs.cpp"
 #include "gm_commands/makepet.cpp"
-#include "gm_commands/mana.cpp"
-#include "gm_commands/max_all_skills.cpp"
 #include "gm_commands/memspell.cpp"
-#include "gm_commands/merchantcloseshop.cpp"
-#include "gm_commands/merchantopenshop.cpp"
+#include "gm_commands/merchantshop.cpp"
 #include "gm_commands/modifynpcstat.cpp"
-#include "gm_commands/motd.cpp"
 #include "gm_commands/movechar.cpp"
 #include "gm_commands/movement.cpp"
 #include "gm_commands/myskills.cpp"
 #include "gm_commands/mysql.cpp"
 #include "gm_commands/mystats.cpp"
-#include "gm_commands/name.cpp"
-#include "gm_commands/netstats.cpp"
-#include "gm_commands/network.cpp"
 #include "gm_commands/npccast.cpp"
 #include "gm_commands/npcedit.cpp"
 #include "gm_commands/npceditmass.cpp"
@@ -1066,31 +858,18 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/npcsay.cpp"
 #include "gm_commands/npcshout.cpp"
 #include "gm_commands/npcspawn.cpp"
-#include "gm_commands/npcstats.cpp"
 #include "gm_commands/npctypespawn.cpp"
 #include "gm_commands/nudge.cpp"
 #include "gm_commands/nukebuffs.cpp"
 #include "gm_commands/nukeitem.cpp"
 #include "gm_commands/object.cpp"
-#include "gm_commands/oocmute.cpp"
 #include "gm_commands/path.cpp"
-#include "gm_commands/peekinv.cpp"
 #include "gm_commands/peqzone.cpp"
-#include "gm_commands/peqzone_flags.cpp"
-#include "gm_commands/permaclass.cpp"
-#include "gm_commands/permagender.cpp"
-#include "gm_commands/permarace.cpp"
 #include "gm_commands/petitems.cpp"
-#include "gm_commands/petitioninfo.cpp"
 #include "gm_commands/petname.cpp"
 #include "gm_commands/picklock.cpp"
 #include "gm_commands/profanity.cpp"
-#include "gm_commands/proximity.cpp"
 #include "gm_commands/push.cpp"
-#include "gm_commands/pvp.cpp"
-#include "gm_commands/qglobal.cpp"
-#include "gm_commands/questerrors.cpp"
-#include "gm_commands/race.cpp"
 #include "gm_commands/raidloot.cpp"
 #include "gm_commands/randomfeatures.cpp"
 #include "gm_commands/refreshgroup.cpp"
@@ -1109,44 +888,12 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/scribespells.cpp"
 #include "gm_commands/sendzonespawns.cpp"
 #include "gm_commands/sensetrap.cpp"
-#include "gm_commands/serverinfo.cpp"
-#include "gm_commands/serverlock.cpp"
-#include "gm_commands/serverrules.cpp"
-#include "gm_commands/set_adventure_points.cpp"
-#include "gm_commands/setaapts.cpp"
-#include "gm_commands/setaaxp.cpp"
-#include "gm_commands/setaltcurrency.cpp"
-#include "gm_commands/setanim.cpp"
-#include "gm_commands/setanon.cpp"
-#include "gm_commands/setcrystals.cpp"
-#include "gm_commands/setendurance.cpp"
-#include "gm_commands/setfaction.cpp"
-#include "gm_commands/sethp.cpp"
-#include "gm_commands/setlanguage.cpp"
-#include "gm_commands/setlsinfo.cpp"
-#include "gm_commands/setmana.cpp"
-#include "gm_commands/setpass.cpp"
-#include "gm_commands/setpvppoints.cpp"
-#include "gm_commands/setskill.cpp"
-#include "gm_commands/setskillall.cpp"
-#include "gm_commands/setstartzone.cpp"
-#include "gm_commands/setstat.cpp"
-#include "gm_commands/setxp.cpp"
-#include "gm_commands/showbonusstats.cpp"
-#include "gm_commands/showbuffs.cpp"
-#include "gm_commands/shownpcgloballoot.cpp"
-#include "gm_commands/shownumhits.cpp"
-#include "gm_commands/showskills.cpp"
-#include "gm_commands/showspellslist.cpp"
-#include "gm_commands/showstats.cpp"
-#include "gm_commands/showzonegloballoot.cpp"
-#include "gm_commands/showzonepoints.cpp"
+#include "gm_commands/set.cpp"
+#include "gm_commands/show.cpp"
 #include "gm_commands/shutdown.cpp"
 #include "gm_commands/spawn.cpp"
 #include "gm_commands/spawneditmass.cpp"
 #include "gm_commands/spawnfix.cpp"
-#include "gm_commands/spawnstatus.cpp"
-#include "gm_commands/spellinfo.cpp"
 #include "gm_commands/faction_association.cpp"
 #include "gm_commands/stun.cpp"
 #include "gm_commands/summon.cpp"
@@ -1155,53 +902,23 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/suspend.cpp"
 #include "gm_commands/suspendmulti.cpp"
 #include "gm_commands/task.cpp"
-#include "gm_commands/tempname.cpp"
-#include "gm_commands/texture.cpp"
-#include "gm_commands/time.cpp"
-#include "gm_commands/timers.cpp"
-#include "gm_commands/timezone.cpp"
-#include "gm_commands/title.cpp"
-#include "gm_commands/titlesuffix.cpp"
 #include "gm_commands/traindisc.cpp"
-#include "gm_commands/trapinfo.cpp"
 #include "gm_commands/tune.cpp"
 #include "gm_commands/undye.cpp"
-#include "gm_commands/unfreeze.cpp"
 #include "gm_commands/unmemspell.cpp"
 #include "gm_commands/unmemspells.cpp"
 #include "gm_commands/unscribespell.cpp"
 #include "gm_commands/unscribespells.cpp"
-#include "gm_commands/updatechecksum.cpp"
 #include "gm_commands/untraindisc.cpp"
 #include "gm_commands/untraindiscs.cpp"
-#include "gm_commands/uptime.cpp"
-#include "gm_commands/version.cpp"
-#include "gm_commands/viewcurrencies.cpp"
-#include "gm_commands/viewnpctype.cpp"
-#include "gm_commands/viewpetition.cpp"
-#include "gm_commands/viewrecipe.cpp"
-#include "gm_commands/viewzoneloot.cpp"
 #include "gm_commands/wc.cpp"
-#include "gm_commands/weather.cpp"
-#include "gm_commands/who.cpp"
 #include "gm_commands/worldshutdown.cpp"
 #include "gm_commands/worldwide.cpp"
 #include "gm_commands/wp.cpp"
 #include "gm_commands/wpadd.cpp"
-#include "gm_commands/wpinfo.cpp"
-#include "gm_commands/xtargets.cpp"
-#include "gm_commands/zclip.cpp"
-#include "gm_commands/zcolor.cpp"
-#include "gm_commands/zheader.cpp"
 #include "gm_commands/zone.cpp"
 #include "gm_commands/zonebootup.cpp"
-#include "gm_commands/zonelock.cpp"
 #include "gm_commands/zoneshutdown.cpp"
-#include "gm_commands/zonestatus.cpp"
 #include "gm_commands/zone_instance.cpp"
 #include "gm_commands/zopp.cpp"
-#include "gm_commands/zsafecoords.cpp"
 #include "gm_commands/zsave.cpp"
-#include "gm_commands/zsky.cpp"
-#include "gm_commands/zstats.cpp"
-#include "gm_commands/zunderworld.cpp"
@@ -26,19 +26,18 @@ void command_deinit(void);
 int command_add(std::string command_name, std::string description, uint8 admin, CmdFuncPtr function);
 int command_notavail(Client *c, std::string message, bool ignore_status);
 int command_realdispatch(Client *c, std::string message, bool ignore_status);
-uint8 GetCommandStatus(Client *c, std::string command_name);
+uint8 GetCommandStatus(std::string command_name);
 void ListModifyNPCStatMap(Client *c);
 std::map<std::string, std::string> GetModifyNPCStatMap();
 std::string GetModifyNPCStatDescription(std::string stat);
 void SendNPCEditSubCommands(Client *c);
 void SendRuleSubCommands(Client *c);
 void SendGuildSubCommands(Client *c);
-void SendPeekInvSubCommands(Client *c);
+void SendShowInventorySubCommands(Client *c);

 // Commands
 void command_acceptrules(Client *c, const Seperator *sep);
 void command_advnpcspawn(Client *c, const Seperator *sep);
-void command_aggro(Client *c, const Seperator *sep);
 void command_aggrozone(Client *c, const Seperator *sep);
 void command_ai(Client *c, const Seperator *sep);
 void command_appearance(Client *c, const Seperator *sep);
@@ -47,20 +46,16 @@ void command_apply_shared_memory(Client *c, const Seperator *sep);
 void command_attack(Client *c, const Seperator *sep);
 void command_augmentitem(Client *c, const Seperator *sep);
 void command_ban(Client *c, const Seperator *sep);
-void command_bind(Client *c, const Seperator *sep);
 void command_bugs(Client *c, const Seperator *sep);
 void command_camerashake(Client *c, const Seperator *sep);
 void command_castspell(Client *c, const Seperator *sep);
 void command_chat(Client *c, const Seperator *sep);
-void command_checklos(Client *c, const Seperator *sep);
 void command_copycharacter(Client *c, const Seperator *sep);
 void command_corpse(Client *c, const Seperator *sep);
 void command_corpsefix(Client *c, const Seperator *sep);
 void command_countitem(Client *c, const Seperator *sep);
-void command_cvs(Client *c, const Seperator *sep);
 void command_damage(Client *c, const Seperator *sep);
 void command_databuckets(Client *c, const Seperator *sep);
-void command_date(Client *c, const Seperator *sep);
 void command_dbspawn2(Client *c, const Seperator *sep);
 void command_delacct(Client *c, const Seperator *sep);
 void command_delpetition(Client *c, const Seperator *sep);
@@ -70,103 +65,55 @@ void command_devtools(Client *c, const Seperator *sep);
 void command_disablerecipe(Client *c, const Seperator *sep);
 void command_disarmtrap(Client *c, const Seperator *sep);
 void command_door(Client *c, const Seperator *sep);
-void command_distance(Client *c, const Seperator *sep);
 void command_doanim(Client *c, const Seperator *sep);
 void command_dye(Client *c, const Seperator *sep);
 void command_dz(Client *c, const Seperator *sep);
 void command_dzkickplayers(Client *c, const Seperator *sep);
 void command_editmassrespawn(Client *c, const Seperator *sep);
 void command_emote(Client *c, const Seperator *sep);
-void command_emotesearch(Client *c, const Seperator *sep);
-void command_emoteview(Client *c, const Seperator *sep);
 void command_emptyinventory(Client *c, const Seperator *sep);
 void command_enablerecipe(Client *c, const Seperator *sep);
-void command_endurance(Client *c, const Seperator *sep);
 void command_entityvariable(Client *c, const Seperator *sep);
 void command_exptoggle(Client *c, const Seperator *sep);
 void command_faction(Client *c, const Seperator *sep);
 void command_faction_association(Client *c, const Seperator *sep);
 void command_feature(Client *c, const Seperator *sep);
-void command_findaa(Client *c, const Seperator *sep);
-void command_findaliases(Client *c, const Seperator *sep);
-void command_findcharacter(Client *c, const Seperator *sep);
-void command_findclass(Client *c, const Seperator *sep);
-void command_findcurrency(Client *c, const Seperator *sep);
-void command_findfaction(Client *c, const Seperator *sep);
-void command_findnpctype(Client *c, const Seperator *sep);
-void command_findrace(Client *c, const Seperator *sep);
-void command_findrecipe(Client *c, const Seperator *sep);
-void command_findskill(Client *c, const Seperator *sep);
-void command_findspell(Client *c, const Seperator *sep);
-void command_findtask(Client *c, const Seperator *sep);
-void command_findzone(Client *c, const Seperator *sep);
+void command_find(Client *c, const Seperator *sep);
 void command_fixmob(Client *c, const Seperator *sep);
-void command_flag(Client *c, const Seperator *sep);
 void command_flagedit(Client *c, const Seperator *sep);
-void command_flags(Client *c, const Seperator *sep);
-void command_flymode(Client *c, const Seperator *sep);
-void command_fov(Client *c, const Seperator *sep);
-void command_freeze(Client *c, const Seperator *sep);
-void command_gassign(Client *c, const Seperator *sep);
 void command_gearup(Client *c, const Seperator *sep);
-void command_gender(Client *c, const Seperator *sep);
-void command_getplayerburiedcorpsecount(Client *c, const Seperator *sep);
-void command_getvariable(Client *c, const Seperator *sep);
-void command_ginfo(Client *c, const Seperator *sep);
 void command_giveitem(Client *c, const Seperator *sep);
 void command_givemoney(Client *c, const Seperator *sep);
-void command_globalview(Client *c, const Seperator *sep);
-void command_gm(Client *c, const Seperator *sep);
-void command_gmspeed(Client *c, const Seperator *sep);
 void command_gmzone(Client *c, const Seperator *sep);
-void command_godmode(Client* c, const Seperator *sep);
 void command_goto(Client *c, const Seperator *sep);
 void command_grid(Client *c, const Seperator *sep);
 void command_guild(Client *c, const Seperator *sep);
-void command_haste(Client *c, const Seperator *sep);
-void command_hatelist(Client *c, const Seperator *sep);
-void command_heal(Client *c, const Seperator *sep);
 void command_help(Client *c, const Seperator *sep);
-void command_heromodel(Client *c, const Seperator *sep);
-void command_hideme(Client *c, const Seperator *sep);
 void command_hotfix(Client *c, const Seperator *sep);
 void command_hp(Client *c, const Seperator *sep);
-void command_incstat(Client *c, const Seperator *sep);
 void command_instance(Client *c, const Seperator *sep);
 void command_interrogateinv(Client *c, const Seperator *sep);
 void command_interrupt(Client *c, const Seperator *sep);
 void command_invsnapshot(Client *c, const Seperator *sep);
-void command_invul(Client *c, const Seperator *sep);
 void command_ipban(Client *c, const Seperator *sep);
-void command_iplookup(Client *c, const Seperator *sep);
-void command_itemsearch(Client *c, const Seperator *sep);
 void command_kick(Client *c, const Seperator *sep);
 void command_killallnpcs(Client *c, const Seperator *sep);
 void command_kill(Client *c, const Seperator *sep);
-void command_lastname(Client *c, const Seperator *sep);
 void command_level(Client *c, const Seperator *sep);
 void command_list(Client *c, const Seperator *sep);
-void command_listpetition(Client *c, const Seperator *sep);
 void command_lootsim(Client *c, const Seperator *sep);
 void command_load_shared_memory(Client *c, const Seperator *sep);
 void command_loc(Client *c, const Seperator *sep);
 void command_logs(Client *c, const Seperator *sep);
 void command_makepet(Client *c, const Seperator *sep);
-void command_mana(Client *c, const Seperator *sep);
-void command_max_all_skills(Client *c, const Seperator *sep);
 void command_memspell(Client *c, const Seperator *sep);
-void command_merchantcloseshop(Client *c, const Seperator *sep);
-void command_merchantopenshop(Client *c, const Seperator *sep);
+void command_merchantshop(Client *c, const Seperator *sep);
 void command_modifynpcstat(Client *c, const Seperator *sep);
-void command_motd(Client *c, const Seperator *sep);
 void command_movechar(Client *c, const Seperator *sep);
 void command_movement(Client *c, const Seperator *sep);
 void command_myskills(Client *c, const Seperator *sep);
 void command_mysql(Client *c, const Seperator *sep);
 void command_mystats(Client *c, const Seperator *sep);
-void command_name(Client *c, const Seperator *sep);
-void command_netstats(Client *c, const Seperator *sep);
-void command_network(Client *c, const Seperator *sep);
 void command_npccast(Client *c, const Seperator *sep);
 void command_npcedit(Client *c, const Seperator *sep);
 void command_npceditmass(Client *c, const Seperator *sep);
@@ -175,36 +122,19 @@ void command_npcloot(Client *c, const Seperator *sep);
 void command_npcsay(Client *c, const Seperator *sep);
 void command_npcshout(Client *c, const Seperator *sep);
 void command_npcspawn(Client *c, const Seperator *sep);
-void command_npcstats(Client *c, const Seperator *sep);
 void command_npctypespawn(Client *c, const Seperator *sep);
 void command_nudge(Client *c, const Seperator *sep);
 void command_nukebuffs(Client *c, const Seperator *sep);
 void command_nukeitem(Client *c, const Seperator *sep);
 void command_object(Client *c, const Seperator *sep);
 void command_oocmute(Client *c, const Seperator *sep);
-
-#ifdef PACKET_PROFILER
-void command_packetprofile(Client *c, const Seperator *sep);
-#endif
-
 void command_path(Client *c, const Seperator *sep);
-void command_peekinv(Client *c, const Seperator *sep);
 void command_peqzone(Client *c, const Seperator *sep);
-void command_peqzone_flags(Client *c, const Seperator *sep);
-void command_permaclass(Client *c, const Seperator *sep);
-void command_permagender(Client *c, const Seperator *sep);
-void command_permarace(Client *c, const Seperator *sep);
 void command_petitems(Client *c, const Seperator *sep);
-void command_petitioninfo(Client *c, const Seperator *sep);
 void command_picklock(Client *c, const Seperator *sep);
 void command_profanity(Client *c, const Seperator *sep);
-
-void command_proximity(Client *c, const Seperator *sep);
 void command_push(Client *c, const Seperator *sep);
-void command_pvp(Client *c, const Seperator *sep);
-void command_qglobal(Client *c, const Seperator *sep);
-void command_questerrors(Client *c, const Seperator *sep);
-void command_race(Client *c, const Seperator *sep);
+void command_pvp(Client *c, const Seperator *sep);;
 void command_raidloot(Client* c, const Seperator* sep);
 void command_randomfeatures(Client *c, const Seperator *sep);
 void command_refreshgroup(Client *c, const Seperator *sep);
@@ -218,50 +148,18 @@ void command_revoke(Client *c, const Seperator *sep);
 void command_roambox(Client *c, const Seperator *sep);
 void command_rules(Client *c, const Seperator *sep);
 void command_save(Client *c, const Seperator *sep);
-void command_serverlock(Client *c, const Seperator *sep);
 void command_scale(Client *c, const Seperator *sep);
 void command_scribespell(Client *c, const Seperator *sep);
 void command_scribespells(Client *c, const Seperator *sep);
 void command_sendzonespawns(Client *c, const Seperator *sep);
 void command_sensetrap(Client *c, const Seperator *sep);
-void command_serverinfo(Client *c, const Seperator *sep);
 void command_serverrules(Client *c, const Seperator *sep);
-void command_set_adventure_points(Client *c, const Seperator *sep);
-void command_setaapts(Client *c, const Seperator *sep);
-void command_setaaxp(Client *c, const Seperator *sep);
-void command_setaltcurrency(Client *c, const Seperator *sep);
-void command_setanim(Client *c, const Seperator *sep);
-void command_setanon(Client *c, const Seperator *sep);
-void command_setcrystals(Client *c, const Seperator *sep);
-void command_setendurance(Client *c, const Seperator *sep);
-void command_setfaction(Client *c, const Seperator *sep);
-void command_sethp(Client *c, const Seperator *sep);
-void command_setlanguage(Client *c, const Seperator *sep);
-void command_setlsinfo(Client *c, const Seperator *sep);
-void command_setmana(Client *c, const Seperator *sep);
-void command_setpass(Client *c, const Seperator *sep);
-void command_setpvppoints(Client *c, const Seperator *sep);
-void command_setskill(Client *c, const Seperator *sep);
-void command_setskillall(Client *c, const Seperator *sep);
-void command_setstartzone(Client *c, const Seperator *sep);
-void command_setstat(Client *c, const Seperator *sep);
-void command_setxp(Client *c, const Seperator *sep);
-void command_showbonusstats(Client *c, const Seperator *sep);
-void command_showbuffs(Client *c, const Seperator *sep);
-void command_shownumhits(Client *c, const Seperator *sep);
-void command_shownpcgloballoot(Client *c, const Seperator *sep);
-void command_showpetspell(Client *c, const Seperator *sep);
-void command_showskills(Client *c, const Seperator *sep);
-void command_showspellslist(Client *c, const Seperator *sep);
-void command_showstats(Client *c, const Seperator *sep);
-void command_showzonegloballoot(Client *c, const Seperator *sep);
-void command_showzonepoints(Client *c, const Seperator *sep);
+void command_set(Client *c, const Seperator *sep);
+void command_show(Client *c, const Seperator *sep);
 void command_shutdown(Client *c, const Seperator *sep);
 void command_spawn(Client *c, const Seperator *sep);
 void command_spawneditmass(Client *c, const Seperator *sep);
 void command_spawnfix(Client *c, const Seperator *sep);
-void command_spawnstatus(Client *c, const Seperator *sep);
-void command_spellinfo(Client *c, const Seperator *sep);
 void command_stun(Client *c, const Seperator *sep);
 void command_summon(Client *c, const Seperator *sep);
 void command_summonburiedplayercorpse(Client *c, const Seperator *sep);
@@ -269,58 +167,28 @@ void command_summonitem(Client *c, const Seperator *sep);
 void command_suspend(Client *c, const Seperator *sep);
 void command_suspendmulti(Client *c, const Seperator *sep);
 void command_task(Client *c, const Seperator *sep);
-void command_tempname(Client *c, const Seperator *sep);
 void command_petname(Client *c, const Seperator *sep);
-void command_texture(Client *c, const Seperator *sep);
-void command_time(Client *c, const Seperator *sep);
-void command_timers(Client *c, const Seperator *sep);
-void command_timezone(Client *c, const Seperator *sep);
-void command_title(Client *c, const Seperator *sep);
-void command_titlesuffix(Client *c, const Seperator *sep);
 void command_traindisc(Client *c, const Seperator *sep);
-void command_trapinfo(Client *c, const Seperator *sep);
 void command_tune(Client *c, const Seperator *sep);
 void command_undye(Client *c, const Seperator *sep);
-void command_unfreeze(Client *c, const Seperator *sep);
-void command_unlock(Client *c, const Seperator *sep);
 void command_unmemspell(Client *c, const Seperator *sep);
 void command_unmemspells(Client *c, const Seperator *sep);
 void command_unscribespell(Client *c, const Seperator *sep);
 void command_unscribespells(Client *c, const Seperator *sep);
 void command_untraindisc(Client *c, const Seperator *sep);
 void command_untraindiscs(Client *c, const Seperator *sep);
-void command_updatechecksum(Client* c, const Seperator* sep);
-void command_uptime(Client *c, const Seperator *sep);
-void command_version(Client *c, const Seperator *sep);
-void command_viewcurrencies(Client *c, const Seperator *sep);
-void command_viewnpctype(Client *c, const Seperator *sep);
-void command_viewpetition(Client *c, const Seperator *sep);
-void command_viewrecipe(Client *c, const Seperator *sep);
-void command_viewzoneloot(Client *c, const Seperator *sep);
 void command_wc(Client *c, const Seperator *sep);
-void command_weather(Client *c, const Seperator *sep);
-void command_who(Client *c, const Seperator *sep);
 void command_worldshutdown(Client *c, const Seperator *sep);
 void command_wp(Client *c, const Seperator *sep);
 void command_wpadd(Client *c, const Seperator *sep);
-void command_wpinfo(Client *c, const Seperator *sep);
 void command_worldwide(Client *c, const Seperator *sep);
-void command_xtargets(Client *c, const Seperator *sep);
-void command_zclip(Client *c, const Seperator *sep);
-void command_zcolor(Client *c, const Seperator *sep);
-void command_zheader(Client *c, const Seperator *sep);
 void command_zone(Client *c, const Seperator *sep);
 void command_zone_instance(Client *c, const Seperator *sep);
 void command_zonebootup(Client *c, const Seperator *sep);
-void command_zonelock(Client *c, const Seperator *sep);
 void command_zoneshutdown(Client *c, const Seperator *sep);
-void command_zonestatus(Client *c, const Seperator *sep);
 void command_zopp(Client *c, const Seperator *sep);
 void command_zsafecoords(Client *c, const Seperator *sep);
 void command_zsave(Client *c, const Seperator *sep);
-void command_zsky(Client *c, const Seperator *sep);
-void command_zstats(Client *c, const Seperator *sep);
-void command_zunderworld(Client *c, const Seperator *sep);

 #include "bot.h"
 void command_bot(Client*c, const Seperator *sep);
@@ -1207,7 +1207,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
 			client->Message(
 				Chat::Yellow,
 				fmt::format(
-					"This corpse Contains {}.",
+					"This corpse contains {}.",
 					Strings::Money(
 						GetPlatinum(),
 						GetGold(),
@@ -1217,7 +1217,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
 				).c_str()
 			);
 		} else {
-			client->Message(Chat::Yellow, "This corpse Contains no money.");
+			client->Message(Chat::Yellow, "This corpse contains no money.");
 		}

 		auto outapp = new EQApplicationPacket(OP_MoneyOnCorpse, sizeof(moneyOnCorpseStruct));
@@ -1,205 +1,665 @@
 #include "data_bucket.h"
+#include "entity.h"
 #include "zonedb.h"
+#include "mob.h"
+#include "worldserver.h"
 #include <ctime>
 #include <cctype>

-/**
- * Persists data via bucket_name as key
- * @param bucket_key
- * @param bucket_value
- * @param expires_time
- */
-void DataBucket::SetData(const std::string& bucket_key, const std::string& bucket_value, std::string expires_time) {
-	uint64 bucket_id = DataBucket::DoesBucketExist(bucket_key);
+extern WorldServer worldserver;

-	std::string query;
-	long long expires_time_unix = 0;
+std::vector<DataBucketCacheEntry> g_data_bucket_cache = {};

-	if (!expires_time.empty()) {
-		if (isalpha(expires_time[0]) || isalpha(expires_time[expires_time.length() - 1])) {
-			expires_time_unix = (long long) std::time(nullptr) + Strings::TimeToSeconds(expires_time);
-		} else {
-			expires_time_unix = (long long) std::time(nullptr) + Strings::ToInt(expires_time);
+void DataBucket::SetData(const std::string &bucket_key, const std::string &bucket_value, std::string expires_time)
+{
+	auto k = DataBucketKey{
+		.key = bucket_key,
+		.value = bucket_value,
+		.expires = expires_time,
+		.character_id = 0,
+		.npc_id = 0,
+		.bot_id = 0
+	};
+
+	DataBucket::SetData(k);
+}
+
+void DataBucket::SetData(const DataBucketKey &k)
+{
+	auto b = DataBucketsRepository::NewEntity();
+	auto r = GetData(k, true);
+	// if we have an entry, use it
+	if (r.id > 0) {
+		b = r;
+	}
+
+	// add scoping to bucket
+	if (k.character_id > 0) {
+		b.character_id = k.character_id;
+	}
+	else if (k.npc_id > 0) {
+		b.npc_id = k.npc_id;
+	}
+	else if (k.bot_id > 0) {
+		b.bot_id = k.bot_id;
+	}
+
+	const uint64 bucket_id         = b.id;
+	int64        expires_time_unix = 0;
+
+	if (!k.expires.empty()) {
+		expires_time_unix = static_cast<int64>(std::time(nullptr)) + Strings::ToInt(k.expires);
+		if (isalpha(k.expires[0]) || isalpha(k.expires[k.expires.length() - 1])) {
+			expires_time_unix = static_cast<int64>(std::time(nullptr)) + Strings::TimeToSeconds(k.expires);
 		}
 	}

-	if (bucket_id > 0) {
-		std::string update_expired_time;
-		if (expires_time_unix > 0) {
-			update_expired_time = StringFormat(", `expires` = %lld ", expires_time_unix);
+	b.expires = expires_time_unix;
+	b.value   = k.value;
+
+	if (bucket_id) {
+		// loop cache and update cache value and timestamp
+		for (auto &ce: g_data_bucket_cache) {
+			if (CheckBucketMatch(ce.e, k)) {
+				ce.e             = b;
+				ce.updated_time  = GetCurrentTimeUNIX();
+				ce.update_action = DataBucketCacheUpdateAction::Upsert;
+				SendDataBucketCacheUpdate(ce);
+				break;
+			}
 		}

-		query = StringFormat(
-				"UPDATE `data_buckets` SET `value` = '%s' %s WHERE `id` = %i",
-				Strings::Escape(bucket_value).c_str(),
-				Strings::Escape(update_expired_time).c_str(),
-				bucket_id
-		);
+		DataBucketsRepository::UpdateOne(database, b);
 	}
 	else {
-		query = StringFormat(
-				"INSERT INTO `data_buckets` (`key`, `value`, `expires`) VALUES ('%s', '%s', '%lld')",
-				Strings::Escape(bucket_key).c_str(),
-				Strings::Escape(bucket_value).c_str(),
-				expires_time_unix
-		);
-	}
+		b.key_ = k.key;
+		b = DataBucketsRepository::InsertOne(database, b);
+		if (!ExistsInCache(b)) {
+			// add data bucket and timestamp to cache
+			auto ce = DataBucketCacheEntry{
+				.e = b,
+				.updated_time = DataBucket::GetCurrentTimeUNIX(),
+				.update_action = DataBucketCacheUpdateAction::Upsert
+			};

-	database.QueryDatabase(query);
+			g_data_bucket_cache.emplace_back(ce);
+
+			SendDataBucketCacheUpdate(ce);
+
+			DeleteFromMissesCache(b);
+		}
+	}
 }

-/**
- * Retrieves data via bucket_name as key
- * @param bucket_key
- * @return
- */
-std::string DataBucket::GetData(const std::string& bucket_key) {
-	std::string query = StringFormat(
-			"SELECT `value` from `data_buckets` WHERE `key` = '%s' AND (`expires` > %lld OR `expires` = 0)  LIMIT 1",
-			bucket_key.c_str(),
-			(long long) std::time(nullptr)
-	);
-
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
-		return std::string();
-	}
-
-	if (results.RowCount() != 1)
-		return std::string();
-
-	auto row = results.begin();
-
-	return std::string(row[0]);
-}
-
-/**
- * Retrieves data expires time via bucket_name as key
- * @param bucket_key
- * @return
- */
-std::string DataBucket::GetDataExpires(const std::string& bucket_key) {
-	std::string query = StringFormat(
-			"SELECT `expires` from `data_buckets` WHERE `key` = '%s' AND (`expires` > %lld OR `expires` = 0)  LIMIT 1",
-			bucket_key.c_str(),
-			(long long) std::time(nullptr)
-	);
-
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
-		return std::string();
-	}
-
-	if (results.RowCount() != 1)
-		return std::string();
-
-	auto row = results.begin();
-
-	return std::string(row[0]);
-}
-
-std::string DataBucket::GetDataRemaining(const std::string& bucket_key) {
-	if (DataBucket::GetDataExpires(bucket_key).empty()) {
-		return "0";
-	}
-	std::string query = fmt::format(
-		"SELECT (`expires` - UNIX_TIMESTAMP()) AS `remaining` from `data_buckets` WHERE `key` = '{}' AND (`expires` > {} OR `expires` = 0) LIMIT 1",
-		bucket_key.c_str(),
-		(long long) std::time(nullptr)
-	);
-
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
-		return std::string();
-	}
-
-	if (results.RowCount() != 1)
-		return std::string();
-
-	auto row = results.begin();
-
-	return std::string(row[0]);
-}
-
-/**
- * Checks for bucket existence by bucket_name key
- * @param bucket_key
- * @return
- */
-uint64 DataBucket::DoesBucketExist(const std::string& bucket_key) {
-	std::string query = StringFormat(
-			"SELECT `id` from `data_buckets` WHERE `key` = '%s' AND (`expires` > %lld OR `expires` = 0) LIMIT 1",
-			Strings::Escape(bucket_key).c_str(),
-			(long long) std::time(nullptr)
-	);
-
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
-		return 0;
-	}
-
-	auto row = results.begin();
-	if (results.RowCount() != 1)
-		return 0;
-
-	return Strings::ToUnsignedBigInt(row[0]);
-}
-
-/**
- * Deletes data bucket by key
- * @param bucket_key
- * @return
- */
-bool DataBucket::DeleteData(const std::string& bucket_key) {
-	std::string query = StringFormat(
-			"DELETE FROM `data_buckets` WHERE `key` = '%s'",
-			Strings::Escape(bucket_key).c_str()
-	);
-
-	auto results = database.QueryDatabase(query);
-
-	return results.Success();
-}
-
-bool DataBucket::GetDataBuckets(Mob* mob)
+std::string DataBucket::GetData(const std::string &bucket_key)
 {
-	auto l = BaseDataBucketsRepository::GetWhere(
+	DataBucketKey k = {};
+	k.key = bucket_key;
+	return GetData(k).value;
+}
+
+// GetData fetches bucket data from the database or cache if it exists
+// if the bucket doesn't exist, it will be added to the cache as a miss
+// if ignore_misses_cache is true, the bucket will not be added to the cache as a miss
+// the only place we should be ignoring the misses cache is on the initial read during SetData
+DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k, bool ignore_misses_cache)
+{
+	LogDataBuckets(
+		"Getting bucket key [{}] bot_id [{}] character_id [{}] npc_id [{}]",
+		k.key,
+		k.bot_id,
+		k.character_id,
+		k.npc_id
+	);
+
+	for (const auto &ce: g_data_bucket_cache) {
+		if (CheckBucketMatch(ce.e, k)) {
+			if (ce.e.expires > 0 && ce.e.expires < std::time(nullptr)) {
+				LogDataBuckets("Attempted to read expired key [{}] removing from cache", ce.e.key_);
+				DeleteData(k);
+				return DataBucketsRepository::NewEntity();
+			}
+
+			// this is a bucket miss, return empty entity
+			// we still cache bucket misses, so we don't have to hit the database
+			if (ce.e.id == 0) {
+				return DataBucketsRepository::NewEntity();
+			}
+
+			LogDataBuckets("Returning key [{}] value [{}] from cache", ce.e.key_, ce.e.value);
+			return ce.e;
+		}
+	}
+
+	auto r = DataBucketsRepository::GetWhere(
 		database,
 		fmt::format(
-			"`key` LIKE '{}-%'",
-			Strings::Escape(mob->GetBucketKey())
+			"{} `key` = '{}' LIMIT 1",
+			DataBucket::GetScopedDbFilters(k),
+			k.key
 		)
 	);

-	if (l.empty()) {
+	if (r.empty()) {
+
+		// if we're ignoring the misses cache, don't add to the cache
+		// the only place this is ignored is during the initial read of SetData
+		if (!ignore_misses_cache) {
+			size_t size_before = g_data_bucket_cache.size();
+
+			// cache bucket misses, so we don't have to hit the database
+			// when scripts try to read a bucket that doesn't exist
+			g_data_bucket_cache.emplace_back(
+				DataBucketCacheEntry{
+					.e = DataBucketsRepository::DataBuckets{
+						.id = 0,
+						.key_ = k.key,
+						.value = "",
+						.expires = 0,
+						.character_id = k.character_id,
+						.npc_id = k.npc_id,
+						.bot_id = k.bot_id
+					},
+					.updated_time = DataBucket::GetCurrentTimeUNIX()
+				}
+			);
+
+			LogDataBuckets(
+				"Key [{}] not found in database, adding to cache as a miss character_id [{}] npc_id [{}] bot_id [{}] cache size before [{}] after [{}]",
+				k.key,
+				k.character_id,
+				k.npc_id,
+				k.bot_id,
+				size_before,
+				g_data_bucket_cache.size()
+			);
+		}
+
+		return {};
+	}
+
+	// if the entry has expired, delete it
+	if (r[0].expires > 0 && r[0].expires < (long long) std::time(nullptr)) {
+		DeleteData(k);
+		return {};
+	}
+
+	bool      has_cache = false;
+	for (auto &ce: g_data_bucket_cache) {
+		if (ce.e.id == r[0].id) {
+			has_cache = true;
+			break;
+		}
+	}
+
+	if (!has_cache) {
+		// add data bucket and timestamp to cache
+		g_data_bucket_cache.emplace_back(
+			DataBucketCacheEntry{
+				.e = r[0],
+				.updated_time = DataBucket::GetCurrentTimeUNIX()
+			}
+		);
+	}
+
+	return r[0];
+}
+
+std::string DataBucket::GetDataExpires(const std::string &bucket_key)
+{
+	DataBucketKey k = {};
+	k.key = bucket_key;
+
+	return GetDataExpires(k);
+}
+
+std::string DataBucket::GetDataRemaining(const std::string &bucket_key)
+{
+	DataBucketKey k = {};
+	k.key = bucket_key;
+	return GetDataRemaining(k);
+}
+
+bool DataBucket::DeleteData(const std::string &bucket_key)
+{
+	DataBucketKey k = {};
+	k.key = bucket_key;
+	return DeleteData(k);
+}
+
+// GetDataBuckets bulk loads all data buckets for a mob
+bool DataBucket::GetDataBuckets(Mob *mob)
+{
+	DataBucketLoadType::Type t;
+	const uint32             id = mob->GetMobTypeIdentifier();
+
+	if (!id) {
 		return false;
 	}

-	mob->m_data_bucket_cache.clear();
-
-	DataBucketCache d;
-
-	for (const auto& e : l) {
-		d.bucket_id = e.id;
-		d.bucket_key = e.key_;
-		d.bucket_value = e.value;
-		d.bucket_expires = e.expires;
-
-		mob->m_data_bucket_cache.emplace_back(d);
+	if (mob->IsBot()) {
+		t = DataBucketLoadType::Bot;
 	}
+	else if (mob->IsClient()) {
+		t = DataBucketLoadType::Client;
+	}
+	else if (mob->IsNPC()) {
+		t = DataBucketLoadType::NPC;
+	}
+
+	BulkLoadEntities(t, {id});

 	return true;
 }

-std::string DataBucket::CheckBucketKey(const Mob* mob, std::string_view full_name)
+bool DataBucket::DeleteData(const DataBucketKey &k)
 {
-	std::string bucket_value;
-	for (const auto &d : mob->m_data_bucket_cache) {
-		if (d.bucket_key == full_name) {
-			bucket_value = d.bucket_value;
+	size_t size_before = g_data_bucket_cache.size();
+
+	// delete from cache where contents match
+	g_data_bucket_cache.erase(
+		std::remove_if(
+			g_data_bucket_cache.begin(),
+			g_data_bucket_cache.end(),
+			[&](DataBucketCacheEntry &ce) {
+				bool match = CheckBucketMatch(ce.e, k);
+				if (match) {
+					ce.update_action = DataBucketCacheUpdateAction::Delete;
+					SendDataBucketCacheUpdate(ce);
+				}
+
+				return match;
+			}
+		),
+		g_data_bucket_cache.end()
+	);
+
+	LogDataBuckets(
+		"Deleting bucket key [{}] bot_id [{}] character_id [{}] npc_id [{}] cache size before [{}] after [{}]",
+		k.key,
+		k.bot_id,
+		k.character_id,
+		k.npc_id,
+		size_before,
+		g_data_bucket_cache.size()
+	);
+
+	return DataBucketsRepository::DeleteWhere(
+		database,
+		fmt::format(
+			"{} `key` = '{}'",
+			DataBucket::GetScopedDbFilters(k),
+			k.key
+		)
+	);
+}
+
+std::string DataBucket::GetDataExpires(const DataBucketKey &k)
+{
+	LogDataBuckets(
+		"Getting bucket expiration key [{}] bot_id [{}] character_id [{}] npc_id [{}]",
+		k.key,
+		k.bot_id,
+		k.character_id,
+		k.npc_id
+	);
+
+	auto r = GetData(k);
+	if (r.id == 0) {
+		return {};
+	}
+
+	return std::to_string(r.expires);
+}
+
+std::string DataBucket::GetDataRemaining(const DataBucketKey &k)
+{
+	LogDataBuckets(
+		"Getting bucket remaining key [{}] bot_id [{}] character_id [{}] npc_id [{}]",
+		k.key,
+		k.bot_id,
+		k.character_id,
+		k.npc_id
+	);
+
+	auto r = GetData(k);
+	if (r.id == 0) {
+		return "0";
+	}
+
+	return fmt::format("{}", r.expires - (long long) std::time(nullptr));
+}
+
+std::string DataBucket::GetScopedDbFilters(const DataBucketKey &k)
+{
+	std::vector<std::string> query = {};
+	if (k.character_id > 0) {
+		query.emplace_back(fmt::format("character_id = {}", k.character_id));
+	}
+	else {
+		query.emplace_back("character_id = 0");
+	}
+
+	if (k.npc_id > 0) {
+		query.emplace_back(fmt::format("npc_id = {}", k.npc_id));
+	}
+	else {
+		query.emplace_back("npc_id = 0");
+	}
+
+	if (k.bot_id > 0) {
+		query.emplace_back(fmt::format("bot_id = {}", k.bot_id));
+	}
+	else {
+		query.emplace_back("bot_id = 0");
+	}
+
+	return fmt::format(
+		"{} {}",
+		Strings::Join(query, " AND "),
+		!query.empty() ? "AND" : ""
+	);
+}
+
+bool DataBucket::CheckBucketMatch(const DataBucketsRepository::DataBuckets &dbe, const DataBucketKey &k)
+{
+	return (
+		dbe.key_ == k.key &&
+		dbe.bot_id == k.bot_id &&
+		dbe.character_id == k.character_id &&
+		dbe.npc_id == k.npc_id
+	);
+}
+
+void DataBucket::BulkLoadEntities(DataBucketLoadType::Type t, std::vector<uint32> ids)
+{
+	if (ids.empty()) {
+		return;
+	}
+
+	if (ids.size() == 1) {
+		bool            has_cache = false;
+		for (const auto &ce: g_data_bucket_cache) {
+			if (t == DataBucketLoadType::Bot) {
+				has_cache = ce.e.bot_id == ids[0];
+			}
+			else if (t == DataBucketLoadType::Client) {
+				has_cache = ce.e.character_id == ids[0];
+			}
+			else if (t == DataBucketLoadType::NPC) {
+				has_cache = ce.e.npc_id == ids[0];
+			}
+		}
+
+		if (has_cache) {
+			LogDataBucketsDetail("LoadType [{}] ID [{}] has cache", DataBucketLoadType::Name[t], ids[0]);
+			return;
+		}
+	}
+
+	std::string column;
+
+	switch (t) {
+		case DataBucketLoadType::Bot:
+			column = "bot_id";
+			break;
+		case DataBucketLoadType::Client:
+			column = "character_id";
+			break;
+		case DataBucketLoadType::NPC:
+			column = "npc_id";
+			break;
+		default:
+			LogError("Incorrect LoadType [{}]", t);
+			break;
+	}
+
+	const auto &l = DataBucketsRepository::GetWhere(
+		database,
+		fmt::format(
+			"{} IN ({}) AND (`expires` > {} OR `expires` = 0)",
+			column,
+			Strings::Join(ids, ", "),
+			(long long) std::time(nullptr)
+		)
+	);
+
+	if (l.empty()) {
+		return;
+	}
+
+	size_t size_before = g_data_bucket_cache.size();
+
+	LogDataBucketsDetail("cache size before [{}] l size [{}]", g_data_bucket_cache.size(), l.size());
+
+	uint32 added_count = 0;
+
+	for (const auto &e: l) {
+		if (!ExistsInCache(e)) {
+			added_count++;
+		}
+	}
+
+	g_data_bucket_cache.reserve(g_data_bucket_cache.size() + added_count);
+
+	for (const auto &e: l) {
+		if (!ExistsInCache(e)) {
+			LogDataBucketsDetail("bucket id [{}] bucket key [{}] bucket value [{}]", e.id, e.key_, e.value);
+
+			g_data_bucket_cache.emplace_back(
+				DataBucketCacheEntry{
+					.e = e,
+					.updated_time = GetCurrentTimeUNIX()
+				}
+			);
+		}
+	}
+
+	LogDataBucketsDetail("cache size after [{}]", g_data_bucket_cache.size());
+
+	LogDataBuckets(
+		"Bulk Loaded ids [{}] column [{}] new cache size is [{}]",
+		ids.size(),
+		column,
+		g_data_bucket_cache.size()
+	);
+}
+
+void DataBucket::DeleteCachedBuckets(DataBucketLoadType::Type t, uint32 id)
+{
+	size_t size_before = g_data_bucket_cache.size();
+
+	g_data_bucket_cache.erase(
+		std::remove_if(
+			g_data_bucket_cache.begin(),
+			g_data_bucket_cache.end(),
+			[&](DataBucketCacheEntry &ce) {
+				return (
+					(t == DataBucketLoadType::Bot && ce.e.bot_id == id) ||
+					(t == DataBucketLoadType::Client && ce.e.character_id == id) ||
+					(t == DataBucketLoadType::NPC && ce.e.npc_id == id)
+				);
+			}
+		),
+		g_data_bucket_cache.end()
+	);
+
+	LogDataBuckets(
+		"LoadType [{}] id [{}] cache size before [{}] after [{}]",
+		DataBucketLoadType::Name[t],
+		id,
+		size_before,
+		g_data_bucket_cache.size()
+	);
+}
+
+int64_t DataBucket::GetCurrentTimeUNIX()
+{
+	return std::chrono::duration_cast<std::chrono::nanoseconds>(
+		std::chrono::system_clock::now().time_since_epoch()
+	).count();
+}
+
+bool DataBucket::ExistsInCache(const DataBucketsRepository::DataBuckets &e)
+{
+	for (const auto &ce: g_data_bucket_cache) {
+		if (ce.e.id == e.id) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool DataBucket::SendDataBucketCacheUpdate(const DataBucketCacheEntry &e)
+{
+	if (!e.e.id) {
+		return false;
+	}
+
+	EQ::Net::DynamicPacket p;
+	p.PutSerialize(0, e);
+
+	auto pack_size = sizeof(ServerDataBucketCacheUpdate_Struct) + p.Length();
+	auto pack      = new ServerPacket(ServerOP_DataBucketCacheUpdate, static_cast<uint32_t>(pack_size));
+	auto buf       = reinterpret_cast<ServerDataBucketCacheUpdate_Struct *>(pack->pBuffer);
+
+	buf->cereal_size = static_cast<uint32_t>(p.Length());
+
+	memcpy(buf->cereal_data, p.Data(), p.Length());
+
+	worldserver.SendPacket(pack);
+
+	return true;
+}
+
+void DataBucket::HandleWorldMessage(ServerPacket *p)
+{
+	DataBucketCacheEntry         n;
+	auto                         s = (ServerDataBucketCacheUpdate_Struct *) p->pBuffer;
+	EQ::Util::MemoryStreamReader ss(s->cereal_data, s->cereal_size);
+	cereal::BinaryInputArchive   archive(ss);
+	archive(n);
+
+	LogDataBucketsDetail(
+		"Received cache packet for id [{}] key [{}] value [{}] action [{}]",
+		n.e.id,
+		n.e.key_,
+		n.e.value,
+		n.update_action
+	);
+
+	// delete
+	if (n.update_action == DataBucketCacheUpdateAction::Delete) {
+		g_data_bucket_cache.erase(
+			std::remove_if(
+				g_data_bucket_cache.begin(),
+				g_data_bucket_cache.end(),
+				[&](DataBucketCacheEntry &ce) {
+					bool match = n.e.id > 0 && ce.e.id == n.e.id;
+					if (match) {
+						LogDataBuckets(
+							"[delete] cache key [{}] id [{}] cache_size before [{}] after [{}]",
+							ce.e.key_,
+							ce.e.id,
+							g_data_bucket_cache.size(),
+							g_data_bucket_cache.size() - 1
+						);
+					}
+					return match;
+				}
+			),
+			g_data_bucket_cache.end()
+		);
+
+		return;
+	}
+
+	// update
+	bool has_key = false;
+
+	for (auto &ce: g_data_bucket_cache) {
+		int64 time_delta = ce.updated_time - n.updated_time;
+		if (ce.updated_time >= n.updated_time) {
+			LogDataBuckets(
+				"Attempted to update older cache key [{}] rejecting old time [{}] new time [{}] delta [{}] cache_size [{}]",
+				ce.e.key_,
+				ce.updated_time,
+				n.updated_time,
+				time_delta,
+				g_data_bucket_cache.size()
+			);
+			return;
+		}
+
+		// update cache
+		if (ce.e.id == n.e.id) {
+			DeleteFromMissesCache(n.e);
+
+			LogDataBuckets(
+				"[update] cache id [{}] key [{}] value [{}] old time [{}] new time [{}] delta [{}] cache_size [{}]",
+				ce.e.id,
+				ce.e.key_,
+				n.e.value,
+				ce.updated_time,
+				n.updated_time,
+				time_delta,
+				g_data_bucket_cache.size()
+			);
+			ce.e            = n.e;
+			ce.updated_time = n.updated_time;
+			has_key = true;
 			break;
 		}
 	}
-	return bucket_value;
+
+	// create
+	if (!has_key) {
+		DeleteFromMissesCache(n.e);
+
+		size_t size_before = g_data_bucket_cache.size();
+
+		g_data_bucket_cache.emplace_back(
+			DataBucketCacheEntry{
+				.e = n.e,
+				.updated_time = GetCurrentTimeUNIX()
+			}
+		);
+
+		LogDataBuckets(
+			"[create] Adding new cache id [{}] key [{}] value [{}] cache size before [{}] after [{}]",
+			n.e.id,
+			n.e.key_,
+			n.e.value,
+			size_before,
+			g_data_bucket_cache.size()
+		);
+	}
 }

+void DataBucket::DeleteFromMissesCache(DataBucketsRepository::DataBuckets e)
+{
+	// delete from cache where there might have been a written bucket miss to the cache
+	// this is to prevent the cache from growing too large
+	size_t size_before = g_data_bucket_cache.size();
+
+	g_data_bucket_cache.erase(
+		std::remove_if(
+			g_data_bucket_cache.begin(),
+			g_data_bucket_cache.end(),
+			[&](DataBucketCacheEntry &ce) {
+				return ce.e.id == 0 && ce.e.key_ == e.key_ &&
+					   ce.e.character_id == e.character_id &&
+					   ce.e.npc_id == e.npc_id &&
+					   ce.e.bot_id == e.bot_id;
+			}
+		),
+		g_data_bucket_cache.end()
+	);
+	LogDataBucketsDetail(
+		"Deleted bucket misses from cache where key [{}] size before [{}] after [{}]",
+		e.key_,
+		size_before,
+		g_data_bucket_cache.size()
+	);
+}
@@ -9,19 +9,85 @@
 #include "../common/types.h"
 #include "../common/repositories/data_buckets_repository.h"
 #include "mob.h"
+#include "../common/json/json_archive_single_line.h"
+#include "../common/servertalk.h"
+
+enum DataBucketCacheUpdateAction : uint8 {
+	Upsert,
+	Delete
+};
+
+struct DataBucketCacheEntry {
+	DataBucketsRepository::DataBuckets e;
+	int64_t                            updated_time{};
+	DataBucketCacheUpdateAction        update_action{};
+
+	template<class Archive>
+	void serialize(Archive &ar)
+	{
+		ar(
+			CEREAL_NVP(e),
+			CEREAL_NVP(updated_time),
+			CEREAL_NVP(update_action)
+		);
+	}
+};
+
+struct DataBucketKey {
+	std::string key;
+	std::string value;
+	std::string expires;
+	int64_t     character_id;
+	int64_t     npc_id;
+	int64_t     bot_id;
+};
+
+namespace DataBucketLoadType {
+	enum Type : uint8 {
+		Bot,
+		Client,
+		NPC,
+		MaxType
+	};
+
+	static const std::string Name[Type::MaxType] = {
+		"Bot",
+		"Client",
+		"NPC",
+	};
+}

 class DataBucket {
 public:
-	static void SetData(const std::string& bucket_key, const std::string& bucket_value, std::string expires_time = "");
-	static bool DeleteData(const std::string& bucket_key);
-	static std::string GetData(const std::string& bucket_key);
-	static std::string GetDataExpires(const std::string& bucket_key);
-	static std::string GetDataRemaining(const std::string& bucket_key);
-	static bool GetDataBuckets(Mob* mob);
-	static std::string CheckBucketKey(const Mob* mob, std::string_view full_name);
+	// non-scoped bucket methods (for global buckets)
+	static void SetData(const std::string &bucket_key, const std::string &bucket_value, std::string expires_time = "");
+	static bool DeleteData(const std::string &bucket_key);
+	static std::string GetData(const std::string &bucket_key);
+	static std::string GetDataExpires(const std::string &bucket_key);
+	static std::string GetDataRemaining(const std::string &bucket_key);

-private:
-	static uint64 DoesBucketExist(const std::string& bucket_key);
+	static bool GetDataBuckets(Mob *mob);
+
+	static int64_t GetCurrentTimeUNIX();
+
+	// scoped bucket methods
+	static void SetData(const DataBucketKey &k);
+	static bool DeleteData(const DataBucketKey &k);
+	static DataBucketsRepository::DataBuckets GetData(const DataBucketKey &k, bool ignore_misses_cache = false);
+	static std::string GetDataExpires(const DataBucketKey &k);
+	static std::string GetDataRemaining(const DataBucketKey &k);
+	static std::string GetScopedDbFilters(const DataBucketKey &k);
+
+	// bucket repository versus key matching
+	static bool CheckBucketMatch(const DataBucketsRepository::DataBuckets &dbe, const DataBucketKey &k);
+	static bool ExistsInCache(const DataBucketsRepository::DataBuckets &e);
+
+	static void BulkLoadEntities(DataBucketLoadType::Type t, std::vector<uint32> ids);
+	static void DeleteCachedBuckets(DataBucketLoadType::Type t, uint32 id);
+
+	static bool SendDataBucketCacheUpdate(const DataBucketCacheEntry &e);
+	static void HandleWorldMessage(ServerPacket *p);
+	static void DeleteFromMissesCache(DataBucketsRepository::DataBuckets e);
 };

 #endif //EQEMU_DATABUCKET_H
@@ -83,6 +83,8 @@ Doors::Doors(const DoorsRepository::Doors &door) :
 	m_close_timer.Disable();

 	m_disable_timer = (door.disable_timer == 1 ? true : false);
+
+	m_is_blacklisted_to_open = GetIsDoorBlacklisted();
 }

 Doors::Doors(const char *model, const glm::vec4 &position, uint8 open_type, uint16 size) :
@@ -901,3 +903,27 @@ bool Doors::IsDestinationZoneSame() const
 {
 	return m_same_destination_zone;
 }
+
+// IsDoorBlacklisted has a static list of doors that are blacklisted
+// from being opened by NPCs. This is used to prevent NPCs from opening
+// doors that are not meant to be opened by NPCs.
+bool Doors::GetIsDoorBlacklisted()
+{
+	std::vector<std::string> blacklist = {
+		"TOGGLE",
+		"PNDRESSER101",
+	};
+
+	for (auto& name : blacklist) {
+		std::string door_name = GetDoorName();
+		if (name == door_name) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool Doors::IsDoorBlacklisted() {
+	return m_is_blacklisted_to_open;
+}
@@ -69,7 +69,10 @@ public:
 	bool HasDestinationZone() const;
 	bool IsDestinationZoneSame() const;

+	bool IsDoorBlacklisted();
+
 private:
+	bool GetIsDoorBlacklisted();

 	bool      m_has_destination_zone = false;
 	bool      m_same_destination_zone = false;
@@ -99,5 +102,6 @@ private:
 	uint8     m_is_ldon_door;
 	int       m_dz_switch_id = 0;
 	uint32    m_client_version_mask;
+	bool      m_is_blacklisted_to_open = false; // is door blacklisted to open by npcs
 };
 #endif
@@ -622,8 +622,8 @@ bool Client::TrainDiscipline(uint32 itemid) {
 	const std::string item_name = item->Name;

 	if (
-		item_name.substr(0, 5) != std::string("Tome ") &&
-		item_name.substr(0, 7) != std::string("Skill: ")
+		!Strings::BeginsWith(item_name, "Tome of ") &&
+		!Strings::BeginsWith(item_name, "Skill: ")
 	) {
 		Message(Chat::Red, "This item is not a tome.");
 		//summon them the item back...
@@ -709,8 +709,8 @@ bool Client::MemorizeSpellFromItem(uint32 item_id) {
 	const std::string item_name = item->Name;

 	if (
-		item_name.substr(0, 7) != std::string("Spell: ") &&
-		item_name.substr(0, 6) != std::string("Song: ")
+		!Strings::BeginsWith(item_name, "Spell: ") &&
+		!Strings::BeginsWith(item_name, "Song: ")
 	) {
 		Message(Chat::Red, "This item is not a scroll.");
 		SummonItem(item_id);
@@ -46,7 +46,10 @@ void perl_register_group();
 void perl_register_raid();
 void perl_register_inventory();
 void perl_register_questitem();
+void perl_register_questitem_data();
+void perl_register_spawn();
 void perl_register_spell();
+void perl_register_stat_bonuses();
 void perl_register_hateentry();
 void perl_register_object();
 void perl_register_doors();
@@ -1068,7 +1071,10 @@ void PerlembParser::MapFunctions()
 	perl_register_raid();
 	perl_register_inventory();
 	perl_register_questitem();
+	perl_register_questitem_data();
+	perl_register_spawn();
 	perl_register_spell();
+	perl_register_stat_bonuses();
 	perl_register_hateentry();
 	perl_register_object();
 	perl_register_doors();
@@ -2315,17 +2315,17 @@ void Perl__removetitle(int title_set)
 	quest_manager.removetitle(title_set);
 }

-void Perl__wearchange(uint8 slot, uint16 texture_id)
+void Perl__wearchange(uint8 slot, uint32 texture_id)
 {
 	quest_manager.wearchange(slot, texture_id);
 }

-void Perl__wearchange(uint8 slot, uint16 texture_id, uint32 hero_forge_model_id)
+void Perl__wearchange(uint8 slot, uint32 texture_id, uint32 hero_forge_model_id)
 {
 	quest_manager.wearchange(slot, texture_id, hero_forge_model_id);
 }

-void Perl__wearchange(uint8 slot, uint16 texture_id, uint32 hero_forge_model_id, uint32 elite_material_id)
+void Perl__wearchange(uint8 slot, uint32 texture_id, uint32 hero_forge_model_id, uint32 elite_material_id)
 {
 	quest_manager.wearchange(slot, texture_id, hero_forge_model_id, elite_material_id);
 }
@@ -6214,9 +6214,9 @@ void perl_register_quest()
 	package.add("varlink", (std::string(*)(uint32, int16, uint32, uint32, uint32, uint32, uint32, uint32, bool))&Perl__varlink);
 	package.add("voicetell", &Perl__voicetell);
 	package.add("we", &Perl__we);
-	package.add("wearchange", (void(*)(uint8, uint16))&Perl__wearchange);
-	package.add("wearchange", (void(*)(uint8, uint16, uint32))&Perl__wearchange);
-	package.add("wearchange", (void(*)(uint8, uint16, uint32, uint32))&Perl__wearchange);
+	package.add("wearchange", (void(*)(uint8, uint32))&Perl__wearchange);
+	package.add("wearchange", (void(*)(uint8, uint32, uint32))&Perl__wearchange);
+	package.add("wearchange", (void(*)(uint8, uint32, uint32, uint32))&Perl__wearchange);
 	package.add("whisper", &Perl__whisper);
 	package.add("write", &Perl__write);
 	package.add("ze", &Perl__ze);
@@ -2244,6 +2244,18 @@ Raid* EntityList::GetRaidByBot(const Bot* bot)
 	return nullptr;
 }

+Raid* EntityList::GetRaidByName(const char* name)
+{
+	for (const auto& r : raid_list) {
+		for (const auto& m : r->members) {
+			if (Strings::EqualFold(m.member_name, name)) {
+				return r;
+			}
+		}
+	}
+	return nullptr;
+}
+
 Client *EntityList::GetClientByAccID(uint32 accid)
 {
 	auto it = client_list.begin();
@@ -198,6 +198,7 @@ public:
 	Raid *GetRaidByID(uint32 id);
 	Raid* GetRaidByBotName(const char* name);
 	Raid* GetRaidByBot(const Bot* bot);
+	Raid* GetRaidByName(const char* name);

 	Corpse *GetCorpseByOwner(Client* client);
 	Corpse *GetCorpseByOwnerWithinRange(Client* client, Mob* center, int range);
@@ -539,7 +540,7 @@ public:
 	inline const std::unordered_map<uint16, Object *> &GetObjectList() { return object_list; }
 	inline const std::unordered_map<uint16, Doors *> &GetDoorsList() { return door_list; }

-	std::unordered_map<uint16, Mob *> &GetCloseMobList(Mob *mob, float distance = 0);
+	std::unordered_map<uint16, Mob *> &GetCloseMobList(Mob *mob, float distance = 0.0f);

 	void	DepopAll(int NPCTypeID, bool StartSpawnTimer = true);

@@ -553,7 +554,7 @@ public:
 		bool add_self_to_other_lists = false
 	);

-	void GetTrapInfo(Client* client);
+	void GetTrapInfo(Client* c);
 	bool IsTrapGroupSpawned(uint32 trap_id, uint8 group);
 	void UpdateAllTraps(bool respawn, bool repopnow = false);
 	void ClearTrapPointers();
@@ -1273,27 +1273,13 @@ uint8 Client::GetCharMaxLevelFromQGlobal() {

 uint8 Client::GetCharMaxLevelFromBucket()
 {
-	auto new_bucket_name = fmt::format(
-		"{}-CharMaxLevel",
-		GetBucketKey()
-	);
+	DataBucketKey k = GetScopedBucketKeys();
+	k.key = "CharMaxLevel";

-	auto bucket_value = DataBucket::GetData(new_bucket_name);
-	if (!bucket_value.empty()) {
-		if (Strings::IsNumber(bucket_value)) {
-			return static_cast<uint8>(Strings::ToUnsignedInt(bucket_value));
-		}
-	}
-
-	auto old_bucket_name = fmt::format(
-		"{}-CharMaxLevel",
-		CharacterID()
-	);
-
-	bucket_value = DataBucket::GetData(old_bucket_name);
-	if (!bucket_value.empty()) {
-		if (Strings::IsNumber(bucket_value)) {
-			return static_cast<uint8>(Strings::ToUnsignedInt(bucket_value));
+	auto b = DataBucket::GetData(k);
+	if (!b.value.empty()) {
+		if (Strings::IsNumber(b.value)) {
+			return static_cast<uint8>(Strings::ToUnsignedInt(b.value));
 		}
 	}

@@ -2,6 +2,7 @@
 #include "npc.h"
 #include "client.h"
 #include "zone.h"
+#include "dialogue_window.h"

 extern Zone *zone;

@@ -21,62 +22,77 @@ std::vector<int> GlobalLootManager::GetGlobalLootTables(NPC *mob) const
 	return tables;
 }

-void GlobalLootManager::ShowZoneGlobalLoot(Client *to) const
+void GlobalLootManager::ShowZoneGlobalLoot(Client *c) const
 {
-	int table_number = 1;
+	std::string global_loot_table;
+
+	global_loot_table += DialogueWindow::TableRow(
+		fmt::format(
+			"{}{}{}",
+			DialogueWindow::TableCell("ID"),
+			DialogueWindow::TableCell("Table Name"),
+			DialogueWindow::TableCell("Loottable ID")
+		)
+	);

 	for (auto &e : m_entries) {
-		to->Message(
-			Chat::White,
+		global_loot_table += DialogueWindow::TableRow(
 			fmt::format(
-				"Table {} | Name: {}",
-				table_number,
-				e.GetDescription()
-			).c_str()
+				"{}{}{}",
+				DialogueWindow::TableCell(Strings::Commify(e.GetID())),
+				DialogueWindow::TableCell(e.GetDescription()),
+				DialogueWindow::TableCell(Strings::Commify(e.GetLootTableID()))
+			)
 		);
-
-		to->Message(
-			Chat::White,
-			fmt::format(
-				"Table {} | Global Table ID: {} Loot Table ID: {}",
-				table_number,
-				e.GetID(),
-				e.GetLootTableID()
-			).c_str()
-		);
-
-		table_number++;
 	}
+
+	global_loot_table = DialogueWindow::Table(global_loot_table);
+
+	c->SendPopupToClient(
+		fmt::format(
+			"Global Loot for {} ({})",
+			zone->GetLongName(),
+			zone->GetZoneID()
+		).c_str(),
+		global_loot_table.c_str()
+	);
 }

-void GlobalLootManager::ShowNPCGlobalLoot(Client *to, NPC *who) const
+void GlobalLootManager::ShowNPCGlobalLoot(Client *c, NPC *t) const
 {
-	int table_number = 1;
+	std::string global_loot_table;
+
+	global_loot_table += DialogueWindow::TableRow(
+		fmt::format(
+			"{}{}{}",
+			DialogueWindow::TableCell("ID"),
+			DialogueWindow::TableCell("Table Name"),
+			DialogueWindow::TableCell("Loottable ID")
+		)
+	);

 	for (auto &e : m_entries) {
-		if (e.PassesRules(who)) {
-			to->Message(
-				Chat::White,
+		if (e.PassesRules(t)) {
+			global_loot_table += DialogueWindow::TableRow(
 				fmt::format(
-					"Table {} | Name: {}",
-					table_number,
-					e.GetDescription()
-				).c_str()
+					"{}{}{}",
+					DialogueWindow::TableCell(Strings::Commify(e.GetID())),
+					DialogueWindow::TableCell(e.GetDescription()),
+					DialogueWindow::TableCell(Strings::Commify(e.GetLootTableID()))
+				)
 			);
-
-			to->Message(
-				Chat::White,
-				fmt::format(
-					"Table {} | Global Table ID: {} Loot Table ID: {}",
-					table_number,
-					e.GetID(),
-					e.GetLootTableID()
-				).c_str()
-			);
-
-			table_number++;
 		}
 	}
+
+	global_loot_table = DialogueWindow::Table(global_loot_table);
+
+	c->SendPopupToClient(
+		fmt::format(
+			"Global Loot for {}",
+			c->GetTargetDescription(t)
+		).c_str(),
+		global_loot_table.c_str()
+	);
 }

 bool GlobalLootEntry::PassesRules(NPC *mob) const
@@ -1,28 +0,0 @@
-#include "../client.h"
-
-void command_aggro(Client *c, const Seperator *sep)
-{
-	int arguments = sep->argnum;
-	if (!arguments || !sep->IsNumber(1)) {
-		c->Message(Chat::White, "Usage: #aggro [Distance] [-v] (-v is verbose Faction Information)");
-		return;
-	}
-
-	if (
-		!c->GetTarget() ||
-		(
-			c->GetTarget() &&
-			!c->GetTarget()->IsNPC()
-		)
-	) {
-		c->Message(Chat::White, "You must target an NPC to use this command.");
-		return;
-	}
-
-	NPC* target = c->GetTarget()->CastToNPC();
-
-	float distance = Strings::ToFloat(sep->arg[1]);
-	bool verbose = !strcasecmp("-v", sep->arg[2]);
-	entity_list.DescribeAggro(c, target, distance, verbose);
-}
-
@@ -1,44 +0,0 @@
-#include "../client.h"
-
-void command_bind(Client *c, const Seperator *sep)
-{
-	Client *target = c;
-	if (c->GetTarget() && c->GetTarget()->IsClient()) {
-		target = c->GetTarget()->CastToClient();
-	}
-
-	bool bind_allowed = (
-		!zone->GetInstanceID() ||
-		(
-			zone->GetInstanceID() != 0 &&
-			zone->IsInstancePersistent()
-		)
-	);
-
-	if (!bind_allowed) {
-		c->Message(Chat::White, "You cannot bind here.");
-		return;
-	}
-
-	target->SetBindPoint();
-
-	c->Message(
-		Chat::White,
-		fmt::format(
-			"Set Bind Point for {} | Zone: {}",
-			c->GetTargetDescription(target),
-			zone->GetZoneDescription()
-		).c_str()
-	);
-
-	c->Message(
-		Chat::White,
-		fmt::format(
-			"Set Bind Point for {} | XYZ: {:.2f}, {:.2f}, {:.2f}",
-			c->GetTargetDescription(target),
-			target->GetX(),
-			target->GetY(),
-			target->GetZ()
-		).c_str()
-	);
-}
@@ -1,23 +0,0 @@
-#include "../client.h"
-
-void command_checklos(Client *c, const Seperator *sep)
-{
-	if (!c->GetTarget()) {
-		c->Message(Chat::White, "You must have a target to use this command.");
-		return;
-	}
-
-	auto target = c->GetTarget();
-
-	bool has_los = c->CheckLosFN(target);
-
-	c->Message(
-		Chat::White,
-		fmt::format(
-			"You {}have line of sight to {}.",
-			has_los ? "" : "do not ",
-			c->GetTargetDescription(target)
-		).c_str()
-	);
-}
-
@@ -2,26 +2,31 @@

 void command_copycharacter(Client *c, const Seperator *sep)
 {
-	if (sep->argnum < 3) {
+	if (
+		sep->argnum < 3 ||
+		sep->IsNumber(1) ||
+		sep->IsNumber(2) ||
+		sep->IsNumber(3)
+	) {
 		c->Message(
 			Chat::White,
-			"Usage: [source_character_name] [destination_character_name] [destination_account_name]"
+			"Usage: #copycharacter [source_character_name] [destination_character_name] [destination_account_name]"
 		);
 		return;
 	}

-	std::string source_character_name      = sep->arg[1];
-	std::string destination_character_name = sep->arg[2];
-	std::string destination_account_name   = sep->arg[3];
+	const std::string& source_character_name      = sep->arg[1];
+	const std::string& destination_character_name = sep->arg[2];
+	const std::string& destination_account_name   = sep->arg[3];

-	bool result = database.CopyCharacter(
+	const bool result = database.CopyCharacter(
 		source_character_name,
 		destination_character_name,
 		destination_account_name
 	);

 	c->Message(
-		Chat::Yellow,
+		Chat::White,
 		fmt::format(
 			"Character Copy [{}] to [{}] via account [{}] [{}]",
 			source_character_name,
@@ -1,14 +0,0 @@
-#include "../client.h"
-#include "../worldserver.h"
-
-extern WorldServer worldserver;
-
-void command_cvs(Client *c, const Seperator *sep)
-{
-	auto pack = new ServerPacket(ServerOP_ClientVersionSummary, sizeof(ServerRequestClientVersionSummary_Struct));
-	auto srcvss = (ServerRequestClientVersionSummary_Struct *) pack->pBuffer;
-	strn0cpy(srcvss->Name, c->GetName(), sizeof(srcvss->Name));
-	worldserver.SendPacket(pack);
-	safe_delete(pack);
-}
-
@@ -1,67 +0,0 @@
-#include "../client.h"
-
-void command_date(Client *c, const Seperator *sep)
-{
-	int arguments = sep->argnum;
-	if (
-		!arguments ||
-		!sep->IsNumber(1) ||
-		!sep->IsNumber(2) ||
-		!sep->IsNumber(3)
-	) {
-		c->Message(Chat::White, "Usage: #date [Year] [Month] [Day] [Hour] [Minute]");
-		return;
-	}
-
-	TimeOfDay_Struct eq_time;
-	zone->zone_time.GetCurrentEQTimeOfDay(time(0), &eq_time);
-
-	auto year = static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[1]));
-	auto month = static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[2]));
-	auto day = static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[3]));
-
-	auto hour = !sep->IsNumber(4) ? eq_time.hour : static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[4]) + 1);
-	auto minute = !sep->IsNumber(5) ? eq_time.minute : static_cast<uint8>(Strings::ToUnsignedInt(sep->arg[5]));
-
-	c->Message(
-		Chat::White,
-		fmt::format("Setting world time to {}/{}/{} {:02}:{:02} {}.",
-			year,
-			month,
-			day,
-			(
-				(hour % 12) == 0 ?
-				12 :
-				(hour % 12)
-			),
-			minute,
-			(
-				hour >= 13 ?
-				"PM" :
-				"AM"
-			)
-		).c_str()
-	);
-
-	zone->SetDate(year, month, day, hour, minute);
-
-	LogInfo(
-		"{} :: Setting world time to {}/{}/{} {:02}:{:02} {}.",
-		c->GetCleanName(),
-		year,
-		month,
-		day,
-		(
-			(hour % 12) == 0 ?
-			12 :
-			(hour % 12)
-		),
-		minute,
-		(
-			hour >= 13 ?
-			"PM" :
-			"AM"
-		)
-	);
-}
-
@@ -1,22 +0,0 @@
-#include "../client.h"
-
-void command_distance(Client *c, const Seperator *sep)
-{
-	if (c->GetTarget()) {
-		Mob *target = c->GetTarget();
-		if (c != target) {
-			c->Message(
-				Chat::White,
-				fmt::format(
-					"{} is {:.2f} units from you.",
-					c->GetTargetDescription(target),
-					Distance(
-						c->GetPosition(),
-						target->GetPosition()
-					)
-				).c_str()
-			);
-		}
-	}
-}
-
@@ -1,142 +0,0 @@
-#include "../client.h"
-
-void command_emotesearch(Client *c, const Seperator *sep)
-{
-	auto arguments = sep->argnum;
-	if (!arguments) {
-		c->Message(Chat::White, "Usage: #emotesearch [Emote ID]");
-		c->Message(Chat::White, "Usage: #emotesearch [Search Crteria]");
-		return;
-	}
-
-	auto emote_count = 0;
-	auto emote_number = 1;
-
-	std::string search_criteria = sep->argplus[1];
-	bool found_by_id = false;
-
-	if (!sep->IsNumber(1)) {
-		LinkedListIterator<NPC_Emote_Struct *> iterator(zone->NPCEmoteList);
-		iterator.Reset();
-		while (iterator.MoreElements()) {
-			auto &e = iterator.GetData();
-			auto current_text = Strings::ToLower(e->text);
-
-			if (Strings::Contains(current_text, Strings::ToLower(search_criteria))) {
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Emote {} | Emote ID: {}",
-						emote_number,
-						e->emoteid
-					).c_str()
-				);
-
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Emote {} | Event: {} ({}) Type: {} ({})",
-						emote_number,
-						EQ::constants::GetEmoteEventTypeName(e->event_),
-						e->event_,
-						EQ::constants::GetEmoteTypeName(e->type),
-						e->type
-					).c_str()
-				);
-
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Emote {} | Text: {}",
-						emote_number,
-						e->text
-					).c_str()
-				);
-
-				emote_count++;
-				emote_number++;
-			}
-
-			if (emote_count == 50) {
-				break;
-			}
-
-			iterator.Advance();
-		}
-	} else {
-		auto emote_id = Strings::ToUnsignedInt(search_criteria);
-
-		LinkedListIterator<NPC_Emote_Struct *> iterator(zone->NPCEmoteList);
-		iterator.Reset();
-		while (iterator.MoreElements()) {
-			auto &e = iterator.GetData();
-			if (emote_id == e->emoteid) {
-				found_by_id = true;
-
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Emote {} | Event: {} ({}) Type: {} ({})",
-						emote_number,
-						EQ::constants::GetEmoteEventTypeName(e->event_),
-						e->event_,
-						EQ::constants::GetEmoteTypeName(e->type),
-						e->type
-					).c_str()
-				);
-
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Emote {} | Text: {}",
-						emote_number,
-						e->text
-					).c_str()
-				);
-
-				emote_count++;
-				emote_number++;
-			}
-
-			if (emote_count == 50) {
-				break;
-			}
-
-			iterator.Advance();
-		}
-	}
-
-	auto found_string = (
-		found_by_id ?
-		fmt::format("ID {}", search_criteria) :
-		search_criteria
-	);
-
-	if (!emote_count) {
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"No Emotes found matching {}.",
-				found_string
-			).c_str()
-		);
-	} else if (emote_count == 50) {
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"50 Emotes shown matching {}, too many results.",
-				found_string
-			).c_str()
-		);
-	} else {
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"{} Emote{} found matching {}.",
-				emote_count,
-				emote_count != 1 ? "s" : "",
-				found_string
-			).c_str()
-		);
-	}
-}
@@ -1,28 +0,0 @@
-#include "../client.h"
-
-void command_endurance(Client *c, const Seperator *sep)
-{
-	Mob* target = c;
-	if (c->GetTarget()) {
-		target = c->GetTarget();
-	}
-
-	int endurance = 0;
-	if (target->IsClient()) {
-		endurance = target->CastToClient()->GetMaxEndurance();
-		target->CastToClient()->SetEndurance(endurance);
-	} else {
-		endurance = target->GetMaxEndurance();
-		target->SetEndurance(endurance);
-	}
-
-	c->Message(
-		Chat::White,
-		fmt::format(
-			"Set {} to full Endurance ({}).",
-			c->GetTargetDescription(target),
-			endurance
-		).c_str()
-	);
-}
-
@@ -0,0 +1,110 @@
+#include "../client.h"
+#include "find/aa.cpp"
+#include "find/character.cpp"
+#include "find/class.cpp"
+#include "find/currency.cpp"
+#include "find/deity.cpp"
+#include "find/emote.cpp"
+#include "find/faction.cpp"
+#include "find/item.cpp"
+#include "find/language.cpp"
+#include "find/npctype.cpp"
+#include "find/race.cpp"
+#include "find/recipe.cpp"
+#include "find/skill.cpp"
+#include "find/spell.cpp"
+#include "find/task.cpp"
+#include "find/zone.cpp"
+
+void command_find(Client *c, const Seperator *sep)
+{
+	// Cmd represents a command
+	// variables are short to save space horizontally
+	// when adding a new sub-command, add it to the vector below
+	struct Cmd {
+		std::string cmd{}; // command
+		std::string u{}; // usage
+		void (*fn)(Client *c, const Seperator *sep) = nullptr; // function
+		std::vector<std::string> a{}; // aliases
+	};
+
+	std::vector<Cmd> commands = {
+		Cmd{.cmd = "aa", .u = "aa [Search Criteria]", .fn = FindAA, .a = {"#findaa"}},
+		Cmd{.cmd = "character", .u = "character [Search Criteria]", .fn = FindCharacter, .a = {"#findcharacter"}},
+		Cmd{.cmd = "class", .u = "class [Search Criteria]", .fn = FindClass, .a = {"#findclass"}},
+		Cmd{.cmd = "currency", .u = "currency [Search Criteria]", .fn = FindCurrency, .a = {"#findcurrency"}},
+		Cmd{.cmd = "deity", .u = "deity [Search Criteria]", .fn = FindDeity, .a = {"#finddeity"}},
+		Cmd{.cmd = "emote", .u = "emote [Search Criteria]", .fn = FindEmote, .a = {"#findemote"}},
+		Cmd{.cmd = "faction", .u = "faction [Search Criteria]", .fn = FindFaction, .a = {"#findfaction"}},
+		Cmd{.cmd = "item", .u = "item [Search Criteria]", .fn = FindItem, .a = {"#fi", "#finditem"}},
+		Cmd{.cmd = "language", .u = "language [Search Criteria]", .fn = FindLanguage, .a = {"#findlanguage"}},
+		Cmd{
+			.cmd = "npctype", .u = "npctype [Search Criteria]", .fn = FindNPCType, .a = {
+				"#fn",
+				"#findnpc",
+				"#findnpctype"
+			}
+		},
+		Cmd{.cmd = "race", .u = "race [Search Criteria]", .fn = FindRace, .a = {"#findrace"}},
+		Cmd{.cmd = "recipe", .u = "recipe [Search Criteria]", .fn = FindRecipe, .a = {"#findrecipe"}},
+		Cmd{.cmd = "skill", .u = "skill [Search Criteria]", .fn = FindSkill, .a = {"#findskill"}},
+		Cmd{.cmd = "spell", .u = "spell [Search Criteria]", .fn = FindSpell, .a = {"#fs", "#findspell"}},
+		Cmd{.cmd = "task", .u = "task [Search Criteria]", .fn = FindTask, .a = {"#findtask"}},
+		Cmd{.cmd = "zone", .u = "zone [Search Criteria]", .fn = FindZone, .a = {"#fz", "#findzone"}},
+	};
+
+	// Check for arguments
+	const auto arguments = sep->argnum;
+	if (!arguments) {
+		for (const auto &cmd: commands) {
+			c->Message(Chat::White, fmt::format("Usage: #find {}", cmd.u).c_str());
+		}
+		return;
+	}
+
+	// look for alias or command
+	for (const auto &cmd: commands) {
+		// Check for alias first
+		for (const auto &alias: cmd.a) {
+			if (!alias.empty() && alias == Strings::ToLower(sep->arg[0])) {
+				// build string from sep args
+				std::vector<std::string> args = {};
+
+				// skip the first arg
+				for (auto i = 1; i <= arguments; i++) {
+					args.emplace_back(sep->arg[i]);
+				}
+
+				// build the rewrite string
+				std::string rewrite = fmt::format("#find {} {}", cmd.cmd, Strings::Join(args, " "));
+
+				// rewrite to #find <sub-command <args>>
+				c->SendGMCommand(rewrite);
+
+				c->Message(
+					Chat::Gray,
+					fmt::format(
+						"{} is now located under {}, using {}.",
+						sep->arg[0],
+						Saylink::Silent("#find"),
+						Saylink::Silent(rewrite)
+					).c_str()
+				);
+
+				return;
+			}
+		}
+
+		// Check for command
+		if (cmd.cmd == Strings::ToLower(sep->arg[1])) {
+			cmd.fn(c, sep);
+			return;
+		}
+	}
+
+	// Command not found
+	c->Message(Chat::White, "Command not found. Usage: #find [command]");
+	for (const auto &cmd: commands) {
+		c->Message(Chat::White, fmt::format("Usage: #find {}", cmd.u).c_str());
+	}
+}
@@ -0,0 +1,88 @@
+#include "../../client.h"
+
+void FindAA(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto  aa_id   = Strings::ToInt(sep->arg[2]);
+		const auto& aa_name = zone->GetAAName(aa_id);
+		if (!aa_name.empty()) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"AA {} | {}",
+					Strings::Commify(aa_id),
+					aa_name
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"AA ID {} was not found.",
+				Strings::Commify(aa_id)
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	auto found_count = 0;
+
+	std::map<int, std::string> ordered_aas;
+
+	for (const auto &a: zone->aa_abilities) {
+		ordered_aas[a.second.get()->first->id] = a.second.get()->name;
+	}
+
+	for (const auto &a: ordered_aas) {
+		const auto& aa_name = zone->GetAAName(a.first);
+		if (!aa_name.empty()) {
+			const auto& aa_name_lower = Strings::ToLower(aa_name);
+			if (!Strings::Contains(aa_name_lower, search_criteria)) {
+				continue;
+			}
+
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"AA {} | {}",
+					Strings::Commify(a.first),
+					aa_name
+				).c_str()
+			);
+
+			found_count++;
+
+			if (found_count == 50) {
+				break;
+			}
+		}
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 AAs were found matching '{}', max reached.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} AA{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			sep->argplus[2]
+		).c_str()
+	);
+}
@@ -0,0 +1,95 @@
+#include "../../client.h"
+#include "../../common/repositories/character_data_repository.h"
+
+void FindCharacter(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto character_id = Strings::ToUnsignedInt(sep->arg[2]);
+
+		const auto& e = CharacterDataRepository::FindOne(content_db, character_id);
+		if (!e.id) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Character ID {} does not exist or is invalid.",
+					Strings::Commify(character_id)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Character ID {} | {}",
+				Strings::Commify(character_id),
+				e.name
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	const auto& l = CharacterDataRepository::GetWhere(
+		content_db,
+		fmt::format(
+			"LOWER(`name`) LIKE '%%{}%%' ORDER BY `id` ASC LIMIT 50",
+			search_criteria
+		)
+	);
+
+	if (l.empty()) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"No characters found matching '{}'.",
+				sep->argplus[2]
+			).c_str()
+		);
+	}
+
+	auto found_count = 0;
+
+	for (const auto& e : l) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Character ID {} | {}",
+				Strings::Commify(e.id),
+				e.name
+			).c_str()
+		);
+
+		found_count++;
+
+		if (found_count == 50) {
+			break;
+		}
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 Characters found matching '{}', max reached.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Character{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			sep->argplus[2]
+		).c_str()
+	);
+}
+
@@ -0,0 +1,80 @@
+#include "../../client.h"
+
+void FindClass(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto class_id = Strings::ToInt(sep->arg[2]);
+		if (EQ::ValueWithin(class_id, WARRIOR, BERSERKER)) {
+			const std::string& class_name = GetClassIDName(class_id);
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Class {} | {}{}",
+					class_id,
+					class_name,
+					(
+						IsPlayerClass(class_id) ?
+						fmt::format(
+							" ({})",
+							Strings::Commify(GetPlayerClassBit(class_id))
+						) :
+						""
+					)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Class ID {} was not found.",
+				class_id
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	auto found_count = 0;
+
+	for (uint16 class_id = WARRIOR; class_id <= MERCENARY_MASTER; class_id++) {
+		const std::string& class_name       = GetClassIDName(class_id);
+		const auto&        class_name_lower = Strings::ToLower(class_name);
+		if (!Strings::Contains(class_name_lower, search_criteria)) {
+			continue;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Class {} | {}{}",
+				class_id,
+				class_name,
+				(
+					IsPlayerClass(class_id) ?
+					fmt::format(
+						" | ({})",
+						Strings::Commify(GetPlayerClassBit(class_id))
+					) :
+					""
+				)
+			).c_str()
+		);
+
+		found_count++;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+		"{} Class{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "es" : "",
+			sep->argplus[2]
+		).c_str()
+	);
+}
@@ -0,0 +1,131 @@
+#include "../../client.h"
+
+void FindCurrency(Client *c, const Seperator *sep)
+{
+	const auto can_summon_items = c->Admin() >= GetCommandStatus("summonitem");
+
+	if (sep->IsNumber(2)) {
+		const auto item_id     = Strings::ToUnsignedInt(sep->arg[2]);
+		const auto currency_id = zone->GetCurrencyID(item_id);
+
+		if (!currency_id) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"There is no currency with an item ID of {}.",
+					Strings::Commify(item_id)
+				).c_str()
+			);
+
+			return;
+		}
+
+		const auto item_data = database.GetItem(item_id);
+		if (!item_data) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Item ID {} does not exist.",
+					Strings::Commify(item_id)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Currency {} | {}{}",
+				currency_id,
+				database.CreateItemLink(item_id),
+				(
+					can_summon_items ?
+					fmt::format(
+						" | {}",
+						Saylink::Silent(
+							fmt::format(
+								"#summonitem {} {}",
+								item_id,
+								item_data->StackSize
+							),
+							"Summon"
+						)
+					) :
+					""
+				)
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	auto found_count = 0;
+
+	for (const auto& e : zone->AlternateCurrencies) {
+		const auto item_data = database.GetItem(e.item_id);
+		if (!item_data) {
+			continue;
+		}
+
+		const auto& item_name = Strings::ToLower(item_data->Name);
+
+		if (!Strings::Contains(item_name, search_criteria)) {
+			continue;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Currency {} | {}{}",
+				e.id,
+				database.CreateItemLink(e.item_id),
+				(
+					can_summon_items ?
+					fmt::format(
+						" | {}",
+						Saylink::Silent(
+							fmt::format(
+								"#summonitem {} {}",
+								e.item_id,
+								item_data->StackSize
+							),
+							"Summon"
+						)
+					) :
+					""
+				)
+			).c_str()
+		);
+
+		found_count++;
+
+		if (found_count == 50) {
+			break;
+		}
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 Currencies found matching '{}', max reached.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Currenc{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "ies" : "y",
+			sep->argplus[2]
+		).c_str()
+	);
+}
@@ -0,0 +1,69 @@
+#include "../../client.h"
+
+void FindDeity(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto  deity_id   = static_cast<EQ::deity::DeityType>(Strings::ToInt(sep->arg[2]));
+		const auto& deity_name = EQ::deity::GetDeityName(deity_id);
+		if (!deity_name.empty()) {
+			const auto deity_bit = EQ::deity::GetDeityBitmask(deity_id);
+
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Deity {} | {} ({})",
+					deity_id,
+					deity_name,
+					Strings::Commify(deity_bit)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Deity ID {} was not found.",
+				deity_id
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	auto found_count = 0;
+
+	for (const auto& d : EQ::deity::GetDeityMap()) {
+		const auto& deity_name_lower = Strings::ToLower(d.second);
+		if (!Strings::Contains(deity_name_lower, search_criteria)) {
+			continue;
+		}
+
+		const auto deity_bit = EQ::deity::GetDeityBitmask(d.first);
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Deity {} | {} ({})",
+				d.first,
+				d.second,
+				Strings::Commify(deity_bit)
+			).c_str()
+		);
+
+		found_count++;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Deit{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "ies" : "y",
+			sep->argplus[2]
+		).c_str()
+	);
+}
@@ -0,0 +1,133 @@
+#include "../../client.h"
+
+void FindEmote(Client *c, const Seperator *sep)
+{
+	uint32 found_count = 0;
+
+	if (sep->IsNumber(2)) {
+		auto emote_id = Strings::ToUnsignedInt(sep->arg[2]);
+
+		LinkedListIterator<NPC_Emote_Struct *> iterator(zone->NPCEmoteList);
+		iterator.Reset();
+		while (iterator.MoreElements()) {
+			auto &e = iterator.GetData();
+			if (emote_id == e->emoteid) {
+				c->Message(
+					Chat::White,
+					fmt::format(
+						"Emote {} | Event: {} ({}) Type: {} ({})",
+						e->emoteid,
+						EQ::constants::GetEmoteEventTypeName(e->event_),
+						e->event_,
+						EQ::constants::GetEmoteTypeName(e->type),
+						e->type
+					).c_str()
+				);
+
+				c->Message(
+					Chat::White,
+					fmt::format(
+						"Emote {} | Text: {}",
+						e->emoteid,
+						e->text
+					).c_str()
+				);
+
+				found_count++;
+			}
+
+			if (found_count == 50) {
+				break;
+			}
+
+			iterator.Advance();
+		}
+
+		if (found_count == 50) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"50 Emotes shown matching ID '{}', max reached.",
+					emote_id
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"{} Emote{} found matching ID '{}'.",
+				found_count,
+				found_count != 1 ? "s" : "",
+				emote_id
+			).c_str()
+		);
+
+		return;
+	}
+
+	const std::string& search_criteria = sep->argplus[2];
+
+	LinkedListIterator<NPC_Emote_Struct *> iterator(zone->NPCEmoteList);
+	iterator.Reset();
+	while (iterator.MoreElements()) {
+		auto &e = iterator.GetData();
+
+		const std::string& current_text = Strings::ToLower(e->text);
+
+		if (Strings::Contains(current_text, Strings::ToLower(search_criteria))) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Emote {} | Event: {} ({}) Type: {} ({})",
+					e->emoteid,
+					EQ::constants::GetEmoteEventTypeName(e->event_),
+					e->event_,
+					EQ::constants::GetEmoteTypeName(e->type),
+					e->type
+				).c_str()
+			);
+
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Emote {} | Text: {}",
+					e->emoteid,
+					e->text
+				).c_str()
+			);
+
+			found_count++;
+		}
+
+		if (found_count == 50) {
+			break;
+		}
+
+		iterator.Advance();
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 Emotes shown matching '{}', max reached.",
+				search_criteria
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Emote{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			search_criteria
+		).c_str()
+	);
+}
@@ -0,0 +1,84 @@
+#include "../../client.h"
+
+void FindFaction(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto  faction_id   = Strings::ToInt(sep->arg[2]);
+		const auto& faction_name = content_db.GetFactionName(faction_id);
+		if (!faction_name.empty()) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Faction {} | {}",
+					Strings::Commify(faction_id),
+					faction_name
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Faction ID {} was not found.",
+				Strings::Commify(faction_id)
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+	auto        found_count     = 0;
+	const auto  max_faction_id  = content_db.GetMaxFaction();
+
+	for (uint32 faction_id = 0; faction_id < max_faction_id; faction_id++) {
+		const auto& faction_name       = content_db.GetFactionName(faction_id);
+		const auto& faction_name_lower = Strings::ToLower(faction_name);
+		if (faction_name.empty()) {
+			continue;
+		}
+
+		if (!Strings::Contains(faction_name_lower, search_criteria)) {
+			continue;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Faction {} | {}",
+				Strings::Commify(faction_id),
+				faction_name
+			).c_str()
+		);
+
+		found_count++;
+
+		if (found_count == 50) {
+			break;
+		}
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 Factions found matching '{}', max reached.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Faction{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			sep->argplus[2]
+		).c_str()
+	);
+}
@@ -0,0 +1,140 @@
+#include "../../client.h"
+#include "../../common/repositories/items_repository.h"
+
+void FindItem(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto  item_id = Strings::ToUnsignedInt(sep->arg[2]);
+		const auto* item    = database.GetItem(item_id);
+		if (item) {
+			std::string summon_links = Saylink::Silent(
+				fmt::format(
+					"#si {}",
+					item_id
+				),
+				"X"
+			);
+
+			if (item->Stackable && item->StackSize > 1) {
+				summon_links += fmt::format(
+					" | {}",
+					Saylink::Silent(
+						fmt::format(
+							"#si {} {}",
+							item_id,
+							item->StackSize
+						),
+						std::to_string(item->StackSize)
+					)
+				);
+			}
+
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"{} | {}",
+					summon_links,
+					database.CreateItemLink(item_id)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Item ID {} not found",
+				item_id
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	const auto& l = ItemsRepository::GetItemIDsBySearchCriteria(content_db, search_criteria, 50);
+
+	if (l.empty()) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"No items were found matching '{}'.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	auto found_count = 0;
+
+	for (const auto& e : l) {
+		const auto item = database.GetItem(e);
+		if (!item) {
+			continue;
+		}
+
+		std::string summon_links = Saylink::Silent(
+			fmt::format(
+				"#si {}",
+				e
+			),
+			"X"
+		);
+
+		if (item->Stackable && item->StackSize > 1) {
+			summon_links += fmt::format(
+				" | {}",
+				Saylink::Silent(
+					fmt::format(
+						"#si {} {}",
+						e,
+						item->StackSize
+					),
+					std::to_string(item->StackSize)
+				)
+			);
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"{} | {} ({})",
+				summon_links,
+				database.CreateItemLink(e),
+				Strings::Commify(item->ID)
+			).c_str()
+		);
+
+		found_count++;
+
+		if (found_count == 50) {
+			break;
+		}
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 Items found matching '{}', max reached.",
+				sep->argplus[2]
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Item{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" :"",
+			sep->argplus[2]
+		).c_str()
+	);
+}
+
@@ -0,0 +1,64 @@
+#include "../../client.h"
+#include "../../common/languages.h"
+
+void FindLanguage(Client *c, const Seperator *sep)
+{
+	if (sep->IsNumber(2)) {
+		const auto language_id = Strings::ToInt(sep->arg[2]);
+		if (EQ::ValueWithin(language_id, LANG_COMMON_TONGUE, LANG_UNKNOWN)) {
+			c->Message(
+				Chat::White,
+				fmt::format(
+					"Language {} | {}",
+					language_id,
+					EQ::constants::GetLanguageName(language_id)
+				).c_str()
+			);
+
+			return;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Language ID {} was not found.",
+				language_id
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto& search_criteria = Strings::ToLower(sep->argplus[2]);
+
+	auto found_count = 0;
+
+	for (const auto& l : EQ::constants::GetLanguageMap()) {
+		const auto& language_name_lower = Strings::ToLower(l.second);
+		if (!Strings::Contains(language_name_lower, search_criteria)) {
+			continue;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Language {} | {}",
+				l.first,
+				l.second
+			).c_str()
+		);
+
+		found_count++;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} Language{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			sep->argplus[2]
+		).c_str()
+	);
+}
+
@@ -0,0 +1,94 @@
+#include "../../client.h"
+
+void FindNPCType(Client *c, const Seperator *sep)
+{
+	std::string query = "SELECT `id`, `name` FROM npc_types WHERE ";
+	const std::string& search_criteria = sep->argplus[2];
+	if (sep->IsNumber(2)) {
+		const auto npc_id = Strings::ToUnsignedInt(sep->arg[2]);
+
+		query += fmt::format(
+			"id = {}",
+			npc_id
+		);
+	} else {
+		query += fmt::format(
+			"`name` LIKE '%%{}%%'",
+			Strings::Escape(search_criteria)
+		);
+	}
+
+	query += " ORDER BY `id` ASC LIMIT 50";
+
+	auto results = content_db.QueryDatabase(query);
+	if (!results.Success() || !results.RowCount()) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"No NPCs matching '{}' were found.",
+				search_criteria
+			).c_str()
+		);
+
+		return;
+	}
+
+	const auto can_spawn_npcs = c->Admin() >= GetCommandStatus("#npctypespawn");
+
+	auto found_count = 0;
+
+	for (auto row : results) {
+		auto found_number = (found_count + 1);
+		if (found_count == 50) {
+			break;
+		}
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"NPC {} | {}{}",
+				Strings::Commify(row[0]),
+				row[1],
+				(
+					can_spawn_npcs ?
+					fmt::format(
+						" | {}",
+						Saylink::Silent(
+							fmt::format(
+								"#npctypespawn {}",
+								row[0]
+							),
+							"Spawn"
+						)
+					) :
+					""
+				)
+			).c_str()
+		);
+
+		found_count++;
+	}
+
+	if (found_count == 50) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"50 NPCs found matching '{}', max reached.",
+				search_criteria
+			).c_str()
+		);
+
+		return;
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"{} NPC{} found matching '{}'.",
+			found_count,
+			found_count != 1 ? "s" : "",
+			search_criteria
+		).c_str()
+	);
+}
+
--- a/Show More
+++ b/Show More