[Release] 22.36.0 (#3774)

* [Bug Fix] Fix Starting Items SQL

# Notes
- `race_list` comes before `class_list`,query had them in the wrong order.

* Real fix.

* Update database_update_manifest.cpp

* Manifest change

* Repository generate

---------

Co-authored-by: Akkadius <akkadius1@gmail.com>

CHANGELOG.md

@@ -1,3 +1,100 @@
+## [22.36.0] - 12/16/2023
+
+### Bots
+
+* Add rule to toggle DT hitting owner ([#3757](https://github.com/EQEmu/Server/pull/3757)) @nytmyr 2023-12-11
+* Enable auto-saving of bots. ([#3758](https://github.com/EQEmu/Server/pull/3758)) @nytmyr 2023-12-13
+
+### Code
+
+* Cleanup classes.cpp/classes.h ([#3752](https://github.com/EQEmu/Server/pull/3752)) @Kinglykrab 2023-12-13
+
+### Corpse
+
+* Fix /corpse command regression from #3727 ([#3770](https://github.com/EQEmu/Server/pull/3770)) @Akkadius 2023-12-16
+
+### Database
+
+* Make it clearer to users that a database backup is occurring ([#3769](https://github.com/EQEmu/Server/pull/3769)) @Akkadius 2023-12-16
+* When database version is greater than binary, we are up to date ([#3771](https://github.com/EQEmu/Server/pull/3771)) @Akkadius 2023-12-16
+
+### Fixes
+
+* Fix Starting Items SQL ([#3766](https://github.com/EQEmu/Server/pull/3766)) @Kinglykrab 2023-12-16
+
+### Logging
+
+* Change empty object loading to warning ([#3759](https://github.com/EQEmu/Server/pull/3759)) @nytmyr 2023-12-11
+
+### Rules
+
+* Add DOT and HOT Rules ([#3760](https://github.com/EQEmu/Server/pull/3760)) @Kinglykrab 2023-12-16
+
+## [22.35.0] - 12/10/2023
+
+### Bots
+
+* Add BotHealOnLevel to fully heal/mana on level. ([#3745](https://github.com/EQEmu/Server/pull/3745)) @nytmyr 2023-12-08
+* Fix bots learning spells on level ([#3744](https://github.com/EQEmu/Server/pull/3744)) @nytmyr 2023-12-08
+
+### Bug
+
+* Fix blocked spells regression from #3638 ([#3753](https://github.com/EQEmu/Server/pull/3753)) @joligario 2023-12-11
+* PR 3638 Missed the blocked spells repository updates ([#3748](https://github.com/EQEmu/Server/pull/3748)) @fryguy503 2023-12-08
+
+### CMake
+
+* Update minimum version of CMake ([#3743](https://github.com/EQEmu/Server/pull/3743)) @joligario 2023-12-08
+
+### Code
+
+* Remove hard-coded Status Checks ([#3727](https://github.com/EQEmu/Server/pull/3727)) @Kinglykrab 2023-12-03
+
+### Commands
+
+* #guild set CharName 0 did not remove char from guild. ([#3717](https://github.com/EQEmu/Server/pull/3717)) @noudess 2023-11-25
+* #petname changes PC to Nobody if selected. ([#3720](https://github.com/EQEmu/Server/pull/3720)) @noudess 2023-11-26
+* Add #show aas Command ([#3710](https://github.com/EQEmu/Server/pull/3710)) @Kinglykrab 2023-11-26
+* Add #task complete Command ([#3711](https://github.com/EQEmu/Server/pull/3711)) @Kinglykrab 2023-11-26
+* Cleanup #acceptrules Command ([#3716](https://github.com/EQEmu/Server/pull/3716)) @Kinglykrab 2023-11-26
+* Cleanup #disarmtrap Command ([#3713](https://github.com/EQEmu/Server/pull/3713)) @Kinglykrab 2023-11-26
+* Cleanup #list Command ([#3714](https://github.com/EQEmu/Server/pull/3714)) @Kinglykrab 2023-11-26
+* Cleanup #movement Command ([#3715](https://github.com/EQEmu/Server/pull/3715)) @Kinglykrab 2023-11-26
+* Cleanup #object Command ([#3722](https://github.com/EQEmu/Server/pull/3722)) @Kinglykrab 2023-12-03
+* Cleanup #zonebootup and #zoneshutdown Commands ([#3729](https://github.com/EQEmu/Server/pull/3729)) @Kinglykrab 2023-12-03
+* Fix formatting of #wpinfo output. ([#3728](https://github.com/EQEmu/Server/pull/3728)) @noudess 2023-12-01
+
+### Database
+
+* Add primary key to keyring table ([#3746](https://github.com/EQEmu/Server/pull/3746)) @Kinglykrab 2023-12-08
+* Consolidate Starting Items Table ([#3723](https://github.com/EQEmu/Server/pull/3723)) @Kinglykrab 2023-11-30
+* Extra whitespace in #3723 ([#3730](https://github.com/EQEmu/Server/pull/3730)) @joligario 2023-12-02
+* Minor adjustment to #3726 ([#3732](https://github.com/EQEmu/Server/pull/3732)) @joligario 2023-12-03
+* Modify `updated` column in `items` table with proper default. ([#3726](https://github.com/EQEmu/Server/pull/3726)) @joligario 2023-12-02
+* Pull Spell Group Cache from Content DB ([#3749](https://github.com/EQEmu/Server/pull/3749)) @fryguy503 2023-12-08
+
+### Faction
+
+* Alliance line is only allowed 1 faction change at a time. ([#3718](https://github.com/EQEmu/Server/pull/3718)) @noudess 2023-11-26
+
+### Fixes
+
+* Changing Group Leader Invalidated GetLeaderName() ([#3712](https://github.com/EQEmu/Server/pull/3712)) @Kinglykrab 2023-11-26
+* Fix 9245 SQL ([#3740](https://github.com/EQEmu/Server/pull/3740)) @Kinglykrab 2023-12-05
+* Fix Swarm Pets Requiring NPC Aggros Flag ([#3738](https://github.com/EQEmu/Server/pull/3738)) @Kinglykrab 2023-12-05
+* Guild Message Limits ([#3724](https://github.com/EQEmu/Server/pull/3724)) @neckkola 2023-11-29
+
+### Quest API
+
+* Add EVENT_AA_GAIN to AddAAPoints() ([#3733](https://github.com/EQEmu/Server/pull/3733)) @Kinglykrab 2023-12-03
+* Add GMMove Overloads to Perl/Lua ([#3719](https://github.com/EQEmu/Server/pull/3719)) @Kinglykrab 2023-11-25
+
+### Scripts
+
+* Import items into `items_new` table instead of writing directly to the existing `items` table. ([#3725](https://github.com/EQEmu/Server/pull/3725)) @joligario 2023-11-30
+* Revert database engine change from #3702. ([#3736](https://github.com/EQEmu/Server/pull/3736)) @joligario 2023-12-03
+* Update 13th Floor Import Tool ([#3702](https://github.com/EQEmu/Server/pull/3702)) @joligario 2023-11-26
+
 ## [22.34.2] - 11/23/2023
 
 ### Admin

client_files/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 
 add_subdirectory(import)
 add_subdirectory(export)

common/classes.h

@@ -19,99 +19,106 @@
 #define CLASSES_CH
 
 #include "../common/types.h"
+#include "../common/rulesys.h"
 #include <string>
+#include <map>
 
-#define NO_CLASS 0
-#define WARRIOR 1
-#define CLERIC 2
-#define PALADIN 3
-#define RANGER 4
-#define SHADOWKNIGHT 5
-#define DRUID 6
-#define MONK 7
-#define BARD 8
-#define ROGUE 9
-#define SHAMAN 10
-#define NECROMANCER 11
-#define WIZARD 12
-#define MAGICIAN 13
-#define ENCHANTER 14
-#define BEASTLORD 15
-#define BERSERKER 16
-#define WARRIORGM 20
-#define CLERICGM 21
-#define PALADINGM 22
-#define RANGERGM 23
-#define SHADOWKNIGHTGM 24
-#define DRUIDGM 25
-#define MONKGM 26
-#define BARDGM 27
-#define ROGUEGM 28
-#define SHAMANGM 29
-#define NECROMANCERGM 30
-#define WIZARDGM 31
-#define MAGICIANGM 32
-#define ENCHANTERGM 33
-#define BEASTLORDGM 34
-#define BERSERKERGM 35
-#define BANKER 40
-#define MERCHANT 41
-#define DISCORD_MERCHANT 59
-#define ADVENTURE_RECRUITER 60
-#define ADVENTURE_MERCHANT 61
-#define LDON_TREASURE 62	// objects you can use /open on first seen in LDONs, seen on Danvi's Corpse in Akheva
-#define TRIBUTE_MASTER 63
-#define GUILD_TRIBUTE_MASTER 64	// not sure
-#define GUILD_BANKER 66
-#define NORRATHS_KEEPERS_MERCHANT 67
-#define DARK_REIGN_MERCHANT 68
-#define FELLOWSHIP_MASTER 69
-#define ALT_CURRENCY_MERCHANT 70
-#define MERCENARY_MASTER 71
+namespace Class {
+	constexpr uint8 None                      = 0;
+	constexpr uint8 Warrior                   = 1;
+	constexpr uint8 Cleric                    = 2;
+	constexpr uint8 Paladin                   = 3;
+	constexpr uint8 Ranger                    = 4;
+	constexpr uint8 ShadowKnight              = 5;
+	constexpr uint8 Druid                     = 6;
+	constexpr uint8 Monk                      = 7;
+	constexpr uint8 Bard                      = 8;
+	constexpr uint8 Rogue                     = 9;
+	constexpr uint8 Shaman                    = 10;
+	constexpr uint8 Necromancer               = 11;
+	constexpr uint8 Wizard                    = 12;
+	constexpr uint8 Magician                  = 13;
+	constexpr uint8 Enchanter                 = 14;
+	constexpr uint8 Beastlord                 = 15;
+	constexpr uint8 Berserker                 = 16;
+	constexpr uint8 WarriorGM                 = 20;
+	constexpr uint8 ClericGM                  = 21;
+	constexpr uint8 PaladinGM                 = 22;
+	constexpr uint8 RangerGM                  = 23;
+	constexpr uint8 ShadowKnightGM            = 24;
+	constexpr uint8 DruidGM                   = 25;
+	constexpr uint8 MonkGM                    = 26;
+	constexpr uint8 BardGM                    = 27;
+	constexpr uint8 RogueGM                   = 28;
+	constexpr uint8 ShamanGM                  = 29;
+	constexpr uint8 NecromancerGM             = 30;
+	constexpr uint8 WizardGM                  = 31;
+	constexpr uint8 MagicianGM                = 32;
+	constexpr uint8 EnchanterGM               = 33;
+	constexpr uint8 BeastlordGM               = 34;
+	constexpr uint8 BerserkerGM               = 35;
+	constexpr uint8 Banker                    = 40;
+	constexpr uint8 Merchant                  = 41;
+	constexpr uint8 DiscordMerchant           = 59;
+	constexpr uint8 AdventureRecruiter        = 60;
+	constexpr uint8 AdventureMerchant         = 61;
+	constexpr uint8 LDoNTreasure              = 62;
+	constexpr uint8 TributeMaster             = 63;
+	constexpr uint8 GuildTributeMaster        = 64;
+	constexpr uint8 GuildBanker               = 66;
+	constexpr uint8 NorrathsKeepersMerchant   = 67;
+	constexpr uint8 DarkReignMerchant         = 68;
+	constexpr uint8 FellowshipMaster          = 69;
+	constexpr uint8 AlternateCurrencyMerchant = 70;
+	constexpr uint8 MercenaryLiaison          = 71;
 
+	constexpr uint8  PLAYER_CLASS_COUNT  = 16;
+	constexpr uint16 ALL_CLASSES_BITMASK = 65535;
+};
 
-// player class values
-#define PLAYER_CLASS_UNKNOWN 0
-#define PLAYER_CLASS_WARRIOR 1
-#define PLAYER_CLASS_CLERIC 2
-#define PLAYER_CLASS_PALADIN 3
-#define PLAYER_CLASS_RANGER 4
-#define PLAYER_CLASS_SHADOWKNIGHT 5
-#define PLAYER_CLASS_DRUID 6
-#define PLAYER_CLASS_MONK 7
-#define PLAYER_CLASS_BARD 8
-#define PLAYER_CLASS_ROGUE 9
-#define PLAYER_CLASS_SHAMAN 10
-#define PLAYER_CLASS_NECROMANCER 11
-#define PLAYER_CLASS_WIZARD 12
-#define PLAYER_CLASS_MAGICIAN 13
-#define PLAYER_CLASS_ENCHANTER 14
-#define PLAYER_CLASS_BEASTLORD 15
-#define PLAYER_CLASS_BERSERKER 16
+static std::map<uint8, uint16> player_class_bitmasks = {
+	{Class::Warrior,      1},
+	{Class::Cleric,       2},
+	{Class::Paladin,      4},
+	{Class::Ranger,       8},
+	{Class::ShadowKnight, 16},
+	{Class::Druid,        32},
+	{Class::Monk,         64},
+	{Class::Bard,         128},
+	{Class::Rogue,        256},
+	{Class::Shaman,       512},
+	{Class::Necromancer,  1024},
+	{Class::Wizard,       2048},
+	{Class::Magician,     4096},
+	{Class::Enchanter,    8192},
+	{Class::Beastlord,    16384},
+	{Class::Berserker,    32768},
+};
 
-#define PLAYER_CLASS_COUNT 16
+static std::string shadow_knight_class_name = (
+	RuleB(World, UseOldShadowKnightClassExport) ?
+	"Shadowknight" :
+	"Shadow Knight"
+);
 
-
-// player class bits
-#define PLAYER_CLASS_UNKNOWN_BIT 0
-#define PLAYER_CLASS_WARRIOR_BIT 1
-#define PLAYER_CLASS_CLERIC_BIT 2
-#define PLAYER_CLASS_PALADIN_BIT 4
-#define PLAYER_CLASS_RANGER_BIT 8
-#define PLAYER_CLASS_SHADOWKNIGHT_BIT 16
-#define PLAYER_CLASS_DRUID_BIT 32
-#define PLAYER_CLASS_MONK_BIT 64
-#define PLAYER_CLASS_BARD_BIT 128
-#define PLAYER_CLASS_ROGUE_BIT 256
-#define PLAYER_CLASS_SHAMAN_BIT 512
-#define PLAYER_CLASS_NECROMANCER_BIT 1024
-#define PLAYER_CLASS_WIZARD_BIT 2048
-#define PLAYER_CLASS_MAGICIAN_BIT 4096
-#define PLAYER_CLASS_ENCHANTER_BIT 8192
-#define PLAYER_CLASS_BEASTLORD_BIT 16384
-#define PLAYER_CLASS_BERSERKER_BIT 32768
-
-#define PLAYER_CLASS_ALL_MASK 65535	// was 65536
+static std::map<uint8, std::string> class_names = {
+	{Class::Warrior,      "Warrior"},
+	{Class::Cleric,       "Cleric"},
+	{Class::Paladin,      "Paladin"},
+	{Class::Ranger,       "Ranger"},
+	{Class::ShadowKnight, shadow_knight_class_name},
+	{Class::Druid,        "Druid"},
+	{Class::Monk,         "Monk"},
+	{Class::Bard,         "Bard"},
+	{Class::Rogue,        "Rogue"},
+	{Class::Shaman,       "Shaman"},
+	{Class::Necromancer,  "Necromancer"},
+	{Class::Wizard,       "Wizard"},
+	{Class::Magician,     "Magician"},
+	{Class::Enchanter,    "Enchanter"},
+	{Class::Beastlord,    "Beastlord"},
+	{Class::Berserker,    "Berserker"},
+};
 
 
 #define ARMOR_TYPE_UNKNOWN 0
@@ -126,16 +133,12 @@
 
 
 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);
-
-uint8 GetClassIDFromPlayerClassValue(uint32 player_class_value);
-uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit);
+uint8 GetPlayerClassValue(uint8 class_id);
+uint16 GetPlayerClassBit(uint8 class_id);
 
 bool IsFighterClass(uint8 class_id);
 bool IsSpellFighterClass(uint8 class_id);

common/database.cpp

@@ -29,6 +29,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "../common/repositories/account_repository.h"
+
 // Disgrace: for windows compile
 #ifdef _WINDOWS
 #include <windows.h>
@@ -1643,25 +1645,20 @@ void Database::ClearGroupLeader(uint32 gid) {
 		std::cout << "Unable to clear group leader: " << results.ErrorMessage() << std::endl;
 }
 
-uint8 Database::GetAgreementFlag(uint32 acctid) {
-
-	std::string query = StringFormat("SELECT rulesflag FROM account WHERE id=%i",acctid);
-	auto results = QueryDatabase(query);
-
-	if (!results.Success())
+uint8 Database::GetAgreementFlag(uint32 account_id)
+{
+	const auto& e = AccountRepository::FindOne(*this, account_id);
+	if (!e.id) {
 		return 0;
+	}
 
-	if (results.RowCount() != 1)
-		return 0;
-
-	auto row = results.begin();
-
-	return Strings::ToUnsignedInt(row[0]);
+	return e.rulesflag;
 }
 
-void Database::SetAgreementFlag(uint32 acctid) {
-	std::string query = StringFormat("UPDATE account SET rulesflag=1 where id=%i", acctid);
-	QueryDatabase(query);
+void Database::SetAgreementFlag(uint32 account_id) {
+	auto e = AccountRepository::FindOne(*this, account_id);
+	e.rulesflag = 1;
+	AccountRepository::UpdateOne(*this, e);
 }
 
 void Database::ClearRaid(uint32 rid) {

common/database.h

@@ -188,10 +188,10 @@ public:
 	uint32	CheckLogin(const char* name, const char* password, const char *loginserver, int16* oStatus = 0);
 	uint32	CreateAccount(const char* name, const char* password, int16 status, const char* loginserver, uint32 lsaccount_id);
 	uint32	GetAccountIDFromLSID(const std::string& in_loginserver_id, uint32 in_loginserver_account_id, char* in_account_name = 0, int16* in_status = 0);
-	uint8	GetAgreementFlag(uint32 acctid);
+	uint8	GetAgreementFlag(uint32 account_id);
 
 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
-	void	SetAgreementFlag(uint32 acctid);
+	void	SetAgreementFlag(uint32 account_id);
 
 	int  GetIPExemption(std::string account_ip);
 	void SetIPExemption(std::string account_ip, int exemption_amount);

common/database/database_dump_service.cpp

@@ -322,6 +322,10 @@ void DatabaseDumpService::DatabaseDump()
 			pipe_file
 		);
 
+		LogInfo("Backing up database [{}]", execute_command);
+		LogInfo("This can take a few minutes depending on the size of your database");
+		LogInfo("LOADING... PLEASE WAIT...");
+
 		BuildCredentialsFile();
 		std::string execution_result = Process::execute(execute_command);
 		if (!execution_result.empty() && IsDumpOutputToConsole()) {

common/database/database_update.cpp

@@ -274,9 +274,9 @@ bool DatabaseUpdate::CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b)
 	LogInfo("{}", Strings::Repeat("-", BREAK_LENGTH));
 
 	// server database version is required
-	bool server_up_to_date = v.server_database_version == b.server_database_version;
+	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;
+	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;
 }

common/database/database_update_manifest.cpp

@@ -5019,17 +5019,123 @@ ALTER TABLE `spawn2` DROP COLUMN `enabled`;
 )"
 	},
 	ManifestEntry{
-	  .version = 9242,
-	  .description = "2023_11_7_mintime_maxtime_spawnentry.sql",
-	  .check = "SHOW COLUMNS FROM `spawnentry` LIKE 'min_time'",
-	  .condition = "empty",
-	  .match = "",
-	  .sql = R"(
+		.version = 9242,
+		.description = "2023_11_7_mintime_maxtime_spawnentry.sql",
+		.check = "SHOW COLUMNS FROM `spawnentry` LIKE 'min_time'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
 ALTER TABLE `spawnentry`
 ADD COLUMN `min_time` smallint(4) NOT NULL DEFAULT 0 AFTER `condition_value_filter`,
 ADD COLUMN `max_time` smallint(4) NOT NULL DEFAULT 0 AFTER `min_time`;
 )"
-  },
+	},
+	ManifestEntry{
+		.version = 9243,
+		.description = "2023_11_27_starting_items_revamp.sql",
+		.check = "SHOW COLUMNS FROM `starting_items` LIKE 'race_list'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+CREATE TABLE `starting_items_backup_9243` LIKE `starting_items`;
+INSERT INTO `starting_items_backup_9243` SELECT * FROM `starting_items`;
+
+CREATE TABLE `starting_items_new`  (
+  `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT,
+  `race_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL,
+  `class_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL,
+  `deity_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL,
+  `zone_id_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL,
+  `item_id` int(11) UNSIGNED NOT NULL DEFAULT 0,
+  `item_charges` tinyint(3) UNSIGNED NOT NULL DEFAULT 1,
+  `gm` mediumint(3) UNSIGNED NOT NULL DEFAULT 0,
+  `slot` mediumint(9) NOT NULL DEFAULT -1,
+  `min_expansion` tinyint(4) NOT NULL DEFAULT -1,
+  `max_expansion` tinyint(4) NOT NULL DEFAULT -1,
+  `content_flags` varchar(100) NULL,
+  `content_flags_disabled` varchar(100) NULL,
+  PRIMARY KEY (`id`)
+);
+
+INSERT INTO
+`starting_items_new`
+(
+	SELECT
+		0 AS `id`,
+		GROUP_CONCAT(DISTINCT `class` ORDER BY class ASC SEPARATOR '|') AS `class_list`,
+		GROUP_CONCAT(DISTINCT `race` ORDER BY race ASC SEPARATOR '|') AS `race_list`,
+		GROUP_CONCAT(DISTINCT `deityid` ORDER BY deityid ASC SEPARATOR '|') AS `deity_list`,
+		GROUP_CONCAT(DISTINCT `zoneid` ORDER BY zoneid ASC SEPARATOR '|') AS `zone_list`,
+		`itemid`,
+		`item_charges`,
+		`gm`,
+		`slot`,
+		`min_expansion`,
+		`max_expansion`,
+		`content_flags`,
+		`content_flags_disabled`
+	FROM
+		`starting_items`
+	GROUP BY
+		`itemid`
+);
+
+DROP TABLE `starting_items`;
+RENAME TABLE `starting_items_new` TO `starting_items`;
+)"
+	},
+	ManifestEntry{
+		.version = 9244,
+		.description = "2023_11_30_items_table_schema.sql",
+		.check = "SHOW COLUMNS FROM `items` LIKE 'updated'",
+		.condition = "contains",
+		.match = "0000-00-00 00:00:00",
+		.sql = R"(
+ALTER TABLE `items` MODIFY COLUMN `updated` datetime NULL DEFAULT NULL;
+		)"
+	},
+	ManifestEntry{
+		.version = 9245,
+		.description = "2023_12_03_object_incline.sql",
+		.check = "SHOW COLUMNS FROM `object` LIKE 'incline'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `object` CHANGE COLUMN `unknown08` `size_percentage` float NOT NULL DEFAULT 0 AFTER `icon`;
+ALTER TABLE `object` CHANGE COLUMN `unknown10` `solid_type` mediumint(5) NOT NULL DEFAULT 0 AFTER `size`;
+ALTER TABLE `object` CHANGE COLUMN `unknown20` `incline` int(11) NOT NULL DEFAULT 0 AFTER `solid_type`;
+)"
+	},
+	ManifestEntry{
+		.version = 9246,
+		.description = "2023_12_07_keyring_id.sql",
+		.check = "SHOW COLUMNS FROM `keyring` LIKE 'id'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `keyring`
+ADD COLUMN `id` int UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
+ADD PRIMARY KEY (`id`);
+)"
+	},
+	ManifestEntry{
+		.version = 9247,
+		.description = "2023_12_14_starting_items_fix.sql",
+		.check = "SHOW COLUMNS FROM `starting_items` LIKE 'inventory_slot'",
+		.condition = "empty",
+		.match = "",
+		.sql = R"(
+ALTER TABLE `starting_items`
+CHANGE COLUMN `race_list` `temporary` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `id`,
+CHANGE COLUMN `class_list` `race_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `temporary`,
+CHANGE COLUMN `gm` `status` mediumint(3) NOT NULL DEFAULT 0 AFTER `item_charges`,
+CHANGE COLUMN `slot` `inventory_slot` mediumint(9) NOT NULL DEFAULT -1 AFTER `status`;
+
+ALTER TABLE `starting_items`
+CHANGE COLUMN `temporary` `class_list` text CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL AFTER `id`;
+)"
+	}
+
 // -- template; copy/paste this when you need to create a new entry
 //	ManifestEntry{
 //		.version = 9228,

common/eq_packet_structs.h

@@ -2594,11 +2594,11 @@ struct BookButton_Struct
 struct Object_Struct {
 /*00*/	uint32	linked_list_addr[2];// They are, get this, prev and next, ala linked list
 /*08*/	float	size;				//
-/*10*/	uint16	solidtype;			//
+/*10*/	uint16	solid_type;			//
 /*12*/	uint32	drop_id;			// Unique object id for zone
 /*16*/	uint16	zone_id;			// Redudant, but: Zone the object appears in
 /*18*/	uint16	zone_instance;		//
-/*20*/	uint32	unknown020;			//
+/*20*/	uint32	incline;			//
 /*24*/	uint32	unknown024;			//
 /*28*/	float	tilt_x;
 /*32*/	float	tilt_y;

common/features.h

@@ -238,25 +238,6 @@ enum {	//some random constants
 // Timer to update aggrometer
 #define AGGRO_METER_UPDATE_MS 1000
 
-//Some hard coded statuses from commands and other places:
-enum {
-	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
-	commandCastSpecials           = 100, //can cast special spells
-	commandDoAnimOthers           = 100, //can #doanim on others
-	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
-};
-
-
 // This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
 #define SAYLINK_ITEM_ID 0xFFFFF
 

common/inventory_profile.h

@@ -132,7 +132,7 @@ namespace EQ
 
 		// Swap items in inventory
 		enum SwapItemFailState : int8 { swapInvalid = -1, swapPass = 0, swapNotAllowed, swapNullData, swapRaceClass, swapDeity, swapLevel };
-		bool SwapItem(int16 source_slot, int16 destination_slot, SwapItemFailState& fail_state, uint16 race_id = RACE_DOUG_0, uint8 class_id = NO_CLASS, uint16 deity_id = deity::DeityType::DeityUnknown, uint8 level = 0);
+		bool SwapItem(int16 source_slot, int16 destination_slot, SwapItemFailState& fail_state, uint16 race_id = RACE_DOUG_0, uint8 class_id = Class::None, uint16 deity_id = deity::DeityType::DeityUnknown, uint8 level = 0);
 
 		// Remove item from inventory
 		bool DeleteItem(int16 slot_id, int16 quantity = 0);

common/patches/rof2.cpp

@@ -2706,7 +2706,7 @@ namespace RoF2
 
 		switch (raid_gen->action)
 		{
-		case raidAdd: 
+		case raidAdd:
 		{
 			RaidAddMember_Struct* emu = (RaidAddMember_Struct*)__emu_buffer;
 
@@ -3986,7 +3986,7 @@ namespace RoF2
 			if (strlen(emu->suffix))
 				PacketSize += strlen(emu->suffix) + 1;
 
-			if (emu->DestructibleObject || emu->class_ == LDON_TREASURE)
+			if (emu->DestructibleObject || emu->class_ == Class::LDoNTreasure)
 			{
 				if (emu->DestructibleObject)
 					PacketSize = PacketSize - 4;	// No bodytype
@@ -4076,7 +4076,7 @@ namespace RoF2
 			// actually part of bitfields
 			uint8 OtherData = 0;
 
-			if (emu->class_ == LDON_TREASURE) //LDoN Chest
+			if (emu->class_ == Class::LDoNTreasure) //LDoN Chest
 			{
 				OtherData = OtherData | 0x04;
 			}
@@ -4104,7 +4104,7 @@ namespace RoF2
 			// int DefaultEmitterID
 			VARSTRUCT_ENCODE_TYPE(float, Buffer, 0);	// unknown4
 
-			if (emu->DestructibleObject || emu->class_ == LDON_TREASURE)
+			if (emu->DestructibleObject || emu->class_ == Class::LDoNTreasure)
 			{
 				VARSTRUCT_ENCODE_STRING(Buffer, emu->DestructibleModel);
 				VARSTRUCT_ENCODE_STRING(Buffer, emu->DestructibleName2);

common/patches/uf.cpp

@@ -2758,7 +2758,7 @@ namespace UF
 			if (strlen(emu->suffix))
 				PacketSize += strlen(emu->suffix) + 1;
 
-			if (emu->DestructibleObject || emu->class_ == LDON_TREASURE)
+			if (emu->DestructibleObject || emu->class_ == Class::LDoNTreasure)
 			{
 				if (emu->DestructibleObject)
 					PacketSize = PacketSize - 4;	// No bodytype
@@ -2847,7 +2847,7 @@ namespace UF
 
 			uint8 OtherData = 0;
 
-			if (emu->class_ == LDON_TREASURE) //Ldon chest
+			if (emu->class_ == Class::LDoNTreasure) //Ldon chest
 			{
 				OtherData = OtherData | 0x01;
 			}
@@ -2873,7 +2873,7 @@ namespace UF
 			}
 			VARSTRUCT_ENCODE_TYPE(float, Buffer, 0);	// unknown4
 
-			if (emu->DestructibleObject || emu->class_ == LDON_TREASURE)
+			if (emu->DestructibleObject || emu->class_ == Class::LDoNTreasure)
 			{
 				VARSTRUCT_ENCODE_STRING(Buffer, emu->DestructibleModel);
 				VARSTRUCT_ENCODE_STRING(Buffer, emu->DestructibleName2);

common/repositories/base/base_blocked_spells_repository.h

@@ -16,6 +16,7 @@
 #include "../../strings.h"
 #include <ctime>
 
+
 class BaseBlockedSpellsRepository {
 public:
 	struct BlockedSpells {
@@ -31,6 +32,10 @@ public:
 		float       z_diff;
 		std::string message;
 		std::string description;
+		int8_t      min_expansion;
+		int8_t      max_expansion;
+		std::string content_flags;
+		std::string content_flags_disabled;
 	};
 
 	static std::string PrimaryKey()
@@ -53,6 +58,10 @@ public:
 			"z_diff",
 			"message",
 			"description",
+			"min_expansion",
+			"max_expansion",
+			"content_flags",
+			"content_flags_disabled",
 		};
 	}
 
@@ -71,6 +80,10 @@ public:
 			"z_diff",
 			"message",
 			"description",
+			"min_expansion",
+			"max_expansion",
+			"content_flags",
+			"content_flags_disabled",
 		};
 	}
 
@@ -111,18 +124,22 @@ public:
 	{
 		BlockedSpells e{};
 
-		e.id          = 0;
-		e.spellid     = 0;
-		e.type        = 0;
-		e.zoneid      = 0;
-		e.x           = 0;
-		e.y           = 0;
-		e.z           = 0;
-		e.x_diff      = 0;
-		e.y_diff      = 0;
-		e.z_diff      = 0;
-		e.message     = "";
-		e.description = "";
+		e.id                     = 0;
+		e.spellid                = 0;
+		e.type                   = 0;
+		e.zoneid                 = 0;
+		e.x                      = 0;
+		e.y                      = 0;
+		e.z                      = 0;
+		e.x_diff                 = 0;
+		e.y_diff                 = 0;
+		e.z_diff                 = 0;
+		e.message                = "";
+		e.description            = "";
+		e.min_expansion          = -1;
+		e.max_expansion          = -1;
+		e.content_flags          = "";
+		e.content_flags_disabled = "";
 
 		return e;
 	}
@@ -148,8 +165,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				blocked_spells_id
 			)
 		);
@@ -158,18 +176,22 @@ public:
 		if (results.RowCount() == 1) {
 			BlockedSpells e{};
 
-			e.id          = static_cast<int32_t>(atoi(row[0]));
-			e.spellid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type        = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid      = static_cast<int32_t>(atoi(row[3]));
-			e.x           = strtof(row[4], nullptr);
-			e.y           = strtof(row[5], nullptr);
-			e.z           = strtof(row[6], nullptr);
-			e.x_diff      = strtof(row[7], nullptr);
-			e.y_diff      = strtof(row[8], nullptr);
-			e.z_diff      = strtof(row[9], nullptr);
-			e.message     = row[10] ? row[10] : "";
-			e.description = row[11] ? row[11] : "";
+			e.id                     = static_cast<int32_t>(atoi(row[0]));
+			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.type                   = static_cast<int8_t>(atoi(row[2]));
+			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
+			e.x                      = strtof(row[4], nullptr);
+			e.y                      = strtof(row[5], nullptr);
+			e.z                      = strtof(row[6], nullptr);
+			e.x_diff                 = strtof(row[7], nullptr);
+			e.y_diff                 = strtof(row[8], nullptr);
+			e.z_diff                 = strtof(row[9], nullptr);
+			e.message                = row[10] ? row[10] : "";
+			e.description            = row[11] ? row[11] : "";
+			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
+			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.content_flags          = row[14] ? row[14] : "";
+			e.content_flags_disabled = row[15] ? row[15] : "";
 
 			return e;
 		}
@@ -214,6 +236,10 @@ public:
 		v.push_back(columns[9] + " = " + std::to_string(e.z_diff));
 		v.push_back(columns[10] + " = '" + Strings::Escape(e.message) + "'");
 		v.push_back(columns[11] + " = '" + Strings::Escape(e.description) + "'");
+		v.push_back(columns[12] + " = " + std::to_string(e.min_expansion));
+		v.push_back(columns[13] + " = " + std::to_string(e.max_expansion));
+		v.push_back(columns[14] + " = '" + Strings::Escape(e.content_flags) + "'");
+		v.push_back(columns[15] + " = '" + Strings::Escape(e.content_flags_disabled) + "'");
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -247,6 +273,10 @@ public:
 		v.push_back(std::to_string(e.z_diff));
 		v.push_back("'" + Strings::Escape(e.message) + "'");
 		v.push_back("'" + Strings::Escape(e.description) + "'");
+		v.push_back(std::to_string(e.min_expansion));
+		v.push_back(std::to_string(e.max_expansion));
+		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
+		v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -288,6 +318,10 @@ public:
 			v.push_back(std::to_string(e.z_diff));
 			v.push_back("'" + Strings::Escape(e.message) + "'");
 			v.push_back("'" + Strings::Escape(e.description) + "'");
+			v.push_back(std::to_string(e.min_expansion));
+			v.push_back(std::to_string(e.max_expansion));
+			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
+			v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'");
 
 			insert_chunks.push_back("(" + Strings::Implode(",", v) + ")");
 		}
@@ -321,18 +355,22 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BlockedSpells e{};
 
-			e.id          = static_cast<int32_t>(atoi(row[0]));
-			e.spellid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type        = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid      = static_cast<int32_t>(atoi(row[3]));
-			e.x           = strtof(row[4], nullptr);
-			e.y           = strtof(row[5], nullptr);
-			e.z           = strtof(row[6], nullptr);
-			e.x_diff      = strtof(row[7], nullptr);
-			e.y_diff      = strtof(row[8], nullptr);
-			e.z_diff      = strtof(row[9], nullptr);
-			e.message     = row[10] ? row[10] : "";
-			e.description = row[11] ? row[11] : "";
+			e.id                     = static_cast<int32_t>(atoi(row[0]));
+			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.type                   = static_cast<int8_t>(atoi(row[2]));
+			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
+			e.x                      = strtof(row[4], nullptr);
+			e.y                      = strtof(row[5], nullptr);
+			e.z                      = strtof(row[6], nullptr);
+			e.x_diff                 = strtof(row[7], nullptr);
+			e.y_diff                 = strtof(row[8], nullptr);
+			e.z_diff                 = strtof(row[9], nullptr);
+			e.message                = row[10] ? row[10] : "";
+			e.description            = row[11] ? row[11] : "";
+			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
+			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.content_flags          = row[14] ? row[14] : "";
+			e.content_flags_disabled = row[15] ? row[15] : "";
 
 			all_entries.push_back(e);
 		}
@@ -357,18 +395,22 @@ public:
 		for (auto row = results.begin(); row != results.end(); ++row) {
 			BlockedSpells e{};
 
-			e.id          = static_cast<int32_t>(atoi(row[0]));
-			e.spellid     = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
-			e.type        = static_cast<int8_t>(atoi(row[2]));
-			e.zoneid      = static_cast<int32_t>(atoi(row[3]));
-			e.x           = strtof(row[4], nullptr);
-			e.y           = strtof(row[5], nullptr);
-			e.z           = strtof(row[6], nullptr);
-			e.x_diff      = strtof(row[7], nullptr);
-			e.y_diff      = strtof(row[8], nullptr);
-			e.z_diff      = strtof(row[9], nullptr);
-			e.message     = row[10] ? row[10] : "";
-			e.description = row[11] ? row[11] : "";
+			e.id                     = static_cast<int32_t>(atoi(row[0]));
+			e.spellid                = static_cast<uint32_t>(strtoul(row[1], nullptr, 10));
+			e.type                   = static_cast<int8_t>(atoi(row[2]));
+			e.zoneid                 = static_cast<int32_t>(atoi(row[3]));
+			e.x                      = strtof(row[4], nullptr);
+			e.y                      = strtof(row[5], nullptr);
+			e.z                      = strtof(row[6], nullptr);
+			e.x_diff                 = strtof(row[7], nullptr);
+			e.y_diff                 = strtof(row[8], nullptr);
+			e.z_diff                 = strtof(row[9], nullptr);
+			e.message                = row[10] ? row[10] : "";
+			e.description            = row[11] ? row[11] : "";
+			e.min_expansion          = static_cast<int8_t>(atoi(row[12]));
+			e.max_expansion          = static_cast<int8_t>(atoi(row[13]));
+			e.content_flags          = row[14] ? row[14] : "";
+			e.content_flags_disabled = row[15] ? row[15] : "";
 
 			all_entries.push_back(e);
 		}

common/repositories/base/base_items_repository.h

@@ -75,7 +75,7 @@ public:
 		int32_t     damageshield;
 		int32_t     deity;
 		int32_t     delay;
-		int32_t     augdistiller;
+		uint32_t    augdistiller;
 		int32_t     dotshielding;
 		int32_t     dr;
 		int32_t     clicktype;
@@ -227,7 +227,7 @@ public:
 		int32_t     focusunk5;
 		std::string focusunk6;
 		int32_t     focusunk7;
-		int32_t     scrollunk1;
+		uint32_t    scrollunk1;
 		int32_t     scrollunk2;
 		int32_t     scrollunk3;
 		int32_t     scrollunk4;
@@ -266,10 +266,10 @@ public:
 		std::string created;
 		int16_t     elitematerial;
 		int16_t     ldonsellbackrate;
-		int16_t     scriptfileid;
+		int32_t     scriptfileid;
 		int16_t     expendablearrow;
-		int16_t     powersourcecapacity;
-		int16_t     bardeffect;
+		int32_t     powersourcecapacity;
+		int32_t     bardeffect;
 		int16_t     bardeffecttype;
 		int16_t     bardlevel2;
 		int16_t     bardlevel;
@@ -1307,7 +1307,7 @@ public:
 			e.damageshield        = static_cast<int32_t>(atoi(row[52]));
 			e.deity               = static_cast<int32_t>(atoi(row[53]));
 			e.delay               = static_cast<int32_t>(atoi(row[54]));
-			e.augdistiller        = static_cast<int32_t>(atoi(row[55]));
+			e.augdistiller        = static_cast<uint32_t>(strtoul(row[55], nullptr, 10));
 			e.dotshielding        = static_cast<int32_t>(atoi(row[56]));
 			e.dr                  = static_cast<int32_t>(atoi(row[57]));
 			e.clicktype           = static_cast<int32_t>(atoi(row[58]));
@@ -1459,7 +1459,7 @@ public:
 			e.focusunk5           = static_cast<int32_t>(atoi(row[204]));
 			e.focusunk6           = row[205] ? row[205] : "";
 			e.focusunk7           = static_cast<int32_t>(atoi(row[206]));
-			e.scrollunk1          = static_cast<int32_t>(atoi(row[207]));
+			e.scrollunk1          = static_cast<uint32_t>(strtoul(row[207], nullptr, 10));
 			e.scrollunk2          = static_cast<int32_t>(atoi(row[208]));
 			e.scrollunk3          = static_cast<int32_t>(atoi(row[209]));
 			e.scrollunk4          = static_cast<int32_t>(atoi(row[210]));
@@ -1498,10 +1498,10 @@ public:
 			e.created             = row[243] ? row[243] : "";
 			e.elitematerial       = static_cast<int16_t>(atoi(row[244]));
 			e.ldonsellbackrate    = static_cast<int16_t>(atoi(row[245]));
-			e.scriptfileid        = static_cast<int16_t>(atoi(row[246]));
+			e.scriptfileid        = static_cast<int32_t>(atoi(row[246]));
 			e.expendablearrow     = static_cast<int16_t>(atoi(row[247]));
-			e.powersourcecapacity = static_cast<int16_t>(atoi(row[248]));
-			e.bardeffect          = static_cast<int16_t>(atoi(row[249]));
+			e.powersourcecapacity = static_cast<int32_t>(atoi(row[248]));
+			e.bardeffect          = static_cast<int32_t>(atoi(row[249]));
 			e.bardeffecttype      = static_cast<int16_t>(atoi(row[250]));
 			e.bardlevel2          = static_cast<int16_t>(atoi(row[251]));
 			e.bardlevel           = static_cast<int16_t>(atoi(row[252]));
@@ -2563,7 +2563,7 @@ public:
 			e.damageshield        = static_cast<int32_t>(atoi(row[52]));
 			e.deity               = static_cast<int32_t>(atoi(row[53]));
 			e.delay               = static_cast<int32_t>(atoi(row[54]));
-			e.augdistiller        = static_cast<int32_t>(atoi(row[55]));
+			e.augdistiller        = static_cast<uint32_t>(strtoul(row[55], nullptr, 10));
 			e.dotshielding        = static_cast<int32_t>(atoi(row[56]));
 			e.dr                  = static_cast<int32_t>(atoi(row[57]));
 			e.clicktype           = static_cast<int32_t>(atoi(row[58]));
@@ -2715,7 +2715,7 @@ public:
 			e.focusunk5           = static_cast<int32_t>(atoi(row[204]));
 			e.focusunk6           = row[205] ? row[205] : "";
 			e.focusunk7           = static_cast<int32_t>(atoi(row[206]));
-			e.scrollunk1          = static_cast<int32_t>(atoi(row[207]));
+			e.scrollunk1          = static_cast<uint32_t>(strtoul(row[207], nullptr, 10));
 			e.scrollunk2          = static_cast<int32_t>(atoi(row[208]));
 			e.scrollunk3          = static_cast<int32_t>(atoi(row[209]));
 			e.scrollunk4          = static_cast<int32_t>(atoi(row[210]));
@@ -2754,10 +2754,10 @@ public:
 			e.created             = row[243] ? row[243] : "";
 			e.elitematerial       = static_cast<int16_t>(atoi(row[244]));
 			e.ldonsellbackrate    = static_cast<int16_t>(atoi(row[245]));
-			e.scriptfileid        = static_cast<int16_t>(atoi(row[246]));
+			e.scriptfileid        = static_cast<int32_t>(atoi(row[246]));
 			e.expendablearrow     = static_cast<int16_t>(atoi(row[247]));
-			e.powersourcecapacity = static_cast<int16_t>(atoi(row[248]));
-			e.bardeffect          = static_cast<int16_t>(atoi(row[249]));
+			e.powersourcecapacity = static_cast<int32_t>(atoi(row[248]));
+			e.bardeffect          = static_cast<int32_t>(atoi(row[249]));
 			e.bardeffecttype      = static_cast<int16_t>(atoi(row[250]));
 			e.bardlevel2          = static_cast<int16_t>(atoi(row[251]));
 			e.bardlevel           = static_cast<int16_t>(atoi(row[252]));
@@ -2872,7 +2872,7 @@ public:
 			e.damageshield        = static_cast<int32_t>(atoi(row[52]));
 			e.deity               = static_cast<int32_t>(atoi(row[53]));
 			e.delay               = static_cast<int32_t>(atoi(row[54]));
-			e.augdistiller        = static_cast<int32_t>(atoi(row[55]));
+			e.augdistiller        = static_cast<uint32_t>(strtoul(row[55], nullptr, 10));
 			e.dotshielding        = static_cast<int32_t>(atoi(row[56]));
 			e.dr                  = static_cast<int32_t>(atoi(row[57]));
 			e.clicktype           = static_cast<int32_t>(atoi(row[58]));
@@ -3024,7 +3024,7 @@ public:
 			e.focusunk5           = static_cast<int32_t>(atoi(row[204]));
 			e.focusunk6           = row[205] ? row[205] : "";
 			e.focusunk7           = static_cast<int32_t>(atoi(row[206]));
-			e.scrollunk1          = static_cast<int32_t>(atoi(row[207]));
+			e.scrollunk1          = static_cast<uint32_t>(strtoul(row[207], nullptr, 10));
 			e.scrollunk2          = static_cast<int32_t>(atoi(row[208]));
 			e.scrollunk3          = static_cast<int32_t>(atoi(row[209]));
 			e.scrollunk4          = static_cast<int32_t>(atoi(row[210]));
@@ -3063,10 +3063,10 @@ public:
 			e.created             = row[243] ? row[243] : "";
 			e.elitematerial       = static_cast<int16_t>(atoi(row[244]));
 			e.ldonsellbackrate    = static_cast<int16_t>(atoi(row[245]));
-			e.scriptfileid        = static_cast<int16_t>(atoi(row[246]));
+			e.scriptfileid        = static_cast<int32_t>(atoi(row[246]));
 			e.expendablearrow     = static_cast<int16_t>(atoi(row[247]));
-			e.powersourcecapacity = static_cast<int16_t>(atoi(row[248]));
-			e.bardeffect          = static_cast<int16_t>(atoi(row[249]));
+			e.powersourcecapacity = static_cast<int32_t>(atoi(row[248]));
+			e.bardeffect          = static_cast<int32_t>(atoi(row[249]));
 			e.bardeffecttype      = static_cast<int16_t>(atoi(row[250]));
 			e.bardlevel2          = static_cast<int16_t>(atoi(row[251]));
 			e.bardlevel           = static_cast<int16_t>(atoi(row[252]));

common/repositories/base/base_keyring_repository.h

@@ -0,0 +1,344 @@
+/**
+ * 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_KEYRING_REPOSITORY_H
+#define EQEMU_BASE_KEYRING_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../strings.h"
+#include <ctime>
+
+
+class BaseKeyringRepository {
+public:
+	struct Keyring {
+		uint32_t id;
+		int32_t  char_id;
+		int32_t  item_id;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"char_id",
+			"item_id",
+		};
+	}
+
+	static std::vector<std::string> SelectColumns()
+	{
+		return {
+			"id",
+			"char_id",
+			"item_id",
+		};
+	}
+
+	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("keyring");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			SelectColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			ColumnsRaw()
+		);
+	}
+
+	static Keyring NewEntity()
+	{
+		Keyring e{};
+
+		e.id      = 0;
+		e.char_id = 0;
+		e.item_id = 0;
+
+		return e;
+	}
+
+	static Keyring GetKeyring(
+		const std::vector<Keyring> &keyrings,
+		int keyring_id
+	)
+	{
+		for (auto &keyring : keyrings) {
+			if (keyring.id == keyring_id) {
+				return keyring;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static Keyring FindOne(
+		Database& db,
+		int keyring_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{} WHERE {} = {} LIMIT 1",
+				BaseSelect(),
+				PrimaryKey(),
+				keyring_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			Keyring e{};
+
+			e.id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.char_id = static_cast<int32_t>(atoi(row[1]));
+			e.item_id = static_cast<int32_t>(atoi(row[2]));
+
+			return e;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		Database& db,
+		int keyring_id
+	)
+	{
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				keyring_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		Database& db,
+		const Keyring &e
+	)
+	{
+		std::vector<std::string> v;
+
+		auto columns = Columns();
+
+		v.push_back(columns[1] + " = " + std::to_string(e.char_id));
+		v.push_back(columns[2] + " = " + std::to_string(e.item_id));
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				Strings::Implode(", ", v),
+				PrimaryKey(),
+				e.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static Keyring InsertOne(
+		Database& db,
+		Keyring e
+	)
+	{
+		std::vector<std::string> v;
+
+		v.push_back(std::to_string(e.id));
+		v.push_back(std::to_string(e.char_id));
+		v.push_back(std::to_string(e.item_id));
+
+		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<Keyring> &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(std::to_string(e.char_id));
+			v.push_back(std::to_string(e.item_id));
+
+			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<Keyring> All(Database& db)
+	{
+		std::vector<Keyring> all_entries;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			Keyring e{};
+
+			e.id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.char_id = static_cast<int32_t>(atoi(row[1]));
+			e.item_id = static_cast<int32_t>(atoi(row[2]));
+
+			all_entries.push_back(e);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<Keyring> GetWhere(Database& db, const std::string &where_filter)
+	{
+		std::vector<Keyring> 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) {
+			Keyring e{};
+
+			e.id      = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
+			e.char_id = static_cast<int32_t>(atoi(row[1]));
+			e.item_id = static_cast<int32_t>(atoi(row[2]));
+
+			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_KEYRING_REPOSITORY_H

common/repositories/base/base_object_repository.h

@@ -16,6 +16,7 @@
 #include "../../strings.h"
 #include <ctime>
 
+
 class BaseObjectRepository {
 public:
 	struct Object {
@@ -31,9 +32,9 @@ public:
 		std::string objectname;
 		int32_t     type;
 		int32_t     icon;
-		int32_t     unknown08;
-		int32_t     unknown10;
-		int32_t     unknown20;
+		float       size_percentage;
+		int32_t     solid_type;
+		int32_t     incline;
 		int32_t     unknown24;
 		int32_t     unknown60;
 		int32_t     unknown64;
@@ -71,9 +72,9 @@ public:
 			"objectname",
 			"type",
 			"icon",
-			"unknown08",
-			"unknown10",
-			"unknown20",
+			"size_percentage",
+			"solid_type",
+			"incline",
 			"unknown24",
 			"unknown60",
 			"unknown64",
@@ -107,9 +108,9 @@ public:
 			"objectname",
 			"type",
 			"icon",
-			"unknown08",
-			"unknown10",
-			"unknown20",
+			"size_percentage",
+			"solid_type",
+			"incline",
 			"unknown24",
 			"unknown60",
 			"unknown64",
@@ -177,9 +178,9 @@ public:
 		e.objectname             = "";
 		e.type                   = 0;
 		e.icon                   = 0;
-		e.unknown08              = 0;
-		e.unknown10              = 0;
-		e.unknown20              = 0;
+		e.size_percentage        = 0;
+		e.solid_type             = 0;
+		e.incline                = 0;
 		e.unknown24              = 0;
 		e.unknown60              = 0;
 		e.unknown64              = 0;
@@ -220,8 +221,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				object_id
 			)
 		);
@@ -242,9 +244,9 @@ public:
 			e.objectname             = row[9] ? row[9] : "";
 			e.type                   = static_cast<int32_t>(atoi(row[10]));
 			e.icon                   = static_cast<int32_t>(atoi(row[11]));
-			e.unknown08              = static_cast<int32_t>(atoi(row[12]));
-			e.unknown10              = static_cast<int32_t>(atoi(row[13]));
-			e.unknown20              = static_cast<int32_t>(atoi(row[14]));
+			e.size_percentage        = strtof(row[12], nullptr);
+			e.solid_type             = static_cast<int32_t>(atoi(row[13]));
+			e.incline                = static_cast<int32_t>(atoi(row[14]));
 			e.unknown24              = static_cast<int32_t>(atoi(row[15]));
 			e.unknown60              = static_cast<int32_t>(atoi(row[16]));
 			e.unknown64              = static_cast<int32_t>(atoi(row[17]));
@@ -304,9 +306,9 @@ public:
 		v.push_back(columns[9] + " = '" + Strings::Escape(e.objectname) + "'");
 		v.push_back(columns[10] + " = " + std::to_string(e.type));
 		v.push_back(columns[11] + " = " + std::to_string(e.icon));
-		v.push_back(columns[12] + " = " + std::to_string(e.unknown08));
-		v.push_back(columns[13] + " = " + std::to_string(e.unknown10));
-		v.push_back(columns[14] + " = " + std::to_string(e.unknown20));
+		v.push_back(columns[12] + " = " + std::to_string(e.size_percentage));
+		v.push_back(columns[13] + " = " + std::to_string(e.solid_type));
+		v.push_back(columns[14] + " = " + std::to_string(e.incline));
 		v.push_back(columns[15] + " = " + std::to_string(e.unknown24));
 		v.push_back(columns[16] + " = " + std::to_string(e.unknown60));
 		v.push_back(columns[17] + " = " + std::to_string(e.unknown64));
@@ -355,9 +357,9 @@ public:
 		v.push_back("'" + Strings::Escape(e.objectname) + "'");
 		v.push_back(std::to_string(e.type));
 		v.push_back(std::to_string(e.icon));
-		v.push_back(std::to_string(e.unknown08));
-		v.push_back(std::to_string(e.unknown10));
-		v.push_back(std::to_string(e.unknown20));
+		v.push_back(std::to_string(e.size_percentage));
+		v.push_back(std::to_string(e.solid_type));
+		v.push_back(std::to_string(e.incline));
 		v.push_back(std::to_string(e.unknown24));
 		v.push_back(std::to_string(e.unknown60));
 		v.push_back(std::to_string(e.unknown64));
@@ -414,9 +416,9 @@ public:
 			v.push_back("'" + Strings::Escape(e.objectname) + "'");
 			v.push_back(std::to_string(e.type));
 			v.push_back(std::to_string(e.icon));
-			v.push_back(std::to_string(e.unknown08));
-			v.push_back(std::to_string(e.unknown10));
-			v.push_back(std::to_string(e.unknown20));
+			v.push_back(std::to_string(e.size_percentage));
+			v.push_back(std::to_string(e.solid_type));
+			v.push_back(std::to_string(e.incline));
 			v.push_back(std::to_string(e.unknown24));
 			v.push_back(std::to_string(e.unknown60));
 			v.push_back(std::to_string(e.unknown64));
@@ -477,9 +479,9 @@ public:
 			e.objectname             = row[9] ? row[9] : "";
 			e.type                   = static_cast<int32_t>(atoi(row[10]));
 			e.icon                   = static_cast<int32_t>(atoi(row[11]));
-			e.unknown08              = static_cast<int32_t>(atoi(row[12]));
-			e.unknown10              = static_cast<int32_t>(atoi(row[13]));
-			e.unknown20              = static_cast<int32_t>(atoi(row[14]));
+			e.size_percentage        = strtof(row[12], nullptr);
+			e.solid_type             = static_cast<int32_t>(atoi(row[13]));
+			e.incline                = static_cast<int32_t>(atoi(row[14]));
 			e.unknown24              = static_cast<int32_t>(atoi(row[15]));
 			e.unknown60              = static_cast<int32_t>(atoi(row[16]));
 			e.unknown64              = static_cast<int32_t>(atoi(row[17]));
@@ -531,9 +533,9 @@ public:
 			e.objectname             = row[9] ? row[9] : "";
 			e.type                   = static_cast<int32_t>(atoi(row[10]));
 			e.icon                   = static_cast<int32_t>(atoi(row[11]));
-			e.unknown08              = static_cast<int32_t>(atoi(row[12]));
-			e.unknown10              = static_cast<int32_t>(atoi(row[13]));
-			e.unknown20              = static_cast<int32_t>(atoi(row[14]));
+			e.size_percentage        = strtof(row[12], nullptr);
+			e.solid_type             = static_cast<int32_t>(atoi(row[13]));
+			e.incline                = static_cast<int32_t>(atoi(row[14]));
 			e.unknown24              = static_cast<int32_t>(atoi(row[15]));
 			e.unknown60              = static_cast<int32_t>(atoi(row[16]));
 			e.unknown64              = static_cast<int32_t>(atoi(row[17]));

common/repositories/base/base_starting_items_repository.h

@@ -16,18 +16,19 @@
 #include "../../strings.h"
 #include <ctime>
 
+
 class BaseStartingItemsRepository {
 public:
 	struct StartingItems {
 		uint32_t    id;
-		int32_t     race;
-		int32_t     class_;
-		int32_t     deityid;
-		int32_t     zoneid;
-		int32_t     itemid;
+		std::string class_list;
+		std::string race_list;
+		std::string deity_list;
+		std::string zone_id_list;
+		uint32_t    item_id;
 		uint8_t     item_charges;
-		int8_t      gm;
-		int32_t     slot;
+		int32_t     status;
+		int32_t     inventory_slot;
 		int8_t      min_expansion;
 		int8_t      max_expansion;
 		std::string content_flags;
@@ -43,14 +44,14 @@ public:
 	{
 		return {
 			"id",
-			"race",
-			"`class`",
-			"deityid",
-			"zoneid",
-			"itemid",
+			"class_list",
+			"race_list",
+			"deity_list",
+			"zone_id_list",
+			"item_id",
 			"item_charges",
-			"gm",
-			"slot",
+			"status",
+			"inventory_slot",
 			"min_expansion",
 			"max_expansion",
 			"content_flags",
@@ -62,14 +63,14 @@ public:
 	{
 		return {
 			"id",
-			"race",
-			"`class`",
-			"deityid",
-			"zoneid",
-			"itemid",
+			"class_list",
+			"race_list",
+			"deity_list",
+			"zone_id_list",
+			"item_id",
 			"item_charges",
-			"gm",
-			"slot",
+			"status",
+			"inventory_slot",
 			"min_expansion",
 			"max_expansion",
 			"content_flags",
@@ -115,14 +116,14 @@ public:
 		StartingItems e{};
 
 		e.id                     = 0;
-		e.race                   = 0;
-		e.class_                 = 0;
-		e.deityid                = 0;
-		e.zoneid                 = 0;
-		e.itemid                 = 0;
+		e.class_list             = "";
+		e.race_list              = "";
+		e.deity_list             = "";
+		e.zone_id_list           = "";
+		e.item_id                = 0;
 		e.item_charges           = 1;
-		e.gm                     = 0;
-		e.slot                   = -1;
+		e.status                 = 0;
+		e.inventory_slot         = -1;
 		e.min_expansion          = -1;
 		e.max_expansion          = -1;
 		e.content_flags          = "";
@@ -152,8 +153,9 @@ public:
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
-				"{} WHERE id = {} LIMIT 1",
+				"{} WHERE {} = {} LIMIT 1",
 				BaseSelect(),
+				PrimaryKey(),
 				starting_items_id
 			)
 		);
@@ -163,14 +165,14 @@ public:
 			StartingItems e{};
 
 			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.race                   = static_cast<int32_t>(atoi(row[1]));
-			e.class_                 = static_cast<int32_t>(atoi(row[2]));
-			e.deityid                = static_cast<int32_t>(atoi(row[3]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[4]));
-			e.itemid                 = static_cast<int32_t>(atoi(row[5]));
+			e.class_list             = row[1] ? row[1] : "";
+			e.race_list              = row[2] ? row[2] : "";
+			e.deity_list             = row[3] ? row[3] : "";
+			e.zone_id_list           = row[4] ? row[4] : "";
+			e.item_id                = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
 			e.item_charges           = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.gm                     = static_cast<int8_t>(atoi(row[7]));
-			e.slot                   = static_cast<int32_t>(atoi(row[8]));
+			e.status                 = static_cast<int32_t>(atoi(row[7]));
+			e.inventory_slot         = static_cast<int32_t>(atoi(row[8]));
 			e.min_expansion          = static_cast<int8_t>(atoi(row[9]));
 			e.max_expansion          = static_cast<int8_t>(atoi(row[10]));
 			e.content_flags          = row[11] ? row[11] : "";
@@ -208,14 +210,14 @@ public:
 
 		auto columns = Columns();
 
-		v.push_back(columns[1] + " = " + std::to_string(e.race));
-		v.push_back(columns[2] + " = " + std::to_string(e.class_));
-		v.push_back(columns[3] + " = " + std::to_string(e.deityid));
-		v.push_back(columns[4] + " = " + std::to_string(e.zoneid));
-		v.push_back(columns[5] + " = " + std::to_string(e.itemid));
+		v.push_back(columns[1] + " = '" + Strings::Escape(e.class_list) + "'");
+		v.push_back(columns[2] + " = '" + Strings::Escape(e.race_list) + "'");
+		v.push_back(columns[3] + " = '" + Strings::Escape(e.deity_list) + "'");
+		v.push_back(columns[4] + " = '" + Strings::Escape(e.zone_id_list) + "'");
+		v.push_back(columns[5] + " = " + std::to_string(e.item_id));
 		v.push_back(columns[6] + " = " + std::to_string(e.item_charges));
-		v.push_back(columns[7] + " = " + std::to_string(e.gm));
-		v.push_back(columns[8] + " = " + std::to_string(e.slot));
+		v.push_back(columns[7] + " = " + std::to_string(e.status));
+		v.push_back(columns[8] + " = " + std::to_string(e.inventory_slot));
 		v.push_back(columns[9] + " = " + std::to_string(e.min_expansion));
 		v.push_back(columns[10] + " = " + std::to_string(e.max_expansion));
 		v.push_back(columns[11] + " = '" + Strings::Escape(e.content_flags) + "'");
@@ -242,14 +244,14 @@ public:
 		std::vector<std::string> v;
 
 		v.push_back(std::to_string(e.id));
-		v.push_back(std::to_string(e.race));
-		v.push_back(std::to_string(e.class_));
-		v.push_back(std::to_string(e.deityid));
-		v.push_back(std::to_string(e.zoneid));
-		v.push_back(std::to_string(e.itemid));
+		v.push_back("'" + Strings::Escape(e.class_list) + "'");
+		v.push_back("'" + Strings::Escape(e.race_list) + "'");
+		v.push_back("'" + Strings::Escape(e.deity_list) + "'");
+		v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
+		v.push_back(std::to_string(e.item_id));
 		v.push_back(std::to_string(e.item_charges));
-		v.push_back(std::to_string(e.gm));
-		v.push_back(std::to_string(e.slot));
+		v.push_back(std::to_string(e.status));
+		v.push_back(std::to_string(e.inventory_slot));
 		v.push_back(std::to_string(e.min_expansion));
 		v.push_back(std::to_string(e.max_expansion));
 		v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -284,14 +286,14 @@ public:
 			std::vector<std::string> v;
 
 			v.push_back(std::to_string(e.id));
-			v.push_back(std::to_string(e.race));
-			v.push_back(std::to_string(e.class_));
-			v.push_back(std::to_string(e.deityid));
-			v.push_back(std::to_string(e.zoneid));
-			v.push_back(std::to_string(e.itemid));
+			v.push_back("'" + Strings::Escape(e.class_list) + "'");
+			v.push_back("'" + Strings::Escape(e.race_list) + "'");
+			v.push_back("'" + Strings::Escape(e.deity_list) + "'");
+			v.push_back("'" + Strings::Escape(e.zone_id_list) + "'");
+			v.push_back(std::to_string(e.item_id));
 			v.push_back(std::to_string(e.item_charges));
-			v.push_back(std::to_string(e.gm));
-			v.push_back(std::to_string(e.slot));
+			v.push_back(std::to_string(e.status));
+			v.push_back(std::to_string(e.inventory_slot));
 			v.push_back(std::to_string(e.min_expansion));
 			v.push_back(std::to_string(e.max_expansion));
 			v.push_back("'" + Strings::Escape(e.content_flags) + "'");
@@ -330,14 +332,14 @@ public:
 			StartingItems e{};
 
 			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.race                   = static_cast<int32_t>(atoi(row[1]));
-			e.class_                 = static_cast<int32_t>(atoi(row[2]));
-			e.deityid                = static_cast<int32_t>(atoi(row[3]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[4]));
-			e.itemid                 = static_cast<int32_t>(atoi(row[5]));
+			e.class_list             = row[1] ? row[1] : "";
+			e.race_list              = row[2] ? row[2] : "";
+			e.deity_list             = row[3] ? row[3] : "";
+			e.zone_id_list           = row[4] ? row[4] : "";
+			e.item_id                = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
 			e.item_charges           = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.gm                     = static_cast<int8_t>(atoi(row[7]));
-			e.slot                   = static_cast<int32_t>(atoi(row[8]));
+			e.status                 = static_cast<int32_t>(atoi(row[7]));
+			e.inventory_slot         = static_cast<int32_t>(atoi(row[8]));
 			e.min_expansion          = static_cast<int8_t>(atoi(row[9]));
 			e.max_expansion          = static_cast<int8_t>(atoi(row[10]));
 			e.content_flags          = row[11] ? row[11] : "";
@@ -367,14 +369,14 @@ public:
 			StartingItems e{};
 
 			e.id                     = static_cast<uint32_t>(strtoul(row[0], nullptr, 10));
-			e.race                   = static_cast<int32_t>(atoi(row[1]));
-			e.class_                 = static_cast<int32_t>(atoi(row[2]));
-			e.deityid                = static_cast<int32_t>(atoi(row[3]));
-			e.zoneid                 = static_cast<int32_t>(atoi(row[4]));
-			e.itemid                 = static_cast<int32_t>(atoi(row[5]));
+			e.class_list             = row[1] ? row[1] : "";
+			e.race_list              = row[2] ? row[2] : "";
+			e.deity_list             = row[3] ? row[3] : "";
+			e.zone_id_list           = row[4] ? row[4] : "";
+			e.item_id                = static_cast<uint32_t>(strtoul(row[5], nullptr, 10));
 			e.item_charges           = static_cast<uint8_t>(strtoul(row[6], nullptr, 10));
-			e.gm                     = static_cast<int8_t>(atoi(row[7]));
-			e.slot                   = static_cast<int32_t>(atoi(row[8]));
+			e.status                 = static_cast<int32_t>(atoi(row[7]));
+			e.inventory_slot         = static_cast<int32_t>(atoi(row[8]));
 			e.min_expansion          = static_cast<int8_t>(atoi(row[9]));
 			e.max_expansion          = static_cast<int8_t>(atoi(row[10]));
 			e.content_flags          = row[11] ? row[11] : "";

common/repositories/command_subsettings_repository.h

@@ -120,6 +120,7 @@ public:
 			{.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 = "aas", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showaas"},
 			{.parent_command = "show", .sub_command = "aa_points", .access_level = AccountStatus::QuestTroupe, .top_level_aliases = "showaapoints|showaapts"},
 			{.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"},

common/repositories/keyring_repository.h

@@ -0,0 +1,50 @@
+#ifndef EQEMU_KEYRING_REPOSITORY_H
+#define EQEMU_KEYRING_REPOSITORY_H
+
+#include "../database.h"
+#include "../strings.h"
+#include "base/base_keyring_repository.h"
+
+class KeyringRepository: public BaseKeyringRepository {
+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
+     *
+     * KeyringRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * KeyringRepository::GetWhereNeverExpires()
+     * KeyringRepository::GetWhereXAndY()
+     * KeyringRepository::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
+
+};
+
+#endif //EQEMU_KEYRING_REPOSITORY_H

common/ruletypes.h

@@ -304,6 +304,8 @@ RULE_BOOL(World, EnableDevTools, true, "Enable or Disable the Developer Tools gl
 RULE_BOOL(World, EnableChecksumVerification, false, "Enable or Disable the Checksum Verification for eqgame.exe and spells_us.txt")
 RULE_INT(World, MaximumQuestErrors, 30, "Changes the maximum number of quest errors that can be displayed in #questerrors, default is 30")
 RULE_INT(World, BootHour, 0, "Sets the in-game hour world will set when it first boots. 0-24 are valid options, where 0 disables this rule")
+RULE_BOOL(World, UseItemLinksForKeyRing, false, "Uses item links for Key Ring Listing instead of item name")
+RULE_BOOL(World, UseOldShadowKnightClassExport, true, "Disable to have Shadowknight show as Shadow Knight (live-like)")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Zone)
@@ -457,6 +459,8 @@ RULE_INT(Spells, WizardCritMinimumRandomRatio, 20, "The minimum value for the ra
 RULE_INT(Spells, WizardCritMaximumRandomRatio, 70, "The maximum value for the random range which Wizards and Caster DPS Mercs innately have for spell crit ratio. Set to 70 for vanilla values.")
 RULE_INT(Spells, DefensiveProcPenaltyLevelGap, 6, "Defensive Proc Penalty Level Gap where procs start losing their proc rate at RuleR(Spells, DefensiveProcPenaltyModifier)% per level difference")
 RULE_REAL(Spells, DefensiveProcPenaltyLevelGapModifier, 10.0f, "Defensive Proc Penalty Level Gap Modifier where procs start losing their proc rate at defined % after RuleI(Spells, DefensiveProcLevelGap) level difference")
+RULE_BOOL(Spells, DOTBonusDamageSplitOverDuration, true, "Disable to have Damage Over Time total bonus damage added to each tick instead of divided across duration")
+RULE_BOOL(Spells, HOTBonusHealingSplitOverDuration, true, "Disable to have Heal Over Time total bonus healing added to each tick instead of divided across duration")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Combat)
@@ -649,6 +653,9 @@ RULE_BOOL(Bots, ResurrectionSickness, true, "Use Resurrection Sickness based on
 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_BOOL(Bots, BotHealOnLevel, false, "Setting whether a bot should heal completely when leveling. Default FALSE.")
+RULE_INT(Bots, AutosaveIntervalSeconds, 300, "Number of seconds after which a timer is triggered which stores the bot data. The value 0 means no periodic automatic saving.")
+RULE_BOOL(Bots, CazicTouchBotsOwner, true, "Default True. Cazic Touch/DT will hit bot owner rather than bot.")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Chat)

common/servertalk.h

@@ -461,12 +461,12 @@ struct SPackSendQueue {
 	uchar buffer[0];
 };
 
-struct ServerZoneStateChange_struct {
-	uint32 ZoneServerID;
-	char adminname[64];
-	uint32 zoneid;
-	uint16 instanceid;
-	bool makestatic;
+struct ServerZoneStateChange_Struct {
+	uint32 zone_server_id;
+	uint32 zone_id;
+	uint16 instance_id;
+	bool   is_static;
+	char   admin_name[64];
 };
 
 struct ServerZoneIncomingClient_Struct {

common/shareddb.cpp

@@ -41,6 +41,7 @@
 #include "repositories/criteria/content_filter_criteria.h"
 #include "repositories/account_repository.h"
 #include "repositories/faction_association_repository.h"
+#include "repositories/starting_items_repository.h"
 #include "path_manager.h"
 #include "repositories/loottable_repository.h"
 
@@ -446,45 +447,81 @@ bool SharedDatabase::SetSharedPlatinum(uint32 account_id, int32 amount_to_add) {
 	return true;
 }
 
-bool SharedDatabase::SetStartingItems(PlayerProfile_Struct* pp, EQ::InventoryProfile* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin_level) {
+bool SharedDatabase::SetStartingItems(
+	PlayerProfile_Struct *pp,
+	EQ::InventoryProfile *inv,
+	uint32 si_race,
+	uint32 si_class,
+	uint32 si_deity,
+	uint32 si_current_zone,
+	char *si_name,
+	int admin_level
+)
+{
+	const EQ::ItemData *item_data;
 
-	const EQ::ItemData *myitem;
+	const auto &l = StartingItemsRepository::All(*this);
 
-	const std::string query   = StringFormat(
-		"SELECT itemid, item_charges, slot FROM starting_items "
-		"WHERE (race = %i or race = 0) AND (class = %i or class = 0) AND "
-		"(deityid = %i or deityid = 0) AND (zoneid = %i or zoneid = 0) AND "
-		"gm <= %i %s ORDER BY id",
-		si_race,
-		si_class,
-		si_deity,
-		si_current_zone,
-		admin_level,
-		ContentFilterCriteria::apply().c_str()
-	);
-
-	auto results = QueryDatabase(query);
-	if (!results.Success()) {
+	if (l.empty()) {
 		return false;
 	}
 
+	std::vector<StartingItemsRepository::StartingItems> v;
 
-	for (auto& row = results.begin(); row != results.end(); ++row) {
-		const int32 itemid = Strings::ToInt(row[0]);
-		const int32 charges = Strings::ToInt(row[1]);
-		int32 slot = Strings::ToInt(row[2]);
-		myitem = GetItem(itemid);
+	for (const auto &e : l) {
+		const auto &classes = Strings::Split(e.class_list, "|");
+		const auto &deities = Strings::Split(e.deity_list, "|");
+		const auto &races   = Strings::Split(e.race_list, "|");
+		const auto &zones   = Strings::Split(e.zone_id_list, "|");
 
-		if(!myitem)
+		const std::string &all = std::to_string(0);
+
+		if (classes[0] != all) {
+			if (!Strings::Contains(classes, std::to_string(si_class))) {
+				continue;
+			}
+		}
+
+		if (deities[0] != all) {
+			if (!Strings::Contains(deities, std::to_string(si_deity))) {
+				continue;
+			}
+		}
+
+		if (races[0] != all) {
+			if (!Strings::Contains(races, std::to_string(si_race))) {
+				continue;
+			}
+		}
+
+		if (zones[0] != all) {
+			if (!Strings::Contains(zones, std::to_string(si_current_zone))) {
+				continue;
+			}
+		}
+
+		v.emplace_back(e);
+	}
+
+	for (const auto &e : v) {
+		const uint32 item_id      = e.item_id;
+		const uint8  item_charges = e.item_charges;
+		int32        slot         = e.inventory_slot;
+
+		item_data = GetItem(item_id);
+
+		if (!item_data) {
 			continue;
+		}
 
-		const EQ::ItemInstance* myinst = CreateBaseItem(myitem, charges);
+		const auto *inst = CreateBaseItem(item_data, item_charges);
 
-		if(slot < 0)
-			slot = inv->FindFreeSlot(0, 0);
+		if (slot < EQ::invslot::slotCharm) {
+			slot = inv->FindFreeSlot(false, false);
+		}
 
-		inv->PutItem(slot, *myinst);
-		safe_delete(myinst);
+		inv->PutItem(slot, *inst);
+		safe_delete(inst);
 	}
 
 	return true;
@@ -1771,7 +1808,7 @@ bool SharedDatabase::LoadSkillCaps(const std::string &prefix) {
 }
 
 void SharedDatabase::LoadSkillCaps(void *data) {
-	const uint32 class_count = PLAYER_CLASS_COUNT;
+	const uint32 class_count = Class::PLAYER_CLASS_COUNT;
 	const uint32 skill_count = EQ::skills::HIGHEST_SKILL + 1;
 	const uint32 level_count = HARD_LEVEL_CAP + 1;
 	uint16 *skill_caps_table = static_cast<uint16*>(data);
@@ -1811,7 +1848,7 @@ uint16 SharedDatabase::GetSkillCap(uint8 Class_, EQ::skills::SkillType Skill, ui
 		SkillMaxLevel = RuleI(Character, MaxLevel);
 	}
 
-	const uint32 class_count = PLAYER_CLASS_COUNT;
+	const uint32 class_count = Class::PLAYER_CLASS_COUNT;
 	const uint32 skill_count = EQ::skills::HIGHEST_SKILL + 1;
 	const uint32 level_count = HARD_LEVEL_CAP + 1;
 	if(Class_ > class_count || static_cast<uint32>(Skill) > skill_count || Level > level_count) {
@@ -1841,7 +1878,7 @@ uint8 SharedDatabase::GetTrainLevel(uint8 Class_, EQ::skills::SkillType Skill, u
 		SkillMaxLevel = RuleI(Character, MaxLevel);
 	}
 
-	const uint32 class_count = PLAYER_CLASS_COUNT;
+	const uint32 class_count = Class::PLAYER_CLASS_COUNT;
 	const uint32 skill_count = EQ::skills::HIGHEST_SKILL + 1;
 	const uint32 level_count = HARD_LEVEL_CAP + 1;
 	if(Class_ > class_count || static_cast<uint32>(Skill) > skill_count || Level > level_count) {
@@ -2024,7 +2061,7 @@ void SharedDatabase::LoadSpells(void *data, int max_spells) {
 		sp[tempid].environment_type=Strings::ToInt(row[102]);
 		sp[tempid].time_of_day=Strings::ToInt(row[103]);
 
-		for(y=0; y < PLAYER_CLASS_COUNT;y++)
+		for(y=0; y < Class::PLAYER_CLASS_COUNT;y++)
 			sp[tempid].classes[y]=Strings::ToInt(row[104+y]);
 
 		sp[tempid].casting_animation=Strings::ToInt(row[120]);

common/spdat.cpp

@@ -666,7 +666,7 @@ bool IsBardSong(uint16 spell_id)
 	const auto& spell = spells[spell_id];
 
 	if (
-		spell.classes[BARD - 1] < UINT8_MAX &&
+		spell.classes[Class::Bard - 1] < UINT8_MAX &&
 		!spell.is_discipline
 	) {
 		return true;
@@ -780,7 +780,7 @@ uint8 GetSpellMinimumLevel(uint16 spell_id)
 
 	const auto& spell = spells[spell_id];
 
-	for (int i = 0; i < PLAYER_CLASS_COUNT; i++) {
+	for (int i = 0; i < Class::PLAYER_CLASS_COUNT; i++) {
 		if (spell.classes[i] < minimum_level) {
 			minimum_level = spell.classes[i];
 		}
@@ -798,7 +798,7 @@ uint8 GetSpellLevel(uint16 spell_id, uint8 class_id)
 		return UINT8_MAX;
 	}
 
-	if (class_id >= PLAYER_CLASS_COUNT) {
+	if (class_id >= Class::PLAYER_CLASS_COUNT) {
 		return UINT8_MAX;
 	}
 

common/spdat.h

@@ -1369,7 +1369,7 @@ struct SPDat_Spell_Struct
 /* 101 */	int8 zone_type; // 01=Outdoors, 02=dungeons, ff=Any -- ZONETYPE
 /* 102 */	int8 environment_type; // -- ENVIRONMENTTYPE
 /* 103 */	int8 time_of_day; // -- TIMEOFDAY
-/* 104 */	uint8 classes[PLAYER_CLASS_COUNT]; // Classes, and their min levels -- WARRIORMIN ... BERSERKERMIN
+/* 104 */	uint8 classes[Class::PLAYER_CLASS_COUNT]; // Classes, and their min levels -- WARRIORMIN ... BERSERKERMIN
 /* 120 */	uint8 casting_animation; // -- CASTINGANIM
 /* 121 */	//uint8 TargetAnim; // -- TARGETANIM
 /* 122 */	//uint32 TravelType; // -- TRAVELTYPE

common/version.h

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "eqemu-server",
-  "version": "22.34.2",
+  "version": "22.36.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/EQEmu/Server.git"

shared_memory/skill_caps.cpp

@@ -29,7 +29,7 @@ void LoadSkillCaps(SharedDatabase *database, const std::string &prefix) {
 	EQ::IPCMutex mutex("skill_caps");
 	mutex.Lock();
 
-	uint32 class_count = PLAYER_CLASS_COUNT;
+	uint32 class_count = Class::PLAYER_CLASS_COUNT;
 	uint32 skill_count = EQ::skills::HIGHEST_SKILL + 1;
 	uint32 level_count = HARD_LEVEL_CAP + 1;
 	uint32 size = (class_count * skill_count * level_count * sizeof(uint16));

utils/scripts/import_13th_floor.pl

@@ -2,8 +2,13 @@
 
 ########################################################################
 #::: 13th floor import script
-#::: Current Source: http://items.sodeq.org/download.php
-#::: Authors: (Natedog, Akkadius)
+#::: Items Source: http://items.sodeq.org/download.php
+#::: How To:
+#:::   1. Place this script with your server eqemu_config.json
+#:::   2. Download the items.txt file and place with this script
+#:::   3. Run this script with Perl
+#:::   4. Review new and updated items in the items_new table
+#:::   5. Make any desired changes and replace the items table contents
 ########################################################################
 
 use DBI;
@@ -16,6 +21,7 @@ my $db_user = "";
 my $db_pass = "";
 my $total_items = 0;
 my $read_items_file = "items.txt"; #default
+my $keep_temp_items_table = 0; #keeps the imported items table
 
 read_eqemu_config_json();
 
@@ -24,7 +30,7 @@ my $dbh = DBI->connect("DBI:mysql:database=$db_name;host=$db_host;port=$db_port"
 read_items_file_from_13th_floor_text();
 update_items_table();
 
-print "\n\nImport complete!\n\n";
+print "\n\nImport complete! Review items_new table before replacing into items table.\n\n";
 
 sub read_eqemu_config_json {
     use JSON;
@@ -139,7 +145,12 @@ sub read_items_file_from_13th_floor_text {
 
 sub update_items_table {
 
-        print "Updating items table...\n";
+        #::: Establish items_new table
+        print "Setting up new items table...\n";
+        $dbh->do("DROP TABLE IF EXISTS items_new");
+        $dbh->do("CREATE TABLE items_new AS SELECT * FROM items");
+
+        print "Updating new items table...\n";
 
         my @matching_table;
         my @missing_items_table;
@@ -147,7 +158,7 @@ sub update_items_table {
 
         print "Comparing table structure...\n";
         #::: Get columns from `items`
-        my $sth = $dbh->prepare("SHOW COLUMNS FROM `items`;");
+        my $sth = $dbh->prepare("SHOW COLUMNS FROM `items_new`;");
         $sth->execute();
         my @items_table;
         while (my @row = $sth->fetchrow_array()) {
@@ -230,7 +241,7 @@ sub update_items_table {
         }
 
         my $update_query = "
-                INSERT INTO items (" . $items_field_list . ")
+                INSERT INTO items_new (" . $items_field_list . ")
                 SELECT " . $items_floor_field_list . "
                 FROM items_floor fi
                 ON DUPLICATE KEY UPDATE " . $update_fields;
@@ -257,14 +268,20 @@ sub update_items_table {
 
         #::: Update stackables
         print "Updating stackable field...\n";
-        $dbh->do("UPDATE items i SET i.stackable = 1 WHERE i.stacksize > 1");
+        $dbh->do("UPDATE items_new i SET i.stackable = 1 WHERE i.stacksize > 1");
 
         #::: Update legacy research tome bagtypes
         print "Updating legacy research tomes...\n";
-        $dbh->do("UPDATE items i SET i.bagtype = 24 WHERE i.id IN (17655, 17903)"); #RESEARCHWIZ
-        $dbh->do("UPDATE items i SET i.bagtype = 25 WHERE i.id IN (17502, 17653)"); #RESEARCHMAG
-        $dbh->do("UPDATE items i SET i.bagtype = 26 WHERE i.id IN (17501, 17654)"); #RESEARCHNEC
-        $dbh->do("UPDATE items i SET i.bagtype = 27 WHERE i.id IN (17500, 17652)"); #RESEARCHENC
+        $dbh->do("UPDATE items_new i SET i.bagtype = 24 WHERE i.id IN (17655, 17903)"); #RESEARCHWIZ
+        $dbh->do("UPDATE items_new i SET i.bagtype = 25 WHERE i.id IN (17502, 17653)"); #RESEARCHMAG
+        $dbh->do("UPDATE items_new i SET i.bagtype = 26 WHERE i.id IN (17501, 17654)"); #RESEARCHNEC
+        $dbh->do("UPDATE items_new i SET i.bagtype = 27 WHERE i.id IN (17500, 17652)"); #RESEARCHENC
+
+        #::: Remove temp table
+        if (!$keep_temp_items_table) {
+          print "Cleaning up temp items table...\n";
+          $dbh->do("DROP TABLE items_floor");
+        }
 }
 
 sub trim($) {

world/client.cpp

@@ -1966,7 +1966,7 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
 	{ /*Drakkin*/    70,  80,  85,  75,  80,  85,  75}
 	};
 
-	static const int BaseClass[PLAYER_CLASS_COUNT][8] =
+	static const int BaseClass[Class::PLAYER_CLASS_COUNT][8] =
 	{              /* STR  STA  AGI  DEX  WIS  INT  CHR  ADD*/
 	{ /*Warrior*/      10,  10,   5,   0,   0,   0,   0,  25},
 	{ /*Cleric*/        5,   5,   0,   0,  10,   0,   0,  30},
@@ -1986,7 +1986,7 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
 	{ /*Berserker*/    10,   5,   0,  10,   0,   0,   0,  25}
 	};
 
-	static const bool ClassRaceLookupTable[PLAYER_CLASS_COUNT][_TABLE_RACES]=
+	static const bool ClassRaceLookupTable[Class::PLAYER_CLASS_COUNT][_TABLE_RACES]=
 	{                   /*Human  Barbarian Erudite Woodelf Highelf Darkelf Halfelf Dwarf  Troll  Ogre   Halfling Gnome  Iksar  Vahshir Froglok Drakkin*/
 	{ /*Warrior*/         true,  true,     false,  true,   false,  true,   true,   true,  true,  true,  true,    true,  true,  true,   true,   true},
 	{ /*Cleric*/          true,  false,    true,   false,  true,   true,   true,   true,  false, false, true,    true,  false, false,  true,   true},
@@ -2021,7 +2021,7 @@ bool CheckCharCreateInfoTitanium(CharCreate_Struct *cc)
 
 	// if out of range looking it up in the table would crash stuff
 	// so we return from these
-	if (classtemp >= PLAYER_CLASS_COUNT) {
+	if (classtemp >= Class::PLAYER_CLASS_COUNT) {
 		LogInfo(" class is out of range");
 		return false;
 	}
@@ -2114,7 +2114,7 @@ void Client::SetClassStartingSkills(PlayerProfile_Struct *pp)
 		}
 	}
 
-	if (cle->GetClientVersion() < static_cast<uint8>(EQ::versions::ClientVersion::RoF2) && pp->class_ == BERSERKER) {
+	if (cle->GetClientVersion() < static_cast<uint8>(EQ::versions::ClientVersion::RoF2) && pp->class_ == Class::Berserker) {
 		pp->skills[EQ::skills::Skill1HPiercing] = pp->skills[EQ::skills::Skill2HPiercing];
 		pp->skills[EQ::skills::Skill2HPiercing] = 0;
 	}
@@ -2299,7 +2299,7 @@ void Client::SetClassLanguages(PlayerProfile_Struct *pp)
 {
 	// we only need to handle one class, but custom server might want to do more
 	switch(pp->class_) {
-	case ROGUE:
+	case Class::Rogue:
 		pp->languages[LANG_THIEVES_CANT] = 100;
 		break;
 	default:

world/console.cpp

@@ -578,25 +578,25 @@ void ConsoleZoneShutdown(
 		strcpy(&tmpname[1], connection->UserName().c_str());
 
 		auto pack = new ServerPacket;
-		pack->size    = sizeof(ServerZoneStateChange_struct);
+		pack->size    = sizeof(ServerZoneStateChange_Struct);
 		pack->pBuffer = new uchar[pack->size];
-		memset(pack->pBuffer, 0, sizeof(ServerZoneStateChange_struct));
-		ServerZoneStateChange_struct *s = (ServerZoneStateChange_struct *) pack->pBuffer;
+		memset(pack->pBuffer, 0, sizeof(ServerZoneStateChange_Struct));
+		auto *s = (ServerZoneStateChange_Struct *) pack->pBuffer;
 		pack->opcode = ServerOP_ZoneShutdown;
-		strcpy(s->adminname, tmpname);
+		strcpy(s->admin_name, tmpname);
 		if (Strings::IsNumber(args[0])) {
-			s->ZoneServerID = Strings::ToInt(args[0]);
+			s->zone_server_id = Strings::ToInt(args[0]);
 		}
 		else {
-			s->zoneid = ZoneID(args[0].c_str());
+			s->zone_id = ZoneID(args[0].c_str());
 		}
 
 		ZoneServer *zs = 0;
-		if (s->ZoneServerID != 0) {
-			zs = zoneserver_list.FindByID(s->ZoneServerID);
+		if (s->zone_server_id != 0) {
+			zs = zoneserver_list.FindByID(s->zone_server_id);
 		}
-		else if (s->zoneid != 0) {
-			zs = zoneserver_list.FindByName(ZoneName(s->zoneid));
+		else if (s->zone_id != 0) {
+			zs = zoneserver_list.FindByName(ZoneName(s->zone_id));
 		}
 		else {
 			connection->SendLine("Error: ZoneShutdown: neither ID nor name specified");

world/lfplist.cpp

@@ -33,7 +33,7 @@ GroupLFP::GroupLFP(uint32 inLeaderID) {
 	LeaderID = inLeaderID;
 	for (auto &member : Members) {
 		member.Name[0] = '\0';
-		member.Class = NO_CLASS;
+		member.Class = Class::None;
 		member.Level = 0;
 		member.Zone = 0;
 	}
@@ -77,7 +77,7 @@ void GroupLFP::SetDetails(ServerLFPUpdate_Struct *Update) {
 				Members[i].GuildID = CLE->GuildID();
 			}
 			else {
-				Members[i].Class = NO_CLASS;
+				Members[i].Class = Class::None;
 				Members[i].Level = 0;
 				Members[i].Zone = 0;
 				Members[i].GuildID = 0xFFFF;

world/zoneserver.cpp

@@ -720,15 +720,15 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 			break;
 		}
 		case ServerOP_ZoneShutdown: {
-			auto s = (ServerZoneStateChange_struct*) pack->pBuffer;
+			auto *s = (ServerZoneStateChange_Struct*) pack->pBuffer;
 			ZoneServer* zs = 0;
-			if (s->ZoneServerID) {
-				zs = zoneserver_list.FindByID(s->ZoneServerID);
-			} else if (s->zoneid) {
-				zs = zoneserver_list.FindByName(ZoneName(s->zoneid));
+			if (s->zone_server_id) {
+				zs = zoneserver_list.FindByID(s->zone_server_id);
+			} else if (s->zone_id) {
+				zs = zoneserver_list.FindByName(ZoneName(s->zone_id));
 			} else {
 				zoneserver_list.SendEmoteMessage(
-					s->adminname,
+					s->admin_name,
 					0,
 					AccountStatus::Player,
 					Chat::White,
@@ -738,7 +738,7 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 
 			if (!zs) {
 				zoneserver_list.SendEmoteMessage(
-					s->adminname,
+					s->admin_name,
 					0,
 					AccountStatus::Player,
 					Chat::White,
@@ -751,8 +751,8 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 			break;
 		}
 		case ServerOP_ZoneBootup: {
-			auto s = (ServerZoneStateChange_struct*) pack->pBuffer;
-			zoneserver_list.SOPZoneBootup(s->adminname, s->ZoneServerID, ZoneName(s->zoneid), s->makestatic);
+			auto *s = (ServerZoneStateChange_Struct*) pack->pBuffer;
+			zoneserver_list.SOPZoneBootup(s->admin_name, s->zone_server_id, ZoneName(s->zone_id), s->is_static);
 			break;
 		}
 		case ServerOP_ZoneStatus: {
@@ -1606,20 +1606,23 @@ void ZoneServer::ChangeWID(uint32 iCharID, uint32 iWID) {
 
 
 void ZoneServer::TriggerBootup(uint32 in_zone_id, uint32 in_instance_id, const char* admin_name, bool is_static_zone) {
-	is_booting_up = true;
+	is_booting_up       = true;
 	zone_server_zone_id = in_zone_id;
-	instance_id = in_instance_id;
+	instance_id         = in_instance_id;
+
+	auto pack = new ServerPacket(ServerOP_ZoneBootup, sizeof(ServerZoneStateChange_Struct));
+	auto *s = (ServerZoneStateChange_Struct*) pack->pBuffer;
+
+	s->zone_server_id = zone_server_id;
+
+	s->zone_id     = in_zone_id ? in_zone_id : GetZoneID();
+	s->instance_id = in_instance_id;
+	s->is_static   = is_static_zone;
 
-	auto pack = new ServerPacket(ServerOP_ZoneBootup, sizeof(ServerZoneStateChange_struct));
-	auto s = (ServerZoneStateChange_struct*) pack->pBuffer;
-	s->ZoneServerID = zone_server_id;
 	if (admin_name) {
-		strn0cpy(s->adminname, admin_name, sizeof(s->adminname));
+		strn0cpy(s->admin_name, admin_name, sizeof(s->admin_name));
 	}
 
-	s->zoneid = in_zone_id ? in_zone_id : GetZoneID();
-	s->instanceid = in_instance_id;
-	s->makestatic = is_static_zone;
 	SendPacket(pack);
 	delete pack;
 	LSBootUpdate(in_zone_id, in_instance_id);

zone/aa.cpp

@@ -373,72 +373,72 @@ void Mob::WakeTheDead(uint16 spell_id, Corpse *corpse_to_use, Mob *tar, uint32 d
 	//some basic combat mods here too since it's convienent
 	switch (corpse_to_use->class_)
 	{
-	case CLERIC:
+	case Class::Cleric:
 		made_npc->npc_spells_id = 1;
 		break;
-	case WIZARD:
+	case Class::Wizard:
 		made_npc->npc_spells_id = 2;
 		break;
-	case NECROMANCER:
+	case Class::Necromancer:
 		made_npc->npc_spells_id = 3;
 		break;
-	case MAGICIAN:
+	case Class::Magician:
 		made_npc->npc_spells_id = 4;
 		break;
-	case ENCHANTER:
+	case Class::Enchanter:
 		made_npc->npc_spells_id = 5;
 		break;
-	case SHAMAN:
+	case Class::Shaman:
 		made_npc->npc_spells_id = 6;
 		break;
-	case DRUID:
+	case Class::Druid:
 		made_npc->npc_spells_id = 7;
 		break;
-	case PALADIN:
+	case Class::Paladin:
 		//SPECATK_TRIPLE
 		strcpy(made_npc->special_abilities, "6,1");
 		made_npc->current_hp = made_npc->current_hp * 150 / 100;
 		made_npc->max_hp = made_npc->max_hp * 150 / 100;
 		made_npc->npc_spells_id = 8;
 		break;
-	case SHADOWKNIGHT:
+	case Class::ShadowKnight:
 		strcpy(made_npc->special_abilities, "6,1");
 		made_npc->current_hp = made_npc->current_hp * 150 / 100;
 		made_npc->max_hp = made_npc->max_hp * 150 / 100;
 		made_npc->npc_spells_id = 9;
 		break;
-	case RANGER:
+	case Class::Ranger:
 		strcpy(made_npc->special_abilities, "7,1");
 		made_npc->current_hp = made_npc->current_hp * 135 / 100;
 		made_npc->max_hp = made_npc->max_hp * 135 / 100;
 		made_npc->npc_spells_id = 10;
 		break;
-	case BARD:
+	case Class::Bard:
 		strcpy(made_npc->special_abilities, "6,1");
 		made_npc->current_hp = made_npc->current_hp * 110 / 100;
 		made_npc->max_hp = made_npc->max_hp * 110 / 100;
 		made_npc->npc_spells_id = 11;
 		break;
-	case BEASTLORD:
+	case Class::Beastlord:
 		strcpy(made_npc->special_abilities, "7,1");
 		made_npc->current_hp = made_npc->current_hp * 110 / 100;
 		made_npc->max_hp = made_npc->max_hp * 110 / 100;
 		made_npc->npc_spells_id = 12;
 		break;
-	case ROGUE:
+	case Class::Rogue:
 		strcpy(made_npc->special_abilities, "7,1");
 		made_npc->max_dmg = made_npc->max_dmg * 150 / 100;
 		made_npc->current_hp = made_npc->current_hp * 110 / 100;
 		made_npc->max_hp = made_npc->max_hp * 110 / 100;
 		break;
-	case MONK:
+	case Class::Monk:
 		strcpy(made_npc->special_abilities, "7,1");
 		made_npc->max_dmg = made_npc->max_dmg * 150 / 100;
 		made_npc->current_hp = made_npc->current_hp * 135 / 100;
 		made_npc->max_hp = made_npc->max_hp * 135 / 100;
 		break;
-	case WARRIOR:
-	case BERSERKER:
+	case Class::Warrior:
+	case Class::Berserker:
 		strcpy(made_npc->special_abilities, "7,1");
 		made_npc->max_dmg = made_npc->max_dmg * 150 / 100;
 		made_npc->current_hp = made_npc->current_hp * 175 / 100;
@@ -1354,7 +1354,7 @@ void Client::ActivateAlternateAdvancementAbility(int rank_id, int target_id) {
 	}
 	else {
 		// Bards can cast instant cast AAs while they are casting or channeling item cast.
-		if (GetClass() == BARD && IsCasting() && spells[rank->spell].cast_time == 0) {
+		if (GetClass() == Class::Bard && IsCasting() && spells[rank->spell].cast_time == 0) {
 			if (!DoCastingChecksOnCaster(rank->spell, EQ::spells::CastingSlot::AltAbility)) {
 				return;
 			}
@@ -2207,3 +2207,97 @@ bool Client::HasAlreadyPurchasedRank(AA::Rank* rank) {
 
 	return false;
 }
+
+void Client::ListPurchasedAAs(Client *to, std::string search_criteria)
+{
+	if (!to) {
+		return;
+	}
+
+	std::map<std::string, uint8> client_aa_ranks;
+
+	for (auto &aa : zone->aa_abilities) {
+		AA::Ability *ability = aa.second.get();
+
+		AA::Rank *rank = ability->first;
+		while (rank) {
+			if (!CanUseAlternateAdvancementRank(rank)) {
+				break;
+			}
+
+			if (HasAlreadyPurchasedRank(rank)) {
+				const std::string aa_name = zone->GetAAName(rank->id);
+				if (
+					search_criteria.empty() ||
+					Strings::Contains(
+						Strings::ToLower(aa_name),
+						Strings::ToLower(search_criteria)
+					)
+				) {
+					if (client_aa_ranks.find(aa_name) == client_aa_ranks.end()) {
+						client_aa_ranks[aa_name] = 1;
+					} else {
+						client_aa_ranks[aa_name]++;
+					}
+				}
+			}
+
+			rank = rank->next;
+		}
+	}
+
+	if (client_aa_ranks.empty()) {
+		to->Message(
+			Chat::White,
+			fmt::format(
+				"{} {} no purchased AAs{}.",
+				to->GetTargetDescription(this, TargetDescriptionType::UCYou),
+				this == to ? "have" : "has",
+				(
+					!search_criteria.empty() ?
+					fmt::format(
+						" matching '{}'",
+						search_criteria
+					) :
+					""
+				)
+			).c_str()
+		);
+		return;
+	}
+
+	int aa_number = 1;
+
+	for (const auto &aa : client_aa_ranks) {
+		to->Message(
+			Chat::White,
+			fmt::format(
+				"{}. {} (Rank {})",
+				aa_number,
+				aa.first,
+				aa.second
+			).c_str()
+		);
+
+		aa_number++;
+	}
+
+	to->Message(
+		Chat::White,
+		fmt::format(
+			"{} {} {} purchased AA{}{}.",
+			to->GetTargetDescription(this, TargetDescriptionType::UCYou),
+			this == to ? "have" : "has",
+			client_aa_ranks.size(),
+			client_aa_ranks.size() > 1 ? "s" : "",
+			(
+				!search_criteria.empty() ?
+				fmt::format(
+					" matching '{}'",
+					search_criteria
+				) :
+				""
+			)
+		).c_str()
+	);
+}

zone/aggro.cpp

@@ -678,7 +678,7 @@ bool Mob::IsAttackAllowed(Mob *target, bool isSpellAttack)
 
 	if(!isSpellAttack)
 	{
-		if(GetClass() == LDON_TREASURE)
+		if(GetClass() == Class::LDoNTreasure)
 		{
 			return false;
 		}
@@ -1070,10 +1070,10 @@ bool Mob::CombatRange(Mob* other, float fixed_size_mod, bool aeRampage, ExtraAtt
 			SetPseudoRoot(false);
 		}
 	}
-	
+
 	if (aeRampage) {
 		float aeramp_size = RuleR(Combat, AERampageMaxDistance);
-		
+
 		LogCombatDetail("AERampage: Default - aeramp_size = [{}] ", aeramp_size);
 
 		if (opts) {
@@ -1093,7 +1093,7 @@ bool Mob::CombatRange(Mob* other, float fixed_size_mod, bool aeRampage, ExtraAtt
 
 		LogCombatDetail("AE Rampage: ramp_range = [{}] -- (size_mod [{}] * aeramp_size [{}])", ramp_range, size_mod, aeramp_size);
 		LogCombatDetail("AE Rampage: _DistNoRoot [{}] <= ramp_range [{}]", _DistNoRoot, ramp_range);
-		
+
 		if (_DistNoRoot <= ramp_range) {
 			LogCombatDetail("AE Rampage: Combat Distance returned [true]");
 			return true;

zone/attack.cpp

@@ -558,7 +558,7 @@ bool Mob::AvoidDamage(Mob *other, DamageHitInfo &hit)
 	}
 
 	// dodge
-	if (CanThisClassDodge() && (InFront || GetClass() == MONK)) {
+	if (CanThisClassDodge() && (InFront || GetClass() == Class::Monk)) {
 		if (IsClient())
 			CastToClient()->CheckIncreaseSkill(EQ::skills::SkillDodge, other, -10);
 		// check auto discs ... I guess aa/items too :P
@@ -674,28 +674,28 @@ int Mob::GetACSoftcap()
 	int level = std::min(105, static_cast<int>(GetLevel())) - 1;
 
 	switch (GetClass()) {
-	case WARRIOR:
+	case Class::Warrior:
 		return war_softcaps[level];
-	case CLERIC:
-	case BARD:
-	case MONK:
+	case Class::Cleric:
+	case Class::Bard:
+	case Class::Monk:
 		return clrbrdmnk_softcaps[level];
-	case PALADIN:
-	case SHADOWKNIGHT:
+	case Class::Paladin:
+	case Class::ShadowKnight:
 		return palshd_softcaps[level];
-	case RANGER:
+	case Class::Ranger:
 		return rng_softcaps[level];
-	case DRUID:
+	case Class::Druid:
 		return dru_softcaps[level];
-	case ROGUE:
-	case SHAMAN:
-	case BEASTLORD:
-	case BERSERKER:
+	case Class::Rogue:
+	case Class::Shaman:
+	case Class::Beastlord:
+	case Class::Berserker:
 		return rogshmbstber_softcaps[level];
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
 		return necwizmagenc_softcaps[level];
 	default:
 		return 350;
@@ -707,28 +707,28 @@ double Mob::GetSoftcapReturns()
 	// These are based on the dev post, they seem to be correct for every level
 	// AKA no more hard caps
 	switch (GetClass()) {
-	case WARRIOR:
+	case Class::Warrior:
 		return 0.35;
-	case CLERIC:
-	case BARD:
-	case MONK:
+	case Class::Cleric:
+	case Class::Bard:
+	case Class::Monk:
 		return 0.3;
-	case PALADIN:
-	case SHADOWKNIGHT:
+	case Class::Paladin:
+	case Class::ShadowKnight:
 		return 0.33;
-	case RANGER:
+	case Class::Ranger:
 		return 0.315;
-	case DRUID:
+	case Class::Druid:
 		return 0.265;
-	case ROGUE:
-	case SHAMAN:
-	case BEASTLORD:
-	case BERSERKER:
+	case Class::Rogue:
+	case Class::Shaman:
+	case Class::Beastlord:
+	case Class::Berserker:
 		return 0.28;
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
 		return 0.25;
 	default:
 		return 0.3;
@@ -739,7 +739,7 @@ int Mob::GetClassRaceACBonus()
 {
 	int ac_bonus = 0;
 	auto level = GetLevel();
-	if (GetClass() == MONK) {
+	if (GetClass() == Class::Monk) {
 		int hardcap = 30;
 		int softcap = 14;
 		if (level > 99) {
@@ -824,7 +824,7 @@ int Mob::GetClassRaceACBonus()
 		}
 	}
 
-	if (GetClass() == ROGUE) {
+	if (GetClass() == Class::Rogue) {
 		int level_scaler = level - 26;
 		if (GetAGI() < 80)
 			ac_bonus = level_scaler / 4;
@@ -840,7 +840,7 @@ int Mob::GetClassRaceACBonus()
 			ac_bonus = 12;
 	}
 
-	if (GetClass() == BEASTLORD) {
+	if (GetClass() == Class::Beastlord) {
 		int level_scaler = level - 6;
 		if (GetAGI() < 80)
 			ac_bonus = level_scaler / 5;
@@ -894,14 +894,14 @@ int Mob::ACSum(bool skip_caps)
 		ac += GetPetACBonusFromOwner();
 		auto spell_aa_ac = aabonuses.AC + spellbonuses.AC;
 		ac += GetSkill(EQ::skills::SkillDefense) / 5;
-		if (EQ::ValueWithin(static_cast<int>(GetClass()), NECROMANCER, ENCHANTER))
+		if (EQ::ValueWithin(static_cast<int>(GetClass()), Class::Necromancer, Class::Enchanter))
 			ac += spell_aa_ac / 3;
 		else
 			ac += spell_aa_ac / 4;
 	}
 	else { // TODO: so we can't set NPC skills ... so the skill bonus ends up being HUGE so lets nerf them a bit
 		auto spell_aa_ac = aabonuses.AC + spellbonuses.AC;
-		if (EQ::ValueWithin(static_cast<int>(GetClass()), NECROMANCER, ENCHANTER))
+		if (EQ::ValueWithin(static_cast<int>(GetClass()), Class::Necromancer, Class::Enchanter))
 			ac += GetSkill(EQ::skills::SkillDefense) / 2 + spell_aa_ac / 3;
 		else
 			ac += GetSkill(EQ::skills::SkillDefense) / 3 + spell_aa_ac / 4;
@@ -1085,7 +1085,7 @@ int64 Mob::GetWeaponDamage(Mob *against, const EQ::ItemData *weapon_item) {
 				return 0;
 			}
 		}
-		else if ((GetClass() == MONK || GetClass() == BEASTLORD) && GetLevel() >= 30) {
+		else if ((GetClass() == Class::Monk || GetClass() == Class::Beastlord) && GetLevel() >= 30) {
 			dmg = GetHandToHandDamage();
 		}
 		else {
@@ -1199,7 +1199,7 @@ int64 Mob::GetWeaponDamage(Mob *against, const EQ::ItemInstance *weapon_item, in
 					MagicGloves = gloves->GetItemMagical(true);
 			}
 
-			if (GetClass() == MONK || GetClass() == BEASTLORD) {
+			if (GetClass() == Class::Monk || GetClass() == Class::Beastlord) {
 				if (MagicGloves || GetLevel() >= 30) {
 					dmg = GetHandToHandDamage();
 					if (hate)
@@ -1295,15 +1295,15 @@ int64 Mob::DoDamageCaps(int64 base_damage)
 	}
 	else if (level >= 40) {
 		switch (GetClass()) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
 			cap = 80;
 			break;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			cap = 40;
 			break;
 		default:
@@ -1313,15 +1313,15 @@ int64 Mob::DoDamageCaps(int64 base_damage)
 	}
 	else if (level >= 30) {
 		switch (GetClass()) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
 			cap = 26;
 			break;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			cap = 18;
 			break;
 		default:
@@ -1331,15 +1331,15 @@ int64 Mob::DoDamageCaps(int64 base_damage)
 	}
 	else if (level >= 20) {
 		switch (GetClass()) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
 			cap = 20;
 			break;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			cap = 12;
 			break;
 		default:
@@ -1349,15 +1349,15 @@ int64 Mob::DoDamageCaps(int64 base_damage)
 	}
 	else if (level >= 10) {
 		switch (GetClass()) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
 			cap = 12;
 			break;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			cap = 10;
 			break;
 		default:
@@ -1367,15 +1367,15 @@ int64 Mob::DoDamageCaps(int64 base_damage)
 	}
 	else {
 		switch (GetClass()) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
 			cap = 9;
 			break;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			cap = 6;
 			break;
 		default:
@@ -1476,7 +1476,7 @@ bool Mob::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
 	LogCombatDetail("Attacking [{}] with hand [{}] [{}]", other->GetName(), Hand, bRiposte ? "this is a riposte" : "");
 
 	if (
-		(IsCasting() && GetClass() != BARD && !IsFromSpell)
+		(IsCasting() && GetClass() != Class::Bard && !IsFromSpell)
 		|| ((IsClient() && CastToClient()->dead) || (other->IsClient() && other->CastToClient()->dead))
 		|| (GetHP() < 0)
 		|| (!IsAttackAllowed(other))
@@ -2019,7 +2019,7 @@ bool Client::Death(Mob* killerMob, int64 damage, uint16 spell, EQ::skills::Skill
 	/*
 	Reset reuse timer for classic skill based Lay on Hands (For tit I guess)
 	*/
-	if (GetClass() == PALADIN) { // we could check if it's not expired I guess, but should be fine not to
+	if (GetClass() == Class::Paladin) { // we could check if it's not expired I guess, but should be fine not to
 		p_timers.Clear(&database, pTimerLayHands);
 	}
 
@@ -2343,7 +2343,7 @@ void NPC::Damage(Mob* other, int64 damage, uint16 spell_id, EQ::skills::SkillTyp
 	if (!IsEngaged())
 		zone->AddAggroMob();
 
-	if (GetClass() == LDON_TREASURE)
+	if (GetClass() == Class::LDoNTreasure)
 	{
 		if (IsLDoNLocked() && GetLDoNLockedSkill() != LDoNTypeMechanical)
 		{
@@ -2461,7 +2461,7 @@ bool NPC::Death(Mob* killer_mob, int64 damage, uint16 spell, EQ::skills::SkillTy
 	BuffFadeAll();
 	const auto killed_level = GetLevel();
 
-	if (GetClass() == LDON_TREASURE) { // open chest
+	if (GetClass() == Class::LDoNTreasure) { // open chest
 		auto outapp = new EQApplicationPacket(OP_Animation, sizeof(Animation_Struct));
 		Animation_Struct* anim = (Animation_Struct*)outapp->pBuffer;
 		anim->spawnid = GetID();
@@ -2488,7 +2488,7 @@ bool NPC::Death(Mob* killer_mob, int64 damage, uint16 spell, EQ::skills::SkillTy
 		respawn2->DeathReset(1);
 	}
 
-	if (killer_mob && GetClass() != LDON_TREASURE) {
+	if (killer_mob && GetClass() != Class::LDoNTreasure) {
 		hate_list.AddEntToHateList(killer_mob, damage);
 	}
 
@@ -2535,7 +2535,7 @@ bool NPC::Death(Mob* killer_mob, int64 damage, uint16 spell, EQ::skills::SkillTy
 		hate_list.DoFactionHits(GetNPCFactionID(), GetPrimaryFaction(), GetFactionAmount());
 	}
 
-	bool IsLdonTreasure = (GetClass() == LDON_TREASURE);
+	bool IsLdonTreasure = (GetClass() == Class::LDoNTreasure);
 
 	if (give_exp_client && !IsCorpse()) {
 		Group *kg = entity_list.GetGroupByClient(give_exp_client);
@@ -2701,7 +2701,7 @@ bool NPC::Death(Mob* killer_mob, int64 damage, uint16 spell, EQ::skills::SkillTy
 	}
 
 	bool    allow_merchant_corpse = RuleB(Merchant, AllowCorpse);
-	bool    is_merchant = (class_ == MERCHANT || class_ == ADVENTURE_MERCHANT || MerchantType != 0);
+	bool    is_merchant = (class_ == Class::Merchant || class_ == Class::AdventureMerchant || MerchantType != 0);
 
 	Corpse* corpse = nullptr;
 
@@ -3295,14 +3295,14 @@ int Mob::GetHandToHandDamage(void)
 		7, 7, 7, 8, 8, 8, 8, 8, 8, 9,        // 21-30
 		9, 9, 9, 9, 9, 10, 10, 10, 10, 10,   // 31-40
 		10, 11, 11, 11, 11, 11, 11, 12, 12 }; // 41-49
-	if (GetClass() == MONK) {
+	if (GetClass() == Class::Monk) {
 		if (IsClient() && CastToClient()->GetItemIDAt(12) == 10652 && GetLevel() > 50)
 			return 9;
 		if (level > 62)
 			return 15;
 		return mnk_dmg[level];
 	}
-	else if (GetClass() == BEASTLORD) {
+	else if (GetClass() == Class::Beastlord) {
 		if (level > 49)
 			return 13;
 		return bst_dmg[level];
@@ -3354,7 +3354,7 @@ int Mob::GetHandToHandDelay(void)
 		28, 28, 28, 27, 27, 27, 27, 27, 26, 26, // 61-70
 		26, 26, 26 };                            // 71-73
 
-	if (GetClass() == MONK) {
+	if (GetClass() == Class::Monk) {
 		// Have a look to see if we have epic fists on
 		if (IsClient() && CastToClient()->GetItemIDAt(12) == 10652 && GetLevel() > 50)
 			return 16;
@@ -3363,7 +3363,7 @@ int Mob::GetHandToHandDelay(void)
 			return GetRace() == IKSAR ? 21 : 20;
 		return GetRace() == IKSAR ? mnk_iks_delay[level] : mnk_hum_delay[level];
 	}
-	else if (GetClass() == BEASTLORD) {
+	else if (GetClass() == Class::Beastlord) {
 		int level = GetLevel();
 		if (level > 73)
 			return 25;
@@ -4067,7 +4067,7 @@ void Mob::CommonDamage(Mob* attacker, int64 &damage, const uint16 spell_id, cons
 				}
 			}
 			else if (skill_used == EQ::skills::SkillKick &&
-				(attacker->GetLevel() > 55 || attacker->IsNPC()) && GetClass() == WARRIOR) {
+				(attacker->GetLevel() > 55 || attacker->IsNPC()) && GetClass() == Class::Warrior) {
 				can_stun = true;
 			}
 
@@ -5053,11 +5053,11 @@ void Mob::TryCriticalHit(Mob *defender, DamageHitInfo &hit, ExtraAttackOptions *
 	// We either require an innate crit chance or some SPA 169 to crit
 	bool innate_crit = false;
 	int crit_chance = GetCriticalChanceBonus(hit.skill);
-	if ((GetClass() == WARRIOR || GetClass() == BERSERKER) && GetLevel() >= 12)
+	if ((GetClass() == Class::Warrior || GetClass() == Class::Berserker) && GetLevel() >= 12)
 		innate_crit = true;
-	else if (GetClass() == RANGER && GetLevel() >= 12 && hit.skill == EQ::skills::SkillArchery)
+	else if (GetClass() == Class::Ranger && GetLevel() >= 12 && hit.skill == EQ::skills::SkillArchery)
 		innate_crit = true;
-	else if (GetClass() == ROGUE && GetLevel() >= 12 && hit.skill == EQ::skills::SkillThrowing)
+	else if (GetClass() == Class::Rogue && GetLevel() >= 12 && hit.skill == EQ::skills::SkillThrowing)
 		innate_crit = true;
 
 	// we have a chance to crit!
@@ -5077,7 +5077,7 @@ void Mob::TryCriticalHit(Mob *defender, DamageHitInfo &hit, ExtraAttackOptions *
 		dex_bonus += 45; // chances did not match live without a small boost
 
 						 // so if we have an innate crit we have a better chance, except for ber throwing
-		if (!innate_crit || (GetClass() == BERSERKER && hit.skill == EQ::skills::SkillThrowing))
+		if (!innate_crit || (GetClass() == Class::Berserker && hit.skill == EQ::skills::SkillThrowing))
 			dex_bonus = dex_bonus * 3 / 5;
 
 		if (crit_chance)
@@ -5101,7 +5101,7 @@ void Mob::TryCriticalHit(Mob *defender, DamageHitInfo &hit, ExtraAttackOptions *
 			LogCombat("Crit success roll [{}] dex chance [{}] og dmg [{}] crit_mod [{}] new dmg [{}]", roll, dex_bonus, og_damage, crit_mod, hit.damage_done);
 
 			// step 3: check deadly strike
-			if (GetClass() == ROGUE && hit.skill == EQ::skills::SkillThrowing) {
+			if (GetClass() == Class::Rogue && hit.skill == EQ::skills::SkillThrowing) {
 				if (BehindMob(defender, GetX(), GetY())) {
 					int chance = GetLevel() * 12;
 					if (zone->random.Int(1, 1000) < chance) {
@@ -5284,7 +5284,7 @@ void Mob::DoRiposte(Mob *defender)
 	if (DoubleRipChance && zone->random.Roll(DoubleRipChance)) {
 		LogCombat("Preforming a return SPECIAL ATTACK ([{}] percent chance)", DoubleRipChance);
 
-		if (defender->GetClass() == MONK)
+		if (defender->GetClass() == Class::Monk)
 			defender->MonkSpecialAttack(this, defender->aabonuses.GiveDoubleRiposte[SBIndex::DOUBLE_RIPOSTE_SKILL]);
 		else if (defender->IsClient()) // so yeah, even if you don't have the skill you can still do the attack :P (and we don't crash anymore)
 			defender->CastToClient()->DoClassAttacks(this, defender->aabonuses.GiveDoubleRiposte[SBIndex::DOUBLE_RIPOSTE_SKILL], true);
@@ -5301,7 +5301,7 @@ void Mob::ApplyMeleeDamageMods(uint16 skill, int64 &damage, Mob *defender, Extra
 		dmgbonusmod += opts->melee_damage_bonus_flat;
 
 	if (defender) {
-		if (defender->IsOfClientBotMerc() && defender->GetClass() == WARRIOR) {
+		if (defender->IsOfClientBotMerc() && defender->GetClass() == Class::Warrior) {
 			dmgbonusmod -= 5;
 		}
 		// 168 defensive
@@ -5445,7 +5445,7 @@ const DamageTable &Mob::GetDamageTable() const
 		{ 415, 15,  40 }, // 105
 	};
 
-	bool monk = GetClass() == MONK;
+	bool monk = GetClass() == Class::Monk;
 	bool melee = IsWarriorClass();
 	// tables caped at 105 for now -- future proofed for a while at least :P
 	int level = std::min(static_cast<int>(GetLevel()), 105);
@@ -5893,7 +5893,7 @@ void Mob::CommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraAttac
 
 	// BER weren't parsing the halving
 	if (hit.skill == EQ::skills::SkillArchery ||
-		(hit.skill == EQ::skills::SkillThrowing && GetClass() != BERSERKER))
+		(hit.skill == EQ::skills::SkillThrowing && GetClass() != Class::Berserker))
 		hit.damage_done /= 2;
 
 	if (hit.damage_done < 1)
@@ -5906,7 +5906,7 @@ void Mob::CommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraAttac
 		if (headshot > 0) {
 			hit.damage_done = headshot;
 		}
-		else if (GetClass() == RANGER && GetLevel() > 50) { // no double dmg on headshot
+		else if (GetClass() == Class::Ranger && GetLevel() > 50) { // no double dmg on headshot
 			if ((defender->IsNPC() && !defender->IsMoving() && !defender->IsRooted()) || !RuleB(Combat, ArcheryBonusRequiresStationary)) {
 				hit.damage_done *= 2;
 				MessageString(Chat::MeleeCrit, BOW_DOUBLE_DAMAGE);
@@ -5931,7 +5931,7 @@ void Mob::CommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraAttac
 				hit.damage_done = ass;
 		}
 	}
-	else if (hit.skill == EQ::skills::SkillFrenzy && GetClass() == BERSERKER && GetLevel() > 50) {
+	else if (hit.skill == EQ::skills::SkillFrenzy && GetClass() == Class::Berserker && GetLevel() > 50) {
 		extra_mincap = 4 * GetLevel() / 5;
 	}
 

zone/bonuses.cpp

@@ -117,7 +117,7 @@ void Client::CalcBonuses()
 
 	// hmm maybe a better way to do this
 	int metabolism = spellbonuses.Metabolism + itembonuses.Metabolism + aabonuses.Metabolism;
-	int timer = GetClass() == MONK ? CONSUMPTION_MNK_TIMER : CONSUMPTION_TIMER;
+	int timer = GetClass() == Class::Monk ? CONSUMPTION_MNK_TIMER : CONSUMPTION_TIMER;
 	timer = timer * (100 + metabolism) / 100;
 	if (timer != consume_food_timer.GetTimerTime())
 		consume_food_timer.SetTimer(timer);
@@ -2053,7 +2053,7 @@ void Mob::CalcSpellBonuses(StatBonuses* newbon)
 		}
 	}
 
-	if (GetClass() == BARD)
+	if (GetClass() == Class::Bard)
 		newbon->ManaRegen = 0; // Bards do not get mana regen from spells.
 }
 

zone/bot.h

@@ -394,14 +394,14 @@ public:
 
 	// Static Class Methods
 	static Bot* LoadBot(uint32 botID);
-	static uint32 SpawnedBotCount(const uint32 owner_id, uint8 class_id = NO_CLASS);
+	static uint32 SpawnedBotCount(const uint32 owner_id, uint8 class_id = Class::None);
 	static void LevelBotWithClient(Client* client, uint8 level, bool sendlvlapp);
 
 	static bool IsBotAttackAllowed(Mob* attacker, Mob* target, bool& hasRuleDefined);
 	static Bot* GetBotByBotClientOwnerAndBotName(Client* c, const std::string& botName);
 	static void ProcessBotGroupInvite(Client* c, std::string const& botName);
 	static void ProcessBotGroupDisband(Client* c, const std::string& botName);
-	static void BotOrderCampAll(Client* c, uint8 class_id = NO_CLASS);
+	static void BotOrderCampAll(Client* c, uint8 class_id = Class::None);
 	static void ProcessBotInspectionRequest(Bot* inspectedBot, Client* client);
 	static void LoadAndSpawnAllZonedBots(Client* bot_owner);
 	static bool GroupHasBot(Group* group);
@@ -604,7 +604,7 @@ public:
 	void SetBotCharmer(bool c) { _botCharmer = c; }
 	void SetPetChooser(bool p) { _petChooser = p; }
 	void SetBotOwner(Mob* botOwner) { this->_botOwner = botOwner; }
-	void SetRangerAutoWeaponSelect(bool enable) { GetClass() == RANGER ? _rangerAutoWeaponSelect = enable : _rangerAutoWeaponSelect = false; }
+	void SetRangerAutoWeaponSelect(bool enable) { GetClass() == Class::Ranger ? _rangerAutoWeaponSelect = enable : _rangerAutoWeaponSelect = false; }
 	void SetBotStance(EQ::constants::StanceType botStance) {
 		if (botStance >= EQ::constants::stancePassive && botStance <= EQ::constants::stanceBurnAE)
 			_botStance = botStance;
@@ -738,7 +738,7 @@ public:
 	//Raid additions
 	Raid* p_raid_instance;
 
-	static uint8 spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND];
+	static uint8 spell_casting_chances[SPELL_TYPE_COUNT][Class::PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND];
 
 	bool BotCastMez(Mob* tar, uint8 botLevel, bool checked_los, BotSpell& botSpell, Raid* raid);
 	bool BotCastHeal(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpell, Raid* raid);
@@ -866,6 +866,7 @@ private:
 	Timer m_evade_timer; // can be moved to pTimers at some point
 	Timer m_alt_combat_hate_timer;
 	Timer m_auto_defend_timer;
+	Timer auto_save_timer;
 	bool m_dirtyautohaters;
 	bool m_guard_flag;
 	bool m_hold_flag;

zone/bot_command.cpp

@@ -84,8 +84,8 @@ namespace
 
 	enum { EffectIDFirst = 1, EffectIDLast = 12 };
 
-#define VALIDATECLASSID(x) ((x >= WARRIOR && x <= BERSERKER) ? (x) : (0))
-#define CLASSIDTOINDEX(x) ((x >= WARRIOR && x <= BERSERKER) ? (x - 1) : (0))
+#define VALIDATECLASSID(x) ((x >= Class::Warrior && x <= Class::Berserker) ? (x) : (0))
+#define CLASSIDTOINDEX(x) ((x >= Class::Warrior && x <= Class::Berserker) ? (x - 1) : (0))
 #define EFFECTIDTOINDEX(x) ((x >= EffectIDFirst && x <= EffectIDLast) ? (x - 1) : (0))
 #define AILMENTIDTOINDEX(x) ((x >= BCEnum::AT_Blindness && x <= BCEnum::AT_Corruption) ? (x - 1) : (0))
 #define RESISTANCEIDTOINDEX(x) ((x >= BCEnum::RT_Fire && x <= BCEnum::RT_Corruption) ? (x - 1) : (0))
@@ -196,7 +196,7 @@ public:
 
 			uint8 class_levels[16] = {0};
 			bool player_spell = false;
-			for (int class_type = WARRIOR; class_type <= BERSERKER; ++class_type) {
+			for (int class_type = Class::Warrior; class_type <= Class::Berserker; ++class_type) {
 				int class_index = CLASSIDTOINDEX(class_type);
 				if (spells[spell_id].classes[class_index] == 0 ||
 					spells[spell_id].classes[class_index] > HARD_LEVEL_CAP) {
@@ -489,7 +489,7 @@ public:
 			entry_prototype->target_type = target_type;
 
 			bcst_levels& bot_levels = bot_levels_map[entry_prototype->BCST()];
-			for (int class_type = WARRIOR; class_type <= BERSERKER; ++class_type) {
+			for (int class_type = Class::Warrior; class_type <= Class::Berserker; ++class_type) {
 				int class_index = CLASSIDTOINDEX(class_type);
 				if (!class_levels[class_index])
 					continue;
@@ -1119,7 +1119,7 @@ private:
 	}
 
 	static void helper_bots_string(BCEnum::SpType type_index, bcst_levels& bot_levels) {
-		for (int i = WARRIOR; i <= BERSERKER; ++i)
+		for (int i = Class::Warrior; i <= Class::Berserker; ++i)
 			required_bots_map_by_class[type_index][i] = "Unavailable...";
 
 		if (bot_levels.empty()) {
@@ -2377,7 +2377,7 @@ namespace ActionableBots
 		else if (!ab_type_arg.compare("healrotationtargets")) {
 			ab_type = ABT_HealRotationTargets;
 		}
-		else if (!ab_type_arg.compare("byclass")) { 
+		else if (!ab_type_arg.compare("byclass")) {
 			ab_type = ABT_Class;
 		}
 		else if (!ab_type_arg.compare("byrace")) {
@@ -2730,9 +2730,9 @@ namespace ActionableBots
 
 	static void Filter_ByHighestPickLock(Client* bot_owner, std::list<Bot*>& sbl, float& pick_lock_value) {
 		sbl.remove_if([bot_owner](Bot* l) { return (!MyBots::IsMyBot(bot_owner, l)); });
-		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() != ROGUE && l->GetClass() != BARD); });
-		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == ROGUE && l->GetLevel() < 5); });
-		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == BARD && l->GetLevel() < 40); });
+		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() != Class::Rogue && l->GetClass() != Class::Bard); });
+		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == Class::Rogue && l->GetLevel() < 5); });
+		sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == Class::Bard && l->GetLevel() < 40); });
 
 		ActionableBots::Filter_ByHighestSkill(bot_owner, sbl, EQ::skills::SkillPickLock, pick_lock_value);
 	}
@@ -2856,7 +2856,7 @@ void bot_command_apply_poison(Client *c, const Seperator *sep)
 		t &&
 		t->IsBot() &&
 		t->CastToBot()->GetBotOwnerCharacterID() == c->CharacterID() &&
-		t->GetClass() == ROGUE
+		t->GetClass() == Class::Rogue
 	) {
 		my_rogue_bot = t->CastToBot();
 	}
@@ -2964,7 +2964,7 @@ void bot_command_apply_potion(Client* c, const Seperator* sep)
 
 	if (potion_data->ItemType == EQ::item::ItemTypePotion && potion_data->Click.Effect > 0) {
 
-		if (RuleB(Bots, RestrictApplyPotionToRogue) && potion_data->Classes != PLAYER_CLASS_ROGUE_BIT) {
+		if (RuleB(Bots, RestrictApplyPotionToRogue) && potion_data->Classes != player_class_bitmasks[Class::Rogue]) {
 
 			c->Message(Chat::White, "This command is restricted to rogue poison potions only!");
 			return;
@@ -3353,8 +3353,8 @@ void bot_command_depart(Client *c, const Seperator *sep)
 
 	std::string destination = sep->arg[1];
 	if (!destination.compare("list")) {
-		Bot* my_druid_bot = ActionableBots::AsGroupMember_ByClass(c, c, DRUID);
-		Bot* my_wizard_bot = ActionableBots::AsGroupMember_ByClass(c, c, WIZARD);
+		Bot* my_druid_bot = ActionableBots::AsGroupMember_ByClass(c, c, Class::Druid);
+		Bot* my_wizard_bot = ActionableBots::AsGroupMember_ByClass(c, c, Class::Wizard);
 		helper_command_depart_list(c, my_druid_bot, my_wizard_bot, local_list, single);
 		return;
 	}
@@ -4647,17 +4647,17 @@ void bot_command_pull(Client *c, const Seperator *sep)
 		}
 
 		switch (bot_iter->GetClass()) {
-		case ROGUE:
-		case MONK:
-		case BARD:
-		case RANGER:
+		case Class::Rogue:
+		case Class::Monk:
+		case Class::Bard:
+		case Class::Ranger:
 			bot_puller = bot_iter;
 			break;
-		case WARRIOR:
-		case SHADOWKNIGHT:
-		case PALADIN:
-		case BERSERKER:
-		case BEASTLORD:
+		case Class::Warrior:
+		case Class::ShadowKnight:
+		case Class::Paladin:
+		case Class::Berserker:
+		case Class::Beastlord:
 			if (!bot_puller) {
 
 				bot_puller = bot_iter;
@@ -4665,22 +4665,22 @@ void bot_command_pull(Client *c, const Seperator *sep)
 			}
 
 			switch (bot_puller->GetClass()) {
-			case DRUID:
-			case SHAMAN:
-			case CLERIC:
-			case WIZARD:
-			case NECROMANCER:
-			case MAGICIAN:
-			case ENCHANTER:
+			case Class::Druid:
+			case Class::Shaman:
+			case Class::Cleric:
+			case Class::Wizard:
+			case Class::Necromancer:
+			case Class::Magician:
+			case Class::Enchanter:
 				bot_puller = bot_iter;
 			default:
 				continue;
 			}
 
 			continue;
-		case DRUID:
-		case SHAMAN:
-		case CLERIC:
+		case Class::Druid:
+		case Class::Shaman:
+		case Class::Cleric:
 			if (!bot_puller) {
 
 				bot_puller = bot_iter;
@@ -4688,20 +4688,20 @@ void bot_command_pull(Client *c, const Seperator *sep)
 			}
 
 			switch (bot_puller->GetClass()) {
-			case WIZARD:
-			case NECROMANCER:
-			case MAGICIAN:
-			case ENCHANTER:
+			case Class::Wizard:
+			case Class::Necromancer:
+			case Class::Magician:
+			case Class::Enchanter:
 				bot_puller = bot_iter;
 			default:
 				continue;
 			}
 
 			continue;
-		case WIZARD:
-		case NECROMANCER:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Wizard:
+		case Class::Necromancer:
+		case Class::Magician:
+		case Class::Enchanter:
 			if (!bot_puller) {
 				bot_puller = bot_iter;
 			}
@@ -5210,15 +5210,15 @@ void bot_command_track(Client *c, const Seperator *sep)
 	std::list<Bot*> sbl;
 	MyBots::PopulateSBL_BySpawnedBots(c, sbl);
 
-	uint16 class_mask = (PLAYER_CLASS_RANGER_BIT | PLAYER_CLASS_DRUID_BIT | PLAYER_CLASS_BARD_BIT);
+	uint16 class_mask = (player_class_bitmasks[Class::Ranger] | player_class_bitmasks[Class::Druid] | player_class_bitmasks[Class::Bard]);
 	ActionableBots::Filter_ByClasses(c, sbl, class_mask);
 
-	Bot* my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 1, RANGER);
+	Bot* my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 1, Class::Ranger);
 	if (tracking_scope.empty()) {
 		if (!my_bot)
-			my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 20, DRUID);
+			my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 20, Class::Druid);
 		if (!my_bot)
-			my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 35, BARD);
+			my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 35, Class::Bard);
 	}
 	if (!my_bot) {
 		c->Message(Chat::White, "No bots are capable of performing this action");
@@ -5229,7 +5229,7 @@ void bot_command_track(Client *c, const Seperator *sep)
 	bool track_named = false;
 	std::string tracking_msg;
 	switch (my_bot->GetClass()) {
-	case RANGER:
+	case Class::Ranger:
 		if (!tracking_scope.compare("local")) {
 			base_distance = 30;
 			tracking_msg = "Local tracking...";
@@ -5244,11 +5244,11 @@ void bot_command_track(Client *c, const Seperator *sep)
 			tracking_msg = "Advanced tracking...";
 		}
 		break;
-	case DRUID:
+	case Class::Druid:
 		base_distance = 30;
 		tracking_msg = "Local tracking...";
 		break;
-	case BARD:
+	case Class::Bard:
 		base_distance = 20;
 		tracking_msg = "Near tracking...";
 		break;
@@ -6612,7 +6612,7 @@ void bot_subcommand_bot_list(Client *c, const Seperator *sep)
 			).c_str()
 		);
 
-		for (uint8 class_id = WARRIOR; class_id <= BERSERKER; class_id++) {
+		for (uint8 class_id = Class::Warrior; class_id <= Class::Berserker; class_id++) {
 			auto class_creation_limit = c->GetBotCreationLimit(class_id);
 
 			if (class_creation_limit != overall_bot_creation_limit) {
@@ -6865,7 +6865,7 @@ void bot_subcommand_bot_spawn(Client *c, const Seperator *sep)
 	std::string bot_name = sep->arg[1];
 
 	uint32 bot_id = 0;
-	uint8 bot_class = NO_CLASS;
+	uint8 bot_class = Class::None;
 	if (!database.botdb.LoadBotID(c->CharacterID(), bot_name, bot_id, bot_class)) {
 		c->Message(
 			Chat::White,
@@ -6972,22 +6972,22 @@ void bot_subcommand_bot_spawn(Client *c, const Seperator *sep)
 
 	static std::string bot_spawn_message[17] = {
 		"I am ready to fight!", // DEFAULT
-		"A solid weapon is my ally!", // WARRIOR
-		"The pious shall never die!", // CLERIC
-		"I am the symbol of Light!", // PALADIN
-		"There are enemies near!", // RANGER
-		"Out of the shadows, I step!", // SHADOWKNIGHT
-		"Nature's fury shall be wrought!", // DRUID
-		"Your punishment will be my fist!", // MONK
+		"A solid weapon is my ally!", // Class::Warrior
+		"The pious shall never die!", // Class::Cleric
+		"I am the symbol of Light!", // Class::Paladin
+		"There are enemies near!", // Class::Ranger
+		"Out of the shadows, I step!", // Class::ShadowKnight
+		"Nature's fury shall be wrought!", // Class::Druid
+		"Your punishment will be my fist!", // Class::Monk
 		"Music is the overture of battle! ", // BARD
-		"Daggers into the backs of my enemies!", // ROGUE
-		"More bones to grind!", // SHAMAN
-		"Death is only the beginning!", // NECROMANCER
-		"I am the harbinger of demise!", // WIZARD
-		"The elements are at my command!", // MAGICIAN
-		"No being can resist my charm!", // ENCHANTER
-		"Battles are won by hand and paw!", // BEASTLORD
-		"My bloodthirst shall not be quenched!" // BERSERKER
+		"Daggers into the backs of my enemies!", // Class::Rogue
+		"More bones to grind!", // Class::Shaman
+		"Death is only the beginning!", // Class::Necromancer
+		"I am the harbinger of demise!", // Class::Wizard
+		"The elements are at my command!", // Class::Magician
+		"No being can resist my charm!", // Class::Enchanter
+		"Battles are won by hand and paw!", // Class::Beastlord
+		"My bloodthirst shall not be quenched!" // Class::Berserker
 	};
 
 	uint8 message_index = 0;
@@ -7257,7 +7257,7 @@ void bot_subcommand_bot_toggle_archer(Client *c, const Seperator *sep)
 		}
 		bot_iter->ChangeBotArcherWeapons(bot_iter->IsBotArcher());
 
-		if (bot_iter->GetClass() == RANGER && bot_iter->GetLevel() >= 61) {
+		if (bot_iter->GetClass() == Class::Ranger && bot_iter->GetLevel() >= 61) {
 			bot_iter->SetRangerAutoWeaponSelect(bot_iter->IsBotArcher());
 		}
 	}
@@ -7467,7 +7467,7 @@ void bot_subcommand_circle(Client *c, const Seperator *sep)
 		return;
 	if (helper_is_help_or_usage(sep->arg[1])) {
 		c->Message(Chat::White, "usage: %s [list | destination] ([option: single])", sep->arg[0]);
-		helper_send_usage_required_bots(c, BCEnum::SpT_Depart, DRUID);
+		helper_send_usage_required_bots(c, BCEnum::SpT_Depart, Class::Druid);
 		return;
 	}
 
@@ -7478,7 +7478,7 @@ void bot_subcommand_circle(Client *c, const Seperator *sep)
 
 	std::string destination = sep->arg[1];
 	if (!destination.compare("list")) {
-		auto my_druid_bot = ActionableBots::AsGroupMember_ByClass(c, c, DRUID);
+		auto my_druid_bot = ActionableBots::AsGroupMember_ByClass(c, c, Class::Druid);
 		helper_command_depart_list(c, my_druid_bot, nullptr, local_list, single);
 		return;
 	}
@@ -7497,7 +7497,7 @@ void bot_subcommand_circle(Client *c, const Seperator *sep)
 		auto local_entry = list_iter->SafeCastToDepart();
 		if (helper_spell_check_fail(local_entry))
 			continue;
-		if (local_entry->caster_class != DRUID)
+		if (local_entry->caster_class != Class::Druid)
 			continue;
 		if (local_entry->single != single)
 			continue;
@@ -8988,7 +8988,7 @@ void bot_subcommand_pet_remove(Client *c, const Seperator *sep)
 	if (ActionableBots::PopulateSBL(c, sep->arg[1], sbl, ab_mask, sep->arg[2]) == ActionableBots::ABT_None)
 		return;
 
-	uint16 class_mask = (PLAYER_CLASS_DRUID_BIT | PLAYER_CLASS_NECROMANCER_BIT | PLAYER_CLASS_ENCHANTER_BIT);
+	uint16 class_mask = (player_class_bitmasks[Class::Druid] | player_class_bitmasks[Class::Necromancer] | player_class_bitmasks[Class::Enchanter]);
 	ActionableBots::Filter_ByClasses(c, sbl, class_mask);
 	if (sbl.empty()) {
 		c->Message(Chat::White, "You have no spawned bots capable of charming");
@@ -9068,7 +9068,7 @@ void bot_subcommand_pet_set_type(Client *c, const Seperator *sep)
 	if (ActionableBots::PopulateSBL(c, sep->arg[2], sbl, ab_mask, sep->arg[3]) == ActionableBots::ABT_None)
 		return;
 
-	uint16 class_mask = PLAYER_CLASS_MAGICIAN_BIT;
+	uint16 class_mask = player_class_bitmasks[Class::Magician];
 	ActionableBots::Filter_ByClasses(c, sbl, class_mask);
 	if (sbl.empty()) {
 		c->Message(Chat::White, "You have no spawned Magician bots");
@@ -9103,7 +9103,7 @@ void bot_subcommand_portal(Client *c, const Seperator *sep)
 		return;
 	if (helper_is_help_or_usage(sep->arg[1])) {
 		c->Message(Chat::White, "usage: %s [list | destination] ([option: single])", sep->arg[0]);
-		helper_send_usage_required_bots(c, BCEnum::SpT_Depart, WIZARD);
+		helper_send_usage_required_bots(c, BCEnum::SpT_Depart, Class::Wizard);
 		return;
 	}
 
@@ -9114,7 +9114,7 @@ void bot_subcommand_portal(Client *c, const Seperator *sep)
 
 	std::string destination = sep->arg[1];
 	if (!destination.compare("list")) {
-		auto my_wizard_bot = ActionableBots::AsGroupMember_ByClass(c, c, WIZARD);
+		auto my_wizard_bot = ActionableBots::AsGroupMember_ByClass(c, c, Class::Wizard);
 		helper_command_depart_list(c, nullptr, my_wizard_bot, local_list, single);
 		return;
 	}
@@ -9133,7 +9133,7 @@ void bot_subcommand_portal(Client *c, const Seperator *sep)
 		auto local_entry = list_iter->SafeCastToDepart();
 		if (helper_spell_check_fail(local_entry))
 			continue;
-		if (local_entry->caster_class != WIZARD)
+		if (local_entry->caster_class != Class::Wizard)
 			continue;
 		if (local_entry->single != single)
 			continue;
@@ -9427,26 +9427,26 @@ void helper_bot_out_of_combat(Client *bot_owner, Bot *my_bot)
 		return;
 
 	switch (my_bot->GetClass()) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case DRUID:
-	case MONK:
+	case Class::Warrior:
+	case Class::Cleric:
+	case Class::Paladin:
+	case Class::Ranger:
+	case Class::ShadowKnight:
+	case Class::Druid:
+	case Class::Monk:
 		bot_owner->Message(Chat::White, "%s has no out-of-combat behavior defined", my_bot->GetCleanName());
 		break;
-	case BARD:
+	case Class::Bard:
 		bot_owner->Message(Chat::White, "%s will %s use out-of-combat behavior for bard songs", my_bot->GetCleanName(), ((my_bot->GetAltOutOfCombatBehavior()) ? ("now") : ("no longer")));
 		break;
-	case ROGUE:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-	case BEASTLORD:
-	case BERSERKER:
+	case Class::Rogue:
+	case Class::Shaman:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
+	case Class::Beastlord:
+	case Class::Berserker:
 		bot_owner->Message(Chat::White, "%s has no out-of-combat behavior defined", my_bot->GetCleanName());
 		break;
 	default:
@@ -10457,8 +10457,8 @@ void bot_command_pickpocket(Client *c, const Seperator *sep)
 	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);
+	ActionableBots::Filter_ByClasses(c, sbl, player_class_bitmasks[Class::Rogue]);
+	Bot *my_bot = ActionableBots::AsSpawned_ByMinLevelAndClass(c, sbl, 7, Class::Rogue);
 	if (!my_bot) {
 		c->Message(Chat::White, "No bots are capable of performing this action");
 		return;

zone/bot_command.h

@@ -677,7 +677,7 @@ void helper_command_depart_list(Client* bot_owner, Bot* druid_bot, Bot* wizard_b
 bool helper_is_help_or_usage(const char* arg);
 bool helper_no_available_bots(Client *bot_owner, Bot *my_bot = nullptr);
 void helper_send_available_subcommands(Client *bot_owner, const char* command_simile, const std::list<const char*>& subcommand_list);
-void helper_send_usage_required_bots(Client *bot_owner, BCEnum::SpType spell_type, uint8 bot_class = NO_CLASS);
+void helper_send_usage_required_bots(Client *bot_owner, BCEnum::SpType spell_type, uint8 bot_class = Class::None);
 bool helper_spell_check_fail(STBaseEntry* local_entry);
 bool helper_spell_list_fail(Client *bot_owner, bcst_list* spell_list, BCEnum::SpType spell_type);
 #endif

zone/bot_database.cpp

@@ -141,7 +141,7 @@ bool BotDatabase::LoadBotSpellCastingChances()
 		if (spell_type_index >= Bot::SPELL_TYPE_COUNT)
 			continue;
 		uint8 class_index = Strings::ToInt(row[1]);
-		if (class_index < WARRIOR || class_index > BERSERKER)
+		if (class_index < Class::Warrior || class_index > Class::Berserker)
 			continue;
 		--class_index;
 		uint8 stance_index = Strings::ToInt(row[2]);
@@ -224,7 +224,7 @@ bool BotDatabase::QueryBotCount(const uint32 owner_id, int class_id, uint32& bot
 	auto row = results.begin();
 	bot_count = Strings::ToUnsignedInt(row[0]);
 
-	if (EQ::ValueWithin(class_id, WARRIOR, BERSERKER)) {
+	if (EQ::ValueWithin(class_id, Class::Warrior, Class::Berserker)) {
 		query = fmt::format(
 			"SELECT COUNT(`bot_id`) FROM `bot_data` WHERE `owner_id` = {} AND `class` = {}",
 			owner_id,
@@ -2517,7 +2517,7 @@ uint8 BotDatabase::GetSpellCastingChance(uint8 spell_type_index, uint8 class_ind
 {
 	if (spell_type_index >= Bot::SPELL_TYPE_COUNT)
 		return 0;
-	if (class_index >= PLAYER_CLASS_COUNT)
+	if (class_index >= Class::PLAYER_CLASS_COUNT)
 		return 0;
 	if (stance_index >= EQ::constants::STANCE_TYPE_COUNT)
 		return 0;

zone/botspellsai.cpp

@@ -101,7 +101,7 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) {
 
 bool Bot::BotCastSong(Mob* tar, uint8 botLevel) {
 	bool casted_spell = false;
-	if (GetClass() != BARD || tar != this || IsEngaged()) // Out-of-Combat songs can not be cast in combat
+	if (GetClass() != Class::Bard || tar != this || IsEngaged()) // Out-of-Combat songs can not be cast in combat
 		return casted_spell;
 
 	for (auto botSongList = GetPrioritizedBotSpellsBySpellType(this, SpellType_OutOfCombatBuffSong);
@@ -169,7 +169,7 @@ bool Bot::BotCastCombatSong(Mob* tar, uint8 botLevel) {
 
 bool Bot::BotCastHateReduction(Mob* tar, uint8 botLevel, const BotSpell& botSpell) {
 	bool casted_spell = false;
-	if (GetClass() == BARD) {
+	if (GetClass() == Class::Bard) {
 		std::list<BotSpell_wPriority> botSongList = GetPrioritizedBotSpellsBySpellType(this, SpellType_HateRedux);
 		for (auto iter : botSongList) {
 			if (!iter.SpellId)
@@ -220,7 +220,7 @@ bool Bot::BotCastCure(Mob* tar, uint8 botClass, BotSpell& botSpell, Raid* raid)
 
 		casted_spell = AIDoSpellCast(botSpell.SpellIndex, tar, botSpell.ManaCost, &TempDontCureMeBeforeTime);
 
-		if (casted_spell && botClass != BARD) {
+		if (casted_spell && botClass != Class::Bard) {
 			if (IsGroupSpell(botSpell.SpellId)) {
 				if (HasGroup()) {
 					Group const* group = GetGroup();
@@ -301,7 +301,7 @@ bool Bot::BotCastSlow(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 		}
 
 		switch (botClass) {
-			case BARD: {
+			case Class::Bard: {
 				// probably needs attackable check
 				for (
 					auto botSongList = GetPrioritizedBotSpellsBySpellType(this, SpellType_Slow);
@@ -339,12 +339,12 @@ bool Bot::BotCastSlow(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 
 				break;
 			}
-			case ENCHANTER: {
+			case Class::Enchanter: {
 				botSpell = GetBestBotSpellForMagicBasedSlow(this);
 				break;
 			}
-			case SHAMAN:
-			case BEASTLORD: {
+			case Class::Shaman:
+			case Class::Beastlord: {
 				botSpell = GetBestBotSpellForDiseaseBasedSlow(this);
 
 				if (botSpell.SpellId == 0 || ((tar->GetMR() - 50) < (tar->GetDR() + spells[botSpell.SpellId].resist_difficulty)))
@@ -364,7 +364,7 @@ bool Bot::BotCastSlow(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 			casted_spell = AIDoSpellCast(botSpell.SpellIndex, tar, botSpell.ManaCost);
 		}
 
-		if (casted_spell && GetClass() != BARD) {
+		if (casted_spell && GetClass() != Class::Bard) {
 			if (raid) {
 				const auto msg = fmt::format("Attempting to slow {}.", tar->GetCleanName());
 				raid->RaidSay(msg.c_str(), GetCleanName(), 0, 100);
@@ -391,7 +391,7 @@ bool Bot::BotCastDOT(Mob* tar, uint8 botLevel, const BotSpell& botSpell, const b
 			return casted_spell;
 		}
 
-		if (GetClass() == BARD) {
+		if (GetClass() == Class::Bard) {
 			std::list<BotSpell_wPriority> dotList = GetPrioritizedBotSpellsBySpellType(this, SpellType_DOT);
 
 			const int maxDotSelect = 5;
@@ -569,7 +569,7 @@ bool Bot::BotCastCombatBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 						(tar == this && spells[s.SpellId].target_type != ST_TargetsTarget) ||
 						spells[s.SpellId].target_type == ST_Group ||
 						spells[s.SpellId].target_type == ST_GroupTeleport ||
-						(botClass == BARD && spells[s.SpellId].target_type == ST_AEBard)
+						(botClass == Class::Bard && spells[s.SpellId].target_type == ST_AEBard)
 					) &&
 					!tar->IsImmuneToSpell(s.SpellId, this) &&
 					tar->CanBuffStack(s.SpellId, botLevel, true) >= 0
@@ -582,7 +582,7 @@ bool Bot::BotCastCombatBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 			if (
 				((IsEffectInSpell(s.SpellId, SE_Levitate) && !zone->CanLevitate()) ||
 				(IsEffectInSpell(s.SpellId, SE_MovementSpeed) && !zone->CanCastOutdoor())) &&
-				(botClass != BARD || !IsSpellUsableInThisZoneType(s.SpellId, zone->GetZoneType()))
+				(botClass != Class::Bard || !IsSpellUsableInThisZoneType(s.SpellId, zone->GetZoneType()))
 			) {
 				continue;
 			}
@@ -625,7 +625,7 @@ bool Bot::BotCastCombatBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 				}
 			}
 			// TODO: Add TriggerSpell Support for Exchanter Runes
-			if (botClass == ENCHANTER && IsEffectInSpell(s.SpellId, SE_Rune)) {
+			if (botClass == Class::Enchanter && IsEffectInSpell(s.SpellId, SE_Rune)) {
 				float manaRatioToCast = 75.0f;
 
 				switch(GetBotStance()) {
@@ -671,7 +671,7 @@ bool Bot::BotCastCombatBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 bool Bot::BotCastPet(Mob* tar, uint8 botClass, BotSpell& botSpell) {
 	bool casted_spell = false;
 	if (!IsPet() && !GetPetID() && !IsBotCharmer()) {
-		if (botClass == WIZARD) {
+		if (botClass == Class::Wizard) {
 			auto buffs_max = GetMaxBuffSlots();
 			auto my_buffs = GetBuffs();
 			int familiar_buff_slot = -1;
@@ -694,7 +694,7 @@ bool Bot::BotCastPet(Mob* tar, uint8 botClass, BotSpell& botSpell) {
 
 			botSpell = GetFirstBotSpellBySpellType(this, SpellType_Pet);
 		}
-		else if (botClass == MAGICIAN) {
+		else if (botClass == Class::Magician) {
 			botSpell = GetBestBotMagicianPetSpell(this);
 		}
 		else {
@@ -735,13 +735,13 @@ bool Bot::BotCastDispel(Mob* tar, BotSpell& botSpell, uint32 iSpellTypes, const
 bool Bot::BotCastNuke(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpell, const bool& checked_los) {
 
 	bool casted_spell = false;
-	if ((tar->GetHPRatio() <= 95.0f) || ((botClass == BARD) || (botClass == SHAMAN) || (botClass == ENCHANTER) || (botClass == PALADIN) || (botClass == SHADOWKNIGHT) || (botClass == WARRIOR)))
+	if ((tar->GetHPRatio() <= 95.0f) || ((botClass == Class::Bard) || (botClass == Class::Shaman) || (botClass == Class::Enchanter) || (botClass == Class::Paladin) || (botClass == Class::ShadowKnight) || (botClass == Class::Warrior)))
 	{
 		if (!checked_los && (!CheckLosFN(tar) || !CheckWaterLoS(tar))) {
 			return casted_spell;
 		}
 
-		if (botClass == CLERIC || botClass == ENCHANTER)
+		if (botClass == Class::Cleric || botClass == Class::Enchanter)
 		{
 			float manaRatioToCast = 75.0f;
 
@@ -770,17 +770,17 @@ bool Bot::BotCastNuke(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 				return casted_spell;
 		}
 
-		if (botClass == MAGICIAN || botClass == SHADOWKNIGHT || botClass == NECROMANCER || botClass == PALADIN || botClass == RANGER || botClass == DRUID || botClass == CLERIC) {
+		if (botClass == Class::Magician || botClass == Class::ShadowKnight || botClass == Class::Necromancer || botClass == Class::Paladin || botClass == Class::Ranger || botClass == Class::Druid || botClass == Class::Cleric) {
 			if (tar->GetBodyType() == BT_Undead || tar->GetBodyType() == BT_SummonedUndead || tar->GetBodyType() == BT_Vampire)
 				botSpell = GetBestBotSpellForNukeByTargetType(this, ST_Undead);
 			else if (tar->GetBodyType() == BT_Summoned || tar->GetBodyType() == BT_Summoned2 || tar->GetBodyType() == BT_Summoned3)
 				botSpell = GetBestBotSpellForNukeByTargetType(this, ST_Summoned);
 		}
 
-		if ((botClass == PALADIN || botClass == DRUID || botClass == CLERIC || botClass == ENCHANTER || botClass == WIZARD) && !IsValidSpell(botSpell.SpellId)) {
+		if ((botClass == Class::Paladin || botClass == Class::Druid || botClass == Class::Cleric || botClass == Class::Enchanter || botClass == Class::Wizard) && !IsValidSpell(botSpell.SpellId)) {
 			uint8 stunChance = (tar->IsCasting() ? 30: 15);
 
-			if (botClass == PALADIN) {
+			if (botClass == Class::Paladin) {
 				stunChance = 50;
 			}
 
@@ -789,7 +789,7 @@ bool Bot::BotCastNuke(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 			}
 		}
 
-		if (botClass == WIZARD && botSpell.SpellId == 0) {
+		if (botClass == Class::Wizard && botSpell.SpellId == 0) {
 			botSpell = GetBestBotWizardNukeSpellByTargetResists(this, tar);
 		}
 
@@ -819,7 +819,7 @@ bool Bot::BotCastEscape(Mob*& tar, uint8 botClass, BotSpell& botSpell, uint32 iS
 	auto hpr = (uint8) GetHPRatio();
 	bool mayGetAggro = false;
 
-	if (hpr > 15 && ((botClass == WIZARD) || (botClass == ENCHANTER) || (botClass == RANGER))) {
+	if (hpr > 15 && ((botClass == Class::Wizard) || (botClass == Class::Enchanter) || (botClass == Class::Ranger))) {
 		mayGetAggro = HasOrMayGetAggro();
 	}
 
@@ -835,7 +835,7 @@ bool Bot::BotCastEscape(Mob*& tar, uint8 botClass, BotSpell& botSpell, uint32 iS
 			tar = this; //target self for invul type spells
 		}
 
-		if (IsValidSpellRange(botSpell.SpellId, tar) || botClass == BARD) {
+		if (IsValidSpellRange(botSpell.SpellId, tar) || botClass == Class::Bard) {
 			casted_spell = AIDoSpellCast(botSpell.SpellIndex, tar, botSpell.ManaCost);
 		}
 	}
@@ -877,7 +877,7 @@ bool Bot::BotCastBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 						(tar == this && spells[s.SpellId].target_type != ST_TargetsTarget) ||
 						spells[s.SpellId].target_type == ST_Group ||
 						spells[s.SpellId].target_type == ST_GroupTeleport ||
-						(botClass == BARD && spells[s.SpellId].target_type == ST_AEBard)
+						(botClass == Class::Bard && spells[s.SpellId].target_type == ST_AEBard)
 					) &&
 					!tar->IsImmuneToSpell(s.SpellId, this) &&
 					tar->CanBuffStack(s.SpellId, botLevel, true) >= 0
@@ -892,7 +892,7 @@ bool Bot::BotCastBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 					(IsEffectInSpell(s.SpellId, SE_Levitate) && !zone->CanLevitate()) ||
 					(IsEffectInSpell(s.SpellId, SE_MovementSpeed) && !zone->CanCastOutdoor())
 				) &&
-				(botClass != BARD || !IsSpellUsableInThisZoneType(s.SpellId, zone->GetZoneType()))
+				(botClass != Class::Bard || !IsSpellUsableInThisZoneType(s.SpellId, zone->GetZoneType()))
 			) {
 				continue;
 			}
@@ -919,7 +919,7 @@ bool Bot::BotCastBuff(Mob* tar, uint8 botLevel, uint8 botClass) {
 					break;
 			}
 
-			if (botClass == ENCHANTER && IsEffectInSpell(s.SpellId, SE_Rune))
+			if (botClass == Class::Enchanter && IsEffectInSpell(s.SpellId, SE_Rune))
 			{
 				float manaRatioToCast = 75.0f;
 
@@ -1003,17 +1003,17 @@ bool Bot::BotCastHeal(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 			isPrimaryHealer = IsGroupHealer();
 		}
 
-		if (hpr < 95 || tar->IsClient() || botClass == BARD) {
-			if (tar->GetClass() == NECROMANCER && hpr >= 40) {
+		if (hpr < 95 || tar->IsClient() || botClass == Class::Bard) {
+			if (tar->GetClass() == Class::Necromancer && hpr >= 40) {
 				return false;
 			}
 
-			if (tar->GetClass() == SHAMAN && hpr >= 80) {
+			if (tar->GetClass() == Class::Shaman && hpr >= 80) {
 				return false;
 			}
 
 			// Evaluate the situation
-			if ((IsEngaged()) && ((botClass == CLERIC) || (botClass == DRUID) || (botClass == SHAMAN) || (botClass == PALADIN))) {
+			if ((IsEngaged()) && ((botClass == Class::Cleric) || (botClass == Class::Druid) || (botClass == Class::Shaman) || (botClass == Class::Paladin))) {
 				if (tar->GetTarget() && tar->GetTarget()->GetHateTop() && tar->GetTarget()->GetHateTop() == tar) {
 					hasAggro = true;
 				}
@@ -1045,7 +1045,7 @@ bool Bot::BotCastHeal(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 					}
 				}
 			}
-			else if ((botClass == CLERIC) || (botClass == DRUID) || (botClass == SHAMAN) || (botClass == PALADIN)) {
+			else if ((botClass == Class::Cleric) || (botClass == Class::Druid) || (botClass == Class::Shaman) || (botClass == Class::Paladin)) {
 				if (GetNumberNeedingHealedInGroup(40, true, raid) >= 2) {
 					botSpell = GetBestBotSpellForGroupCompleteHeal(this);
 
@@ -1119,7 +1119,7 @@ bool Bot::BotCastHeal(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 			if (!IsValidSpell(botSpell.SpellId)) {
 				botSpell = GetFirstBotSpellForSingleTargetHeal(this);
 			}
-			if (botSpell.SpellId == 0 && botClass == BARD) {
+			if (botSpell.SpellId == 0 && botClass == Class::Bard) {
 				botSpell = GetFirstBotSpellBySpellType(this, SpellType_Heal);
 			}
 
@@ -1134,11 +1134,11 @@ bool Bot::BotCastHeal(Mob* tar, uint8 botLevel, uint8 botClass, BotSpell& botSpe
 
 			uint32 TempDontHealMeBeforeTime = tar->DontHealMeBefore();
 
-			if (IsValidSpellRange(botSpell.SpellId, tar) || botClass == BARD) {
+			if (IsValidSpellRange(botSpell.SpellId, tar) || botClass == Class::Bard) {
 				casted_spell = AIDoSpellCast(botSpell.SpellIndex, tar, botSpell.ManaCost, &TempDontHealMeBeforeTime);
 			}
 
-			if (casted_spell && botClass != BARD) {
+			if (casted_spell && botClass != Class::Bard) {
 				if (IsGroupSpell(botSpell.SpellId)) {
 					if (HasGroup()) {
 						Group *group = GetGroup();
@@ -1362,9 +1362,9 @@ bool Bot::AI_IdleCastCheck() {
 		//Ok, IdleCastCheck depends of class.
 		switch (GetClass()) {
 		// Healers WITHOUT pets will check if a heal is needed before buffing.
-		case CLERIC:
-		case PALADIN:
-		case RANGER: {
+		case Class::Cleric:
+		case Class::Paladin:
+		case Class::Ranger: {
 			if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, 100, BotAISpellRange, SpellType_Cure)) {
 				if (!AICastSpell(this, 100, SpellType_Heal)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, 100, BotAISpellRange, SpellType_Heal)) {
@@ -1379,10 +1379,10 @@ bool Bot::AI_IdleCastCheck() {
 			result = true;
 			break;
 		}
-		case MONK:
-		case ROGUE:
-		case WARRIOR:
-		case BERSERKER: {
+		case Class::Monk:
+		case Class::Rogue:
+		case Class::Warrior:
+		case Class::Berserker: {
 			if (!AICastSpell(this, 100, SpellType_Cure)) {
 				if (!AICastSpell(this, 100, SpellType_Heal)) {
 					if (!AICastSpell(this, 100, SpellType_Buff)) {
@@ -1397,10 +1397,10 @@ bool Bot::AI_IdleCastCheck() {
 		}
 		// Pets class will first cast their pet, then buffs
 
-		case MAGICIAN:
-		case SHADOWKNIGHT:
-		case NECROMANCER:
-		case ENCHANTER: {
+		case Class::Magician:
+		case Class::ShadowKnight:
+		case Class::Necromancer:
+		case Class::Enchanter: {
 			if (!AICastSpell(this, 100, SpellType_Pet)) {
 				if (!AICastSpell(this, 100, SpellType_Cure)) {
 					if (!AICastSpell(GetPet(), 100, SpellType_Cure)) {
@@ -1417,9 +1417,9 @@ bool Bot::AI_IdleCastCheck() {
 			result = true;
 			break;
 		}
-		case DRUID:
-		case SHAMAN:
-		case BEASTLORD: {
+		case Class::Druid:
+		case Class::Shaman:
+		case Class::Beastlord: {
 			if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, 100, BotAISpellRange, SpellType_Cure)) {
 				if (!AICastSpell(this, 100, SpellType_Pet)) {
 					if (!AICastSpell(this, 100, SpellType_Heal)) {
@@ -1438,7 +1438,7 @@ bool Bot::AI_IdleCastCheck() {
 			result = true;
 			break;
 		}
-		case WIZARD: { // This can eventually be move into the BEASTLORD case handler once pre-combat is fully implemented
+		case Class::Wizard: { // This can eventually be move into the Class::Beastlord case handler once pre-combat is fully implemented
 			if (pre_combat) {
 				if (!AICastSpell(this, 100, SpellType_Pet)) {
 					if (!AICastSpell(this, 100, SpellType_Cure)) {
@@ -1469,7 +1469,7 @@ bool Bot::AI_IdleCastCheck() {
 			result = true;
 			break;
 		}
-		case BARD: {
+		case Class::Bard: {
 			if (pre_combat) {
 				if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, 100, BotAISpellRange, SpellType_Cure)) {
 					if (!AICastSpell(this, 100, SpellType_Buff)) {
@@ -1518,7 +1518,7 @@ bool Bot::AI_EngagedCastCheck() {
 
 		LogAIDetail("Engaged autocast check triggered (BOTS). Trying to cast healing spells then maybe offensive spells");
 
-		if (botClass == CLERIC) {
+		if (botClass == Class::Cleric) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_Heal), BotAISpellRange, SpellType_Heal)) {
@@ -1534,7 +1534,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == DRUID) {
+		else if (botClass == Class::Druid) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_Heal), BotAISpellRange, SpellType_Heal)) {
@@ -1552,7 +1552,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == SHAMAN) {
+		else if (botClass == Class::Shaman) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Slow), SpellType_Slow)) {
 					if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
@@ -1573,7 +1573,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == RANGER) {
+		else if (botClass == Class::Ranger) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
@@ -1588,7 +1588,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == BEASTLORD) {
+		else if (botClass == Class::Beastlord) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Slow), SpellType_Slow)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1609,7 +1609,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == WIZARD) {
+		else if (botClass == Class::Wizard) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
@@ -1620,7 +1620,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == PALADIN) {
+		else if (botClass == Class::Paladin) {
 			if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 				if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1633,7 +1633,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == SHADOWKNIGHT) {
+		else if (botClass == Class::ShadowKnight) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Lifetap), SpellType_Lifetap)) {
 				if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1646,7 +1646,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == MAGICIAN) {
+		else if (botClass == Class::Magician) {
 			if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Pet), SpellType_Pet)) {
 				if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
 					if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
@@ -1659,7 +1659,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == NECROMANCER) {
+		else if (botClass == Class::Necromancer) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Pet), SpellType_Pet)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1678,7 +1678,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == ENCHANTER) {
+		else if (botClass == Class::Enchanter) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Mez), SpellType_Mez)) {
 				if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Slow), SpellType_Slow)) {
@@ -1695,7 +1695,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == BARD) {
+		else if (botClass == Class::Bard) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {// Bards will use their escape songs
 				if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_HateRedux), BotAISpellRange, SpellType_HateRedux)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Slow), SpellType_Slow)) {
@@ -1714,7 +1714,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == BERSERKER) {
+		else if (botClass == Class::Berserker) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1731,7 +1731,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == MONK) {
+		else if (botClass == Class::Monk) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1748,7 +1748,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == ROGUE) {
+		else if (botClass == Class::Rogue) {
 			if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Escape), SpellType_Escape)) {
 				if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -1765,7 +1765,7 @@ bool Bot::AI_EngagedCastCheck() {
 				}
 			}
 		}
-		else if (botClass == WARRIOR) {
+		else if (botClass == Class::Warrior) {
 			if (!AICastSpell(this, GetChanceToCastBySpellType(SpellType_Heal), SpellType_Heal)) {
 				if (!entity_list.Bot_AICheckCloseBeneficialSpells(this, GetChanceToCastBySpellType(SpellType_InCombatBuff), BotAISpellRange, SpellType_InCombatBuff)) {
 					if (!AICastSpell(GetTarget(), GetChanceToCastBySpellType(SpellType_Debuff), SpellType_Debuff)) {
@@ -3000,7 +3000,7 @@ uint8 Bot::GetChanceToCastBySpellType(uint32 spellType)
 		return 0;
 
 	uint8 class_index = GetClass();
-	if (class_index > BERSERKER || class_index < WARRIOR)
+	if (class_index > Class::Berserker || class_index < Class::Warrior)
 		return 0;
 	--class_index;
 

zone/client.cpp

@@ -65,6 +65,7 @@ extern volatile bool RunLoops;
 #include "../common/repositories/character_disciplines_repository.h"
 #include "../common/repositories/character_data_repository.h"
 #include "../common/repositories/discovered_items_repository.h"
+#include "../common/repositories/keyring_repository.h"
 #include "../common/events/player_events.h"
 #include "../common/events/player_event_logs.h"
 #include "dialogue_window.h"
@@ -2675,7 +2676,7 @@ bool Client::HasSkill(EQ::skills::SkillType skill_id) const {
 }
 
 bool Client::CanHaveSkill(EQ::skills::SkillType skill_id) const {
-	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == BERSERKER && skill_id == EQ::skills::Skill1HPiercing)
+	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == Class::Berserker && skill_id == EQ::skills::Skill1HPiercing)
 		skill_id = EQ::skills::Skill2HPiercing;
 
 	return(content_db.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0);
@@ -2683,7 +2684,7 @@ bool Client::CanHaveSkill(EQ::skills::SkillType skill_id) const {
 }
 
 uint16 Client::MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const {
-	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == EQ::skills::Skill1HPiercing)
+	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == Class::Berserker && skillid == EQ::skills::Skill1HPiercing)
 		skillid = EQ::skills::Skill2HPiercing;
 
 	return(content_db.GetSkillCap(class_, skillid, level));
@@ -2691,7 +2692,7 @@ uint16 Client::MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 lev
 
 uint8 Client::SkillTrainLevel(EQ::skills::SkillType skillid, uint16 class_)
 {
-	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == EQ::skills::Skill1HPiercing)
+	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && class_ == Class::Berserker && skillid == EQ::skills::Skill1HPiercing)
 		skillid = EQ::skills::Skill2HPiercing;
 
 	return(content_db.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel)));
@@ -3027,7 +3028,7 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
 
 						int max_percent = 50 + maxHPBonus;
 
-						if (GetClass() == MONK && GetSkill(EQ::skills::SkillBindWound) > 200) {
+						if (GetClass() == Class::Monk && GetSkill(EQ::skills::SkillBindWound) > 200) {
 							max_percent = 70 + maxHPBonus;
 						}
 
@@ -3076,9 +3077,9 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
 					else {
 						int percent_base = 50;
 						if (GetRawSkill(EQ::skills::SkillBindWound) > 200) {
-							if ((GetClass() == MONK) || (GetClass() == BEASTLORD))
+							if ((GetClass() == Class::Monk) || (GetClass() == Class::Beastlord))
 								percent_base = 70;
-							else if ((GetLevel() > 50) && ((GetClass() == WARRIOR) || (GetClass() == ROGUE) || (GetClass() == CLERIC)))
+							else if ((GetLevel() > 50) && ((GetClass() == Class::Warrior) || (GetClass() == Class::Rogue) || (GetClass() == Class::Cleric)))
 								percent_base = 70;
 						}
 
@@ -4087,54 +4088,87 @@ void Client::SendWindow(
 
 void Client::KeyRingLoad()
 {
-	std::string query = StringFormat("SELECT item_id FROM keyring "
-									"WHERE char_id = '%i' ORDER BY item_id", character_id);
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
+	const auto &l = KeyringRepository::GetWhere(
+		database,
+		fmt::format(
+			"`char_id` = {} ORDER BY `item_id`",
+			character_id
+		)
+	);
+
+	if (l.empty()) {
 		return;
 	}
 
-	for (auto row = results.begin(); row != results.end(); ++row)
-		keyring.push_back(Strings::ToInt(row[0]));
 
+	for (const auto &e : l) {
+		keyring.emplace_back(e.item_id);
+	}
 }
 
 void Client::KeyRingAdd(uint32 item_id)
 {
-	if(0==item_id)
-		return;
-
-	bool found = KeyRingCheck(item_id);
-	if (found)
-		return;
-
-	std::string query = StringFormat("INSERT INTO keyring(char_id, item_id) VALUES(%i, %i)", character_id, item_id);
-	auto results = database.QueryDatabase(query);
-	if (!results.Success()) {
+	if (!item_id) {
 		return;
 	}
 
-	Message(Chat::LightBlue,"Added to keyring.");
+	const bool found = KeyRingCheck(item_id);
+	if (found) {
+		return;
+	}
 
-	keyring.push_back(item_id);
+	auto e = KeyringRepository::NewEntity();
+
+	e.char_id = CharacterID();
+	e.item_id = item_id;
+
+	e = KeyringRepository::InsertOne(database, e);
+
+	if (!e.id) {
+		return;
+	}
+
+	keyring.emplace_back(item_id);
+
+	if (!RuleB(World, UseItemLinksForKeyRing)) {
+		Message(Chat::LightBlue, "Added to keyring.");
+		return;
+	}
+
+	const std::string &item_link = database.CreateItemLink(item_id);
+
+	Message(
+		Chat::LightBlue,
+		fmt::format(
+			"Added {} to keyring.",
+			item_link
+		).c_str()
+	);
 }
 
 bool Client::KeyRingCheck(uint32 item_id)
 {
-	for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) {
-		if(*iter == item_id)
+	for (const auto &e : keyring) {
+		if (e == item_id) {
 			return true;
+		}
 	}
+
 	return false;
 }
 
 void Client::KeyRingList()
 {
-	Message(Chat::LightBlue,"Keys on Keyring:");
+	Message(Chat::LightBlue, "Keys on Keyring:");
+
 	const EQ::ItemData *item = nullptr;
-	for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) {
-		if ((item = database.GetItem(*iter))!=nullptr) {
-			Message(Chat::LightBlue,item->Name);
+
+	for (const auto &e : keyring) {
+		item = database.GetItem(e);
+		if (item) {
+			const std::string &item_string = RuleB(World, UseItemLinksForKeyRing) ? database.CreateItemLink(e) : item->Name;
+
+			Message(Chat::LightBlue, item_string.c_str());
 		}
 	}
 }
@@ -4198,7 +4232,7 @@ void Client::UpdateLFP() {
 
 	for(unsigned int i=0; i<MAX_GROUP_MEMBERS; i++) {
 		LFPMembers[i].Name[0] = '\0';
-		LFPMembers[i].Class = NO_CLASS;
+		LFPMembers[i].Class = Class::None;
 		LFPMembers[i].Level = 0;
 		LFPMembers[i].Zone = 0;
 	}
@@ -4815,7 +4849,7 @@ void Client::HandleLDoNOpen(NPC *target)
 {
 	if(target)
 	{
-		if(target->GetClass() != LDON_TREASURE)
+		if(target->GetClass() != Class::LDoNTreasure)
 		{
 			LogDebug("[{}] tried to open [{}] but [{}] was not a treasure chest",
 				GetName(), target->GetName(), target->GetName());
@@ -4884,7 +4918,7 @@ void Client::HandleLDoNOpen(NPC *target)
 
 void Client::HandleLDoNSenseTraps(NPC *target, uint16 skill, uint8 type)
 {
-	if(target && target->GetClass() == LDON_TREASURE)
+	if(target && target->GetClass() == Class::LDoNTreasure)
 	{
 		if(target->IsLDoNTrapped())
 		{
@@ -4927,7 +4961,7 @@ void Client::HandleLDoNDisarm(NPC *target, uint16 skill, uint8 type)
 {
 	if(target)
 	{
-		if(target->GetClass() == LDON_TREASURE)
+		if(target->GetClass() == Class::LDoNTreasure)
 		{
 			if(!target->IsLDoNTrapped())
 			{
@@ -4977,7 +5011,7 @@ void Client::HandleLDoNPickLock(NPC *target, uint16 skill, uint8 type)
 {
 	if(target)
 	{
-		if(target->GetClass() == LDON_TREASURE)
+		if(target->GetClass() == Class::LDoNTreasure)
 		{
 			if(target->IsLDoNTrapped())
 			{
@@ -8569,20 +8603,20 @@ void Client::InitInnates()
 	}
 
 	switch (class_) {
-		case DRUID:
+		case Class::Druid:
 			m_pp.InnateSkills[InnateHarmony] = InnateEnabled;
 			break;
-		case BARD:
+		case Class::Bard:
 			m_pp.InnateSkills[InnateReveal] = InnateEnabled;
 			break;
-		case ROGUE:
+		case Class::Rogue:
 			m_pp.InnateSkills[InnateSurprise] = InnateEnabled;
 			m_pp.InnateSkills[InnateReveal]   = InnateEnabled;
 			break;
-		case RANGER:
+		case Class::Ranger:
 			m_pp.InnateSkills[InnateAwareness] = InnateEnabled;
 			break;
-		case MONK:
+		case Class::Monk:
 			m_pp.InnateSkills[InnateSurprise]  = InnateEnabled;
 			m_pp.InnateSkills[InnateAwareness] = InnateEnabled;
 		default:
@@ -9720,7 +9754,7 @@ std::vector<int> Client::GetLearnableDisciplines(uint8 min_level, uint8 max_leve
 			continue;
 		}
 
-		if (spells[spell_id].classes[WARRIOR] == 0) {
+		if (spells[spell_id].classes[Class::Warrior] == 0) {
 			continue;
 		}
 
@@ -9791,7 +9825,7 @@ std::vector<int> Client::GetScribeableSpells(uint8 min_level, uint8 max_level) {
 			continue;
 		}
 
-		if (spells[spell_id].classes[WARRIOR] == 0) {
+		if (spells[spell_id].classes[Class::Warrior] == 0) {
 			continue;
 		}
 
@@ -10355,6 +10389,16 @@ void Client::SetDoorToolEntityId(uint16 door_tool_entity_id)
 	Client::m_door_tool_entity_id = door_tool_entity_id;
 }
 
+uint16 Client::GetObjectToolEntityId() const
+{
+	return m_object_tool_entity_id;
+}
+
+void Client::SetObjectToolEntityId(uint16 object_tool_entity_id)
+{
+	Client::m_object_tool_entity_id = object_tool_entity_id;
+}
+
 int Client::GetIPExemption()
 {
 	return database.GetIPExemption(GetIPString());
@@ -10650,37 +10694,37 @@ uint16 Client::LearnDisciplines(uint8 min_level, uint8 max_level)
 
 uint16 Client::GetClassTrackingDistanceMultiplier(uint16 class_) {
 	switch (class_) {
-	case WARRIOR:
+	case Class::Warrior:
 		return RuleI(Character, WarriorTrackingDistanceMultiplier);
-	case CLERIC:
+	case Class::Cleric:
 		return RuleI(Character, ClericTrackingDistanceMultiplier);
-	case PALADIN:
+	case Class::Paladin:
 		return RuleI(Character, PaladinTrackingDistanceMultiplier);
-	case RANGER:
+	case Class::Ranger:
 		return RuleI(Character, RangerTrackingDistanceMultiplier);
-	case SHADOWKNIGHT:
+	case Class::ShadowKnight:
 		return RuleI(Character, ShadowKnightTrackingDistanceMultiplier);
-	case DRUID:
+	case Class::Druid:
 		return RuleI(Character, DruidTrackingDistanceMultiplier);
-	case MONK:
+	case Class::Monk:
 		return RuleI(Character, MonkTrackingDistanceMultiplier);
-	case BARD:
+	case Class::Bard:
 		return RuleI(Character, BardTrackingDistanceMultiplier);
-	case ROGUE:
+	case Class::Rogue:
 		return RuleI(Character, RogueTrackingDistanceMultiplier);
-	case SHAMAN:
+	case Class::Shaman:
 		return RuleI(Character, ShamanTrackingDistanceMultiplier);
-	case NECROMANCER:
+	case Class::Necromancer:
 		return RuleI(Character, NecromancerTrackingDistanceMultiplier);
-	case WIZARD:
+	case Class::Wizard:
 		return RuleI(Character, WizardTrackingDistanceMultiplier);
-	case MAGICIAN:
+	case Class::Magician:
 		return RuleI(Character, MagicianTrackingDistanceMultiplier);
-	case ENCHANTER:
+	case Class::Enchanter:
 		return RuleI(Character, EnchanterTrackingDistanceMultiplier);
-	case BEASTLORD:
+	case Class::Beastlord:
 		return RuleI(Character, BeastlordTrackingDistanceMultiplier);
-	case BERSERKER:
+	case Class::Berserker:
 		return RuleI(Character, BerserkerTrackingDistanceMultiplier);
 	default:
 		return 0;
@@ -11127,16 +11171,15 @@ void Client::AddAAPoints(uint32 points)
 {
 	m_pp.aapoints += points;
 
-	if (points == 1 && m_pp.aapoints == 1)
-	{
+	if (parse->PlayerHasQuestSub(EVENT_AA_GAIN)) {
+		parse->EventPlayer(EVENT_AA_GAIN, this, std::to_string(points), 0);
+	}
+
+	if (points == 1 && m_pp.aapoints == 1) {
 		MessageString(Chat::Yellow, GAIN_SINGLE_AA_SINGLE_AA, fmt::format_int(m_pp.aapoints).c_str());
-	}
-	else if (points == 1 && m_pp.aapoints > 1)
-	{
+	} else if (points == 1 && m_pp.aapoints > 1) {
 		MessageString(Chat::Yellow, GAIN_SINGLE_AA_MULTI_AA, fmt::format_int(m_pp.aapoints).c_str());
-	}
-	else
-	{
+	} else {
 		MessageString(Chat::Yellow, GAIN_MULTI_AA_MULTI_AA, fmt::format_int(points).c_str(), fmt::format_int(m_pp.aapoints).c_str());
 	}
 

zone/client.h

@@ -908,6 +908,7 @@ public:
 	void AutoGrantAAPoints();
 	void GrantAllAAPoints(uint8 unlock_level = 0);
 	bool HasAlreadyPurchasedRank(AA::Rank* rank);
+	void ListPurchasedAAs(Client *to, std::string search_criteria = std::string());
 
 	bool SendGMCommand(std::string message, bool ignore_status = false);
 
@@ -1274,6 +1275,10 @@ public:
 		}
 		else { return 0; }
 	}
+	inline bool CompleteTask(uint32 task_id)
+	{
+		return task_state ? task_state->CompleteTask(this, task_id) : false;
+	}
 	inline void FailTask(int task_id) { if (task_state) { task_state->FailTask(this, task_id); }}
 	inline int TaskTimeLeft(int task_id) { return (task_state ? task_state->TaskTimeLeft(task_id) : 0); }
 	inline int EnabledTaskCount(int task_set_id)
@@ -1809,9 +1814,12 @@ private:
 	bool dev_tools_enabled;
 
 	uint16 m_door_tool_entity_id;
+	uint16 m_object_tool_entity_id;
 public:
 	uint16 GetDoorToolEntityId() const;
 	void SetDoorToolEntityId(uint16 door_tool_entity_id);
+	uint16 GetObjectToolEntityId() const;
+	void SetObjectToolEntityId(uint16 object_tool_entity_id);
 private:
 
 	int32 max_end;
@@ -2037,14 +2045,14 @@ public:
 	bool GetBotPrecombat() { return m_bot_precombat; }
 	void SetBotPrecombat(bool flag = true) { m_bot_precombat = flag; }
 
-	int GetBotRequiredLevel(uint8 class_id = NO_CLASS);
-	uint32 GetBotCreationLimit(uint8 class_id = NO_CLASS);
-	int GetBotSpawnLimit(uint8 class_id = NO_CLASS);
-	void SetBotCreationLimit(uint32 new_creation_limit, uint8 class_id = NO_CLASS);
-	void SetBotRequiredLevel(int new_required_level, uint8 class_id = NO_CLASS);
-	void SetBotSpawnLimit(int new_spawn_limit, uint8 class_id = NO_CLASS);
+	int GetBotRequiredLevel(uint8 class_id = Class::None);
+	uint32 GetBotCreationLimit(uint8 class_id = Class::None);
+	int GetBotSpawnLimit(uint8 class_id = Class::None);
+	void SetBotCreationLimit(uint32 new_creation_limit, uint8 class_id = Class::None);
+	void SetBotRequiredLevel(int new_required_level, uint8 class_id = Class::None);
+	void SetBotSpawnLimit(int new_spawn_limit, uint8 class_id = Class::None);
 
-	void CampAllBots(uint8 class_id = NO_CLASS);
+	void CampAllBots(uint8 class_id = Class::None);
 	void SpawnRaidBotsOnConnect(Raid* raid);
 
 private:

zone/client_mods.cpp

@@ -345,7 +345,7 @@ uint32 Mob::GetClassLevelFactor()
 	uint32 multiplier = 0;
 	uint8  mlevel     = GetLevel();
 	switch (GetClass()) {
-		case WARRIOR: {
+		case Class::Warrior: {
 			if (mlevel < 20) {
 				multiplier = 220;
 			}
@@ -372,9 +372,9 @@ uint32 Mob::GetClassLevelFactor()
 			}
 			break;
 		}
-		case DRUID:
-		case CLERIC:
-		case SHAMAN: {
+		case Class::Druid:
+		case Class::Cleric:
+		case Class::Shaman: {
 			if (mlevel < 70) {
 				multiplier = 150;
 			}
@@ -383,9 +383,9 @@ uint32 Mob::GetClassLevelFactor()
 			}
 			break;
 		}
-		case BERSERKER:
-		case PALADIN:
-		case SHADOWKNIGHT: {
+		case Class::Berserker:
+		case Class::Paladin:
+		case Class::ShadowKnight: {
 			if (mlevel < 35) {
 				multiplier = 210;
 			}
@@ -409,10 +409,10 @@ uint32 Mob::GetClassLevelFactor()
 			}
 			break;
 		}
-		case MONK:
-		case BARD:
-		case ROGUE:
-		case BEASTLORD: {
+		case Class::Monk:
+		case Class::Bard:
+		case Class::Rogue:
+		case Class::Beastlord: {
 			if (mlevel < 51) {
 				multiplier = 180;
 			}
@@ -427,7 +427,7 @@ uint32 Mob::GetClassLevelFactor()
 			}
 			break;
 		}
-		case RANGER: {
+		case Class::Ranger: {
 			if (mlevel < 58) {
 				multiplier = 200;
 			}
@@ -439,10 +439,10 @@ uint32 Mob::GetClassLevelFactor()
 			}
 			break;
 		}
-		case MAGICIAN:
-		case WIZARD:
-		case NECROMANCER:
-		case ENCHANTER: {
+		case Class::Magician:
+		case Class::Wizard:
+		case Class::Necromancer:
+		case Class::Enchanter: {
 			if (mlevel < 70) {
 				multiplier = 120;
 			}
@@ -677,7 +677,7 @@ int64 Client::CalcManaRegen(bool bCombat)
 		if (IsSitting() || CanMedOnHorse()) {
 			// kind of weird to do it here w/e
 			// client does some base medding regen for shrouds here
-			if (GetClass() != BARD) {
+			if (GetClass() != Class::Bard) {
 				auto skill = GetSkill(EQ::skills::SkillMeditate);
 				if (skill > 0) {
 					regen++;
@@ -1077,7 +1077,7 @@ int32	Client::CalcMR()
 			MR = 20;
 	}
 	MR += itembonuses.MR + spellbonuses.MR + aabonuses.MR;
-	if (GetClass() == WARRIOR || GetClass() == BERSERKER) {
+	if (GetClass() == Class::Warrior || GetClass() == Class::Berserker) {
 		MR += GetLevel() / 2;
 	}
 	if (MR < 1) {
@@ -1151,14 +1151,14 @@ int32	Client::CalcFR()
 			FR = 20;
 	}
 	int c = GetClass();
-	if (c == RANGER) {
+	if (c == Class::Ranger) {
 		FR += 4;
 		int l = GetLevel();
 		if (l > 49) {
 			FR += l - 49;
 		}
 	}
-	if (c == MONK) {
+	if (c == Class::Monk) {
 		FR += 8;
 		int l = GetLevel();
 		if (l > 49) {
@@ -1238,19 +1238,19 @@ int32	Client::CalcDR()
 	}
 	int c = GetClass();
 	// the monk one is part of base resist
-	if (c == MONK) {
+	if (c == Class::Monk) {
 		int l = GetLevel();
 		if (l > 50)
 			DR += l - 50;
 	}
-	if (c == PALADIN) {
+	if (c == Class::Paladin) {
 		DR += 8;
 		int l = GetLevel();
 		if (l > 49) {
 			DR += l - 49;
 		}
 	}
-	else if (c == SHADOWKNIGHT || c == BEASTLORD) {
+	else if (c == Class::ShadowKnight || c == Class::Beastlord) {
 		DR += 4;
 		int l = GetLevel();
 		if (l > 49) {
@@ -1330,19 +1330,19 @@ int32	Client::CalcPR()
 	}
 	int c = GetClass();
 	// this monk bonus is part of the base
-	if (c == MONK) {
+	if (c == Class::Monk) {
 		int l = GetLevel();
 		if (l > 50)
 			PR += l - 50;
 	}
-	if (c == ROGUE) {
+	if (c == Class::Rogue) {
 		PR += 8;
 		int l = GetLevel();
 		if (l > 49) {
 			PR += l - 49;
 		}
 	}
-	else if (c == SHADOWKNIGHT) {
+	else if (c == Class::ShadowKnight) {
 		PR += 4;
 		int l = GetLevel();
 		if (l > 49) {
@@ -1421,7 +1421,7 @@ int32	Client::CalcCR()
 			CR = 25;
 	}
 	int c = GetClass();
-	if (c == RANGER || c == BEASTLORD) {
+	if (c == Class::Ranger || c == Class::Beastlord) {
 		CR += 4;
 		int l = GetLevel();
 		if (l > 49) {
@@ -1455,7 +1455,7 @@ int32 Client::CalcATK()
 
 uint32 Mob::GetInstrumentMod(uint16 spell_id)
 {
-	if (GetClass() != BARD) {
+	if (GetClass() != Class::Bard) {
 		//Other classes can get a base effects mod using SPA 413
 		if (HasBaseEffectFocus()) {
 			return (10 + (GetFocusEffect(focusFcBaseEffects, spell_id) / 10));//TODO: change action->instrument mod to float to support < 10% focus values
@@ -1689,7 +1689,7 @@ int64 Client::CalcEnduranceRegen(bool bCombat)
 
 	int weight_limit = GetSTR();
 	auto level = GetLevel();
-	if (GetClass() == MONK) {
+	if (GetClass() == Class::Monk) {
 		if (level > 99)
 			weight_limit = 58;
 		else if (level > 94)

zone/client_packet.cpp

@@ -60,6 +60,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "../common/repositories/criteria/content_filter_criteria.h"
 #include "../common/shared_tasks.h"
 #include "gm_commands/door_manipulation.h"
+#include "gm_commands/object_manipulation.h"
 #include "client.h"
 #include "../common/repositories/account_repository.h"
 
@@ -1380,15 +1381,11 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 	SetClientMaxLevel(client_max_level);
 
 	// we know our class now, so we might have to fix our consume timer!
-	if (class_ == MONK)
+	if (class_ == Class::Monk)
 		consume_food_timer.SetTimer(CONSUMPTION_MNK_TIMER);
 
 	InitInnates();
 
-	/* If GM not set in DB, and does not meet min status to be GM, reset */
-	if (m_pp.gm && admin < minStatusToBeGM)
-		m_pp.gm = 0;
-
 	/* Load Guild */
 	if (!IsInAGuild()) {
 		m_pp.guild_id = GUILD_NONE;
@@ -1595,9 +1592,9 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 			m_pp.spellSlotRefresh[i] = p_timers.GetRemainingTime(pTimerSpellStart + m_pp.mem_spells[i]) * 1000;
 
 	/* Ability slot refresh send SK/PAL */
-	if (m_pp.class_ == SHADOWKNIGHT || m_pp.class_ == PALADIN) {
+	if (m_pp.class_ == Class::ShadowKnight || m_pp.class_ == Class::Paladin) {
 		uint32 abilitynum = 0;
-		if (m_pp.class_ == SHADOWKNIGHT) { abilitynum = pTimerHarmTouch; }
+		if (m_pp.class_ == Class::ShadowKnight) { abilitynum = pTimerHarmTouch; }
 		else { abilitynum = pTimerLayHands; }
 
 		uint32 remaining = p_timers.GetRemainingTime(abilitynum);
@@ -1702,8 +1699,9 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 	this is not quite where live sends inventory, they do it after tribute
 	*/
 	if (loaditems) { /* Don't load if a length error occurs */
-		if (admin >= minStatusToBeGM)
+		if (m_pp.gm) {
 			m_inv.SetGMInventory(true); // set to true to allow expansion-restricted packets through
+		}
 
 		BulkSendInventoryItems();
 		/* Send stuff on the cursor which isn't sent in bulk */
@@ -1937,8 +1935,8 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
 	Adventure_Purchase_Struct* aps = (Adventure_Purchase_Struct*)app->pBuffer;
 	uint32 merchantid = 0;
 	Mob* tmp = entity_list.GetMob(aps->npcid);
-	if (tmp == 0 || !tmp->IsNPC() || ((tmp->GetClass() != ADVENTURE_MERCHANT) &&
-		(tmp->GetClass() != DISCORD_MERCHANT) && (tmp->GetClass() != NORRATHS_KEEPERS_MERCHANT) && (tmp->GetClass() != DARK_REIGN_MERCHANT)))
+	if (tmp == 0 || !tmp->IsNPC() || ((tmp->GetClass() != Class::AdventureMerchant) &&
+		(tmp->GetClass() != Class::DiscordMerchant) && (tmp->GetClass() != Class::NorrathsKeepersMerchant) && (tmp->GetClass() != Class::DarkReignMerchant)))
 		return;
 
 	//you have to be somewhat close to them to be properly using them
@@ -2123,8 +2121,8 @@ void Client::Handle_OP_AdventureMerchantRequest(const EQApplicationPacket *app)
 	uint32 merchantid = 0;
 
 	Mob* tmp = entity_list.GetMob(eid->entity_id);
-	if (tmp == 0 || !tmp->IsNPC() || ((tmp->GetClass() != ADVENTURE_MERCHANT) &&
-		(tmp->GetClass() != DISCORD_MERCHANT) && (tmp->GetClass() != NORRATHS_KEEPERS_MERCHANT) && (tmp->GetClass() != DARK_REIGN_MERCHANT)))
+	if (tmp == 0 || !tmp->IsNPC() || ((tmp->GetClass() != Class::AdventureMerchant) &&
+		(tmp->GetClass() != Class::DiscordMerchant) && (tmp->GetClass() != Class::NorrathsKeepersMerchant) && (tmp->GetClass() != Class::DarkReignMerchant)))
 		return;
 
 	if (!tmp->CastToNPC()->IsMerchantOpen()) {
@@ -2199,8 +2197,8 @@ void Client::Handle_OP_AdventureMerchantSell(const EQApplicationPacket *app)
 	Adventure_Sell_Struct *ams_in = (Adventure_Sell_Struct*)app->pBuffer;
 
 	Mob* vendor = entity_list.GetMob(ams_in->npcid);
-	if (vendor == 0 || !vendor->IsNPC() || ((vendor->GetClass() != ADVENTURE_MERCHANT) &&
-		(vendor->GetClass() != NORRATHS_KEEPERS_MERCHANT) && (vendor->GetClass() != DARK_REIGN_MERCHANT)))
+	if (vendor == 0 || !vendor->IsNPC() || ((vendor->GetClass() != Class::AdventureMerchant) &&
+		(vendor->GetClass() != Class::NorrathsKeepersMerchant) && (vendor->GetClass() != Class::DarkReignMerchant)))
 	{
 		Message(Chat::Red, "Vendor was not found.");
 		return;
@@ -2300,17 +2298,17 @@ void Client::Handle_OP_AdventureMerchantSell(const EQApplicationPacket *app)
 
 	switch (vendor->GetClass())
 	{
-	case ADVENTURE_MERCHANT:
+	case Class::AdventureMerchant:
 	{
 		UpdateLDoNPoints(6, price);
 		break;
 	}
-	case NORRATHS_KEEPERS_MERCHANT:
+	case Class::NorrathsKeepersMerchant:
 	{
 		SetRadiantCrystals(GetRadiantCrystals() + price);
 		break;
 	}
-	case DARK_REIGN_MERCHANT:
+	case Class::DarkReignMerchant:
 	{
 		SetEbonCrystals(GetEbonCrystals() + price);
 		break;
@@ -2484,7 +2482,7 @@ void Client::Handle_OP_AltCurrencyMerchantRequest(const EQApplicationPacket *app
 			return;
 		}
 
-		if (target->GetClass() != ALT_CURRENCY_MERCHANT) {
+		if (target->GetClass() != Class::AlternateCurrencyMerchant) {
 			return;
 		}
 
@@ -2555,7 +2553,7 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
 		if (DistanceSquared(m_Position, tar->GetPosition())> USE_NPC_RANGE2)
 			return;
 
-		if (tar->GetClass() != ALT_CURRENCY_MERCHANT) {
+		if (tar->GetClass() != Class::AlternateCurrencyMerchant) {
 			return;
 		}
 
@@ -2724,7 +2722,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
 		if (DistanceSquared(m_Position, tar->GetPosition()) > USE_NPC_RANGE2)
 			return;
 
-		if (tar->GetClass() != ALT_CURRENCY_MERCHANT) {
+		if (tar->GetClass() != Class::AlternateCurrencyMerchant) {
 			return;
 		}
 
@@ -2860,7 +2858,7 @@ void Client::Handle_OP_AltCurrencySellSelection(const EQApplicationPacket *app)
 		if (DistanceSquared(m_Position, tar->GetPosition()) > USE_NPC_RANGE2)
 			return;
 
-		if (tar->GetClass() != ALT_CURRENCY_MERCHANT) {
+		if (tar->GetClass() != Class::AlternateCurrencyMerchant) {
 			return;
 		}
 
@@ -2968,7 +2966,7 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app)
 
 	bool IsPoison = (poison && poison->ItemType == EQ::item::ItemTypePoison);
 
-	if (IsPoison && GetClass() == ROGUE) {
+	if (IsPoison && GetClass() == Class::Rogue) {
 
 		// Live always checks for skillup, even when poison is too high
 		CheckIncreaseSkill(EQ::skills::SkillApplyPoison, nullptr, 10);
@@ -3928,7 +3926,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app)
 	if (!HasSkill(EQ::skills::SkillBegging) || !GetTarget())
 		return;
 
-	if (GetTarget()->GetClass() == LDON_TREASURE)
+	if (GetTarget()->GetClass() == Class::LDoNTreasure)
 		return;
 
 	p_timers.Start(pTimerBeggingPickPocket, 8);
@@ -4473,7 +4471,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 	else if (slot == CastingSlot::Ability) {
 		uint16 spell_to_cast = 0;
 
-		if (castspell->spell_id == SPELL_LAY_ON_HANDS && GetClass() == PALADIN) {
+		if (castspell->spell_id == SPELL_LAY_ON_HANDS && GetClass() == Class::Paladin) {
 			if (!p_timers.Expired(&database, pTimerLayHands)) {
 				Message(Chat::Red, "Ability recovery time not yet met.");
 				InterruptSpell(castspell->spell_id);
@@ -4483,7 +4481,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 			p_timers.Start(pTimerLayHands, LayOnHandsReuseTime);
 		}
 		else if ((castspell->spell_id == SPELL_HARM_TOUCH
-			|| castspell->spell_id == SPELL_HARM_TOUCH2) && GetClass() == SHADOWKNIGHT) {
+			|| castspell->spell_id == SPELL_HARM_TOUCH2) && GetClass() == Class::ShadowKnight) {
 			if (!p_timers.Expired(&database, pTimerHarmTouch)) {
 				Message(Chat::Red, "Ability recovery time not yet met.");
 				InterruptSpell(castspell->spell_id);
@@ -4653,6 +4651,20 @@ void Client::Handle_OP_ClickObject(const EQApplicationPacket *app)
 			std::vector<std::any> args = { object };
 			parse->EventPlayer(EVENT_CLICK_OBJECT, this, std::to_string(click_object->drop_id), GetID(), &args);
 		}
+
+		if (IsDevToolsEnabled()) {
+			SetObjectToolEntityId(entity->GetID());
+			ObjectManipulation::CommandHeader(this);
+			Message(
+				Chat::White,
+				fmt::format(
+					"Object ({}) [{}] [{}]",
+					entity->CastToObject()->GetDBID(),
+					Saylink::Silent("#object edit", "Edit"),
+					Saylink::Silent("#object delete", "Delete")
+				).c_str()
+			);
+		}
 	}
 
 	// Observed in RoF after OP_ClickObjectAction:
@@ -5110,7 +5122,7 @@ void Client::Handle_OP_Consider(const EQApplicationPacket *app)
 		}
 	}
 
-	if (t->GetClass() == LDON_TREASURE) {
+	if (t->GetClass() == Class::LDoNTreasure) {
 		Message(Chat::Yellow, fmt::format("{}", t->GetCleanName()).c_str());
 		return;
 	}
@@ -6238,7 +6250,7 @@ void Client::Handle_OP_EnvDamage(const EQApplicationPacket *app)
 		damage = 31337;
 	}
 
-	if (admin >= minStatusToAvoidFalling && GetGM()) {
+	if (GetGM()) {
 		Message(
 			Chat::Red,
 			fmt::format(
@@ -6446,84 +6458,90 @@ void Client::Handle_OP_GetGuildsList(const EQApplicationPacket *app)
 
 void Client::Handle_OP_GMBecomeNPC(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToUseGMCommands) {
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /becomenpc when they shouldn't be able to"});
 		return;
 	}
+
 	if (app->size != sizeof(BecomeNPC_Struct)) {
 		LogError("Wrong size: OP_GMBecomeNPC, size=[{}], expected [{}]", app->size, sizeof(BecomeNPC_Struct));
 		return;
 	}
-	//entity_list.QueueClients(this, app, false);
-	BecomeNPC_Struct* bnpc = (BecomeNPC_Struct*)app->pBuffer;
 
-	Mob* cli = (Mob*)entity_list.GetMob(bnpc->id);
-	if (cli == nullptr) {
+	auto *b = (BecomeNPC_Struct *) app->pBuffer;
+
+	Mob *m = entity_list.GetMob(b->id);
+	if (!m) {
 		return;
 	}
 
-	if (cli->IsClient()) {
-		Client* target = cli->CastToClient();
-		target->QueuePacket(app);
-		if(target->GetGM()) {
-			target->SetInvul(false);
-			target->SetHideMe(false);
-			target->SetGM(false);
+	if (m->IsClient()) {
+		Client *t = m->CastToClient();
+		t->QueuePacket(app);
+		if (t->GetGM()) {
+			t->SetInvul(false);
+			t->SetHideMe(false);
+			t->SetGM(false);
 		}
 
-		cli->SendAppearancePacket(AT_NPCName, 1, true);
-		target->SetBecomeNPC(true);
-		target->SetBecomeNPCLevel(bnpc->maxlevel);
-		cli->MessageString(Chat::White, TOGGLE_OFF);
-		target->tellsoff = true;
-		target->UpdateWho();
+		m->SendAppearancePacket(AT_NPCName, 1, true);
+		t->SetBecomeNPC(true);
+		t->SetBecomeNPCLevel(b->maxlevel);
+		m->MessageString(Chat::White, TOGGLE_OFF);
+		t->tellsoff = true;
+		t->UpdateWho();
 	}
-	return;
 }
 
 void Client::Handle_OP_GMDelCorpse(const EQApplicationPacket *app)
 {
-	if (app->size != sizeof(GMDelCorpse_Struct))
+	if (app->size != sizeof(GMDelCorpse_Struct)) {
 		return;
-	if (Admin() < commandEditPlayerCorpses) {
+	}
+
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /delcorpse"});
 		return;
 	}
-	GMDelCorpse_Struct* dc = (GMDelCorpse_Struct *)app->pBuffer;
-	Mob* corpse = entity_list.GetMob(dc->corpsename);
-	if (corpse == 0) {
+
+	auto *c     = (GMDelCorpse_Struct *) app->pBuffer;
+	Mob  *corpse = entity_list.GetMob(c->corpsename);
+	if (!c) {
 		return;
 	}
-	if (corpse->IsCorpse() != true) {
+
+	if (!corpse->IsCorpse()) {
 		return;
 	}
+
 	corpse->CastToCorpse()->Delete();
-	std::cout << name << " deleted corpse " << dc->corpsename << std::endl;
-	Message(Chat::Red, "Corpse %s deleted.", dc->corpsename);
-	return;
+	Message(Chat::Red, fmt::format("Corpse {} deleted.", c->corpsename).c_str());
 }
 
 void Client::Handle_OP_GMEmoteZone(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToUseGMCommands) {
-		Message(Chat::Red, "Your account has been reported for hacking.");
-		return;
-	}
 	if (app->size != sizeof(GMEmoteZone_Struct)) {
 		LogError("Wrong size: OP_GMEmoteZone, size=[{}], expected [{}]", app->size, sizeof(GMEmoteZone_Struct));
 		return;
 	}
-	GMEmoteZone_Struct* gmez = (GMEmoteZone_Struct*)app->pBuffer;
-	char* newmessage = nullptr;
-	if (strstr(gmez->text, "^") == 0)
-		entity_list.Message(Chat::White, 15, gmez->text);
-	else {
-		for (newmessage = strtok((char*)gmez->text, "^"); newmessage != nullptr; newmessage = strtok(nullptr, "^"))
-			entity_list.Message(Chat::White, 15, newmessage);
+
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /emote"});
+		return;
+	}
+
+	auto *gmez = (GMEmoteZone_Struct*)app->pBuffer;
+	char *newmessage = nullptr;
+	if (strstr(gmez->text, "^") == 0) {
+		entity_list.Message(0, Chat::White, gmez->text);
+	} else {
+		for (newmessage = strtok((char *) gmez->text, "^"); newmessage != nullptr; newmessage = strtok(nullptr, "^")) {
+			entity_list.Message(0, Chat::White, newmessage);
+		}
 	}
-	return;
 }
 
 void Client::Handle_OP_GMEndTraining(const EQApplicationPacket *app)
@@ -6533,154 +6551,149 @@ void Client::Handle_OP_GMEndTraining(const EQApplicationPacket *app)
 		DumpPacket(app);
 		return;
 	}
+
 	OPGMEndTraining(app);
-	return;
 }
 
 void Client::Handle_OP_GMFind(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToUseGMCommands) {
-		Message(Chat::Red, "Your account has been reported for hacking.");
-		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /find"});
-		return;
-	}
-
 	if (app->size != sizeof(GMFind_Struct)) {
 		LogError("Wrong size: OP_GMFind, size=[{}], expected [{}]", app->size, sizeof(GMFind_Struct));
 		return;
 	}
 
-	//Break down incoming
-	auto* request = (GMFind_Struct*) app->pBuffer;
-	//Create a new outgoing
-	auto outapp = new EQApplicationPacket(OP_GMFind, sizeof(GMFind_Struct));
-	auto* foundplayer = (GMFind_Struct*) outapp->pBuffer;
-	//Copy the constants
-	strcpy(foundplayer->charname, request->charname);
-	strcpy(foundplayer->gmname, request->gmname);
-	//Check if the NPC exits intrazone...
-	auto* gt = entity_list.GetMob(request->charname);
-	if (gt) {
-		foundplayer->success = 1;
-		foundplayer->x       = gt->GetX();
-		foundplayer->y       = gt->GetY();
-		foundplayer->z       = gt->GetZ();
-		foundplayer->zoneID  = zone->GetZoneID();
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /find"});
+		return;
 	}
-	//Send the packet...
+
+	auto *r = (GMFind_Struct *) app->pBuffer;
+	auto outapp = new EQApplicationPacket(OP_GMFind, sizeof(GMFind_Struct));
+	auto *f = (GMFind_Struct *) outapp->pBuffer;
+
+	strcpy(f->charname, r->charname);
+	strcpy(f->gmname, r->gmname);
+
+	auto* gt = entity_list.GetMob(r->charname);
+	if (gt) {
+		f->success = 1;
+		f->x       = gt->GetX();
+		f->y       = gt->GetY();
+		f->z       = gt->GetZ();
+		f->zoneID  = zone->GetZoneID();
+	}
+
 	FastQueuePacket(&outapp);
-	return;
 }
 
 void Client::Handle_OP_GMGoto(const EQApplicationPacket *app)
 {
 	if (app->size != sizeof(GMSummon_Struct)) {
-		std::cout << "Wrong size on OP_GMGoto. Got: " << app->size << ", Expected: " << sizeof(GMSummon_Struct) << std::endl;
+		LogError("Wrong size: OP_GMGoto, size=[{}], expected [{}]", app->size, sizeof(GMSummon_Struct));
 		return;
 	}
-	if (Admin() < minStatusToUseGMCommands) {
+
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /goto"});
 		return;
 	}
-	GMSummon_Struct* gmg = (GMSummon_Struct*)app->pBuffer;
-	Mob* gt = entity_list.GetMob(gmg->charname);
-	if (gt != nullptr) {
+
+	auto *gmg = (GMSummon_Struct *) app->pBuffer;
+	Mob  *gt  = entity_list.GetMob(gmg->charname);
+	if (!gt) {
 		MovePC(zone->GetZoneID(), zone->GetInstanceID(), gt->GetX(), gt->GetY(), gt->GetZ(), gt->GetHeading());
-	}
-	else if (!worldserver.Connected())
+	} else if (!worldserver.Connected()) {
 		Message(Chat::Red, "Error: World server disconnected.");
-	else {
+	} else {
 		auto pack = new ServerPacket(ServerOP_GMGoto, sizeof(ServerGMGoto_Struct));
 		memset(pack->pBuffer, 0, pack->size);
-		ServerGMGoto_Struct* wsgmg = (ServerGMGoto_Struct*)pack->pBuffer;
+		ServerGMGoto_Struct *wsgmg = (ServerGMGoto_Struct *) pack->pBuffer;
 		strcpy(wsgmg->myname, GetName());
 		strcpy(wsgmg->gotoname, gmg->charname);
 		wsgmg->admin = admin;
 		worldserver.SendPacket(pack);
 		safe_delete(pack);
 	}
-	return;
 }
 
 void Client::Handle_OP_GMHideMe(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToUseGMCommands) {
-		Message(Chat::Red, "Your account has been reported for hacking.");
-		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /hideme"});
-		return;
-	}
 	if (app->size != sizeof(SpawnAppearance_Struct)) {
 		LogError("Wrong size: OP_GMHideMe, size=[{}], expected [{}]", app->size, sizeof(SpawnAppearance_Struct));
 		return;
 	}
-	SpawnAppearance_Struct* sa = (SpawnAppearance_Struct*)app->pBuffer;
-	Message(Chat::Red, "#: %i, %i", sa->type, sa->parameter);
-	SetHideMe(!sa->parameter);
-	return;
 
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /hideme"});
+		return;
+	}
+
+	auto *sa = (SpawnAppearance_Struct *) app->pBuffer;
+	SetHideMe(!sa->parameter);
 }
 
 void Client::Handle_OP_GMKick(const EQApplicationPacket *app)
 {
-	if (app->size != sizeof(GMKick_Struct))
+	if (app->size != sizeof(GMKick_Struct)) {
 		return;
-	if (Admin() < minStatusToKick) {
+	}
+
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /kick"});
 		return;
 	}
-	GMKick_Struct* gmk = (GMKick_Struct *)app->pBuffer;
 
-	Client* client = entity_list.GetClientByName(gmk->name);
-	if (client == 0) {
-		if (!worldserver.Connected())
+	auto *gmk = (GMKick_Struct *)app->pBuffer;
+	Client *c = entity_list.GetClientByName(gmk->name);
+	if (!c) {
+		if (!worldserver.Connected()) {
 			Message(Chat::Red, "Error: World server disconnected");
-		else {
+		} else {
 			auto pack = new ServerPacket(ServerOP_KickPlayer, sizeof(ServerKickPlayer_Struct));
-			ServerKickPlayer_Struct* skp = (ServerKickPlayer_Struct*)pack->pBuffer;
+			auto *skp = (ServerKickPlayer_Struct *) pack->pBuffer;
 			strcpy(skp->adminname, gmk->gmname);
 			strcpy(skp->name, gmk->name);
 			skp->adminrank = Admin();
 			worldserver.SendPacket(pack);
 			safe_delete(pack);
 		}
-	}
-	else {
+	} else {
 		entity_list.QueueClients(this, app);
-		//client->Kick();
 	}
-	return;
 }
 
 void Client::Handle_OP_GMKill(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToUseGMCommands) {
-		Message(Chat::Red, "Your account has been reported for hacking.");
-		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /kill"});
-		return;
-	}
 	if (app->size != sizeof(GMKill_Struct)) {
 		LogError("Wrong size: OP_GMKill, size=[{}], expected [{}]", app->size, sizeof(GMKill_Struct));
 		return;
 	}
-	GMKill_Struct* gmk = (GMKill_Struct *)app->pBuffer;
-	Mob* obj = entity_list.GetMob(gmk->name);
-	Client* client = entity_list.GetClientByName(gmk->name);
-	if (obj != 0) {
-		if (client != 0) {
+
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /kill"});
+		return;
+	}
+
+	auto   *gmk    = (GMKill_Struct *) app->pBuffer;
+	Mob    *obj    = entity_list.GetMob(gmk->name);
+	Client *c = entity_list.GetClientByName(gmk->name);
+	if (obj) {
+		if (c) {
 			entity_list.QueueClients(this, app);
-		}
-		else {
+		} else {
 			obj->Kill();
 		}
-	}
-	else {
-		if (!worldserver.Connected())
+	} else {
+		if (!worldserver.Connected()) {
 			Message(Chat::Red, "Error: World server disconnected");
-		else {
+		} else {
 			auto pack = new ServerPacket(ServerOP_KillPlayer, sizeof(ServerKillPlayer_Struct));
-			ServerKillPlayer_Struct* skp = (ServerKillPlayer_Struct*)pack->pBuffer;
+			auto *skp = (ServerKillPlayer_Struct *) pack->pBuffer;
 			strcpy(skp->gmname, gmk->gmname);
 			strcpy(skp->target, gmk->name);
 			skp->admin = Admin();
@@ -6688,7 +6701,6 @@ void Client::Handle_OP_GMKill(const EQApplicationPacket *app)
 			safe_delete(pack);
 		}
 	}
-	return;
 }
 
 void Client::Handle_OP_GMLastName(const EQApplicationPacket *app)
@@ -6697,32 +6709,30 @@ void Client::Handle_OP_GMLastName(const EQApplicationPacket *app)
 		std::cout << "Wrong size on OP_GMLastName. Got: " << app->size << ", Expected: " << sizeof(GMLastName_Struct) << std::endl;
 		return;
 	}
-	GMLastName_Struct* gmln = (GMLastName_Struct*)app->pBuffer;
-	if (strlen(gmln->lastname) >= 64) {
-		Message(Chat::Red, "/LastName: New last name too long. (max=63)");
-	}
-	else {
-		Client* client = entity_list.GetClientByName(gmln->name);
-		if (client == 0) {
-			Message(Chat::Red, "/LastName: %s not found", gmln->name);
-		}
-		else {
-			if (Admin() < minStatusToUseGMCommands) {
-				Message(Chat::Red, "Your account has been reported for hacking.");
-				RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /lastname"});
-				return;
-			}
-			else
 
-				client->ChangeLastName(gmln->lastname);
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /lastname"});
+		return;
+	}
+
+	auto *gmln = (GMLastName_Struct *) app->pBuffer;
+	if (strlen(gmln->lastname) >= 64) {
+		Message(Chat::Red, "/LastName: New last name too long. Max length is 63.");
+	} else {
+		Client *c = entity_list.GetClientByName(gmln->name);
+		if (!c) {
+			Message(Chat::Red, fmt::format("/LastName: {} not found", gmln->name).c_str());
+		} else {
+			c->ChangeLastName(gmln->lastname);
 		}
+
 		gmln->unknown[0] = 1;
 		gmln->unknown[1] = 1;
 		gmln->unknown[2] = 1;
 		gmln->unknown[3] = 1;
 		entity_list.QueueClients(this, app, false);
 	}
-	return;
 }
 
 void Client::Handle_OP_GMNameChange(const EQApplicationPacket *app)
@@ -6731,44 +6741,49 @@ void Client::Handle_OP_GMNameChange(const EQApplicationPacket *app)
 		LogError("Wrong size: OP_GMNameChange, size=[{}], expected [{}]", app->size, sizeof(GMName_Struct));
 		return;
 	}
-	const GMName_Struct* gmn = (const GMName_Struct *)app->pBuffer;
-	if (Admin() < minStatusToUseGMCommands) {
+
+	auto *gmn = (GMName_Struct *) app->pBuffer;
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /name"});
 		return;
 	}
-	Client* client = entity_list.GetClientByName(gmn->oldname);
-	LogInfo("GM([{}]) changeing players name. Old:[{}] New:[{}]", GetName(), gmn->oldname, gmn->newname);
-	bool usedname = database.CheckUsedName(gmn->newname);
-	if (client == 0) {
-		Message(Chat::Red, "%s not found for name change. Operation failed!", gmn->oldname);
-		return;
-	}
-	if ((strlen(gmn->newname) > 63) || (strlen(gmn->newname) == 0)) {
-		Message(Chat::Red, "Invalid number of characters in new name (%s).", gmn->newname);
-		return;
-	}
-	if (!usedname) {
-		Message(Chat::Red, "%s is already in use. Operation failed!", gmn->newname);
-		return;
 
+	Client *c = entity_list.GetClientByName(gmn->oldname);
+	LogInfo("GM([{}]) changeing players name. Old:[{}] New:[{}]", GetName(), gmn->oldname, gmn->newname);
+
+	const bool used_name = database.CheckUsedName(gmn->newname);
+	if (!c) {
+		Message(Chat::Red, fmt::format("{} not found for name change. Operation failed!", gmn->oldname).c_str());
+		return;
 	}
+
+	if (strlen(gmn->newname) > 63 || strlen(gmn->newname) == 0) {
+		Message(Chat::Red, fmt::format("Invalid number of characters in new name '{}'.", gmn->newname).c_str());
+		return;
+	}
+
+	if (!used_name) {
+		Message(Chat::Red, fmt::format("{} is already in use. Operation failed!", gmn->newname).c_str());
+		return;
+	}
+
 	database.UpdateName(gmn->oldname, gmn->newname);
-	strcpy(client->name, gmn->newname);
-	client->Save();
+	strcpy(c->name, gmn->newname);
+	c->Save();
 
 	if (gmn->badname == 1) {
 		database.AddToNameFilter(gmn->oldname);
 	}
-	EQApplicationPacket* outapp = app->Copy();
-	GMName_Struct* gmn2 = (GMName_Struct*)outapp->pBuffer;
+
+	auto *outapp = app->Copy();
+	auto *gmn2 = (GMName_Struct *) outapp->pBuffer;
 	gmn2->unknown[0] = 1;
 	gmn2->unknown[1] = 1;
 	gmn2->unknown[2] = 1;
 	entity_list.QueueClients(this, outapp, false);
 	safe_delete(outapp);
 	UpdateWho();
-	return;
 }
 
 void Client::Handle_OP_GMSearchCorpse(const EQApplicationPacket *app)
@@ -6863,6 +6878,7 @@ void Client::Handle_OP_GMSummon(const EQApplicationPacket *app)
 		std::cout << "Wrong size on OP_GMSummon. Got: " << app->size << ", Expected: " << sizeof(GMSummon_Struct) << std::endl;
 		return;
 	}
+
 	OPGMSummon(app);
 	return;
 }
@@ -6873,12 +6889,14 @@ void Client::Handle_OP_GMToggle(const EQApplicationPacket *app)
 		std::cout << "Wrong size on OP_GMToggle. Got: " << app->size << ", Expected: " << sizeof(GMToggle_Struct) << std::endl;
 		return;
 	}
-	if (Admin() < minStatusToUseGMCommands) {
+
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /toggle"});
 		return;
 	}
-	GMToggle_Struct *ts = (GMToggle_Struct *)app->pBuffer;
+
+	auto *ts = (GMToggle_Struct *)app->pBuffer;
 	if (ts->toggle == 0) {
 		MessageString(Chat::White, TOGGLE_OFF);
 		tellsoff = true;
@@ -6886,10 +6904,10 @@ void Client::Handle_OP_GMToggle(const EQApplicationPacket *app)
 		MessageString(Chat::White, TOGGLE_ON);
 		tellsoff = false;
 	} else {
-		Message(Chat::White, "Unkown value in /toggle packet");
+		Message(Chat::White, "Unknown value in /toggle packet.");
 	}
+
 	UpdateWho();
-	return;
 }
 
 void Client::Handle_OP_GMTraining(const EQApplicationPacket *app)
@@ -6899,6 +6917,7 @@ void Client::Handle_OP_GMTraining(const EQApplicationPacket *app)
 		DumpPacket(app);
 		return;
 	}
+
 	OPGMTraining(app);
 	return;
 }
@@ -6910,6 +6929,7 @@ void Client::Handle_OP_GMTrainSkill(const EQApplicationPacket *app)
 		DumpPacket(app);
 		return;
 	}
+
 	OPGMTrainSkill(app);
 	return;
 }
@@ -6920,27 +6940,30 @@ void Client::Handle_OP_GMZoneRequest(const EQApplicationPacket *app)
 		std::cout << "Wrong size on OP_GMZoneRequest. Got: " << app->size << ", Expected: " << sizeof(GMZoneRequest_Struct) << std::endl;
 		return;
 	}
-	if (Admin() < minStatusToBeGM) {
+
+	if (!GetGM()) {
 		Message(Chat::Red, "Your account has been reported for hacking.");
 		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /zone"});
 		return;
 	}
 
-	auto* gmzr = (GMZoneRequest_Struct*)app->pBuffer;
+	auto  *gmzr    = (GMZoneRequest_Struct *) app->pBuffer;
 	float target_x = -1, target_y = -1, target_z = -1, target_heading;
 
-	int16 min_status = AccountStatus::Player;
-	uint8 min_level = 0;
-	char target_zone[32];
-	uint16 zone_id = gmzr->zone_id;
-	if (gmzr->zone_id == 0)
+	int16  min_status = AccountStatus::Player;
+	uint8  min_level  = 0;
+	char   target_zone[32];
+	uint16 zone_id    = gmzr->zone_id;
+	if (gmzr->zone_id == 0) {
 		zone_id = zonesummon_id;
+	}
 
-	const char* zone_short_name = ZoneName(zone_id);
-	if (zone_short_name == nullptr)
+	const char *zone_short_name = ZoneName(zone_id);
+	if (zone_short_name == nullptr) {
 		target_zone[0] = 0;
-	else
+	} else {
 		strcpy(target_zone, zone_short_name);
+	}
 
 	// this both loads the safe points and does a sanity check on zone name
 	auto z = GetZone(target_zone, 0);
@@ -6954,41 +6977,40 @@ void Client::Handle_OP_GMZoneRequest(const EQApplicationPacket *app)
 	}
 
 	auto outapp = new EQApplicationPacket(OP_GMZoneRequest, sizeof(GMZoneRequest_Struct));
-	auto* gmzr2 = (GMZoneRequest_Struct*)outapp->pBuffer;
+	auto *gmzr2 = (GMZoneRequest_Struct *) outapp->pBuffer;
 	strcpy(gmzr2->charname, GetName());
 	gmzr2->zone_id = gmzr->zone_id;
-	gmzr2->x = target_x;
-	gmzr2->y = target_y;
-	gmzr2->z = target_z;
+	gmzr2->x       = target_x;
+	gmzr2->y       = target_y;
+	gmzr2->z       = target_z;
 	gmzr2->heading = target_heading;
-	// Next line stolen from ZoneChange as well... - This gives us a nicer message than the normal "zone is down" message...
-	if (target_zone[0] != 0 && admin >= min_status && GetLevel() >= min_level)
+
+	if (target_zone[0] != 0 && admin >= min_status && GetLevel() >= min_level) {
 		gmzr2->success = 1;
-	else {
-		std::cout << "GetZoneSafeCoords failed. zoneid = " << gmzr->zone_id << "; czone = " << zone->GetZoneID() << std::endl;
+	} else {
+		LogError("GetZoneSafeCoords failed. Zone ID [{}] Current Zone [{}]", gmzr->zone_id, zone->GetZoneID());
 		gmzr2->success = 0;
 	}
 
 	QueuePacket(outapp);
 	safe_delete(outapp);
-	return;
 }
 
 void Client::Handle_OP_GMZoneRequest2(const EQApplicationPacket *app)
 {
-	if (Admin() < minStatusToBeGM) {
-		Message(Chat::Red, "Your account has been reported for hacking.");
-		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /zone"});
-		return;
-	}
 	if (app->size < sizeof(uint32)) {
 		LogError("OP size error: OP_GMZoneRequest2 expected:[{}] got:[{}]", sizeof(uint32), app->size);
 		return;
 	}
 
+	if (!GetGM()) {
+		Message(Chat::Red, "Your account has been reported for hacking.");
+		RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = "Used /zone"});
+		return;
+	}
+
 	uint32 zonereq = *((uint32 *)app->pBuffer);
 	GoToSafeCoords(zonereq, 0);
-	return;
 }
 
 void Client::Handle_OP_GroupAcknowledge(const EQApplicationPacket *app)
@@ -8598,7 +8620,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app)
 			hidden = true;
 		tmHidden = Timer::GetCurrentTime();
 	}
-	if (GetClass() == ROGUE) {
+	if (GetClass() == Class::Rogue) {
 		auto outapp = new EQApplicationPacket(OP_SimpleMessage, sizeof(SimpleMessage_Struct));
 		SimpleMessage_Struct *msg = (SimpleMessage_Struct *)outapp->pBuffer;
 		msg->color = 0x010E;
@@ -9147,7 +9169,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 				Bards on live can click items while casting spell gems, it stops that song cast and replaces it with item click cast.
 				Can not click while casting other items.
 			*/
-			if (GetClass() == BARD && IsCasting() && casting_spell_slot < CastingSlot::MaxGems)
+			if (GetClass() == Class::Bard && IsCasting() && casting_spell_slot < CastingSlot::MaxGems)
 			{
 				is_casting_bard_song = true;
 			}
@@ -9313,7 +9335,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 						if (!IsCastWhileInvisibleSpell(item->Click.Effect)) {
 							CommonBreakInvisible(); // client can't do this for us :(
 						}
-						if (GetClass() == BARD){
+						if (GetClass() == Class::Bard){
 							DoBardCastingFromItemClick(is_casting_bard_song, item->CastTime, item->Click.Effect, target_id, CastingSlot::Item, slot_id, item->RecastType, item->RecastDelay);
 						}
 						else {
@@ -9385,7 +9407,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 						if (!IsCastWhileInvisibleSpell(augitem->Click.Effect)) {
 							CommonBreakInvisible(); // client can't do this for us :(
 						}
-						if (GetClass() == BARD) {
+						if (GetClass() == Class::Bard) {
 							DoBardCastingFromItemClick(is_casting_bard_song, augitem->CastTime, augitem->Click.Effect, target_id, CastingSlot::Item, slot_id, augitem->RecastType, augitem->RecastDelay);
 						}
 						else {
@@ -9521,7 +9543,7 @@ void Client::Handle_OP_LDoNDisarmTraps(const EQApplicationPacket *app)
 void Client::Handle_OP_LDoNInspect(const EQApplicationPacket *app)
 {
 	auto* t = GetTarget();
-	if (t && t->GetClass() == LDON_TREASURE && !t->IsAura()) {
+	if (t && t->GetClass() == Class::LDoNTreasure && !t->IsAura()) {
 		if (parse->PlayerHasQuestSub(EVENT_INSPECT)) {
 			std::vector<std::any> args = { t };
 			if (parse->EventPlayer(EVENT_INSPECT, this, "", t->GetID(), &args) == 0) {
@@ -9850,7 +9872,7 @@ void Client::Handle_OP_LFPCommand(const EQApplicationPacket *app)
 
 	for (unsigned int i = 0; i<MAX_GROUP_MEMBERS; i++) {
 		LFPMembers[i].Name[0] = '\0';
-		LFPMembers[i].Class = NO_CLASS;
+		LFPMembers[i].Class = Class::None;
 		LFPMembers[i].Level = 0;
 		LFPMembers[i].Zone = 0;
 		LFPMembers[i].GuildID = 0xFFFF;
@@ -10191,7 +10213,7 @@ void Client::Handle_OP_MercenaryDataRequest(const EQApplicationPacket *app)
 		if (DistanceSquared(m_Position, tar->GetPosition()) > USE_NPC_RANGE2)
 			return;
 
-		if (tar->GetClass() != MERCENARY_MASTER) {
+		if (tar->GetClass() != Class::MercenaryLiaison) {
 			return;
 		}
 
@@ -10566,7 +10588,7 @@ void Client::Handle_OP_OpenGuildTributeMaster(const EQApplicationPacket *app)
 		//Opens the guild tribute master window
 		StartTribute_Struct* st = (StartTribute_Struct*)app->pBuffer;
 		Mob* tribmast = entity_list.GetMob(st->tribute_master_id);
-		if (tribmast && tribmast->IsNPC() && tribmast->GetClass() == GUILD_TRIBUTE_MASTER
+		if (tribmast && tribmast->IsNPC() && tribmast->GetClass() == Class::GuildTributeMaster
 			&& DistanceSquared(m_Position, tribmast->GetPosition()) <= USE_NPC_RANGE2) {
 			st->response = 1;
 			QueuePacket(app);
@@ -10597,7 +10619,7 @@ void Client::Handle_OP_OpenTributeMaster(const EQApplicationPacket *app)
 		//Opens the tribute master window
 		StartTribute_Struct* st = (StartTribute_Struct*)app->pBuffer;
 		Mob* tribmast = entity_list.GetMob(st->tribute_master_id);
-		if (tribmast && tribmast->IsNPC() && tribmast->GetClass() == TRIBUTE_MASTER
+		if (tribmast && tribmast->IsNPC() && tribmast->GetClass() == Class::TributeMaster
 			&& DistanceSquared(m_Position, tribmast->GetPosition()) <= USE_NPC_RANGE2) {
 			st->response = 1;
 			QueuePacket(app);
@@ -13503,7 +13525,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
 		return;
 	}
 
-	if (GetClass() != WARRIOR){
+	if (GetClass() != Class::Warrior){
 		return;
 	}
 
@@ -13559,7 +13581,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 	bool tmpmer_used = false;
 	Mob* tmp = entity_list.GetMob(mp->npcid);
 
-	if (tmp == 0 || !tmp->IsNPC() || tmp->GetClass() != MERCHANT)
+	if (tmp == 0 || !tmp->IsNPC() || tmp->GetClass() != Class::Merchant)
 		return;
 
 	if (mp->quantity < 1) return;
@@ -13868,7 +13890,7 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
 
 	Mob* vendor = entity_list.GetMob(mp->npcid);
 
-	if (vendor == 0 || !vendor->IsNPC() || vendor->GetClass() != MERCHANT)
+	if (vendor == 0 || !vendor->IsNPC() || vendor->GetClass() != Class::Merchant)
 		return;
 
 	//you have to be somewhat close to them to be properly using them
@@ -14094,7 +14116,7 @@ void Client::Handle_OP_ShopRequest(const EQApplicationPacket *app)
 	int merchantid = 0;
 	Mob* tmp = entity_list.GetMob(mc->npcid);
 
-	if (tmp == 0 || !tmp->IsNPC() || tmp->GetClass() != MERCHANT)
+	if (tmp == 0 || !tmp->IsNPC() || tmp->GetClass() != Class::Merchant)
 		return;
 
 	//you have to be somewhat close to them to be properly using them
@@ -14201,7 +14223,7 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app)
 	sa_out->parameter = sneaking;
 	QueuePacket(outapp);
 	safe_delete(outapp);
-	if (GetClass() == ROGUE) {
+	if (GetClass() == Class::Rogue) {
 		outapp = new EQApplicationPacket(OP_SimpleMessage, 12);
 		SimpleMessage_Struct *msg = (SimpleMessage_Struct *)outapp->pBuffer;
 		msg->color = 0x010E;
@@ -15517,7 +15539,7 @@ void Client::Handle_OP_TributeItem(const EQApplicationPacket *app)
 		tribute_master_id = t->tribute_master_id;
 		//make sure they are dealing with a valid tribute master
 		Mob* tribmast = entity_list.GetMob(t->tribute_master_id);
-		if (!tribmast || !tribmast->IsNPC() || tribmast->GetClass() != TRIBUTE_MASTER)
+		if (!tribmast || !tribmast->IsNPC() || tribmast->GetClass() != Class::TributeMaster)
 			return;
 		if (DistanceSquared(m_Position, tribmast->GetPosition()) > USE_NPC_RANGE2)
 			return;
@@ -15544,7 +15566,7 @@ void Client::Handle_OP_TributeMoney(const EQApplicationPacket *app)
 		tribute_master_id = t->tribute_master_id;
 		//make sure they are dealing with a valid tribute master
 		Mob* tribmast = entity_list.GetMob(t->tribute_master_id);
-		if (!tribmast || !tribmast->IsNPC() || tribmast->GetClass() != TRIBUTE_MASTER)
+		if (!tribmast || !tribmast->IsNPC() || tribmast->GetClass() != Class::TributeMaster)
 			return;
 		if (DistanceSquared(m_Position, tribmast->GetPosition()) > USE_NPC_RANGE2)
 			return;

zone/client_process.cpp

@@ -434,7 +434,7 @@ bool Client::Process() {
 			}
 		}
 
-		if (GetClass() == WARRIOR || GetClass() == BERSERKER) {
+		if (GetClass() == Class::Warrior || GetClass() == Class::Berserker) {
 			if (!dead && !IsBerserk() && GetHPRatio() < RuleI(Combat, BerserkerFrenzyStart)) {
 				entity_list.MessageCloseString(this, false, 200, 0, BERSERK_START, GetName());
 				berserk = true;
@@ -1121,7 +1121,7 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
 	if (
 		m->scribing != memSpellForget &&
 		(
-			!EQ::ValueWithin(GetClass(), PLAYER_CLASS_WARRIOR, PLAYER_CLASS_BERSERKER) ||
+			!IsPlayerClass(GetClass()) ||
 			GetLevel() < spells[m->spell_id].classes[GetClass() - 1]
 		)
 	) {
@@ -1552,12 +1552,12 @@ void Client::OPGMTraining(const EQApplicationPacket *app)
 
 	Mob* pTrainer = entity_list.GetMob(gmtrain->npcid);
 
-	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < WARRIORGM || pTrainer->GetClass() > BERSERKERGM)
+	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < Class::WarriorGM || pTrainer->GetClass() > Class::BerserkerGM)
 		return;
 
 	//you can only use your own trainer, client enforces this, but why trust it
 	if (!RuleB(Character, AllowCrossClassTrainers)) {
-		int trains_class = pTrainer->GetClass() - (WARRIORGM - WARRIOR);
+		int trains_class = pTrainer->GetClass() - (Class::WarriorGM - Class::Warrior);
 		if (GetClass() != trains_class)
 			return;
 	}
@@ -1579,7 +1579,7 @@ void Client::OPGMTraining(const EQApplicationPacket *app)
 		}
 	}
 
-	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && GetClass() == BERSERKER) {
+	if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && GetClass() == Class::Berserker) {
 		gmtrain->skills[EQ::skills::Skill1HPiercing] = gmtrain->skills[EQ::skills::Skill2HPiercing];
 		gmtrain->skills[EQ::skills::Skill2HPiercing] = 0;
 	}
@@ -1607,12 +1607,12 @@ void Client::OPGMEndTraining(const EQApplicationPacket *app)
 	FastQueuePacket(&outapp);
 
 	Mob* pTrainer = entity_list.GetMob(p->npcid);
-	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < WARRIORGM || pTrainer->GetClass() > BERSERKERGM)
+	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < Class::WarriorGM || pTrainer->GetClass() > Class::BerserkerGM)
 		return;
 
 	//you can only use your own trainer, client enforces this, but why trust it
 	if (!RuleB(Character, AllowCrossClassTrainers)) {
-		int trains_class = pTrainer->GetClass() - (WARRIORGM - WARRIOR);
+		int trains_class = pTrainer->GetClass() - (Class::WarriorGM - Class::Warrior);
 		if (GetClass() != trains_class)
 			return;
 	}
@@ -1638,12 +1638,12 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
 	GMSkillChange_Struct* gmskill = (GMSkillChange_Struct*) app->pBuffer;
 
 	Mob* pTrainer = entity_list.GetMob(gmskill->npcid);
-	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < WARRIORGM || pTrainer->GetClass() > BERSERKERGM)
+	if(!pTrainer || !pTrainer->IsNPC() || pTrainer->GetClass() < Class::WarriorGM || pTrainer->GetClass() > Class::BerserkerGM)
 		return;
 
 	//you can only use your own trainer, client enforces this, but why trust it
 	if (!RuleB(Character, AllowCrossClassTrainers)) {
-		int trains_class = pTrainer->GetClass() - (WARRIORGM - WARRIOR);
+		int trains_class = pTrainer->GetClass() - (Class::WarriorGM - Class::Warrior);
 		if (GetClass() != trains_class)
 			return;
 	}

zone/command.cpp

@@ -866,6 +866,7 @@ void command_bot(Client *c, const Seperator *sep)
 #include "gm_commands/nukebuffs.cpp"
 #include "gm_commands/nukeitem.cpp"
 #include "gm_commands/object.cpp"
+#include "gm_commands/object_manipulation.cpp"
 #include "gm_commands/path.cpp"
 #include "gm_commands/peqzone.cpp"
 #include "gm_commands/petitems.cpp"

zone/doors.cpp

@@ -277,7 +277,7 @@ void Doors::HandleClick(Client *sender, uint8 trigger)
 	// enforce flags before they hit zoning process
 	auto z = GetZone(m_destination_zone_name, 0);
 	if (z && !z->flag_needed.empty() && Strings::IsNumber(z->flag_needed) && Strings::ToInt(z->flag_needed) == 1) {
-		if (sender->Admin() < minStatusToIgnoreZoneFlags && !sender->HasZoneFlag(z->zoneidnumber)) {
+		if (!sender->GetGM() && !sender->HasZoneFlag(z->zoneidnumber)) {
 			LogInfo(
 				"Character [{}] does not have the flag to be in this zone [{}]!",
 				sender->GetCleanName(),

zone/effects.cpp

@@ -75,7 +75,7 @@ int64 Mob::GetActSpellDamage(uint16 spell_id, int64 value, Mob* target) {
 	chance += itembonuses.FrenziedDevastation + spellbonuses.FrenziedDevastation + aabonuses.FrenziedDevastation;
 
 	//Crtical Hit Calculation pathway
-	if (chance > 0 || (IsOfClientBot() && GetClass() == WIZARD && GetLevel() >= RuleI(Spells, WizCritLevel))) {
+	if (chance > 0 || (IsOfClientBot() && GetClass() == Class::Wizard && GetLevel() >= RuleI(Spells, WizCritLevel))) {
 
 		 int32 ratio = RuleI(Spells, BaseCritRatio); //Critical modifier is applied from spell effects only. Keep at 100 for live like criticals.
 
@@ -92,7 +92,7 @@ int64 Mob::GetActSpellDamage(uint16 spell_id, int64 value, Mob* target) {
 			ratio += itembonuses.SpellCritDmgIncNoStack + spellbonuses.SpellCritDmgIncNoStack + aabonuses.SpellCritDmgIncNoStack;
 		}
 
-		else if ((IsOfClientBot() && GetClass() == WIZARD) || (IsMerc() && GetClass() == CASTERDPS)) {
+		else if ((IsOfClientBot() && GetClass() == Class::Wizard) || (IsMerc() && GetClass() == CASTERDPS)) {
 			if ((GetLevel() >= RuleI(Spells, WizCritLevel)) && zone->random.Roll(RuleI(Spells, WizCritChance))){
 				//Wizard innate critical chance is calculated seperately from spell effect and is not a set ratio. (20-70 is parse confirmed)
 				ratio += zone->random.Int(RuleI(Spells, WizardCritMinimumRandomRatio), RuleI(Spells, WizardCritMaximumRandomRatio));
@@ -100,7 +100,7 @@ int64 Mob::GetActSpellDamage(uint16 spell_id, int64 value, Mob* target) {
 			}
 		}
 
-		if (IsOfClientBot() && GetClass() == WIZARD) {
+		if (IsOfClientBot() && GetClass() == Class::Wizard) {
 			ratio += RuleI(Spells, WizCritRatio); //Default is zero
 		}
 
@@ -285,10 +285,13 @@ int64 Mob::GetActDoTDamage(uint16 spell_id, int64 value, Mob* target, bool from_
 			extra_dmg += GetSkillDmgAmt(spells[spell_id].skill) * ratio / 100;
 		}
 
-		if (extra_dmg) {
-			int duration = CalcBuffDuration(this, target, spell_id);
-			if (duration > 0)
-				extra_dmg /= duration;
+		if (RuleB(Spells, DOTBonusDamageSplitOverDuration)) {
+			if (extra_dmg) {
+				const int duration = CalcBuffDuration(this, target, spell_id);
+				if (duration > 0) {
+					extra_dmg /= duration;
+				}
+			}
 		}
 
 		value -= extra_dmg;
@@ -328,10 +331,13 @@ int64 Mob::GetActDoTDamage(uint16 spell_id, int64 value, Mob* target, bool from_
 			extra_dmg += GetSkillDmgAmt(spells[spell_id].skill);
 		}
 
-		if (extra_dmg) {
-			int duration = CalcBuffDuration(this, target, spell_id);
-			if (duration > 0)
-				extra_dmg /= duration;
+		if (RuleB(Spells, DOTBonusDamageSplitOverDuration)) {
+			if (extra_dmg) {
+				const int duration = CalcBuffDuration(this, target, spell_id);
+				if (duration > 0) {
+					extra_dmg /= duration;
+				}
+			}
 		}
 
 		value -= extra_dmg;
@@ -426,7 +432,7 @@ int64 Mob::GetActSpellHealing(uint16 spell_id, int64 value, Mob* target, bool fr
 		}
 	}
 
-	if (GetClass() == CLERIC) {
+	if (GetClass() == Class::Cleric) {
 		value += int64(base_value*RuleI(Spells, ClericInnateHealFocus) / 100);  //confirmed on live parsing clerics get an innate 5 pct heal focus
 	}
 	value += int64(base_value*GetFocusEffect(focusImprovedHeal, spell_id, nullptr, from_buff_tic) / 100);
@@ -517,11 +523,13 @@ int64 Mob::GetActSpellHealing(uint16 spell_id, int64 value, Mob* target, bool fr
 			}
 		}
 
-		if (extra_heal) {
-			int duration = CalcBuffDuration(this, target, spell_id);
-			if (duration > 0) {
-				extra_heal /= duration;
-				value += extra_heal;
+		if (RuleB(Spells, HOTBonusHealingSplitOverDuration)) {
+			if (extra_heal) {
+				const int duration = CalcBuffDuration(this, target, spell_id);
+				if (duration > 0) {
+					extra_heal /= duration;
+					value += extra_heal;
+				}
 			}
 		}
 
@@ -632,7 +640,7 @@ bool Client::TrainDiscipline(uint32 itemid) {
 	}
 
 	const auto player_class = GetClass();
-	if (player_class == WIZARD || player_class == ENCHANTER || player_class == MAGICIAN || player_class == NECROMANCER) {
+	if (player_class == Class::Wizard || player_class == Class::Enchanter || player_class == Class::Magician || player_class == Class::Necromancer) {
 		Message(Chat::Red, "Your class cannot learn from this tome.");
 		//summon them the item back...
 		SummonItem(itemid);
@@ -906,7 +914,7 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
 		if (reduced_recast > 0) {
 			instant_recast = false;
 
-			if (GetClass() == BARD && IsCasting() && spells[spell_id].cast_time == 0) {
+			if (GetClass() == Class::Bard && IsCasting() && spells[spell_id].cast_time == 0) {
 				if (DoCastingChecksOnCaster(spell_id, EQ::spells::CastingSlot::Discipline)) {
 					SpellFinished(spell_id, entity_list.GetMob(target), EQ::spells::CastingSlot::Discipline, 0, -1, spells[spell_id].resist_difficulty, false, -1, (uint32)DiscTimer, reduced_recast, false);
 				}
@@ -921,7 +929,7 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
 	}
 
 	if (instant_recast) {
-		if (GetClass() == BARD && IsCasting() && spells[spell_id].cast_time == 0) {
+		if (GetClass() == Class::Bard && IsCasting() && spells[spell_id].cast_time == 0) {
 			if (DoCastingChecksOnCaster(spell_id, EQ::spells::CastingSlot::Discipline)) {
 				SpellFinished(spell_id, entity_list.GetMob(target), EQ::spells::CastingSlot::Discipline, 0, -1, spells[spell_id].resist_difficulty, false, -1, 0xFFFFFFFF, 0, false);
 			}
@@ -1320,7 +1328,7 @@ void EntityList::AEAttack(
 			) {
 
 			for (int i = 0; i < attack_rounds; i++) {
-				if (!attacker->IsClient() || attacker->GetClass() == MONK || attacker->GetClass() == RANGER) {
+				if (!attacker->IsClient() || attacker->GetClass() == Class::Monk || attacker->GetClass() == Class::Ranger) {
 					attacker->Attack(current_mob, Hand, false, false, is_from_spell);
 				} else {
 					attacker->CastToClient()->DoAttackRounds(current_mob, Hand, is_from_spell);

zone/entity.cpp

@@ -4918,7 +4918,7 @@ void EntityList::ZoneWho(Client *c, Who_All_Struct *Who)
 				FormatMSGID = 5024; // 5024 %T1[ANONYMOUS] %2 %3
 			else if (ClientEntry->GetAnon() == 2)
 				FormatMSGID = 5023; // 5023 %T1[ANONYMOUS] %2 %3 %4
-			uint32 PlayerClass = NO_CLASS;
+			uint32 PlayerClass = Class::None;
 			uint32 PlayerLevel = 0;
 			uint32 PlayerRace = RACE_DOUG_0;
 			uint32 ZoneMSGID = 0xFFFFFFFF;
@@ -4995,7 +4995,7 @@ uint32 EntityList::CheckNPCsClose(Mob *center)
 	auto it = npc_list.begin();
 	while (it != npc_list.end()) {
 		NPC *cur = it->second;
-		if (!cur || cur == center || cur->IsPet() || cur->GetClass() == LDON_TREASURE ||
+		if (!cur || cur == center || cur->IsPet() || cur->GetClass() == Class::LDoNTreasure ||
 				cur->GetBodyType() == BT_NoTarget || cur->GetBodyType() == BT_Special) {
 			++it;
 			continue;
@@ -5355,7 +5355,7 @@ void EntityList::AddLootToNPCS(uint32 item_id, uint32 count)
 	auto it = npc_list.begin();
 	while (it != npc_list.end()) {
 		if (!it->second->IsPet()
-				&& it->second->GetClass() != LDON_TREASURE
+				&& it->second->GetClass() != Class::LDoNTreasure
 				&& it->second->GetBodyType() != BT_NoTarget
 				&& it->second->GetBodyType() != BT_NoTarget2
 				&& it->second->GetBodyType() != BT_Special)
@@ -5376,7 +5376,7 @@ void EntityList::AddLootToNPCS(uint32 item_id, uint32 count)
 	it = npc_list.begin();
 	while (it != npc_list.end()) {
 		if (!it->second->IsPet()
-				&& it->second->GetClass() != LDON_TREASURE
+				&& it->second->GetClass() != Class::LDoNTreasure
 				&& it->second->GetBodyType() != BT_NoTarget
 				&& it->second->GetBodyType() != BT_NoTarget2
 				&& it->second->GetBodyType() != BT_Special)
@@ -5429,7 +5429,7 @@ NPC *EntityList::GetClosestBanker(Mob *sender, uint32 &distance)
 
 	auto it = npc_list.begin();
 	while (it != npc_list.end()) {
-		if (it->second->GetClass() == BANKER) {
+		if (it->second->GetClass() == Class::Banker) {
 			uint32 nd = ((it->second->GetY() - sender->GetY()) * (it->second->GetY() - sender->GetY())) +
 				((it->second->GetX() - sender->GetX()) * (it->second->GetX() - sender->GetX()));
 			if (nd < distance){

zone/entity.h

@@ -529,8 +529,8 @@ public:
 	inline const std::unordered_map<uint16, Merc *> &GetMercList() { return merc_list; }
 	inline const std::unordered_map<uint16, Client *> &GetClientList() { return client_list; }
 	inline const std::list<Bot *> &GetBotList() { return bot_list; }
-	std::vector<Bot *> GetBotListByCharacterID(uint32 character_id, uint8 class_id = NO_CLASS);
-	std::vector<Bot *> GetBotListByClientName(std::string client_name, uint8 class_id = NO_CLASS);
+	std::vector<Bot *> GetBotListByCharacterID(uint32 character_id, uint8 class_id = Class::None);
+	std::vector<Bot *> GetBotListByClientName(std::string client_name, uint8 class_id = Class::None);
 	void SignalAllBotsByOwnerCharacterID(uint32 character_id, int signal_id);
 	void SignalAllBotsByOwnerName(std::string owner_name, int signal_id);
 	void SignalBotByBotID(uint32 bot_id, int signal_id);

zone/exp.cpp

@@ -128,8 +128,8 @@ uint64 Client::CalcEXP(uint8 consider_level, bool ignore_modifiers) {
 
 		if (RuleB(Character, UseRaceClassExpBonuses)) {
 			if (
-				GetClass() == WARRIOR ||
-				GetClass() == ROGUE ||
+				GetClass() == Class::Warrior ||
+				GetClass() == Class::Rogue ||
 				GetBaseRace() == HALFLING
 			) {
 				total_modifier *= 1.05;
@@ -295,7 +295,7 @@ void Client::CalculateStandardAAExp(uint64 &add_aaxp, uint8 conlevel, bool resex
 			aatotalmod *= 1.05;
 		}
 
-		if (GetClass() == ROGUE || GetClass() == WARRIOR) {
+		if (GetClass() == Class::Rogue || GetClass() == Class::Warrior) {
 			aatotalmod *= 1.05;
 		}
 	}
@@ -443,7 +443,7 @@ void Client::CalculateExp(uint64 in_add_exp, uint64 &add_exp, uint64 &add_aaxp,
 				totalmod *= 1.05;
 			}
 
-			if (GetClass() == ROGUE || GetClass() == WARRIOR) {
+			if (GetClass() == Class::Rogue || GetClass() == Class::Warrior) {
 				totalmod *= 1.05;
 			}
 		}
@@ -1051,15 +1051,15 @@ uint32 Client::GetEXPForLevel(uint16 check_level)
 	if(RuleB(Character,UseOldClassExpPenalties))
 	{
 		float classmod = 1.0;
-		if(GetClass() == PALADIN || GetClass() == SHADOWKNIGHT || GetClass() == RANGER || GetClass() == BARD) {
+		if(GetClass() == Class::Paladin || GetClass() == Class::ShadowKnight || GetClass() == Class::Ranger || GetClass() == Class::Bard) {
 			classmod = 1.4;
-		} else if(GetClass() == MONK) {
+		} else if(GetClass() == Class::Monk) {
 			classmod = 1.2;
-		} else if(GetClass() == WIZARD || GetClass() == ENCHANTER || GetClass() == MAGICIAN || GetClass() == NECROMANCER) {
+		} else if(GetClass() == Class::Wizard || GetClass() == Class::Enchanter || GetClass() == Class::Magician || GetClass() == Class::Necromancer) {
 			classmod = 1.1;
-		} else if(GetClass() == ROGUE) {
+		} else if(GetClass() == Class::Rogue) {
 			classmod = 0.91;
-		} else if(GetClass() == WARRIOR) {
+		} else if(GetClass() == Class::Warrior) {
 			classmod = 0.9;
 		}
 

zone/gm_commands/acceptrules.cpp

@@ -2,10 +2,12 @@
 
 void command_acceptrules(Client *c, const Seperator *sep)
 {
-	if (!database.GetAgreementFlag(c->AccountID())) {
-		database.SetAgreementFlag(c->AccountID());
-		c->SendAppearancePacket(AT_Anim, ANIM_STAND);
-		c->Message(Chat::White, "It is recorded you have agreed to the rules.");
+	if (database.GetAgreementFlag(c->AccountID())) {
+		c->Message(Chat::White, "You have already agreed to the rules.");
+		return;
 	}
-}
 
+	database.SetAgreementFlag(c->AccountID());
+	c->SendAppearancePacket(AT_Anim, ANIM_STAND);
+	c->Message(Chat::White, "It is recorded you have agreed to the rules.");
+}

zone/gm_commands/castspell.cpp

@@ -23,10 +23,7 @@ void command_castspell(Client *c, const Seperator *sep)
 
 	const uint16 spell_id = Strings::ToUnsignedInt(sep->arg[1]);
 
-	if (IsCastRestrictedSpell(spell_id) && c->Admin() < commandCastSpecials) {
-		c->Message(Chat::White, "Unable to cast spell.");
-		return;
-	} else if (spell_id >= SPDAT_RECORDS) {
+	if (spell_id >= SPDAT_RECORDS) {
 		c->Message(Chat::White, "Invalid Spell ID.");
 		return;
 	}

zone/gm_commands/corpse.cpp

@@ -9,18 +9,22 @@ void command_corpse(Client *c, const Seperator *sep)
 		c->Message(Chat::White, "Usage: #corpse deletenpccorpses - Deletes all NPC corpses");
 		c->Message(Chat::White, "Usage: #corpse inspectloot - Inspects the loot on a corpse");
 		c->Message(Chat::White, "Usage: #corpse listnpc - Lists all NPC corpses");
-		c->Message(Chat::White, "Usage: #corpse lock - Locks the corpse, only GMs can loot the corpse when it is locked");
+		c->Message(
+			Chat::White,
+			"Usage: #corpse lock - Locks the corpse, only GMs can loot the corpse when it is locked"
+		);
 		c->Message(Chat::White, "Usage: #corpse removecash - Removes the cash from a corpse");
 		c->Message(Chat::White, "Usage: #corpse unlock - Unlocks the corpses, allowing non-GMs to loot the corpse");
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
-			c->Message(Chat::White, "Usage: #corpse deleteplayercorpses - Deletes all player corpses");
-			c->Message(Chat::White, "Usage: #corpse depop [Bury] - Depops single target corpse.");
-			c->Message(Chat::White, "Usage: #corpse depopall [Bury] - Depops all target player's corpses.");
-			c->Message(Chat::White, "Usage: #corpse listplayer - Lists all player corpses");
-			c->Message(Chat::White, "Usage: #corpse moveallgraveyard - Moves all player corpses to the current zone's graveyard or non-instance");
-			c->Message(Chat::White, "Note: Set bury to 0 to skip burying the corpses.");
-		}
+		c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
+		c->Message(Chat::White, "Usage: #corpse deleteplayercorpses - Deletes all player corpses");
+		c->Message(Chat::White, "Usage: #corpse depop [Bury] - Depops single target corpse.");
+		c->Message(Chat::White, "Usage: #corpse depopall [Bury] - Depops all target player's corpses.");
+		c->Message(Chat::White, "Usage: #corpse listplayer - Lists all player corpses");
+		c->Message(
+			Chat::White,
+			"Usage: #corpse moveallgraveyard - Moves all player corpses to the current zone's graveyard or non-instance"
+		);
+		c->Message(Chat::White, "Note: Set bury to 0 to skip burying the corpses.");
 		return;
 	}
 
@@ -59,72 +63,57 @@ void command_corpse(Client *c, const Seperator *sep)
 		c->Message(Chat::White, "Usage: #corpse deletenpccorpses - Deletes all NPC corpses");
 		c->Message(Chat::White, "Usage: #corpse inspectloot - Inspects the loot on a corpse");
 		c->Message(Chat::White, "Usage: #corpse listnpc - Lists all NPC corpses");
-		c->Message(Chat::White, "Usage: #corpse lock - Locks the corpse, only GMs can loot the corpse when it is locked");
+		c->Message(
+			Chat::White,
+			"Usage: #corpse lock - Locks the corpse, only GMs can loot the corpse when it is locked"
+		);
 		c->Message(Chat::White, "Usage: #corpse removecash - Removes the cash from a corpse");
 		c->Message(Chat::White, "Usage: #corpse unlock - Unlocks the corpses, allowing non-GMs to loot the corpse");
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
-			c->Message(Chat::White, "Usage: #corpse deleteplayercorpses - Deletes all player corpses");
-			c->Message(Chat::White, "Usage: #corpse depop [Bury] - Depops single target corpse.");
-			c->Message(Chat::White, "Usage: #corpse depopall [Bury] - Depops all target player's corpses.");
-			c->Message(Chat::White, "Usage: #corpse listplayer - Lists all player corpses");
-			c->Message(Chat::White, "Usage: #corpse moveallgraveyard - Moves all player corpses to the current zone's graveyard or non-instance");
-			c->Message(Chat::White, "Note: Set bury to 0 to skip burying the corpses.");
-		}
+		c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
+		c->Message(Chat::White, "Usage: #corpse deleteplayercorpses - Deletes all player corpses");
+		c->Message(Chat::White, "Usage: #corpse depop [Bury] - Depops single target corpse.");
+		c->Message(Chat::White, "Usage: #corpse depopall [Bury] - Depops all target player's corpses.");
+		c->Message(Chat::White, "Usage: #corpse listplayer - Lists all player corpses");
+		c->Message(
+			Chat::White,
+			"Usage: #corpse moveallgraveyard - Moves all player corpses to the current zone's graveyard or non-instance"
+		);
+		c->Message(Chat::White, "Note: Set bury to 0 to skip burying the corpses.");
 		return;
 	}
 
 
 	if (is_delete_player_corpses) {
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			auto corpses_deleted = entity_list.DeletePlayerCorpses();
-			auto deleted_string = (
-				corpses_deleted ?
-				fmt::format(
-					"{} Player corpse{} deleted.",
-					corpses_deleted,
-					corpses_deleted != 1 ? "s" : ""
-				) :
-				"There are no player corpses to delete."
-			);
-			c->Message(Chat::White, deleted_string.c_str());
-		} else {
-			c->Message(Chat::White, "Your status is not high enough to delete player corpses.");
-			return;
-		}
+		auto corpses_deleted = entity_list.DeletePlayerCorpses();
+		auto deleted_string  = (
+			corpses_deleted ?
+			fmt::format(
+				"{} Player corpse{} deleted.",
+				corpses_deleted,
+				corpses_deleted != 1 ? "s" : ""
+			) :
+			"There are no player corpses to delete."
+		);
+		c->Message(Chat::White, deleted_string.c_str());
 	} else if (is_delete) {
 		if (!target || !target->IsCorpse()) {
 			c->Message(Chat::White, "You must target a corpse to use this command.");
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to delete a player corpse.");
-			return;
-		}
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Deleting {} corpse {}.",
+				target->IsNPCCorpse() ? "NPC" : "player",
+				c->GetTargetDescription(target)
+			).c_str()
+		);
 
-		if (
-			target->IsNPCCorpse() ||
-			c->Admin() >= commandEditPlayerCorpses
-		) {
-			c->Message(
-				Chat::White,
-				fmt::format(
-					"Deleting {} corpse {}.",
-					target->IsNPCCorpse() ? "NPC" : "player",
-					c->GetTargetDescription(target)
-				).c_str()
-			);
-			target->CastToCorpse()->Delete();
-		}
+		target->CastToCorpse()->Delete();
 	} else if (is_list_npc) {
 		entity_list.ListNPCCorpses(c);
 	} else if (is_list_player) {
-		if (c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to list player corpses.");
-			return;
-		}
-
 		entity_list.ListPlayerCorpses(c);
 	} else if (is_delete_npc_corpses) {
 		auto corpses_deleted = entity_list.DeleteNPCCorpses();
@@ -139,42 +128,32 @@ void command_corpse(Client *c, const Seperator *sep)
 		);
 		c->Message(Chat::White, deleted_string.c_str());
 	} else if (is_character_id) {
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			if (!target || !target->IsPlayerCorpse()) {
-				c->Message(Chat::White, "You must target a player corpse to use this command.");
-				return;
-			}
-
-			if (!sep->IsNumber(2)) {
-				c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
-				return;
-			}
-
-			auto character_id = Strings::ToInt(sep->arg[2]);
-			c->Message(
-				Chat::White,
-				fmt::format(
-					"Setting the owner to {} ({}) for the player corpse {}.",
-					database.GetCharNameByID(character_id),
-					target->CastToCorpse()->SetCharID(character_id),
-					c->GetTargetDescription(target)
-				).c_str()
-			);
-		} else {
-			c->Message(Chat::White, "Your status is not high enough to modify a player corpse's owner.");
+		if (!target || !target->IsPlayerCorpse()) {
+			c->Message(Chat::White, "You must target a player corpse to use this command.");
 			return;
 		}
+
+		if (!sep->IsNumber(2)) {
+			c->Message(Chat::White, "Usage: #corpse charid [Character ID] - Change player corpse's owner");
+			return;
+		}
+
+		const uint32 character_id = Strings::ToUnsignedInt(sep->arg[2]);
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Setting the owner to {} ({}) for the player corpse {}.",
+				database.GetCharNameByID(character_id),
+				target->CastToCorpse()->SetCharID(character_id),
+				c->GetTargetDescription(target)
+			).c_str()
+		);
 	} else if (is_reset_looter) {
 		if (!target || !target->IsCorpse()) {
 			c->Message(Chat::White, "You must target a corpse to use this command.");
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to reset looter on a player corpse.");
-			return;
-		}
-
 		target->CastToCorpse()->ResetLooter();
 		c->Message(
 			Chat::White,
@@ -190,36 +169,22 @@ void command_corpse(Client *c, const Seperator *sep)
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to remove cash from a player corpse.");
-			return;
-		}
+		target->CastToCorpse()->RemoveCash();
 
-		if (
-			target->IsNPCCorpse() ||
-			c->Admin() >= commandEditPlayerCorpses
-		) {
-			target->CastToCorpse()->RemoveCash();
-			c->Message(
-				Chat::White,
-				fmt::format(
-					"Removed cash from {} corpse {}.",
-					target->IsNPCCorpse() ? "NPC" : "player",
-					c->GetTargetDescription(target)
-				).c_str()
-			);
-		}
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Removed cash from {} corpse {}.",
+				target->IsNPCCorpse() ? "NPC" : "player",
+				c->GetTargetDescription(target)
+			).c_str()
+		);
 	} else if (is_inspect_loot) {
 		if (!target || !target->IsCorpse()) {
 			c->Message(Chat::White, "You must target a corpse to use this command.");
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to inspect the loot of a player corpse.");
-			return;
-		}
-
 		target->CastToCorpse()->QueryLoot(c);
 	} else if (is_lock) {
 		if (!target || !target->IsCorpse()) {
@@ -227,11 +192,6 @@ void command_corpse(Client *c, const Seperator *sep)
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to lock player corpses.");
-			return;
-		}
-
 		target->CastToCorpse()->Lock();
 		c->Message(
 			Chat::White,
@@ -247,11 +207,6 @@ void command_corpse(Client *c, const Seperator *sep)
 			return;
 		}
 
-		if (target->IsPlayerCorpse() && c->Admin() < commandEditPlayerCorpses) {
-			c->Message(Chat::White, "Your status is not high enough to unlock player corpses.");
-			return;
-		}
-
 		target->CastToCorpse()->UnLock();
 		c->Message(
 			Chat::White,
@@ -267,30 +222,20 @@ void command_corpse(Client *c, const Seperator *sep)
 			return;
 		}
 
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			bool bury_corpse = (
-				sep->IsNumber(2) ?
-				(
-					Strings::ToInt(sep->arg[2]) != 0 ?
-					true :
-					false
-				) :
-				false
-			);
-			c->Message(
-				Chat::White,
-				fmt::format(
-					"Depopping player corpse {}.",
-					c->GetTargetDescription(target)
-				).c_str()
-			);
-			target->CastToCorpse()->DepopPlayerCorpse();
-			if (bury_corpse) {
-				target->CastToCorpse()->Bury();
-			}
-		} else {
-			c->Message(Chat::White, "Your status is not high enough to depop a player corpse.");
-			return;
+		const bool bury_corpse = sep->IsNumber(2) ? Strings::ToBool(sep->arg[2]) : false;
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Depopping player corpse {}.",
+				c->GetTargetDescription(target)
+			).c_str()
+		);
+
+		target->CastToCorpse()->DepopPlayerCorpse();
+
+		if (bury_corpse) {
+			target->CastToCorpse()->Bury();
 		}
 	} else if (is_depop_all) {
 		if (!target || !target->IsClient()) {
@@ -298,50 +243,36 @@ void command_corpse(Client *c, const Seperator *sep)
 			return;
 		}
 
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			bool bury_corpse = (
-				sep->IsNumber(2) ?
-				(
-					Strings::ToInt(sep->arg[2]) != 0 ?
-					true :
-					false
-				) :
-				false
-			);
+		const bool bury_corpse = sep->IsNumber(2) ? Strings::ToBool(sep->arg[2]) : false;
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Depopping all player corpses for {}.",
+				c->GetTargetDescription(target)
+			).c_str()
+		);
+
+		target->CastToClient()->DepopAllCorpses();
+
+		if (bury_corpse) {
+			target->CastToClient()->BuryPlayerCorpses();
+		}
+	} else if (is_move_all_to_graveyard) {
+		const int moved_count = entity_list.MovePlayerCorpsesToGraveyard(true);
+		if (moved_count) {
 			c->Message(
 				Chat::White,
 				fmt::format(
-					"Depopping all player corpses for {}.",
-					c->GetTargetDescription(target)
+					"Moved {} player corpse{} to graveyard in {} ({}).",
+					moved_count,
+					moved_count != 1 ? "s" : "",
+					ZoneLongName(zone->GetZoneID()),
+					ZoneName(zone->GetZoneID())
 				).c_str()
 			);
-			target->CastToClient()->DepopAllCorpses();
-			if (bury_corpse) {
-				target->CastToClient()->BuryPlayerCorpses();
-			}
 		} else {
-			c->Message(Chat::White, "Your status is not high enough to depop all of a player's corpses.");
-			return;
-		}
-	} else if (is_move_all_to_graveyard) {
-		int moved_count = entity_list.MovePlayerCorpsesToGraveyard(true);
-		if (c->Admin() >= commandEditPlayerCorpses) {
-			if (moved_count) {
-				c->Message(
-					Chat::White,
-					fmt::format(
-						"Moved {} player corpse{} to graveyard in {} ({}).",
-						moved_count,
-						moved_count != 1 ? "s" : "",
-						ZoneLongName(zone->GetZoneID()),
-						ZoneName(zone->GetZoneID())
-					).c_str()
-				);
-			} else {
-				c->Message(Chat::White, "There are no player corpses to move to the graveyard.");
-			}
-		} else {
-			c->Message(Chat::White, "Your status is not high enough to move all player corpses to the graveyard.");
+			c->Message(Chat::White, "There are no player corpses to move to the graveyard.");
 		}
 	}
 }

zone/gm_commands/disarmtrap.cpp

@@ -2,24 +2,27 @@
 
 void command_disarmtrap(Client *c, const Seperator *sep)
 {
-	Mob *target = c->GetTarget();
-
-	if (!target) {
-		c->Message(Chat::Red, "You must have a target.");
+	Mob *t = c->GetTarget();
+	if (!t || !t->IsNPC()) {
+		c->Message(Chat::White, "You must target an NPC to use this command.");
 		return;
 	}
 
-	if (target->IsNPC()) {
-		if (c->HasSkill(EQ::skills::SkillDisarmTraps)) {
-			if (DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse)) {
-				c->Message(Chat::Red, "%s is too far away.", target->GetCleanName());
-				return;
-			}
-			c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(EQ::skills::SkillDisarmTraps), LDoNTypeMechanical);
-		}
-		else {
-			c->Message(Chat::Red, "You do not have the disarm trap skill.");
-		}
+	if (!c->HasSkill(EQ::skills::SkillDisarmTraps)) {
+		c->Message(Chat::White, "You do not have the Disarm Trap skill.");
+		return;
 	}
-}
 
+	if (DistanceSquaredNoZ(c->GetPosition(), t->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse)) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"{} is too far away.",
+				t->GetCleanName()
+			).c_str()
+		);
+		return;
+	}
+
+	c->HandleLDoNDisarm(t->CastToNPC(), c->GetSkill(EQ::skills::SkillDisarmTraps), LDoNTypeMechanical);
+}

zone/gm_commands/doanim.cpp

@@ -10,7 +10,7 @@ void command_doanim(Client *c, const Seperator *sep)
 	}
 
 	Mob* t = c;
-	if (c->GetTarget() && c->Admin() >= commandDoAnimOthers) {
+	if (c->GetTarget()) {
 		t = c->GetTarget();
 	}
 

zone/gm_commands/door.cpp

@@ -1,6 +1,5 @@
 #include "../client.h"
 #include "door_manipulation.h"
-#include "../doors.h"
 
 void command_door(Client *c, const Seperator *sep)
 {

zone/gm_commands/find/class.cpp

@@ -4,7 +4,7 @@ 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)) {
+		if (EQ::ValueWithin(class_id, Class::Warrior, Class::Berserker)) {
 			const std::string& class_name = GetClassIDName(class_id);
 			c->Message(
 				Chat::White,
@@ -41,7 +41,7 @@ void FindClass(Client *c, const Seperator *sep)
 
 	auto found_count = 0;
 
-	for (uint16 class_id = WARRIOR; class_id <= MERCENARY_MASTER; class_id++) {
+	for (uint16 class_id = Class::Warrior; class_id <= Class::MercenaryLiaison; 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)) {

zone/gm_commands/guild.cpp

@@ -81,11 +81,6 @@ void command_guild(Client *c, const Seperator *sep)
 					).c_str()
 				);
 			} else {
-				if (c->Admin() < minStatusToEditOtherGuilds) {
-					c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-					return;
-				}
-
 				auto guild_name = sep->argplus[3];
 				auto guild_id = guild_mgr.CreateGuild(sep->argplus[3], leader_id);
 
@@ -144,16 +139,6 @@ void command_guild(Client *c, const Seperator *sep)
 				return;
 			}
 
-			if (c->Admin() < minStatusToEditOtherGuilds) {
-				if (c->GuildID() != guild_id) {
-					c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-					return;
-				} else if (!guild_mgr.CheckGMStatus(guild_id, c->Admin())) {
-					c->Message(Chat::White, "You cannot edit your current guild, your status is not high enough.");
-					return;
-				}
-			}
-
 			LogGuilds(
 				"[{}]: Deleting guild [{}] ([{}]) with GM command",
 				c->GetName(),
@@ -175,16 +160,10 @@ void command_guild(Client *c, const Seperator *sep)
 		SendGuildSubCommands(c);
 	} else if (is_info) {
 		if (arguments != 2 && c->IsInAGuild()) {
-			if (c->Admin() >= minStatusToEditOtherGuilds) {
-				c->Message(Chat::White, "#guild info [Guild ID]");
-			} else {
-				c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-			}
+			c->Message(Chat::White, "#guild info [Guild ID]");
 		} else {
 			auto guild_id = GUILD_NONE;
-			if (arguments != 2 || !sep->IsNumber(2)) {
-				guild_id = c->GuildID();
-			} else if (c->Admin() >= minStatusToEditOtherGuilds) {
+			if (sep->IsNumber(2)) {
 				guild_id = Strings::ToUnsignedInt(sep->arg[2]);
 			}
 
@@ -193,11 +172,6 @@ void command_guild(Client *c, const Seperator *sep)
 			}
 		}
 	} else if (is_list) {
-		if (c->Admin() < minStatusToEditOtherGuilds) {
-			c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-			return;
-		}
-
 		guild_mgr.ListGuilds(c, std::string());
 	} else if (is_rename) {
 		if (!sep->IsNumber(2)) {
@@ -215,16 +189,6 @@ void command_guild(Client *c, const Seperator *sep)
 				return;
 			}
 
-			if (c->Admin() < minStatusToEditOtherGuilds) {
-				if (c->GuildID() != guild_id) {
-					c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-					return;
-				} else if (!guild_mgr.CheckGMStatus(guild_id, c->Admin())) {
-					c->Message(Chat::White, "You cannot edit your current guild, your status is not high enough.");
-					return;
-				}
-			}
-
 			auto new_guild_name = sep->argplus[3];
 			LogGuilds(
 				"[{}]: Renaming guild [{}] ([{}]) to [{}] with GM command",
@@ -293,11 +257,6 @@ void command_guild(Client *c, const Seperator *sep)
 				return;
 			}
 
-			if (c->Admin() < minStatusToEditOtherGuilds && guild_id != c->GuildID()) {
-				c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-				return;
-			}
-
 			if (!guild_id || guild_id == GUILD_NONE) {
 				LogGuilds(
 					"[{}]: Removing [{}] ([{}]) from guild with GM command",
@@ -329,6 +288,7 @@ void command_guild(Client *c, const Seperator *sep)
 					).c_str()
 				);
 			} else {
+				guild_mgr.SetGuild(character_id, GUILD_NONE, 0);
 				c->Message(
 					Chat::White,
 					fmt::format(
@@ -389,16 +349,6 @@ void command_guild(Client *c, const Seperator *sep)
 					return;
 				}
 
-				if (c->Admin() < minStatusToEditOtherGuilds) {
-					if (c->GuildID() != guild_id) {
-						c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-						return;
-					} else if (!guild_mgr.CheckGMStatus(guild_id, c->Admin())) {
-						c->Message(Chat::White, "You cannot edit your current guild, your status is not high enough.");
-						return;
-					}
-				}
-
 				LogGuilds(
 					"[{}]: Setting leader of guild [{}] ([{}]) to [{}] with GM command",
 					c->GetName(),
@@ -460,11 +410,6 @@ void command_guild(Client *c, const Seperator *sep)
 				return;
 			}
 
-			if (c->Admin() < minStatusToEditOtherGuilds && character_id != c->CharacterID()) {
-				c->Message(Chat::White, "You cannot edit other peoples' guilds.");
-				return;
-			}
-
 			LogGuilds(
 				"[{}]: Setting [{}] ([{}])'s guild rank to [{}] with GM command",
 				c->GetName(),
@@ -497,8 +442,6 @@ void command_guild(Client *c, const Seperator *sep)
 		);
 		if (!client) {
 			c->Message(Chat::White, "You must target someone or specify a character name.");
-		} else if (c->Admin() < minStatusToEditOtherGuilds && client->GuildID() != c->GuildID()) {
-			c->Message(Chat::White, "You cannot edit other peoples' guilds.");
 		} else {
 			if (!client->IsInAGuild()) {
 				c->Message(

zone/gm_commands/interrogateinv.cpp

@@ -15,20 +15,13 @@ void command_interrogateinv(Client *c, const Seperator *sep)
 	// same or not.
 
 	if (strcasecmp(sep->arg[1], "help") == 0) {
-		if (c->Admin() < commandInterrogateInv) {
-			c->Message(Chat::White, "Usage: #interrogateinv");
-			c->Message(Chat::White, "  Displays your inventory's current in-memory nested storage references");
-		}
-		else {
-			c->Message(Chat::White, "Usage: #interrogateinv [log] [silent]");
-			c->Message(
-				Chat::White,
-				"  Displays your or your Player target inventory's current in-memory nested storage references"
-			);
-			c->Message(Chat::White, "  [log] - Logs interrogation to file");
-			c->Message(Chat::White, "  [silent] - Omits the in-game message portion of the interrogation");
-		}
-		return;
+		c->Message(Chat::White, "Usage: #interrogateinv [log] [silent]");
+		c->Message(
+			Chat::White,
+			"  Displays your or your Player target inventory's current in-memory nested storage references"
+		);
+		c->Message(Chat::White, "  [log] - Logs interrogation to file");
+		c->Message(Chat::White, "  [silent] - Omits the in-game message portion of the interrogation");
 	}
 
 	Client                                    *target   = nullptr;
@@ -38,33 +31,20 @@ void command_interrogateinv(Client *c, const Seperator *sep)
 	bool                                      error     = false;
 	bool                                      allowtrip = false;
 
-	if (c->Admin() < commandInterrogateInv) {
-		if (c->GetInterrogateInvState()) {
-			c->Message(Chat::Red, "The last use of #interrogateinv on this inventory instance discovered an error...");
-			c->Message(Chat::Red, "Logging out, zoning or re-arranging items at this point will result in item loss!");
-			return;
-		}
-		target    = c;
-		allowtrip = true;
+	if (c->GetTarget() == nullptr) {
+		target = c;
+	} else if (c->GetTarget()->IsClient()) {
+		target = c->GetTarget()->CastToClient();
+	} else {
+		c->Message(Chat::Default, "Use of this command is limited to Client entities");
+		return;
 	}
-	else {
-		if (c->GetTarget() == nullptr) {
-			target = c;
-		}
-		else if (c->GetTarget()->IsClient()) {
-			target = c->GetTarget()->CastToClient();
-		}
-		else {
-			c->Message(Chat::Default, "Use of this command is limited to Client entities");
-			return;
-		}
 
-		if (strcasecmp(sep->arg[1], "log") == 0) {
-			log = true;
-		}
-		if (strcasecmp(sep->arg[2], "silent") == 0) {
-			silent = true;
-		}
+	if (strcasecmp(sep->arg[1], "log") == 0) {
+		log = true;
+	}
+	if (strcasecmp(sep->arg[2], "silent") == 0) {
+		silent = true;
 	}
 
 	bool success = target->InterrogateInventory(c, log, silent, allowtrip, error);

zone/gm_commands/invsnapshot.cpp

@@ -27,50 +27,48 @@ void command_invsnapshot(Client *c, const Seperator *sep)
 						"<td><c \"#AAAAAA\">takes snapshot of character inventory</td>"
 						"</tr>";
 
-		if (c->Admin() >= commandInvSnapshot) {
-			window_text.append(
-				"<tr>"
-				"<td><c \"#00FF00\">gcount</td>"
-				"<td></td>"
-				"<td><c \"#AAAAAA\">returns global snapshot count</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">gclear</td>"
-				"<td><c \"#FFFF00\"><br>now</td>"
-				"<td><c \"#AAAAAA\">delete all snapshots - rule<br>delete all snapshots - now</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">count</td>"
-				"<td></td>"
-				"<td><c \"#AAAAAA\">returns character snapshot count</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">clear</td>"
-				"<td><c \"#FFFF00\"><br>now</td>"
-				"<td><c \"#AAAAAA\">delete character snapshots - rule<br>delete character snapshots - now</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">list</td>"
-				"<td><br><c \"#FFFF00\">count</td>"
-				"<td><c \"#AAAAAA\">lists entry ids for current character<br>limits to count</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">parse</td>"
-				"<td><c \"#00FF00\">tstmp</td>"
-				"<td><c \"#AAAAAA\">displays slots and items in snapshot</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">compare</td>"
-				"<td><c \"#00FF00\">tstmp</td>"
-				"<td><c \"#AAAAAA\">compares inventory against snapshot</td>"
-				"</tr>"
-				"<tr>"
-				"<td><c \"#00FF00\">restore</td>"
-				"<td><c \"#00FF00\">tstmp</td>"
-				"<td><c \"#AAAAAA\">restores slots and items in snapshot</td>"
-				"</tr>"
-			);
-		}
+		window_text.append(
+			"<tr>"
+			"<td><c \"#00FF00\">gcount</td>"
+			"<td></td>"
+			"<td><c \"#AAAAAA\">returns global snapshot count</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">gclear</td>"
+			"<td><c \"#FFFF00\"><br>now</td>"
+			"<td><c \"#AAAAAA\">delete all snapshots - rule<br>delete all snapshots - now</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">count</td>"
+			"<td></td>"
+			"<td><c \"#AAAAAA\">returns character snapshot count</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">clear</td>"
+			"<td><c \"#FFFF00\"><br>now</td>"
+			"<td><c \"#AAAAAA\">delete character snapshots - rule<br>delete character snapshots - now</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">list</td>"
+			"<td><br><c \"#FFFF00\">count</td>"
+			"<td><c \"#AAAAAA\">lists entry ids for current character<br>limits to count</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">parse</td>"
+			"<td><c \"#00FF00\">tstmp</td>"
+			"<td><c \"#AAAAAA\">displays slots and items in snapshot</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">compare</td>"
+			"<td><c \"#00FF00\">tstmp</td>"
+			"<td><c \"#AAAAAA\">compares inventory against snapshot</td>"
+			"</tr>"
+			"<tr>"
+			"<td><c \"#00FF00\">restore</td>"
+			"<td><c \"#00FF00\">tstmp</td>"
+			"<td><c \"#AAAAAA\">restores slots and items in snapshot</td>"
+			"</tr>"
+		);
 
 		window_text.append(
 			"</table>"
@@ -81,34 +79,30 @@ void command_invsnapshot(Client *c, const Seperator *sep)
 		return;
 	}
 
-	if (c->Admin() >= commandInvSnapshot) { // global arguments
+	if (strcmp(sep->arg[1], "gcount") == 0) {
+		auto is_count = database.CountInvSnapshots();
+		c->Message(
+			Chat::White,
+			"There %s %i inventory snapshot%s.",
+			(is_count == 1 ? "is" : "are"),
+			is_count,
+			(is_count == 1 ? "" : "s"));
 
-		if (strcmp(sep->arg[1], "gcount") == 0) {
-			auto is_count = database.CountInvSnapshots();
+		return;
+	}
+
+	if (strcmp(sep->arg[1], "gclear") == 0) {
+		if (strcmp(sep->arg[2], "now") == 0) {
+			database.ClearInvSnapshots(true);
+			c->Message(Chat::White, "Inventory snapshots cleared using current time.");
+		} else {
+			database.ClearInvSnapshots();
 			c->Message(
-				Chat::White,
-				"There %s %i inventory snapshot%s.",
-				(is_count == 1 ? "is" : "are"),
-				is_count,
-				(is_count == 1 ? "" : "s"));
-
-			return;
+				Chat::White, "Inventory snapshots cleared using RuleI(Character, InvSnapshotHistoryD) (%i day%s).",
+				RuleI(Character, InvSnapshotHistoryD), (RuleI(Character, InvSnapshotHistoryD) == 1 ? "" : "s"));
 		}
 
-		if (strcmp(sep->arg[1], "gclear") == 0) {
-			if (strcmp(sep->arg[2], "now") == 0) {
-				database.ClearInvSnapshots(true);
-				c->Message(Chat::White, "Inventory snapshots cleared using current time.");
-			}
-			else {
-				database.ClearInvSnapshots();
-				c->Message(
-					Chat::White, "Inventory snapshots cleared using RuleI(Character, InvSnapshotHistoryD) (%i day%s).",
-					RuleI(Character, InvSnapshotHistoryD), (RuleI(Character, InvSnapshotHistoryD) == 1 ? "" : "s"));
-			}
-
-			return;
-		}
+		return;
 	}
 
 	if (!c->GetTarget() || !c->GetTarget()->IsClient()) {
@@ -127,8 +121,7 @@ void command_invsnapshot(Client *c, const Seperator *sep)
 				tc->GetName(),
 				RuleI(Character, InvSnapshotMinIntervalM),
 				(RuleI(Character, InvSnapshotMinIntervalM) == 1 ? "" : "s"));
-		}
-		else {
+		} else {
 			tc->SetNextInvSnapshot(RuleI(Character, InvSnapshotMinRetryM));
 			c->Message(
 				Chat::White,
@@ -141,278 +134,266 @@ void command_invsnapshot(Client *c, const Seperator *sep)
 		return;
 	}
 
-	if (c->Admin() >= commandInvSnapshot) {
-		if (strcmp(sep->arg[1], "count") == 0) {
-			auto is_count = database.CountCharacterInvSnapshots(tc->CharacterID());
+	if (strcmp(sep->arg[1], "count") == 0) {
+		auto is_count = database.CountCharacterInvSnapshots(tc->CharacterID());
+		c->Message(
+			Chat::White,
+			"%s (id: %u) has %i inventory snapshot%s.",
+			tc->GetName(),
+			tc->CharacterID(),
+			is_count,
+			(is_count == 1 ? "" : "s"));
+
+		return;
+	}
+
+	if (strcmp(sep->arg[1], "clear") == 0) {
+		if (strcmp(sep->arg[2], "now") == 0) {
+			database.ClearCharacterInvSnapshots(tc->CharacterID(), true);
 			c->Message(
 				Chat::White,
-				"%s (id: %u) has %i inventory snapshot%s.",
+				"%s\'s (id: %u) inventory snapshots cleared using current time.",
+				tc->GetName(),
+				tc->CharacterID());
+		} else {
+			database.ClearCharacterInvSnapshots(tc->CharacterID());
+			c->Message(
+				Chat::White,
+				"%s\'s (id: %u) inventory snapshots cleared using RuleI(Character, InvSnapshotHistoryD) (%i day%s).",
 				tc->GetName(),
 				tc->CharacterID(),
-				is_count,
-				(is_count == 1 ? "" : "s"));
+				RuleI(Character, InvSnapshotHistoryD),
+				(RuleI(Character, InvSnapshotHistoryD) == 1 ? "" : "s"));
+		}
 
+		return;
+	}
+
+	if (strcmp(sep->arg[1], "list") == 0) {
+		std::list<std::pair<uint32, int>> is_list;
+		database.ListCharacterInvSnapshots(tc->CharacterID(), is_list);
+
+		if (is_list.empty()) {
+			c->Message(Chat::White, "No inventory snapshots for %s (id: %u)", tc->GetName(), tc->CharacterID());
 			return;
 		}
 
-		if (strcmp(sep->arg[1], "clear") == 0) {
-			if (strcmp(sep->arg[2], "now") == 0) {
-				database.ClearCharacterInvSnapshots(tc->CharacterID(), true);
-				c->Message(
-					Chat::White,
-					"%s\'s (id: %u) inventory snapshots cleared using current time.",
-					tc->GetName(),
-					tc->CharacterID());
-			}
-			else {
-				database.ClearCharacterInvSnapshots(tc->CharacterID());
-				c->Message(
-					Chat::White,
-					"%s\'s (id: %u) inventory snapshots cleared using RuleI(Character, InvSnapshotHistoryD) (%i day%s).",
-					tc->GetName(),
-					tc->CharacterID(),
-					RuleI(Character, InvSnapshotHistoryD),
-					(RuleI(Character, InvSnapshotHistoryD) == 1 ? "" : "s"));
-			}
-
-			return;
+		auto list_count = 0;
+		if (sep->IsNumber(2)) {
+			list_count = Strings::ToInt(sep->arg[2]);
+		}
+		if (list_count < 1 || list_count > is_list.size()) {
+			list_count = is_list.size();
 		}
 
-		if (strcmp(sep->arg[1], "list") == 0) {
-			std::list<std::pair<uint32, int>> is_list;
-			database.ListCharacterInvSnapshots(tc->CharacterID(), is_list);
+		std::string window_title = StringFormat("Snapshots for %s", tc->GetName());
 
-			if (is_list.empty()) {
-				c->Message(Chat::White, "No inventory snapshots for %s (id: %u)", tc->GetName(), tc->CharacterID());
-				return;
-			}
-
-			auto list_count = 0;
-			if (sep->IsNumber(2)) {
-				list_count = Strings::ToInt(sep->arg[2]);
-			}
-			if (list_count < 1 || list_count > is_list.size()) {
-				list_count = is_list.size();
-			}
-
-			std::string window_title = StringFormat("Snapshots for %s", tc->GetName());
-
-			std::string window_text =
-							"<table>"
-							"<tr>"
-							"<td>Timestamp</td>"
-							"<td>Entry Count</td>"
-							"</tr>";
-
-			for (auto iter : is_list) {
-				if (!list_count) {
-					break;
-				}
-
-				window_text.append(
-					StringFormat(
+		std::string window_text =
+						"<table>"
 						"<tr>"
-						"<td>%u</td>"
-						"<td>%i</td>"
-						"</tr>",
-						iter.first,
-						iter.second
-					));
+						"<td>Timestamp</td>"
+						"<td>Entry Count</td>"
+						"</tr>";
 
-				--list_count;
+		for (auto iter: is_list) {
+			if (!list_count) {
+				break;
 			}
 
 			window_text.append(
-				"</table>"
-			);
-
-			c->SendPopupToClient(window_title.c_str(), window_text.c_str());
-
-			return;
-		}
-
-		if (strcmp(sep->arg[1], "parse") == 0) {
-			if (!sep->IsNumber(2)) {
-				c->Message(Chat::White, "A timestamp is required to use this option.");
-				return;
-			}
-
-			uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
-
-			if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
-				c->Message(
-					Chat::White,
-					"No inventory snapshots for %s (id: %u) exist at %u.",
-					tc->GetName(),
-					tc->CharacterID(),
-					timestamp
-				);
-				return;
-			}
-
-			std::list<std::pair<int16, uint32>> parse_list;
-			database.ParseCharacterInvSnapshot(tc->CharacterID(), timestamp, parse_list);
-
-			std::string window_title = StringFormat("Snapshot Parse for %s @ %u", tc->GetName(), timestamp);
-
-			std::string window_text = "Slot: ItemID - Description<br>";
-
-			for (auto iter : parse_list) {
-				auto        item_data   = database.GetItem(iter.second);
-				std::string window_line = StringFormat(
-					"%i: %u - %s<br>",
+				StringFormat(
+					"<tr>"
+					"<td>%u</td>"
+					"<td>%i</td>"
+					"</tr>",
 					iter.first,
-					iter.second,
-					(item_data ? item_data->Name : "[error]"));
+					iter.second
+				));
 
-				if (window_text.length() + window_line.length() < 4095) {
-					window_text.append(window_line);
-				}
-				else {
-					c->Message(Chat::White, "Too many snapshot entries to list...");
-					break;
-				}
-			}
+			--list_count;
+		}
 
-			c->SendPopupToClient(window_title.c_str(), window_text.c_str());
+		window_text.append(
+			"</table>"
+		);
 
+		c->SendPopupToClient(window_title.c_str(), window_text.c_str());
+
+		return;
+	}
+
+	if (strcmp(sep->arg[1], "parse") == 0) {
+		if (!sep->IsNumber(2)) {
+			c->Message(Chat::White, "A timestamp is required to use this option.");
 			return;
 		}
 
-		if (strcmp(sep->arg[1], "compare") == 0) {
-			if (!sep->IsNumber(2)) {
-				c->Message(Chat::White, "A timestamp is required to use this option.");
-				return;
+		uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
+
+		if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
+			c->Message(
+				Chat::White,
+				"No inventory snapshots for %s (id: %u) exist at %u.",
+				tc->GetName(),
+				tc->CharacterID(),
+				timestamp
+			);
+			return;
+		}
+
+		std::list<std::pair<int16, uint32>> parse_list;
+		database.ParseCharacterInvSnapshot(tc->CharacterID(), timestamp, parse_list);
+
+		std::string window_title = StringFormat("Snapshot Parse for %s @ %u", tc->GetName(), timestamp);
+
+		std::string window_text = "Slot: ItemID - Description<br>";
+
+		for (auto iter: parse_list) {
+			auto        item_data   = database.GetItem(iter.second);
+			std::string window_line = StringFormat(
+				"%i: %u - %s<br>",
+				iter.first,
+				iter.second,
+				(item_data ? item_data->Name : "[error]"));
+
+			if (window_text.length() + window_line.length() < 4095) {
+				window_text.append(window_line);
+			} else {
+				c->Message(Chat::White, "Too many snapshot entries to list...");
+				break;
 			}
+		}
 
-			uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
+		c->SendPopupToClient(window_title.c_str(), window_text.c_str());
 
-			if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
-				c->Message(
-					Chat::White,
-					"No inventory snapshots for %s (id: %u) exist at %u.",
-					tc->GetName(),
-					tc->CharacterID(),
-					timestamp
-				);
-				return;
-			}
+		return;
+	}
 
-			std::list<std::pair<int16, uint32>> inv_compare_list;
-			database.DivergeCharacterInventoryFromInvSnapshot(tc->CharacterID(), timestamp, inv_compare_list);
+	if (strcmp(sep->arg[1], "compare") == 0) {
+		if (!sep->IsNumber(2)) {
+			c->Message(Chat::White, "A timestamp is required to use this option.");
+			return;
+		}
 
-			std::list<std::pair<int16, uint32>> iss_compare_list;
-			database.DivergeCharacterInvSnapshotFromInventory(tc->CharacterID(), timestamp, iss_compare_list);
+		uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
 
-			std::string window_title = StringFormat("Snapshot Comparison for %s @ %u", tc->GetName(), timestamp);
+		if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
+			c->Message(
+				Chat::White,
+				"No inventory snapshots for %s (id: %u) exist at %u.",
+				tc->GetName(),
+				tc->CharacterID(),
+				timestamp
+			);
+			return;
+		}
 
-			std::string window_text = "Slot: (action) Snapshot -&gt; Inventory<br>";
+		std::list<std::pair<int16, uint32>> inv_compare_list;
+		database.DivergeCharacterInventoryFromInvSnapshot(tc->CharacterID(), timestamp, inv_compare_list);
 
-			auto inv_iter = inv_compare_list.begin();
-			auto iss_iter = iss_compare_list.begin();
+		std::list<std::pair<int16, uint32>> iss_compare_list;
+		database.DivergeCharacterInvSnapshotFromInventory(tc->CharacterID(), timestamp, iss_compare_list);
 
-			while (true) {
-				std::string window_line;
+		std::string window_title = StringFormat("Snapshot Comparison for %s @ %u", tc->GetName(), timestamp);
 
-				if (inv_iter == inv_compare_list.end() && iss_iter == iss_compare_list.end()) {
-					break;
-				}
-				else if (inv_iter != inv_compare_list.end() && iss_iter == iss_compare_list.end()) {
-					window_line = StringFormat("%i: (delete) [empty] -&gt; %u<br>", inv_iter->first, inv_iter->second);
+		std::string window_text = "Slot: (action) Snapshot -&gt; Inventory<br>";
+
+		auto inv_iter = inv_compare_list.begin();
+		auto iss_iter = iss_compare_list.begin();
+
+		while (true) {
+			std::string window_line;
+
+			if (inv_iter == inv_compare_list.end() && iss_iter == iss_compare_list.end()) {
+				break;
+			} else if (inv_iter != inv_compare_list.end() && iss_iter == iss_compare_list.end()) {
+				window_line = StringFormat("%i: (delete) [empty] -&gt; %u<br>", inv_iter->first, inv_iter->second);
+				++inv_iter;
+			} else if (inv_iter == inv_compare_list.end() && iss_iter != iss_compare_list.end()) {
+				window_line = StringFormat("%i: (insert) %u -&gt; [empty]<br>", iss_iter->first, iss_iter->second);
+				++iss_iter;
+			} else {
+				if (inv_iter->first < iss_iter->first) {
+					window_line = StringFormat(
+						"%i: (delete) [empty] -&gt; %u<br>",
+						inv_iter->first,
+						inv_iter->second
+					);
+					++inv_iter;
+				} else if (inv_iter->first > iss_iter->first) {
+					window_line = StringFormat(
+						"%i: (insert) %u -&gt; [empty]<br>",
+						iss_iter->first,
+						iss_iter->second
+					);
+					++iss_iter;
+				} else {
+					window_line = StringFormat(
+						"%i: (replace) %u -&gt; %u<br>",
+						iss_iter->first,
+						iss_iter->second,
+						inv_iter->second
+					);
 					++inv_iter;
-				}
-				else if (inv_iter == inv_compare_list.end() && iss_iter != iss_compare_list.end()) {
-					window_line = StringFormat("%i: (insert) %u -&gt; [empty]<br>", iss_iter->first, iss_iter->second);
 					++iss_iter;
 				}
-				else {
-					if (inv_iter->first < iss_iter->first) {
-						window_line = StringFormat(
-							"%i: (delete) [empty] -&gt; %u<br>",
-							inv_iter->first,
-							inv_iter->second
-						);
-						++inv_iter;
-					}
-					else if (inv_iter->first > iss_iter->first) {
-						window_line = StringFormat(
-							"%i: (insert) %u -&gt; [empty]<br>",
-							iss_iter->first,
-							iss_iter->second
-						);
-						++iss_iter;
-					}
-					else {
-						window_line = StringFormat(
-							"%i: (replace) %u -&gt; %u<br>",
-							iss_iter->first,
-							iss_iter->second,
-							inv_iter->second
-						);
-						++inv_iter;
-						++iss_iter;
-					}
-				}
-
-				if (window_text.length() + window_line.length() < 4095) {
-					window_text.append(window_line);
-				}
-				else {
-					c->Message(Chat::White, "Too many comparison entries to list...");
-					break;
-				}
 			}
 
-			c->SendPopupToClient(window_title.c_str(), window_text.c_str());
+			if (window_text.length() + window_line.length() < 4095) {
+				window_text.append(window_line);
+			} else {
+				c->Message(Chat::White, "Too many comparison entries to list...");
+				break;
+			}
+		}
 
+		c->SendPopupToClient(window_title.c_str(), window_text.c_str());
+
+		return;
+	}
+
+	if (strcmp(sep->arg[1], "restore") == 0) {
+		if (!sep->IsNumber(2)) {
+			c->Message(Chat::White, "A timestamp is required to use this option.");
 			return;
 		}
 
-		if (strcmp(sep->arg[1], "restore") == 0) {
-			if (!sep->IsNumber(2)) {
-				c->Message(Chat::White, "A timestamp is required to use this option.");
-				return;
-			}
-
-			uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
-
-			if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
-				c->Message(
-					Chat::White,
-					"No inventory snapshots for %s (id: %u) exist at %u.",
-					tc->GetName(),
-					tc->CharacterID(),
-					timestamp
-				);
-				return;
-			}
-
-			if (database.SaveCharacterInvSnapshot(tc->CharacterID())) {
-				tc->SetNextInvSnapshot(RuleI(Character, InvSnapshotMinIntervalM));
-			}
-			else {
-				c->Message(
-					Chat::Red, "Failed to take pre-restore inventory snapshot of %s (id: %u).",
-					tc->GetName(), tc->CharacterID());
-				return;
-			}
-
-			if (database.RestoreCharacterInvSnapshot(tc->CharacterID(), timestamp)) {
-				// cannot delete all valid item slots from client..so, we worldkick
-				tc->WorldKick(); // self restores update before the 'kick' is processed
-
-				c->Message(
-					Chat::White, "Successfully applied snapshot %u to %s's (id: %u) inventory.",
-					timestamp, tc->GetName(), tc->CharacterID());
-			}
-			else {
-				c->Message(
-					Chat::Red, "Failed to apply snapshot %u to %s's (id: %u) inventory.",
-					timestamp, tc->GetName(), tc->CharacterID());
-			}
+		uint32 timestamp = Strings::ToUnsignedInt(sep->arg[2]);
 
+		if (!database.ValidateCharacterInvSnapshotTimestamp(tc->CharacterID(), timestamp)) {
+			c->Message(
+				Chat::White,
+				"No inventory snapshots for %s (id: %u) exist at %u.",
+				tc->GetName(),
+				tc->CharacterID(),
+				timestamp
+			);
 			return;
 		}
+
+		if (database.SaveCharacterInvSnapshot(tc->CharacterID())) {
+			tc->SetNextInvSnapshot(RuleI(Character, InvSnapshotMinIntervalM));
+		} else {
+			c->Message(
+				Chat::Red, "Failed to take pre-restore inventory snapshot of %s (id: %u).",
+				tc->GetName(), tc->CharacterID());
+			return;
+		}
+
+		if (database.RestoreCharacterInvSnapshot(tc->CharacterID(), timestamp)) {
+			// cannot delete all valid item slots from client..so, we worldkick
+			tc->WorldKick(); // self restores update before the 'kick' is processed
+
+			c->Message(
+				Chat::White, "Successfully applied snapshot %u to %s's (id: %u) inventory.",
+				timestamp, tc->GetName(), tc->CharacterID());
+		} else {
+			c->Message(
+				Chat::Red, "Failed to apply snapshot %u to %s's (id: %u) inventory.",
+				timestamp, tc->GetName(), tc->CharacterID());
+		}
+
+		return;
 	}
 }
 

zone/gm_commands/list.cpp

@@ -3,237 +3,273 @@
 #include "../object.h"
 #include "../doors.h"
 
+struct UniqueEntity {
+	uint16      entity_id;
+	std::string entity_name;
+	uint32      unique_id;
+	glm::vec4   position;
+};
+
 void command_list(Client *c, const Seperator *sep)
 {
+	const int arguments = sep->argnum;
+	if (!arguments) {
+		c->Message(Chat::White, "Usage: #list [corpses|doors|npcs|objects|players] [search]");
+		c->Message(Chat::White, "Example: #list npcs (Blank for all)");
+		return;
+	}
+
+	const bool is_corpses = !strcasecmp(sep->arg[1], "corpses");
+	const bool is_doors   = !strcasecmp(sep->arg[1], "doors");
+	const bool is_npcs    = !strcasecmp(sep->arg[1], "npcs");
+	const bool is_objects = !strcasecmp(sep->arg[1], "objects");
+	const bool is_players = !strcasecmp(sep->arg[1], "players");
+
+	if (
+		!is_corpses &&
+		!is_doors &&
+		!is_npcs &&
+		!is_objects &&
+		!is_players
+	) {
+		c->Message(Chat::White, "Usage: #list [npcs|players|corpses|doors|objects] [search]");
+		c->Message(Chat::White, "Example: #list npcs (Blank for all)");
+		return;
+	}
+
 	std::string search_type;
-	if (strcasecmp(sep->arg[1], "npcs") == 0) {
-		search_type = "npcs";
+	std::string unique_type;
+
+	if (is_corpses) {
+		search_type = "corpse";
+		unique_type = "Corpse ID";
+	} else if (is_doors) {
+		search_type = "door";
+		unique_type = "Door ID";
+	} else if (is_npcs) {
+		search_type = "NPC";
+		unique_type = "NPC ID";
+	} else if (is_objects) {
+		search_type = "object";
+		unique_type = "Object ID";
+	} else if (is_players) {
+		search_type = "player";
+		unique_type = "Character ID";
 	}
 
-	if (strcasecmp(sep->arg[1], "players") == 0) {
-		search_type = "players";
-	}
+	uint32 entity_count = 0;
+	uint32 found_count  = 0;
 
-	if (strcasecmp(sep->arg[1], "corpses") == 0) {
-		search_type = "corpses";
-	}
+	const std::string &search_string = sep->arg[2] ? Strings::ToLower(sep->arg[2]) : std::string();
 
-	if (strcasecmp(sep->arg[1], "doors") == 0) {
-		search_type = "doors";
-	}
+	std::vector<UniqueEntity> unique_entities;
 
-	if (strcasecmp(sep->arg[1], "objects") == 0) {
-		search_type = "objects";
-	}
+	if (is_corpses) {
+		const auto &l = entity_list.GetCorpseList();
 
-	if (search_type.length() > 0) {
+		for (const auto &e : l) {
+			Corpse *entity = e.second;
 
-		int entity_count = 0;
-		int found_count  = 0;
+			entity_count++;
 
-		std::string search_string;
-
-		if (sep->arg[2]) {
-			search_string = Strings::ToLower(sep->arg[2]);
-		}
-
-		// NPC
-		if (search_type.find("npcs") != std::string::npos) {
-			auto &entity_list_search = entity_list.GetMobList();
-
-			for (auto &itr : entity_list_search) {
-				Mob *entity = itr.second;
-				if (!entity->IsNPC()) {
-					continue;
-				}
-
-				entity_count++;
-
-				std::string entity_name = Strings::ToLower(entity->GetName());
-				if (search_string.length() > 0 && entity_name.find(search_string) == std::string::npos) {
-					continue;
-				}
-
-				std::string saylink = StringFormat(
-					"#goto %.0f %0.f %.0f",
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ() + (entity->IsBoat() ? 50 : 0));
-
-				c->Message(
-					0,
-					"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
-					Saylink::Silent(saylink, "Goto").c_str(),
-					entity->GetID(),
-					entity->GetName(),
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ()
-				);
-
-				found_count++;
+			const std::string &entity_name = Strings::ToLower(entity->GetName());
+			if (!search_string.empty() && entity_name.find(search_string) == std::string::npos) {
+				continue;
 			}
-		}
 
-		// Client
-		if (search_type.find("players") != std::string::npos) {
-			auto &entity_list_search = entity_list.GetClientList();
-
-			for (auto &itr : entity_list_search) {
-				Client *entity = itr.second;
-
-				entity_count++;
-
-				std::string entity_name = Strings::ToLower(entity->GetName());
-
-				/**
-				 * Filter by name
-				 */
-				if (search_string.length() > 0 && entity_name.find(search_string) == std::string::npos) {
-					continue;
+			unique_entities.emplace_back(
+				UniqueEntity{
+					.entity_id = entity->GetID(),
+					.entity_name = entity->GetName(),
+					.unique_id = entity->GetCorpseDBID(),
+					.position = entity->GetPosition()
 				}
-
-				std::string saylink = StringFormat(
-					"#goto %.0f %0.f %.0f",
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ());
-
-				c->Message(
-					0,
-					"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
-					Saylink::Silent(saylink, "Goto").c_str(),
-					entity->GetID(),
-					entity->GetName(),
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ()
-				);
-
-				found_count++;
-			}
-		}
-
-		// Corpse
-		if (search_type.find("corpses") != std::string::npos) {
-			auto &entity_list_search = entity_list.GetCorpseList();
-
-			for (auto &itr : entity_list_search) {
-				Corpse *entity = itr.second;
-
-				entity_count++;
-
-				std::string entity_name = Strings::ToLower(entity->GetName());
-				if (search_string.length() > 0 && entity_name.find(search_string) == std::string::npos) {
-					continue;
-				}
-
-				std::string saylink = StringFormat(
-					"#goto %.0f %0.f %.0f",
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ());
-
-				c->Message(
-					0,
-					"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
-					Saylink::Silent(saylink, "Goto").c_str(),
-					entity->GetID(),
-					entity->GetName(),
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ()
-				);
-
-				found_count++;
-			}
-		}
-
-		// Doors
-		if (search_type.find("doors") != std::string::npos) {
-			auto &entity_list_search = entity_list.GetDoorsList();
-
-			for (auto &itr : entity_list_search) {
-				Doors *entity = itr.second;
-
-				entity_count++;
-
-				std::string entity_name = Strings::ToLower(entity->GetDoorName());
-				if (search_string.length() > 0 && entity_name.find(search_string) == std::string::npos) {
-					continue;
-				}
-
-				std::string saylink = StringFormat(
-					"#goto %.0f %0.f %.0f",
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ());
-
-				c->Message(
-					0,
-					"| %s | Entity ID %5d | Door ID %i | %s | x %.0f | y %0.f | z %.0f",
-					Saylink::Silent(saylink, "Goto").c_str(),
-					entity->GetID(),
-					entity->GetDoorID(),
-					entity->GetDoorName(),
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ()
-				);
-
-				found_count++;
-			}
-		}
-
-		// Objects
-		if (search_type.find("objects") != std::string::npos) {
-			auto &entity_list_search = entity_list.GetObjectList();
-
-			for (auto &itr : entity_list_search) {
-				Object *entity = itr.second;
-
-				entity_count++;
-
-				std::string entity_name = Strings::ToLower(entity->GetModelName());
-				if (search_string.length() > 0 && entity_name.find(search_string) == std::string::npos) {
-					continue;
-				}
-
-				std::string saylink = StringFormat(
-					"#goto %.0f %0.f %.0f",
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ());
-
-				c->Message(
-					0,
-					"| %s | Entity ID %5d | Object DBID %i | %s | x %.0f | y %0.f | z %.0f",
-					Saylink::Silent(saylink, "Goto").c_str(),
-					entity->GetID(),
-					entity->GetDBID(),
-					entity->GetModelName(),
-					entity->GetX(),
-					entity->GetY(),
-					entity->GetZ()
-				);
-
-				found_count++;
-			}
-		}
-
-		if (found_count) {
-			c->Message(
-				0, "Found (%i) of type (%s) in zone (%i) total",
-				found_count,
-				search_type.c_str(),
-				entity_count
 			);
+
+			found_count++;
+		}
+	} else if (is_doors) {
+		const auto &l = entity_list.GetDoorsList();
+
+		for (const auto &e : l) {
+			Doors *entity = e.second;
+
+			entity_count++;
+
+			const std::string &entity_name = Strings::ToLower(entity->GetDoorName());
+			if (!search_string.empty() && entity_name.find(search_string) == std::string::npos) {
+				continue;
+			}
+
+			unique_entities.emplace_back(
+				UniqueEntity{
+					.entity_id = entity->GetID(),
+					.entity_name = entity->GetDoorName(),
+					.unique_id = entity->GetDoorID(),
+					.position = entity->GetPosition()
+				}
+			);
+
+			found_count++;
+		}
+	} else if (is_npcs) {
+		const auto &l = entity_list.GetMobList();
+
+		for (const auto &e : l) {
+			Mob *entity = e.second;
+			if (!entity->IsNPC()) {
+				continue;
+			}
+
+			entity_count++;
+
+			const std::string &entity_name = Strings::ToLower(entity->GetName());
+			if (!search_string.empty() && entity_name.find(search_string) == std::string::npos) {
+				continue;
+			}
+
+			unique_entities.emplace_back(
+				UniqueEntity{
+					.entity_id = entity->GetID(),
+					.entity_name = entity->GetName(),
+					.unique_id = entity->GetNPCTypeID(),
+					.position = entity->GetPosition()
+				}
+			);
+
+			found_count++;
+		}
+	} else if (is_objects) {
+		const auto &l = entity_list.GetObjectList();
+
+		for (const auto &e : l) {
+			Object *entity = e.second;
+
+			entity_count++;
+
+			const std::string &entity_name = Strings::ToLower(entity->GetModelName());
+			if (!search_string.empty() && entity_name.find(search_string) == std::string::npos) {
+				continue;
+			}
+
+			unique_entities.emplace_back(
+				UniqueEntity{
+					.entity_id = entity->GetID(),
+					.entity_name = entity->GetModelName(),
+					.unique_id = entity->GetDBID(),
+					.position = glm::vec4(entity->GetX(), entity->GetY(), entity->GetZ(), 0.0f)
+				}
+			);
+
+			found_count++;
+		}
+	} else if (is_players) {
+		const auto &l = entity_list.GetClientList();
+
+		for (const auto &e : l) {
+			Client *entity = e.second;
+
+			entity_count++;
+
+			const std::string &entity_name = Strings::ToLower(entity->GetName());
+			if (!search_string.empty() && entity_name.find(search_string) == std::string::npos) {
+				continue;
+			}
+
+			unique_entities.emplace_back(
+				UniqueEntity{
+					.entity_id = entity->GetID(),
+					.entity_name = entity->GetName(),
+					.unique_id = entity->CharacterID(),
+					.position = entity->GetPosition()
+				}
+			);
+
+			found_count++;
 		}
 	}
-	else {
-		c->Message(Chat::White, "Usage of #list");
-		c->Message(Chat::White, "- #list [npcs|players|corpses|doors|objects] [search]");
-		c->Message(Chat::White, "- Example: #list npcs (Blank for all)");
-	}
-}
 
+	if (!found_count) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Could not find any {}{}.",
+				search_type,
+				(
+					!search_string.empty() ?
+					fmt::format(
+						" matching '{}'",
+						search_string
+					) :
+					""
+				)
+			).c_str()
+		);
+		return;
+	}
+
+	std::sort(unique_entities.begin(), unique_entities.end(), [](UniqueEntity a, UniqueEntity b) {
+		if (a.entity_id && b.entity_id) {
+			return a.entity_id < b.entity_id;
+		} else {
+			return a.unique_id < b.unique_id;
+		}
+	});
+
+	for (const auto& e : unique_entities) {
+		const std::string &saylink = Saylink::Silent(
+			fmt::format(
+				"#goto {:.2f} {:.2f} {:.2f}",
+				e.position.x,
+				e.position.y,
+				e.position.z
+			),
+			"Goto"
+		);
+
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"| {}{}{} | {} |",
+				saylink,
+				(
+					e.entity_id ?
+					fmt::format(
+						" | ID {}",
+						e.entity_id
+					) :
+					""
+				),
+				(
+					e.unique_id ?
+					fmt::format(
+						" | {} {}",
+						unique_type,
+						e.unique_id
+					) :
+					""
+				),
+				e.entity_name
+			).c_str()
+		);
+	}
+
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"Found {} {}{}{}, {} total.",
+			found_count,
+			search_type,
+			found_count != 1 ? "s" : "",
+			(
+				!search_string.empty() ?
+				fmt::format(
+					" matching '{}'",
+					search_string
+				) :
+				""
+			),
+			entity_count
+		).c_str()
+	);
+}

zone/gm_commands/merchantshop.cpp

@@ -7,12 +7,12 @@ void command_merchantshop(Client *c, const Seperator *sep)
 		!m ||
 		!m->IsNPC() ||
 		(
-			m->GetClass() != MERCHANT &&
-			m->GetClass() != DISCORD_MERCHANT &&
-			m->GetClass() != ADVENTURE_MERCHANT &&
-			m->GetClass() != NORRATHS_KEEPERS_MERCHANT &&
-			m->GetClass() != DARK_REIGN_MERCHANT &&
-			m->GetClass() != ALT_CURRENCY_MERCHANT
+			m->GetClass() != Class::Merchant &&
+			m->GetClass() != Class::DiscordMerchant &&
+			m->GetClass() != Class::AdventureMerchant &&
+			m->GetClass() != Class::NorrathsKeepersMerchant &&
+			m->GetClass() != Class::DarkReignMerchant &&
+			m->GetClass() != Class::AlternateCurrencyMerchant
 		)
 	) {
 		c->Message(Chat::White, "You must target a merchant.");

zone/gm_commands/movechar.cpp

@@ -2,18 +2,18 @@
 
 void command_movechar(Client *c, const Seperator *sep)
 {
-	int arguments = sep->argnum;
+	const int arguments = sep->argnum;
 	if (arguments < 2) {
 		c->Message(Chat::White, "Usage: #movechar [Character ID|Character Name] [Zone ID|Zone Short Name]");
 		return;
 	}
 
-	std::string character_name = (
+	const std::string &character_name = (
 		sep->IsNumber(1) ?
 		database.GetCharNameByID(Strings::ToUnsignedInt(sep->arg[1])) :
 		sep->arg[1]
 	);
-	auto character_id = database.GetCharacterID(character_name.c_str());
+	const uint32 character_id = database.GetCharacterID(character_name.c_str());
 	if (!character_id) {
 		c->Message(
 			Chat::White,
@@ -25,15 +25,15 @@ void command_movechar(Client *c, const Seperator *sep)
 		return;
 	}
 
-	auto account_id = database.GetAccountIDByChar(character_name.c_str());
+	const uint32 account_id = database.GetAccountIDByChar(character_name.c_str());
 
-	std::string zone_short_name = Strings::ToLower(
+	const std::string &zone_short_name = Strings::ToLower(
 		sep->IsNumber(2) ?
 		ZoneName(Strings::ToUnsignedInt(sep->arg[2]), true) :
 		sep->arg[2]
 	);
 
-	bool is_unknown_zone = zone_short_name.find("unknown") != std::string::npos;
+	const bool is_unknown_zone = zone_short_name.find("unknown") != std::string::npos;
 	if (is_unknown_zone) {
 		c->Message(
 			Chat::White,
@@ -45,63 +45,34 @@ void command_movechar(Client *c, const Seperator *sep)
 		return;
 	}
 
-	auto zone_id = ZoneID(zone_short_name);
-	auto z = GetZone(zone_id);
+	const uint32 zone_id = ZoneID(zone_short_name);
+	auto         z       = GetZone(zone_id);
 
 	if (!z) {
 		c->Message(Chat::Red, "Invalid zone.");
 		return;
 	}
 
-	bool is_special_zone = (
-		zone_short_name.find("cshome") != std::string::npos ||
-		zone_short_name.find("load") != std::string::npos ||
-		zone_short_name.find("load2") != std::string::npos
+	const bool  moved        = database.MoveCharacterToZone(character_name.c_str(), zone_id);
+	std::string moved_string = moved ? "Succeeded" : "Failed";
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"Character Move {} | Character: {} ({})",
+			moved_string,
+			character_name,
+			character_id
+		).c_str()
 	);
 
-	if (c->Admin() < commandMovecharToSpecials && is_special_zone) {
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"{} ({}) is a special zone and you cannot move someone there.",
-				z->long_name,
-				zone_short_name
-			).c_str()
-		);
-		return;
-	}
-
-	if (
-		c->Admin() >= commandMovecharSelfOnly ||
-		account_id == c->AccountID()
-	) {
-		bool moved = database.MoveCharacterToZone(character_name.c_str(), zone_id);
-		std::string moved_string = (
-			moved ?
-			"Succeeded" :
-			"Failed"
-		);
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"Character Move {} | Character: {} ({})",
-				moved_string,
-				character_name,
-				character_id
-			).c_str()
-		);
-
-		c->Message(
-			Chat::White,
-			fmt::format(
-				"Character Move {} | Zone: {} ({}) ID: {}",
-				moved_string,
-				z->long_name,
-				zone_short_name,
-				zone_id
-			).c_str()
-		);
-	} else {
-		c->Message(Chat::White, "You cannot move characters that are not on your account.");
-	}
+	c->Message(
+		Chat::White,
+		fmt::format(
+			"Character Move {} | Zone: {} ({}) ID: {}",
+			moved_string,
+			z->long_name,
+			zone_short_name,
+			zone_id
+		).c_str()
+	);
 }

zone/gm_commands/movement.cpp

@@ -3,74 +3,84 @@
 
 void command_movement(Client *c, const Seperator *sep)
 {
-	auto &mgr = MobMovementManager::Get();
-
-	if (sep->arg[1][0] == 0) {
-		c->Message(Chat::White, "Usage: #movement stats/clearstats/walkto/runto/rotateto/stop/packet");
+	const int arguments = sep->argnum;
+	if (!arguments) {
+		c->Message(Chat::White, "Usage: #movement [clear|packet|rotate|run|stats|stop|walk]");
 		return;
 	}
 
-	if (strcasecmp(sep->arg[1], "stats") == 0) {
-		mgr.DumpStats(c);
+	const bool is_clear  = !strcasecmp(sep->arg[1], "clear");
+	const bool is_packet = !strcasecmp(sep->arg[1], "packet");
+	const bool is_rotate = !strcasecmp(sep->arg[1], "rotate");
+	const bool is_run    = !strcasecmp(sep->arg[1], "run");
+	const bool is_stats  = !strcasecmp(sep->arg[1], "stats");
+	const bool is_stop   = !strcasecmp(sep->arg[1], "stop");
+	const bool is_walk   = !strcasecmp(sep->arg[1], "walk");
+
+	if (
+		!is_clear &&
+		!is_packet &&
+		!is_rotate &&
+		!is_run &&
+		!is_stats &&
+		!is_stop &&
+		!is_walk
+	) {
+		c->Message(Chat::White, "Usage: #movement [clear|packet|rotate|run|stats|stop|walk]");
+		return;
 	}
-	else if (strcasecmp(sep->arg[1], "clearstats") == 0) {
-		mgr.ClearStats();
-	}
-	else if (strcasecmp(sep->arg[1], "walkto") == 0) {
-		auto target = c->GetTarget();
-		if (target == nullptr) {
-			c->Message(Chat::White, "No target found.");
+
+	auto &m = MobMovementManager::Get();
+
+	if (is_clear) {
+		m.ClearStats();
+	} else if (is_packet) {
+		Mob *t = c->GetTarget();
+		if (!t) {
+			c->Message(Chat::White, "You must have a target to use this command.");
 			return;
 		}
 
-		target->WalkTo(c->GetX(), c->GetY(), c->GetZ());
-	}
-	else if (strcasecmp(sep->arg[1], "runto") == 0) {
-		auto target = c->GetTarget();
-		if (target == nullptr) {
-			c->Message(Chat::White, "No target found.");
+		const float x         = sep->IsNumber(2) ? Strings::ToFloat(sep->arg[2]) : 0.0f;
+		const float y         = sep->IsNumber(3) ? Strings::ToFloat(sep->arg[3]) : 0.0f;
+		const float z         = sep->IsNumber(4) ? Strings::ToFloat(sep->arg[4]) : 0.0f;
+		const float heading   = sep->IsNumber(5) ? Strings::ToFloat(sep->arg[5]) : 0.0f;
+		const int   animation = sep->IsNumber(6) ? Strings::ToInt(sep->arg[6]) : 0.0f;
+
+		m.SendCommandToClients(t, x, y, z, heading, animation, ClientRangeAny);
+	} else if (is_rotate) {
+		Mob *t = c->GetTarget();
+		if (!t) {
+			c->Message(Chat::White, "You must have a target to use this command.");
 			return;
 		}
 
-		target->RunTo(c->GetX(), c->GetY(), c->GetZ());
-	}
-	else if (strcasecmp(sep->arg[1], "rotateto") == 0) {
-		auto target = c->GetTarget();
-		if (target == nullptr) {
-			c->Message(Chat::White, "No target found.");
+		t->RotateToWalking(t->CalculateHeadingToTarget(c->GetX(), c->GetY()));
+	} else if (is_run) {
+		Mob *t = c->GetTarget();
+		if (!t) {
+			c->Message(Chat::White, "You must have a target to use this command.");
 			return;
 		}
 
-		target->RotateToWalking(target->CalculateHeadingToTarget(c->GetX(), c->GetY()));
-	}
-	else if (strcasecmp(sep->arg[1], "stop") == 0) {
-		auto target = c->GetTarget();
-		if (target == nullptr) {
-			c->Message(Chat::White, "No target found.");
+		t->RunTo(c->GetX(), c->GetY(), c->GetZ());
+	} else if (is_stats) {
+		m.DumpStats(c);
+	} else if (is_stop) {
+		Mob *t = c->GetTarget();
+		if (!t) {
+			c->Message(Chat::White, "You must have a target to use this command.");
 			return;
 		}
 
-		target->StopNavigation();
-	}
-	else if (strcasecmp(sep->arg[1], "packet") == 0) {
-		auto target = c->GetTarget();
-		if (target == nullptr) {
-			c->Message(Chat::White, "No target found.");
+		t->StopNavigation();
+	} else if (is_walk) {
+		Mob *t = c->GetTarget();
+		if (!t) {
+			c->Message(Chat::White, "You must have a target to use this command.");
 			return;
 		}
 
-		mgr.SendCommandToClients(
-			target,
-			Strings::ToFloat(sep->arg[2]),
-			Strings::ToFloat(sep->arg[3]),
-			Strings::ToFloat(sep->arg[4]),
-			Strings::ToFloat(sep->arg[5]),
-			Strings::ToInt(sep->arg[6]),
-			ClientRangeAny
-		);
-	}
-	else {
-		c->Message(Chat::White, "Usage: #movement stats/clearstats/walkto/runto/rotateto/stop/packet");
+		t->WalkTo(c->GetX(), c->GetY(), c->GetZ());
 	}
 }
-

zone/gm_commands/object_manipulation.h

@@ -0,0 +1,15 @@
+#ifndef EQEMU_OBJECT_MANIPULATION_H
+#define EQEMU_OBJECT_MANIPULATION_H
+
+#include "../client.h"
+
+class ObjectManipulation {
+
+public:
+	static void CommandHandler(Client *c, const Seperator *sep);
+	static void CommandHeader(Client *c);
+	static void SendSubcommands(Client *c);
+};
+
+
+#endif //EQEMU_OBJECT_MANIPULATION_H

zone/gm_commands/petname.cpp

@@ -5,10 +5,10 @@ void command_petname(Client *c, const Seperator *sep)
 	Mob *target;
 	target = c->GetTarget();
 
-	if (!target) {
-		c->Message(Chat::White, "Usage: #petname newname (requires a target)");
+	if (!target || !target->IsPet()) {
+		c->Message(Chat::White, "Usage: #petname newname (requires a pet target)");
 	}
-	else if (target->IsPet() && (target->GetOwnerID() == c->GetID()) && strlen(sep->arg[1]) > 0) {
+	else if (target->GetOwnerID() == c->GetID() && strlen(sep->arg[1]) > 0) {
 		char *oldname = strdup(target->GetName());
 		target->TempName(sep->arg[1]);
 		c->Message(Chat::White, "Renamed %s to %s", oldname, sep->arg[1]);

zone/gm_commands/scribespell.cpp

@@ -46,7 +46,7 @@ void command_scribespell(Client *c, const Seperator *sep)
 		);
 
 		if (
-			spells[spell_id].classes[WARRIOR] != 0 &&
+			spells[spell_id].classes[Class::Warrior] != 0 &&
 			spells[spell_id].skill != EQ::skills::SkillTigerClaw &&
 			spells[spell_id].classes[t->GetPP().class_ - 1] > 0 &&
 			!IsDiscipline(spell_id)

zone/gm_commands/show.cpp

@@ -1,4 +1,5 @@
 #include "../client.h"
+#include "show/aas.cpp"
 #include "show/aa_points.cpp"
 #include "show/aggro.cpp"
 #include "show/buffs.cpp"
@@ -56,6 +57,7 @@ void command_show(Client *c, const Seperator *sep)
 	};
 
 	std::vector<Cmd> commands = {
+		Cmd{.cmd = "aas", .u = "aas", .fn = ShowAAs, .a = {"#showaas"}},
 		Cmd{.cmd = "aa_points", .u = "aa_points", .fn = ShowAAPoints, .a = {"#showaapoints", "#showaapts"}},
 		Cmd{.cmd = "aggro", .u = "aggro [Distance] [-v] (-v is verbose Faction Information)", .fn = ShowAggro, .a = {"#aggro"}},
 		Cmd{.cmd = "buffs", .u = "buffs", .fn = ShowBuffs, .a = {"#showbuffs"}},

zone/gm_commands/show/aas.cpp

@@ -0,0 +1,13 @@
+#include "../../client.h"
+
+void ShowAAs(Client *c, const Seperator *sep)
+{
+	Client *t = c;
+	if (c->GetTarget() && c->GetTarget()->IsClient()) {
+		t = c->GetTarget()->CastToClient();
+	}
+
+	const std::string& search_criteria = sep->argnum >= 2 ? sep->argplus[2] : std::string();
+
+	t->ListPurchasedAAs(c, search_criteria);
+}

zone/gm_commands/show/flags.cpp

@@ -2,13 +2,8 @@
 
 void ShowFlags(Client *c, const Seperator *sep)
 {
-	auto t = c;
-
-	if (
-		c->GetTarget() &&
-		c->GetTarget()->IsClient() &&
-		c->Admin() >= minStatusToSeeOthersZoneFlags
-	) {
+	Client *t = c;
+	if (c->GetTarget() && c->GetTarget()->IsClient()) {
 		t =  c->GetTarget()->CastToClient();
 	}
 

zone/gm_commands/show/peqzone_flags.cpp

@@ -2,12 +2,8 @@
 
 void ShowPEQZoneFlags(Client *c, const Seperator *sep)
 {
-	auto t = c;
-	if (
-		c->GetTarget() &&
-		c->GetTarget()->IsClient() &&
-		c->Admin() >= minStatusToSeeOthersZoneFlags
-	) {
+	Client *t = c;
+	if (c->GetTarget() && c->GetTarget()->IsClient()) {
 		t =  c->GetTarget()->CastToClient();
 	}
 

zone/gm_commands/task.cpp

@@ -8,7 +8,7 @@ extern WorldServer worldserver;
 
 void command_task(Client *c, const Seperator *sep)
 {
-	int arguments = sep->argnum;
+	const int arguments = sep->argnum;
 	if (!arguments) {
 		c->Message(Chat::White, "Syntax: #task [subcommand]");
 		c->Message(Chat::White, "------------------------------------------------");
@@ -23,6 +23,7 @@ void command_task(Client *c, const Seperator *sep)
 		);
 		c->Message(Chat::White, "--- update <task_id> <activity_id> [count] | Updates task");
 		c->Message(Chat::White, "--- assign <task_id> | Assigns task to client");
+		c->Message(Chat::White, "--- complete <task_id> | Completes a task if a client has it assigned to them");
 		c->Message(Chat::White, "--- uncomplete <task_id> | Uncompletes a task if a client has completed it");
 		c->Message(
 			Chat::White,
@@ -73,22 +74,24 @@ void command_task(Client *c, const Seperator *sep)
 		return;
 	}
 
-	Client *target = c;
+	Client *t = c;
 	if (c->GetTarget() && c->GetTarget()->IsClient()) {
-		target = c->GetTarget()->CastToClient();
+		t = c->GetTarget()->CastToClient();
 	}
 
-	bool is_assign = !strcasecmp(sep->arg[1], "assign");
-	bool is_purgetimers = !strcasecmp(sep->arg[1], "purgetimers");
-	bool is_reload = !strcasecmp(sep->arg[1], "reload");
-	bool is_reloadall = !strcasecmp(sep->arg[1], "reloadall");
-	bool is_sharedpurge = !strcasecmp(sep->arg[1], "sharedpurge");
-	bool is_show = !strcasecmp(sep->arg[1], "show");
-	bool is_uncomplete = !strcasecmp(sep->arg[1], "uncomplete");
-	bool is_update = !strcasecmp(sep->arg[1], "update");
+	const bool is_assign      = !strcasecmp(sep->arg[1], "assign");
+	const bool is_complete    = !strcasecmp(sep->arg[1], "complete");
+	const bool is_purgetimers = !strcasecmp(sep->arg[1], "purgetimers");
+	const bool is_reload      = !strcasecmp(sep->arg[1], "reload");
+	const bool is_reloadall   = !strcasecmp(sep->arg[1], "reloadall");
+	const bool is_sharedpurge = !strcasecmp(sep->arg[1], "sharedpurge");
+	const bool is_show        = !strcasecmp(sep->arg[1], "show");
+	const bool is_uncomplete  = !strcasecmp(sep->arg[1], "uncomplete");
+	const bool is_update      = !strcasecmp(sep->arg[1], "update");
 
 	if (
 		!is_assign &&
+		!is_complete &&
 		!is_purgetimers &&
 		!is_reload &&
 		!is_reloadall &&
@@ -161,70 +164,117 @@ void command_task(Client *c, const Seperator *sep)
 	}
 
 	if (is_assign) {
-		auto task_id = std::strtoul(sep->arg[2], nullptr, 10);
+		const uint32 task_id = Strings::ToUnsignedInt(sep->arg[2]);
 		if (task_id) {
-			target->AssignTask(task_id, 0, false);
+			t->AssignTask(task_id, 0, false);
 			c->Message(
-				Chat::Yellow,
+				Chat::White,
 				fmt::format(
-					"Assigned task ID {} to {}.",
+					"Assigned {} (ID {}) to {}.",
+					task_manager->GetTaskName(task_id),
 					task_id,
-					c->GetTargetDescription(target)
+					c->GetTargetDescription(t)
 				).c_str()
 			);
 		}
-		return;
+	} else if (is_complete) {
+		if (sep->IsNumber(2)) {
+			const uint32 task_id = Strings::ToUnsignedInt(sep->arg[2]);
+			if (!task_id) {
+				c->Message(Chat::White, "Invalid task ID specified.");
+				return;
+			}
+
+			if (t->IsTaskActive(task_id)) {
+				const bool did_complete = t->CompleteTask(task_id);
+				if (did_complete) {
+					c->Message(
+						Chat::White,
+						fmt::format(
+							"Successfully completed {} (ID {}) for {}.",
+							task_manager->GetTaskName(task_id),
+							task_id,
+							c->GetTargetDescription(t)
+						).c_str()
+					);
+				} else {
+					c->Message(
+						Chat::White,
+						fmt::format(
+							"Failed to complete {} (ID {}) for {}.",
+							task_manager->GetTaskName(task_id),
+							task_id,
+							c->GetTargetDescription(t)
+						).c_str()
+					);
+				}
+			} else {
+				c->Message(
+					Chat::White,
+					fmt::format(
+						"{} {} not have not {} (ID {}) assigned to them.",
+						c->GetTargetDescription(t, TargetDescriptionType::UCYou),
+						c == t ? "do" : "does",
+						task_manager->GetTaskName(task_id),
+						task_id
+					).c_str()
+				);
+			}
+		}
 	} else if (is_purgetimers) {
 		c->Message(
-			Chat::Yellow,
+			Chat::White,
 			fmt::format(
 				"Task timers have been purged for {}.",
-				c->GetTargetDescription(target)
+				c->GetTargetDescription(t)
 			).c_str()
 		);
 
-		if (c != target) {
-			target->Message(Chat::Yellow, "Your task timers have been purged by a GM.");
+		if (c != t) {
+			t->Message(Chat::White, "Your task timers have been purged by a GM.");
 		}
 
-		target->PurgeTaskTimers();
-		return;
+		t->PurgeTaskTimers();
 	} else if (is_reload) {
 		if (arguments >= 2) {
-			if (!strcasecmp(sep->arg[2], "sets")) {
-				c->Message(Chat::Yellow, "Attempting to reload task sets.");
+			const bool is_sets = !strcasecmp(sep->arg[2], "sets");
+			const bool is_task = !strcasecmp(sep->arg[2], "task");
+
+			if (is_sets) {
+				c->Message(Chat::White, "Attempting to reload task sets.");
 				worldserver.SendReloadTasks(RELOADTASKSETS);
-				c->Message(Chat::Yellow, "Successfully reloaded task sets.");
-				return;
-			} else if (!strcasecmp(sep->arg[2], "task") && arguments == 3) {
-				int task_id = std::strtoul(sep->arg[3], nullptr, 10);
+				c->Message(Chat::White, "Successfully reloaded task sets.");
+			} else if (is_task && arguments == 3 && sep->IsNumber(3)) {
+				const uint32 task_id = Strings::ToUnsignedInt(sep->arg[3]);
 				if (task_id) {
 					c->Message(
-						Chat::Yellow,
+						Chat::White,
 						fmt::format(
-							"Attempted to reload task ID {}.",
+							"Attempting to reload {} (ID {}).",
+							task_manager->GetTaskName(task_id),
 							task_id
 						).c_str()
 					);
 					worldserver.SendReloadTasks(RELOADTASKS, task_id);
 					c->Message(
-						Chat::Yellow,
+						Chat::White,
 						fmt::format(
-							"Successfully reloaded task ID {}.",
+							"Successfully reloaded {} (ID {}).",
+							task_manager->GetTaskName(task_id),
 							task_id
 						).c_str()
 					);
-					return;
 				}
 			}
 		}
 	} else if (is_reloadall) {
-		c->Message(Chat::Yellow, "Attempting to reload tasks.");
+		c->Message(Chat::White, "Attempting to reload tasks.");
 		worldserver.SendReloadTasks(RELOADTASKS);
-		c->Message(Chat::Yellow, "Successfully reloaded tasks.");
-		return;
+		c->Message(Chat::White, "Successfully reloaded tasks.");
 	} else if (is_sharedpurge) {
-		if (!strcasecmp(sep->arg[2], "confirm")) {
+		const bool is_confirm = !strcasecmp(sep->arg[2], "confirm");
+
+		if (is_confirm) {
 			LogTasksDetail("Sending purge request");
 			auto pack = new ServerPacket(ServerOP_SharedTaskPurgeAllCommand, 0);
 			worldserver.SendPacket(pack);
@@ -239,14 +289,11 @@ void command_task(Client *c, const Seperator *sep)
 				Saylink::Silent("#task sharedpurge confirm", "confirm")
 			).c_str()
 		);
-
-		return;
 	} else if (is_show) {
-		target->ShowClientTasks(c);
-		return;
+		t->ShowClientTasks(c);
 	} else if (is_uncomplete) {
 		if (sep->IsNumber(2)) {
-			auto task_id = Strings::ToUnsignedInt(sep->arg[2]);
+			const uint32 task_id = Strings::ToUnsignedInt(sep->arg[2]);
 			if (!task_id) {
 				c->Message(Chat::White, "Invalid task ID specified.");
 				return;
@@ -257,57 +304,60 @@ void command_task(Client *c, const Seperator *sep)
 					database,
 					fmt::format(
 						"charid = {} AND taskid = {}",
-					target->CharacterID(),
-					task_id
+						t->CharacterID(),
+						task_id
 					)
 				)
 			) {
 				c->Message(
-					Chat::Yellow,
+					Chat::White,
 					fmt::format(
-						"Successfully uncompleted task ID {} for {}.",
+						"Successfully uncompleted {} (ID {}) for {}.",
+						task_manager->GetTaskName(task_id),
 						task_id,
-						c->GetTargetDescription(target)
+						c->GetTargetDescription(t)
 					).c_str()
 				);
 			} else {
 				c->Message(
-					Chat::Yellow,
+					Chat::White,
 					fmt::format(
-						"{} {} not completed task ID {}.",
-						c->GetTargetDescription(target, TargetDescriptionType::UCYou),
-						c == target ? "have" : "has",
+						"{} {} not completed {} (ID {}).",
+						c->GetTargetDescription(t, TargetDescriptionType::UCYou),
+						c == t ? "have" : "has",
+						task_manager->GetTaskName(task_id),
 						task_id
 					).c_str()
 				);
 			}
 		}
 	} else if (is_update) {
-		if (arguments >= 3) {
-			auto task_id = std::strtoul(sep->arg[2], nullptr, 10);
-			auto activity_id = std::strtoul(sep->arg[3], nullptr, 10);
-			int count = 1;
+		if (arguments >= 3 && sep->IsNumber(2) && sep->IsNumber(3)) {
+			const uint32 task_id     = Strings::ToUnsignedInt(sep->arg[2]);
+			const uint32 activity_id = Strings::ToUnsignedInt(sep->arg[3]);
+			int          count       = 1;
 
-			if (arguments >= 4) {
-				count = std::strtol(sep->arg[4], nullptr, 10);
+			if (arguments == 4 && sep->IsNumber(4)) {
+				count = Strings::ToInt(sep->arg[4]);
 				if (count <= 0) {
 					count = 1;
 				}
 			}
 
 			c->Message(
-				Chat::Yellow,
+				Chat::White,
 				fmt::format(
-					"Updating task ID {}, activity {} with a count of {} for {}.",
+					"Updating {} (ID {}), activity {} with a count of {} for {}.",
+					task_manager->GetTaskName(task_id),
 					task_id,
 					activity_id,
 					count,
-					c->GetTargetDescription(target)
+					c->GetTargetDescription(t)
 				).c_str()
 			);
 
-			target->UpdateTaskActivity(task_id, activity_id, count);
-			target->ShowClientTasks(c);
+			t->UpdateTaskActivity(task_id, activity_id, count);
+			t->ShowClientTasks(c);
 		}
 	}
 }

zone/gm_commands/zonebootup.cpp

@@ -5,21 +5,43 @@ extern WorldServer worldserver;
 
 void command_zonebootup(Client *c, const Seperator *sep)
 {
-	if (!worldserver.Connected()) {
-		c->Message(Chat::White, "Error: World server disconnected");
+	const int arguments = sep->argnum;
+	if (arguments < 2 || !sep->IsNumber(1)) {
+		c->Message(Chat::White, "Usage: #zonebootup [Zone Server ID] [Zone ID|Zone Short Name] [Instance ID]");
+		return;
 	}
-	else if (sep->arg[2][0] == 0) {
-		c->Message(Chat::White, "Usage: #zonebootup ZoneServerID# zoneshortname");
-	}
-	else {
-		auto                         pack = new ServerPacket(ServerOP_ZoneBootup, sizeof(ServerZoneStateChange_struct));
-		ServerZoneStateChange_struct *s   = (ServerZoneStateChange_struct *) pack->pBuffer;
-		s->ZoneServerID = Strings::ToInt(sep->arg[1]);
-		strcpy(s->adminname, c->GetName());
-		s->zoneid     = ZoneID(sep->arg[2]);
-		s->makestatic = (bool) (strcasecmp(sep->arg[3], "static") == 0);
-		worldserver.SendPacket(pack);
-		safe_delete(pack);
-	}
-}
 
+	if (!worldserver.Connected()) {
+		c->Message(Chat::White, "World server disconnected.");
+		return;
+	}
+
+	const uint32 zone_server_id = Strings::ToUnsignedInt(sep->arg[1]);
+	const uint32 zone_id        = Strings::IsNumber(sep->arg[2]) ? Strings::ToUnsignedInt(sep->arg[2]) : ZoneID(sep->arg[2]);
+	const bool   is_static      = arguments > 2 ? !strcasecmp(sep->arg[3], "static") : false;
+	const uint16 instance_id    = arguments > 3 ? static_cast<uint16>(Strings::ToUnsignedInt(sep->arg[4])) : 0;
+
+	if (!zone_id) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Zone '{}' does not exist.",
+				sep->arg[1]
+			).c_str()
+		);
+		return;
+	}
+
+	auto pack = new ServerPacket(ServerOP_ZoneBootup, sizeof(ServerZoneStateChange_Struct));
+	auto *s   = (ServerZoneStateChange_Struct *) pack->pBuffer;
+
+	s->zone_server_id = zone_server_id;
+	s->zone_id        = zone_id;
+	s->instance_id    = instance_id;
+	s->is_static      = is_static;
+
+	strn0cpy(s->admin_name, c->GetName(), sizeof(s->admin_name));
+
+	worldserver.SendPacket(pack);
+	safe_delete(pack);
+}

zone/gm_commands/zoneshutdown.cpp

@@ -5,26 +5,37 @@ extern WorldServer worldserver;
 
 void command_zoneshutdown(Client *c, const Seperator *sep)
 {
-	if (!worldserver.Connected()) {
-		c->Message(Chat::White, "Error: World server disconnected");
+	const int arguments = sep->argnum;
+	if (!arguments) {
+		c->Message(Chat::White, "Usage: #zoneshutdown [Zone ID|Zone Short Name]");
+		return;
 	}
-	else if (sep->arg[1][0] == 0) {
-		c->Message(Chat::White, "Usage: #zoneshutdown zoneshortname");
-	}
-	else {
-		auto                         pack = new ServerPacket(
-			ServerOP_ZoneShutdown,
-			sizeof(ServerZoneStateChange_struct));
-		ServerZoneStateChange_struct *s   = (ServerZoneStateChange_struct *) pack->pBuffer;
-		strcpy(s->adminname, c->GetName());
-		if (sep->arg[1][0] >= '0' && sep->arg[1][0] <= '9') {
-			s->ZoneServerID = Strings::ToInt(sep->arg[1]);
-		}
-		else {
-			s->zoneid = ZoneID(sep->arg[1]);
-		}
-		worldserver.SendPacket(pack);
-		safe_delete(pack);
-	}
-}
 
+	if (!worldserver.Connected()) {
+		c->Message(Chat::White, "World server disconnected.");
+		return;
+	}
+
+	const uint32 zone_id = sep->IsNumber(1) ? Strings::ToUnsignedInt(sep->arg[1]) : ZoneID(sep->arg[1]);
+
+	if (!zone_id) {
+		c->Message(
+			Chat::White,
+			fmt::format(
+				"Zone '{}' does not exist.",
+				sep->arg[1]
+			).c_str()
+		);
+		return;
+	}
+
+	auto pack = new ServerPacket(ServerOP_ZoneShutdown, sizeof(ServerZoneStateChange_Struct));
+	auto *s   = (ServerZoneStateChange_Struct *) pack->pBuffer;
+
+	s->zone_id = zone_id;
+
+	strn0cpy(s->admin_name, c->GetName(), sizeof(s->admin_name));
+
+	worldserver.SendPacket(pack);
+	safe_delete(pack);
+}

zone/groups.cpp

@@ -2510,3 +2510,9 @@ bool Group::IsLeader(const char* name) {
 
 	return false;
 }
+
+std::string Group::GetGroupLeaderName(uint32 group_id) {
+	char leader_name_buffer[64] = { 0 };
+	database.GetGroupLeadershipInfo(group_id, leader_name_buffer);
+	return std::string(leader_name_buffer);
+}

zone/groups.h

@@ -76,7 +76,7 @@ public:
 	void	SplitMoney(uint32 copper, uint32 silver, uint32 gold, uint32 platinum, Client *splitter = nullptr);
 	inline	void SetLeader(Mob* c){ leader = c; };
 	inline	Mob* GetLeader() { return leader; };
-	const char*	GetLeaderName() { return membername[0]; };
+	const char*	GetLeaderName() { return GetGroupLeaderName(GetID()).c_str(); };
 	void	SendHPManaEndPacketsTo(Mob* newmember);
 	void	SendHPPacketsFrom(Mob* member);
 	void	SendManaPacketFrom(Mob* member);
@@ -177,6 +177,8 @@ private:
 	int mentor_percent;
 
 	XTargetAutoHaters m_autohatermgr;
+
+	std::string GetGroupLeaderName(uint32 group_id);
 };
 
 #endif

zone/heal_rotation.cpp

@@ -600,7 +600,7 @@ bool HealRotation::healable_target(bool use_class_at, bool critical_only)
 			return false;
 		if (healable_target->GetHPRatio() > m_safe_hp_ratio[ClassArmorType(healable_target->GetClass())])
 			return false;
-		if (healable_target->IsBerserk() && (healable_target->GetClass() == WARRIOR || healable_target->GetClass() == BERSERKER)) {
+		if (healable_target->IsBerserk() && (healable_target->GetClass() == Class::Warrior || healable_target->GetClass() == Class::Berserker)) {
 			if (healable_target->GetHPRatio() <= RuleI(Combat, BerserkerFrenzyEnd) && healable_target->GetHPRatio() > m_critical_hp_ratio[ClassArmorType(healable_target->GetClass())])
 				return false;
 		}
@@ -610,7 +610,7 @@ bool HealRotation::healable_target(bool use_class_at, bool critical_only)
 			return false;
 		if (healable_target->GetHPRatio() > SAFE_HP_RATIO_BASE)
 			return false;
-		if (healable_target->IsBerserk() && (healable_target->GetClass() == WARRIOR || healable_target->GetClass() == BERSERKER)) {
+		if (healable_target->IsBerserk() && (healable_target->GetClass() == Class::Warrior || healable_target->GetClass() == Class::Berserker)) {
 			if (healable_target->GetHPRatio() <= RuleI(Combat, BerserkerFrenzyEnd) && healable_target->GetHPRatio() > CRITICAL_HP_RATIO_BASE)
 				return false;
 		}
@@ -938,9 +938,9 @@ void HealRotation::validate_hot()
 bool IsHealRotationMemberClass(uint8 class_id)
 {
 	switch (class_id) {
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
+	case Class::Cleric:
+	case Class::Druid:
+	case Class::Shaman:
 		return true;
 	default:
 		return false;

zone/lua_general.cpp

@@ -5431,7 +5431,7 @@ void lua_create_npc(luabind::adl::object table, float x, float y, float z, float
 	LuaCreateNPCParse(runspeed, float, 1.25f);
 	LuaCreateNPCParse(gender, uint8, 0);
 	LuaCreateNPCParse(race, uint16, 1);
-	LuaCreateNPCParse(class_, uint8, WARRIOR);
+	LuaCreateNPCParse(class_, uint8, Class::Warrior);
 	LuaCreateNPCParse(bodytype, uint8, 0);
 	LuaCreateNPCParse(deity, uint8, 0);
 	LuaCreateNPCParse(level, uint8, 1);
@@ -6778,51 +6778,52 @@ luabind::scope lua_register_classes() {
 	return luabind::class_<Classes>("Class")
 		.enum_("constants")
 		[(
-			luabind::value("WARRIOR", WARRIOR),
-			luabind::value("CLERIC", CLERIC),
-			luabind::value("PALADIN", PALADIN),
-			luabind::value("RANGER", RANGER),
-			luabind::value("SHADOWKNIGHT", SHADOWKNIGHT),
-			luabind::value("DRUID", DRUID),
-			luabind::value("MONK", MONK),
-			luabind::value("BARD", BARD),
-			luabind::value("ROGUE", ROGUE),
-			luabind::value("SHAMAN", SHAMAN),
-			luabind::value("NECROMANCER", NECROMANCER),
-			luabind::value("WIZARD", WIZARD),
-			luabind::value("MAGICIAN", MAGICIAN),
-			luabind::value("ENCHANTER", ENCHANTER),
-			luabind::value("BEASTLORD", BEASTLORD),
-			luabind::value("BERSERKER", BERSERKER),
-			luabind::value("WARRIORGM", WARRIORGM),
-			luabind::value("CLERICGM", CLERICGM),
-			luabind::value("PALADINGM", PALADINGM),
-			luabind::value("RANGERGM", RANGERGM),
-			luabind::value("SHADOWKNIGHTGM", SHADOWKNIGHTGM),
-			luabind::value("DRUIDGM", DRUIDGM),
-			luabind::value("MONKGM", MONKGM),
-			luabind::value("BARDGM", BARDGM),
-			luabind::value("ROGUEGM", ROGUEGM),
-			luabind::value("SHAMANGM", SHAMANGM),
-			luabind::value("NECROMANCERGM", NECROMANCERGM),
-			luabind::value("WIZARDGM", WIZARDGM),
-			luabind::value("MAGICIANGM", MAGICIANGM),
-			luabind::value("ENCHANTERGM", ENCHANTERGM),
-			luabind::value("BEASTLORDGM", BEASTLORDGM),
-			luabind::value("BERSERKERGM", BERSERKERGM),
-			luabind::value("BANKER", BANKER),
-			luabind::value("MERCHANT", MERCHANT),
-			luabind::value("DISCORD_MERCHANT", DISCORD_MERCHANT),
-			luabind::value("ADVENTURE_RECRUITER", ADVENTURE_RECRUITER),
-			luabind::value("ADVENTURE_MERCHANT", ADVENTURE_MERCHANT),
-			luabind::value("LDON_TREASURE", LDON_TREASURE),
-			luabind::value("TRIBUTE_MASTER", TRIBUTE_MASTER),
-			luabind::value("GUILD_TRIBUTE_MASTER", GUILD_TRIBUTE_MASTER),
-			luabind::value("NORRATHS_KEEPERS_MERCHANT", NORRATHS_KEEPERS_MERCHANT),
-			luabind::value("DARK_REIGN_MERCHANT", DARK_REIGN_MERCHANT),
-			luabind::value("FELLOWSHIP_MASTER", FELLOWSHIP_MASTER),
-			luabind::value("ALT_CURRENCY_MERCHANT", ALT_CURRENCY_MERCHANT),
-			luabind::value("MERCENARY_MASTER", MERCENARY_MASTER)
+			luabind::value("WARRIOR", Class::Warrior),
+			luabind::value("CLERIC", Class::Cleric),
+			luabind::value("PALADIN", Class::Paladin),
+			luabind::value("RANGER", Class::Ranger),
+			luabind::value("SHADOWKNIGHT", Class::ShadowKnight),
+			luabind::value("DRUID", Class::Druid),
+			luabind::value("MONK", Class::Monk),
+			luabind::value("BARD", Class::Bard),
+			luabind::value("ROGUE", Class::Rogue),
+			luabind::value("SHAMAN", Class::Shaman),
+			luabind::value("NECROMANCER", Class::Necromancer),
+			luabind::value("WIZARD", Class::Wizard),
+			luabind::value("MAGICIAN", Class::Magician),
+			luabind::value("ENCHANTER", Class::Enchanter),
+			luabind::value("BEASTLORD", Class::Beastlord),
+			luabind::value("BERSERKER", Class::Berserker),
+			luabind::value("WARRIORGM", Class::WarriorGM),
+			luabind::value("CLERICGM", Class::ClericGM),
+			luabind::value("PALADINGM", Class::PaladinGM),
+			luabind::value("RANGERGM", Class::RangerGM),
+			luabind::value("SHADOWKNIGHTGM", Class::ShadowKnightGM),
+			luabind::value("DRUIDGM", Class::DruidGM),
+			luabind::value("MONKGM", Class::MonkGM),
+			luabind::value("BARDGM", Class::BardGM),
+			luabind::value("ROGUEGM", Class::RogueGM),
+			luabind::value("SHAMANGM", Class::ShamanGM),
+			luabind::value("NECROMANCERGM", Class::NecromancerGM),
+			luabind::value("WIZARDGM", Class::WizardGM),
+			luabind::value("MAGICIANGM", Class::MagicianGM),
+			luabind::value("ENCHANTERGM", Class::EnchanterGM),
+			luabind::value("BEASTLORDGM", Class::BeastlordGM),
+			luabind::value("BERSERKERGM", Class::BerserkerGM),
+			luabind::value("BANKER", Class::Banker),
+			luabind::value("MERCHANT", Class::Merchant),
+			luabind::value("DISCORD_MERCHANT", Class::DiscordMerchant),
+			luabind::value("ADVENTURE_RECRUITER", Class::AdventureRecruiter),
+			luabind::value("ADVENTURE_MERCHANT", Class::AdventureMerchant),
+			luabind::value("LDON_TREASURE", Class::LDoNTreasure),
+			luabind::value("TRIBUTE_MASTER", Class::TributeMaster),
+			luabind::value("GUILD_TRIBUTE_MASTER", Class::GuildTributeMaster),
+			luabind::value("GUILD_BANKER", Class::GuildBanker),
+			luabind::value("NORRATHS_KEEPERS_MERCHANT", Class::NorrathsKeepersMerchant),
+			luabind::value("DARK_REIGN_MERCHANT", Class::DarkReignMerchant),
+			luabind::value("FELLOWSHIP_MASTER", Class::FellowshipMaster),
+			luabind::value("ALT_CURRENCY_MERCHANT", Class::AlternateCurrencyMerchant),
+			luabind::value("MERCENARY_MASTER", Class::MercenaryLiaison)
 		)];
 }
 

zone/lua_mob.cpp

@@ -285,6 +285,11 @@ void Lua_Mob::GMMove(double x, double y, double z, double heading) {
 	self->GMMove(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(heading));
 }
 
+void Lua_Mob::GMMove(double x, double y, double z, double heading, bool save_guard_spot) {
+	Lua_Safe_Call_Void();
+	self->GMMove(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(heading), save_guard_spot);
+}
+
 void Lua_Mob::TryMoveAlong(float distance, float angle) {
 	Lua_Safe_Call_Void();
 	self->TryMoveAlong(distance, angle);
@@ -3350,6 +3355,7 @@ luabind::scope lua_register_mob() {
 	.def("FindType", (bool(Lua_Mob::*)(int,bool,int))&Lua_Mob::FindType)
 	.def("GMMove", (void(Lua_Mob::*)(double,double,double))&Lua_Mob::GMMove)
 	.def("GMMove", (void(Lua_Mob::*)(double,double,double,double))&Lua_Mob::GMMove)
+	.def("GMMove", (void(Lua_Mob::*)(double,double,double,double,bool))&Lua_Mob::GMMove)
 	.def("GetAA", (int(Lua_Mob::*)(int))&Lua_Mob::GetAA)
 	.def("GetAABonuses", &Lua_Mob::GetAABonuses)
 	.def("GetAAByAAID", (int(Lua_Mob::*)(int))&Lua_Mob::GetAAByAAID)

zone/lua_mob.h

@@ -80,6 +80,7 @@ public:
 	bool RandomizeFeatures(bool send_illusion, bool save_variables);
 	void GMMove(double x, double y, double z);
 	void GMMove(double x, double y, double z, double heading);
+	void GMMove(double x, double y, double z, double heading, bool save_guard_spot);
 	void TryMoveAlong(float distance, float heading);
 	void TryMoveAlong(float distance, float heading, bool send);
 	bool HasProcs();

zone/merc.cpp

@@ -60,7 +60,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
 	SetStance(EQ::constants::stanceBalanced);
 	rest_timer.Disable();
 
-	if (GetClass() == ROGUE)
+	if (GetClass() == Class::Rogue)
 		evade_timer.Start();
 
 	int r;
@@ -1090,7 +1090,7 @@ void Merc::AI_Process() {
 
 		float meleeDistance = GetMaxMeleeRangeToTarget(GetTarget());
 
-		if(GetClass() == SHADOWKNIGHT || GetClass() == PALADIN || GetClass() == WARRIOR) {
+		if(GetClass() == Class::ShadowKnight || GetClass() == Class::Paladin || GetClass() == Class::Warrior) {
 			meleeDistance = meleeDistance * .30;
 		}
 		else {
@@ -1118,7 +1118,7 @@ void Merc::AI_Process() {
 
 			if(AI_movement_timer->Check()) {
 				if (!IsMoving()) {
-					if (GetClass() == ROGUE) {
+					if (GetClass() == Class::Rogue) {
 						if (HasTargetReflection() && !GetTarget()->IsFeared() && !GetTarget()->IsStunned()) {
 							// Hate redux actions
 							if (evade_timer.Check(false)) {
@@ -1161,7 +1161,7 @@ void Merc::AI_Process() {
 							}
 						}
 					}
-					else if (GetClass() != ROGUE && (DistanceSquaredNoZ(m_Position, GetTarget()->GetPosition()) < GetTarget()->GetSize())) {
+					else if (GetClass() != Class::Rogue && (DistanceSquaredNoZ(m_Position, GetTarget()->GetPosition()) < GetTarget()->GetSize())) {
 						// If we are not a rogue trying to backstab, let's try to adjust our melee range so we don't appear to be bunched up
 						float newX = 0;
 						float newY = 0;
@@ -1240,7 +1240,7 @@ void Merc::AI_Process() {
 				}
 
 				// TODO: Do mercs berserk? Find this out on live...
-				//if (GetClass() == WARRIOR || GetClass() == BERSERKER) {
+				//if (GetClass() == Class::Warrior || GetClass() == Class::Berserker) {
 				//      if(GetHP() > 0 && !berserk && GetHPRatio() < 30) {
 				//              entity_list.MessageCloseString(this, false, 200, 0, BERSERK_START, GetName());
 				//              berserk = true;
@@ -1685,8 +1685,8 @@ bool Merc::AICastSpell(int8 iChance, uint32 iSpellTypes) {
 											continue;
 										}
 
-										if(IsEngaged() && (g->members[i]->GetClass() == NECROMANCER && hpr >= 50)
-											|| (g->members[i]->GetClass() == SHAMAN && hpr >= 80)) {
+										if(IsEngaged() && (g->members[i]->GetClass() == Class::Necromancer && hpr >= 50)
+											|| (g->members[i]->GetClass() == Class::Shaman && hpr >= 80)) {
 												//allow necros to lifetap & shaman to canni without wasting mana
 												continue;
 										}

zone/mob.cpp

@@ -515,6 +515,7 @@ Mob::Mob(
 
 	is_boat = IsBoat();
 
+	current_alliance_faction = -1;
 }
 
 Mob::~Mob()
@@ -982,33 +983,33 @@ int64 Mob::GetSpellHPBonuses() {
 char Mob::GetCasterClass() const {
 	switch(class_)
 	{
-	case CLERIC:
-	case PALADIN:
-	case RANGER:
-	case DRUID:
-	case SHAMAN:
-	case BEASTLORD:
-	case CLERICGM:
-	case PALADINGM:
-	case RANGERGM:
-	case DRUIDGM:
-	case SHAMANGM:
-	case BEASTLORDGM:
+	case Class::Cleric:
+	case Class::Paladin:
+	case Class::Ranger:
+	case Class::Druid:
+	case Class::Shaman:
+	case Class::Beastlord:
+	case Class::ClericGM:
+	case Class::PaladinGM:
+	case Class::RangerGM:
+	case Class::DruidGM:
+	case Class::ShamanGM:
+	case Class::BeastlordGM:
 		return 'W';
 		break;
 
-	case SHADOWKNIGHT:
-	case BARD:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-	case SHADOWKNIGHTGM:
-	case BARDGM:
-	case NECROMANCERGM:
-	case WIZARDGM:
-	case MAGICIANGM:
-	case ENCHANTERGM:
+	case Class::ShadowKnight:
+	case Class::Bard:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
+	case Class::ShadowKnightGM:
+	case Class::BardGM:
+	case Class::NecromancerGM:
+	case Class::WizardGM:
+	case Class::MagicianGM:
+	case Class::EnchanterGM:
 		return 'I';
 		break;
 
@@ -1021,42 +1022,42 @@ char Mob::GetCasterClass() const {
 uint8 Mob::GetArchetype() const {
 	switch(class_)
 	{
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case BARD:
-	case BEASTLORD:
-	case PALADINGM:
-	case RANGERGM:
-	case SHADOWKNIGHTGM:
-	case BARDGM:
-	case BEASTLORDGM:
+	case Class::Paladin:
+	case Class::Ranger:
+	case Class::ShadowKnight:
+	case Class::Bard:
+	case Class::Beastlord:
+	case Class::PaladinGM:
+	case Class::RangerGM:
+	case Class::ShadowKnightGM:
+	case Class::BardGM:
+	case Class::BeastlordGM:
 		return ARCHETYPE_HYBRID;
 		break;
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-	case CLERICGM:
-	case DRUIDGM:
-	case SHAMANGM:
-	case NECROMANCERGM:
-	case WIZARDGM:
-	case MAGICIANGM:
-	case ENCHANTERGM:
+	case Class::Cleric:
+	case Class::Druid:
+	case Class::Shaman:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
+	case Class::ClericGM:
+	case Class::DruidGM:
+	case Class::ShamanGM:
+	case Class::NecromancerGM:
+	case Class::WizardGM:
+	case Class::MagicianGM:
+	case Class::EnchanterGM:
 		return ARCHETYPE_CASTER;
 		break;
-	case WARRIOR:
-	case MONK:
-	case ROGUE:
-	case BERSERKER:
-	case WARRIORGM:
-	case MONKGM:
-	case ROGUEGM:
-	case BERSERKERGM:
+	case Class::Warrior:
+	case Class::Monk:
+	case Class::Rogue:
+	case Class::Berserker:
+	case Class::WarriorGM:
+	case Class::MonkGM:
+	case Class::RogueGM:
+	case Class::BerserkerGM:
 		return ARCHETYPE_MELEE;
 		break;
 	default:
@@ -1068,73 +1069,73 @@ uint8 Mob::GetArchetype() const {
 void Mob::SetSpawnLastNameByClass(NewSpawn_Struct* ns)
 {
 	switch (ns->spawn.class_) {
-		case TRIBUTE_MASTER:
+		case Class::TributeMaster:
 			strcpy(ns->spawn.lastName, "Tribute Master");
 			break;
-		case GUILD_TRIBUTE_MASTER:
+		case Class::GuildTributeMaster:
 			strcpy(ns->spawn.lastName, "Guild Tribute Master");
 			break;
-		case GUILD_BANKER:
+		case Class::GuildBanker:
 			strcpy(ns->spawn.lastName, "Guild Banker");
 			break;
-		case ADVENTURE_RECRUITER:
+		case Class::AdventureRecruiter:
 			strcpy(ns->spawn.lastName, "Adventure Recruiter");
 			break;
-		case ADVENTURE_MERCHANT:
+		case Class::AdventureMerchant:
 			strcpy(ns->spawn.lastName, "Adventure Merchant");
 			break;
-		case BANKER:
+		case Class::Banker:
 			strcpy(ns->spawn.lastName, "Banker");
 			break;
-		case WARRIORGM:
+		case Class::WarriorGM:
 			strcpy(ns->spawn.lastName, "Warrior Guildmaster");
 			break;
-		case CLERICGM:
+		case Class::ClericGM:
 			strcpy(ns->spawn.lastName, "Cleric Guildmaster");
 			break;
-		case PALADINGM:
+		case Class::PaladinGM:
 			strcpy(ns->spawn.lastName, "Paladin Guildmaster");
 			break;
-		case RANGERGM:
+		case Class::RangerGM:
 			strcpy(ns->spawn.lastName, "Ranger Guildmaster");
 			break;
-		case SHADOWKNIGHTGM:
+		case Class::ShadowKnightGM:
 			strcpy(ns->spawn.lastName, "Shadow Knight Guildmaster");
 			break;
-		case DRUIDGM:
+		case Class::DruidGM:
 			strcpy(ns->spawn.lastName, "Druid Guildmaster");
 			break;
-		case MONKGM:
+		case Class::MonkGM:
 			strcpy(ns->spawn.lastName, "Monk Guildmaster");
 			break;
-		case BARDGM:
+		case Class::BardGM:
 			strcpy(ns->spawn.lastName, "Bard Guildmaster");
 			break;
-		case ROGUEGM:
+		case Class::RogueGM:
 			strcpy(ns->spawn.lastName, "Rogue Guildmaster");
 			break;
-		case SHAMANGM:
+		case Class::ShamanGM:
 			strcpy(ns->spawn.lastName, "Shaman Guildmaster");
 			break;
-		case NECROMANCERGM:
+		case Class::NecromancerGM:
 			strcpy(ns->spawn.lastName, "Necromancer Guildmaster");
 			break;
-		case WIZARDGM:
+		case Class::WizardGM:
 			strcpy(ns->spawn.lastName, "Wizard Guildmaster");
 			break;
-		case MAGICIANGM:
+		case Class::MagicianGM:
 			strcpy(ns->spawn.lastName, "Magician Guildmaster");
 			break;
-		case ENCHANTERGM:
+		case Class::EnchanterGM:
 			strcpy(ns->spawn.lastName, "Enchanter Guildmaster");
 			break;
-		case BEASTLORDGM:
+		case Class::BeastlordGM:
 			strcpy(ns->spawn.lastName, "Beastlord Guildmaster");
 			break;
-		case BERSERKERGM:
+		case Class::BerserkerGM:
 			strcpy(ns->spawn.lastName, "Berserker Guildmaster");
 			break;
-		case MERCENARY_MASTER:
+		case Class::MercenaryLiaison:
 			strcpy(ns->spawn.lastName, "Mercenary Liaison");
 			break;
 		default:
@@ -1345,8 +1346,8 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
 	}
 
 	if (RuleB(Character, AllowCrossClassTrainers) && ForWho) {
-		if (ns->spawn.class_ >= WARRIORGM && ns->spawn.class_ <= BERSERKERGM) {
-			int trainer_class = WARRIORGM + (ForWho->GetClass() - 1);
+		if (ns->spawn.class_ >= Class::WarriorGM && ns->spawn.class_ <= Class::BerserkerGM) {
+			int trainer_class = Class::WarriorGM + (ForWho->GetClass() - 1);
 			ns->spawn.class_ = trainer_class;
 		}
 	}
@@ -2117,7 +2118,7 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 
 	std::string bard_info;
 
-	if (GetClass() == BARD) {
+	if (GetClass() == Class::Bard) {
 		const auto brass_mod  = IsBot() ? CastToBot()->GetBrassMod() : CastToClient()->GetBrassMod();
 		const auto perc_mod   = IsBot() ? CastToBot()->GetPercMod() : CastToClient()->GetPercMod();
 		const auto sing_mod   = IsBot() ? CastToBot()->GetSingMod() : CastToClient()->GetSingMod();
@@ -2418,7 +2419,7 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 	}
 
 	// Bard Modifiers
-	if (GetClass() == BARD) {
+	if (GetClass() == Class::Bard) {
 		final_string += bard_info + DialogueWindow::Break(1);
 	}
 
@@ -2687,7 +2688,7 @@ void Mob::SendStatsWindow(Client* c, bool use_window)
 		);
 	}
 
-	if (GetClass() == BARD) {
+	if (GetClass() == Class::Bard) {
 		const auto brass_mod  = IsBot() ? CastToBot()->GetBrassMod() : CastToClient()->GetBrassMod();
 		const auto perc_mod   = IsBot() ? CastToBot()->GetPercMod() : CastToClient()->GetPercMod();
 		const auto sing_mod   = IsBot() ? CastToBot()->GetSingMod() : CastToClient()->GetSingMod();
@@ -4530,7 +4531,7 @@ bool Mob::CanThisClassDualWield(void) const {
 
 		// Dual-Wielding Empty Fists
 		if(!pinst && !sinst)
-			if(class_ != MONK && class_ != MONKGM && class_ != BEASTLORD && class_ != BEASTLORDGM)
+			if(class_ != Class::Monk && class_ != Class::MonkGM && class_ != Class::Beastlord && class_ != Class::BeastlordGM)
 				return false;
 
 		return true;
@@ -4563,24 +4564,24 @@ bool Mob::IsWarriorClass(void) const
 {
 	switch(GetClass())
 	{
-	case WARRIOR:
-	case WARRIORGM:
-	case ROGUE:
-	case ROGUEGM:
-	case MONK:
-	case MONKGM:
-	case PALADIN:
-	case PALADINGM:
-	case SHADOWKNIGHT:
-	case SHADOWKNIGHTGM:
-	case RANGER:
-	case RANGERGM:
-	case BEASTLORD:
-	case BEASTLORDGM:
-	case BERSERKER:
-	case BERSERKERGM:
-	case BARD:
-	case BARDGM:
+	case Class::Warrior:
+	case Class::WarriorGM:
+	case Class::Rogue:
+	case Class::RogueGM:
+	case Class::Monk:
+	case Class::MonkGM:
+	case Class::Paladin:
+	case Class::PaladinGM:
+	case Class::ShadowKnight:
+	case Class::ShadowKnightGM:
+	case Class::Ranger:
+	case Class::RangerGM:
+	case Class::Beastlord:
+	case Class::BeastlordGM:
+	case Class::Berserker:
+	case Class::BerserkerGM:
+	case Class::Bard:
+	case Class::BardGM:
 		{
 			return true;
 		}
@@ -5184,7 +5185,7 @@ int32 Mob::GetActSpellCasttime(uint16 spell_id, int32 casttime)
 	int32 cast_reducer_no_limit = GetFocusEffect(focusFcCastTimeMod2, spell_id);
 
 	if (level > 50 && casttime >= 3000 && !spells[spell_id].good_effect &&
-	    (GetClass() == RANGER || GetClass() == SHADOWKNIGHT || GetClass() == PALADIN || GetClass() == BEASTLORD)) {
+	    (GetClass() == Class::Ranger || GetClass() == Class::ShadowKnight || GetClass() == Class::Paladin || GetClass() == Class::Beastlord)) {
 		int level_mod = std::min(15, GetLevel() - 50);
 		cast_reducer += level_mod * 3;
 	}
@@ -7126,24 +7127,10 @@ int8 Mob::GetDecayEffectValue(uint16 spell_id, uint16 spelleffect) {
 	return effect_value;
 }
 
-// Faction Mods for Alliance type spells
+// Faction Mods for Alliance type spells (only 1 ever active)
 void Mob::AddFactionBonus(uint32 pFactionID,int32 bonus) {
-	std::map <uint32, int32> :: const_iterator faction_bonus;
-	typedef std::pair <uint32, int32> NewFactionBonus;
-
-	faction_bonus = faction_bonuses.find(pFactionID);
-	if(faction_bonus == faction_bonuses.end())
-	{
-		faction_bonuses.emplace(NewFactionBonus(pFactionID,bonus));
-	}
-	else
-	{
-		if(faction_bonus->second<bonus)
-		{
-			faction_bonuses.erase(pFactionID);
-			faction_bonuses.emplace(NewFactionBonus(pFactionID,bonus));
-		}
-	}
+	current_alliance_faction = pFactionID;
+	current_alliance_mod = bonus;
 }
 
 // Faction Mods from items
@@ -7167,11 +7154,9 @@ void Mob::AddItemFactionBonus(uint32 pFactionID,int32 bonus) {
 }
 
 int32 Mob::GetFactionBonus(uint32 pFactionID) {
-	std::map <uint32, int32> :: const_iterator faction_bonus;
-	faction_bonus = faction_bonuses.find(pFactionID);
-	if(faction_bonus != faction_bonuses.end())
+	if(current_alliance_faction == pFactionID)
 	{
-		return (*faction_bonus).second;
+		return current_alliance_mod;
 	}
 	return 0;
 }
@@ -7535,29 +7520,23 @@ int32 Mob::GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot)
 
 bool Mob::CanClassEquipItem(uint32 item_id)
 {
-	const EQ::ItemData* itm = nullptr;
-	itm = database.GetItem(item_id);
-
-	if (!itm) {
+	const auto *item = database.GetItem(item_id);
+	if (!item) {
 		return false;
 	}
 
-	auto item_classes = itm->Classes;
-	if(item_classes == PLAYER_CLASS_ALL_MASK) {
+	const uint16 item_classes = item->Classes;
+	if (item_classes == Class::ALL_CLASSES_BITMASK) {
 		return true;
 	}
 
-	auto class_id = GetClass();
-	if (class_id > BERSERKER) {
+	const uint8 class_id = GetClass();
+	if (!IsPlayerClass(class_id)) {
 		return false;
 	}
 
-	int class_bitmask = GetPlayerClassBit(class_id);
-	if(!(item_classes & class_bitmask)) {
-		return false;
-	} else {
-		return true;
-	}
+	const uint16 class_bitmask = GetPlayerClassBit(class_id);
+	return (item_classes & class_bitmask);
 }
 
 bool Mob::CanRaceEquipItem(uint32 item_id)
@@ -8279,37 +8258,37 @@ std::string Mob::GetRacePlural()
 std::string Mob::GetClassPlural()
 {
 	switch (GetClass()) {
-		case WARRIOR:
+		case Class::Warrior:
 			return "Warriors";
-		case CLERIC:
+		case Class::Cleric:
 			return "Clerics";
-		case PALADIN:
+		case Class::Paladin:
 			return "Paladins";
-		case RANGER:
+		case Class::Ranger:
 			return "Rangers";
-		case SHADOWKNIGHT:
-			return "Shadowknights";
-		case DRUID:
+		case Class::ShadowKnight:
+			return fmt::format("{}s", shadow_knight_class_name);
+		case Class::Druid:
 			return "Druids";
-		case MONK:
+		case Class::Monk:
 			return "Monks";
-		case BARD:
+		case Class::Bard:
 			return "Bards";
-		case ROGUE:
+		case Class::Rogue:
 			return "Rogues";
-		case SHAMAN:
+		case Class::Shaman:
 			return "Shamans";
-		case NECROMANCER:
+		case Class::Necromancer:
 			return "Necromancers";
-		case WIZARD:
+		case Class::Wizard:
 			return "Wizards";
-		case MAGICIAN:
+		case Class::Magician:
 			return "Magicians";
-		case ENCHANTER:
+		case Class::Enchanter:
 			return "Enchanters";
-		case BEASTLORD:
+		case Class::Beastlord:
 			return "Beastlords";
-		case BERSERKER:
+		case Class::Berserker:
 			return "Berserkers";
 		default:
 			return "Classes";

zone/mob.h

@@ -1774,8 +1774,9 @@ protected:
 	uint32 time_until_can_move;
 	HateList hate_list;
 	std::set<uint32> feign_memory_list;
-	// This is to keep track of mobs we cast faction mod spells on
-	std::map<uint32,int32> faction_bonuses; // Primary FactionID, Bonus
+	// This is to keep track of the current (one only) faction mod (alliance)
+	uint32 current_alliance_faction;
+	int32 current_alliance_mod;
 	void AddFactionBonus(uint32 pFactionID,int32 bonus);
 	int32 GetFactionBonus(uint32 pFactionID);
 	// This is to keep track of item faction modifiers

zone/mob_ai.cpp

@@ -1062,10 +1062,15 @@ void Mob::AI_Process() {
 			SetTarget(hate_list.GetClosestEntOnHateList(this));
 		else {
 			if (AI_target_check_timer->Check()) {
-				if (IsNPC() && (!IsPet() || (HasOwner() && GetOwner()->IsNPC())) && !CastToNPC()->WillAggroNPCs()) {
+				if (
+					IsNPC() &&
+					!CastToNPC()->GetSwarmInfo() &&
+					(!IsPet() || (HasOwner() && GetOwner()->IsNPC())) &&
+					!CastToNPC()->WillAggroNPCs()
+				) {
 					WipeHateList(true); // wipe NPCs from hate list to prevent faction war
 				}
-				
+
 				if (IsFocused()) {
 					if (!target) {
 						SetTarget(hate_list.GetEntWithMostHateOnList(this));
@@ -1293,7 +1298,7 @@ void Mob::AI_Process() {
 							if (cur > 0) {
 								opts.range_percent = cur;
 							}
-							
+
 							AreaRampage(&opts);
 							specialed = true;
 						}
@@ -1325,7 +1330,7 @@ void Mob::AI_Process() {
 				// Now pursue
 				// TODO: Check here for another person on hate list with close hate value
 				if (AI_PursueCastCheck()) {
-					if (IsCasting() && GetClass() != BARD) {
+					if (IsCasting() && GetClass() != Class::Bard) {
 						StopNavigation();
 						FaceTarget();
 					}
@@ -1377,7 +1382,7 @@ void Mob::AI_Process() {
 			}
 		}
 		if (AI_IdleCastCheck()) {
-			if (IsCasting() && GetClass() != BARD) {
+			if (IsCasting() && GetClass() != Class::Bard) {
 				StopNavigation();
 			}
 		}

zone/npc.cpp

@@ -245,12 +245,12 @@ NPC::NPC(const NPCType *npc_type_data, Spawn2 *in_respawn, const glm::vec4 &posi
 
 	MerchantType          = npc_type_data->merchanttype;
 	merchant_open         = (
-		GetClass() == MERCHANT ||
-		GetClass() == DISCORD_MERCHANT ||
-		GetClass() == ADVENTURE_MERCHANT ||
-		GetClass() == NORRATHS_KEEPERS_MERCHANT ||
-		GetClass() == DARK_REIGN_MERCHANT ||
-		GetClass() == ALT_CURRENCY_MERCHANT
+		GetClass() == Class::Merchant ||
+		GetClass() == Class::DiscordMerchant ||
+		GetClass() == Class::AdventureMerchant ||
+		GetClass() == Class::NorrathsKeepersMerchant ||
+		GetClass() == Class::DarkReignMerchant ||
+		GetClass() == Class::AlternateCurrencyMerchant
 	);
 	adventure_template_id = npc_type_data->adventure_template;
 	flymode               = iflymode;
@@ -294,7 +294,7 @@ NPC::NPC(const NPCType *npc_type_data, Spawn2 *in_respawn, const glm::vec4 &posi
 	innate_proc_spell_id = 0;
 	m_record_loot_stats  = false;
 
-	if (GetClass() == MERCENARY_MASTER && RuleB(Mercs, AllowMercs)) {
+	if (GetClass() == Class::MercenaryLiaison && RuleB(Mercs, AllowMercs)) {
 		LoadMercTypes();
 		LoadMercs();
 	}
@@ -364,10 +364,10 @@ NPC::NPC(const NPCType *npc_type_data, Spawn2 *in_respawn, const glm::vec4 &posi
 	// There are some known low level SHM/BST pets that do not follow this, which supports
 	// the theory of needing to be able to set skills for each mob separately
 	if (IsBot()) {
-		if (GetClass() != PALADIN && GetClass() != SHADOWKNIGHT) {
+		if (GetClass() != Class::Paladin && GetClass() != Class::ShadowKnight) {
 			knightattack_timer.Disable();
 		}
-		else if (GetClass() != MONK || GetLevel() < 10) {
+		else if (GetClass() != Class::Monk || GetLevel() < 10) {
 			monkattack_timer.Disable();
 		}
 	}

zone/npc_scale_manager.cpp

@@ -417,7 +417,7 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 	uint32 multiplier;
 
 	switch (npc_class) {
-		case WARRIOR: {
+		case Class::Warrior: {
 			if (level < 20) {
 				multiplier = 220;
 			}
@@ -444,9 +444,9 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 			}
 			break;
 		}
-		case DRUID:
-		case CLERIC:
-		case SHAMAN: {
+		case Class::Druid:
+		case Class::Cleric:
+		case Class::Shaman: {
 			if (level < 70) {
 				multiplier = 150;
 			}
@@ -455,9 +455,9 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 			}
 			break;
 		}
-		case BERSERKER:
-		case PALADIN:
-		case SHADOWKNIGHT: {
+		case Class::Berserker:
+		case Class::Paladin:
+		case Class::ShadowKnight: {
 			if (level < 35) {
 				multiplier = 210;
 			}
@@ -481,10 +481,10 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 			}
 			break;
 		}
-		case MONK:
-		case BARD:
-		case ROGUE:
-		case BEASTLORD: {
+		case Class::Monk:
+		case Class::Bard:
+		case Class::Rogue:
+		case Class::Beastlord: {
 			if (level < 51) {
 				multiplier = 180;
 			}
@@ -499,7 +499,7 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 			}
 			break;
 		}
-		case RANGER: {
+		case Class::Ranger: {
 			if (level < 58) {
 				multiplier = 200;
 			}
@@ -511,10 +511,10 @@ uint32 NpcScaleManager::GetClassLevelDamageMod(uint32 level, uint32 npc_class)
 			}
 			break;
 		}
-		case MAGICIAN:
-		case WIZARD:
-		case NECROMANCER:
-		case ENCHANTER: {
+		case Class::Magician:
+		case Class::Wizard:
+		case Class::Necromancer:
+		case Class::Enchanter: {
 			if (level < 70) {
 				multiplier = 120;
 			}

zone/object.cpp

@@ -40,19 +40,24 @@ extern EntityList entity_list;
 extern WorldServer worldserver;
 
 // Loading object from database
-Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst)
- : respawn_timer(0), decay_timer(300000)
+Object::Object(
+	uint32 id,
+	uint32 type,
+	uint32 icon,
+	const Object_Struct &object,
+	const EQ::ItemInstance *inst
+) : respawn_timer(0), decay_timer(300000)
 {
-
-	user = nullptr;
+	user      = nullptr;
 	last_user = nullptr;
 
 	// Initialize members
-	m_id = id;
-	m_type = type;
-	m_icon = icon;
-	m_inst = nullptr;
-	m_ground_spawn=false;
+	m_id           = id;
+	m_type         = type;
+	m_icon         = icon;
+	m_inst         = nullptr;
+	m_ground_spawn = false;
+
 	// Copy object data
 	memcpy(&m_data, &object, sizeof(Object_Struct));
 	if (inst) {
@@ -61,13 +66,14 @@ Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object,
 	} else {
 		decay_timer.Disable();
 	}
+
 	respawn_timer.Disable();
 
 	// Set drop_id to zero - it will be set when added to zone with SetID()
 	m_data.drop_id = 0;
-	m_data.size = object.size;
-	m_data.tilt_x = object.tilt_x;
-	m_data.tilt_y = object.tilt_y;
+	m_data.size    = object.size;
+	m_data.tilt_x  = object.tilt_x;
+	m_data.tilt_y  = object.tilt_y;
 
 	FixZ();
 }
@@ -85,7 +91,7 @@ Object::Object(const EQ::ItemInstance* inst, char* name,float max_x,float min_x,
 	m_min_y=min_y;
 	m_id	= 0;
 	m_inst	= (inst) ? inst->Clone() : nullptr;
-	m_type	= OT_DROPPEDITEM;
+	m_type	= ObjectTypes::Temporary;
 	m_icon	= 0;
 	m_ground_spawn = true;
 	decay_timer.Disable();
@@ -116,7 +122,7 @@ Object::Object(Client* client, const EQ::ItemInstance* inst)
 	// Initialize members
 	m_id	= 0;
 	m_inst	= (inst) ? inst->Clone() : nullptr;
-	m_type	= OT_DROPPEDITEM;
+	m_type	= ObjectTypes::Temporary;
 	m_icon	= 0;
 	m_ground_spawn = false;
 	// Set as much struct data as we can
@@ -179,7 +185,7 @@ Object::Object(const EQ::ItemInstance *inst, float x, float y, float z, float he
 	// Initialize members
 	m_id	= 0;
 	m_inst	= (inst) ? inst->Clone() : nullptr;
-	m_type	= OT_DROPPEDITEM;
+	m_type	= ObjectTypes::Temporary;
 	m_icon	= 0;
 	m_ground_spawn = false;
 	// Set as much struct data as we can
@@ -436,7 +442,7 @@ void Object::CreateDeSpawnPacket(EQApplicationPacket* app)
 }
 
 bool Object::Process(){
-	if(m_type == OT_DROPPEDITEM && decay_timer.Enabled() && decay_timer.Check()) {
+	if(m_type == ObjectTypes::Temporary && decay_timer.Enabled() && decay_timer.Check()) {
 		// Send click to all clients (removes entity on client)
 		auto outapp = new EQApplicationPacket(OP_ClickObject, sizeof(ClickObject_Struct));
 		ClickObject_Struct* click_object = (ClickObject_Struct*)outapp->pBuffer;
@@ -497,7 +503,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
 	if(m_ground_spawn) {//This is a Cool Groundspawn
 		respawn_timer.Start();
 	}
-	if (m_type == OT_DROPPEDITEM) {
+	if (m_type == ObjectTypes::Temporary) {
 		bool cursordelete = false;
 		bool duplicate_lore = false;
 		if (m_inst && sender) {
@@ -969,7 +975,7 @@ void Object::SetSize(float size)
 
 void Object::SetSolidType(uint16 solidtype)
 {
-	m_data.solidtype = solidtype;
+	m_data.solid_type = solidtype;
 	auto app = new EQApplicationPacket();
 	auto app2 = new EQApplicationPacket();
 	CreateDeSpawnPacket(app);
@@ -987,7 +993,7 @@ float Object::GetSize()
 
 uint16 Object::GetSolidType()
 {
-	return m_data.solidtype;
+	return m_data.solid_type;
 }
 
 const char* Object::GetModelName()

zone/object.h

@@ -73,8 +73,6 @@ IT10714_ACTORDEF=Augmentation Sealer
 IT10725_ACTORDEF=Shuriken
 */
 
-#define OT_DROPPEDITEM EQ::item::BagTypeLargeBag
-
 // Icon values:
 //0x0453 a pie
 //0x0454 cookies?
@@ -89,6 +87,51 @@ IT10725_ACTORDEF=Shuriken
 //0x045D is a hammer
 //0x045E is a wierd rope shape
 
+enum ObjectTypes {
+	StaticLocked = 0,
+	Temporary = 1,
+	ToolBox = 10,
+	Research = 11,
+	Mortar = 12,
+	SelfDusting = 13,
+	Baking1 = 14,
+	Baking2 = 15,
+	Tailoring = 16,
+	Forge = 17,
+	Fletching = 18,
+	BrewBarrel = 19,
+	Jewelcrafting = 20,
+	PotteryWheel = 21,
+	PotteryKiln = 22,
+	WizardResearch = 24,
+	MagicianResearch = 25,
+	NecromancerResearch = 26,
+	EnchanterResearch = 27,
+	Invalid1 = 28,
+	Invalid2 = 29,
+	Experimental = 30,
+	HighElfForge = 31,
+	DarkElfForge = 32,
+	OgreForge = 33,
+	DwarfForge = 34,
+	GnomeForge = 35,
+	BarbarianForge = 36,
+	IksarForge = 38,
+	HumanForge = 39,
+	HumanForge2 = 40,
+	HalflingTailoring = 41,
+	EruditeTailoring = 42,
+	WoodElfTailoring = 43,
+	WoodElfFletching = 44,
+	IksarPotteryWheel = 45,
+	TrollForge = 47,
+	WoodElfForge = 48,
+	HalflingForge = 49,
+	EruditeForge = 50,
+	AugmentationPool = 53,
+	StaticUnlocked = 255
+};
+
 class Object: public Entity
 {
 public:

zone/perl_mob.cpp

@@ -326,6 +326,11 @@ void Perl_Mob_GMMove(Mob* self, float x, float y, float z, float heading) // @ca
 	self->GMMove(x, y, z, heading);
 }
 
+void Perl_Mob_GMMove(Mob* self, float x, float y, float z, float heading, bool save_guard_spot) // @categories Script Utility
+{
+	self->GMMove(x, y, z, heading, save_guard_spot);
+}
+
 bool Perl_Mob_HasProcs(Mob* self) // @categories Stats and Attributes
 {
 	return self->HasProcs();
@@ -3469,6 +3474,7 @@ void perl_register_mob()
 	package.add("FindType", (bool(*)(Mob*, uint16_t, bool, uint16_t))&Perl_Mob_FindType);
 	package.add("GMMove", (void(*)(Mob*, float, float, float))&Perl_Mob_GMMove);
 	package.add("GMMove", (void(*)(Mob*, float, float, float, float))&Perl_Mob_GMMove);
+	package.add("GMMove", (void(*)(Mob*, float, float, float, float, bool))&Perl_Mob_GMMove);
 	package.add("Gate", &Perl_Mob_Gate);
 	package.add("GetAA", &Perl_Mob_GetAA);
 	package.add("GetAABonuses", &Perl_Mob_GetAABonuses);

zone/petitions.cpp

@@ -70,7 +70,7 @@ void Petition::SendPetitionToPlayer(Client* clientto) {
 Petition::Petition(uint32 id)
 {
 	petid = id;
-	charclass = NO_CLASS;
+	charclass = Class::None;
 	charrace = RACE_DOUG_0;
 	charlevel = 0;
 	checkouts = 0;

zone/questmgr.cpp

@@ -1029,10 +1029,10 @@ bool QuestManager::isdisctome(uint32 item_id) {
 
 	//we know for sure none of the int casters get disciplines
 	uint32 class_bit = 0;
-	class_bit |= 1 << (WIZARD - 1);
-	class_bit |= 1 << (ENCHANTER - 1);
-	class_bit |= 1 << (MAGICIAN - 1);
-	class_bit |= 1 << (NECROMANCER - 1);
+	class_bit |= 1 << (Class::Wizard - 1);
+	class_bit |= 1 << (Class::Enchanter - 1);
+	class_bit |= 1 << (Class::Magician - 1);
+	class_bit |= 1 << (Class::Necromancer - 1);
 	if (item->Classes & class_bit) {
 		return false;
 	}
@@ -1045,10 +1045,10 @@ bool QuestManager::isdisctome(uint32 item_id) {
 	//we know for sure none of the int casters get disciplines
 	const auto& spell = spells[spell_id];
 	if(
-		spell.classes[WIZARD - 1] != 255 &&
-		spell.classes[ENCHANTER - 1] != 255 &&
-		spell.classes[MAGICIAN - 1] != 255 &&
-		spell.classes[NECROMANCER - 1] != 255
+		spell.classes[Class::Wizard - 1] != 255 &&
+		spell.classes[Class::Enchanter - 1] != 255 &&
+		spell.classes[Class::Magician - 1] != 255 &&
+		spell.classes[Class::Necromancer - 1] != 255
 	) {
 		return false;
 	}
@@ -3128,7 +3128,7 @@ void QuestManager::UpdateSpawnTimer(uint32 id, uint32 newTime)
 void QuestManager::MerchantSetItem(uint32 NPCid, uint32 itemid, uint32 quantity) {
 	Mob* merchant = entity_list.GetMobByNpcTypeID(NPCid);
 
-	if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
+	if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != Class::Merchant))
 		return;	// don't do anything if NPCid isn't a merchant
 
 	const EQ::ItemData* item = nullptr;
@@ -3141,7 +3141,7 @@ void QuestManager::MerchantSetItem(uint32 NPCid, uint32 itemid, uint32 quantity)
 uint32 QuestManager::MerchantCountItem(uint32 NPCid, uint32 itemid) {
 	Mob* merchant = entity_list.GetMobByNpcTypeID(NPCid);
 
-	if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
+	if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != Class::Merchant))
 		return 0;	// if it isn't a merchant, it doesn't have any items
 
 	const EQ::ItemData* item = nullptr;

zone/questmgr.h

@@ -365,8 +365,8 @@ public:
 	std::string GetEncounter() const;
 	inline bool ProximitySayInUse() { return HaveProximitySays; }
 
-	int createbotcount(uint8 class_id = NO_CLASS);
-	int spawnbotcount(uint8 class_id = NO_CLASS);
+	int createbotcount(uint8 class_id = Class::None);
+	int spawnbotcount(uint8 class_id = Class::None);
 	bool botquest();
 	bool createBot(const char *name, const char *lastname, uint8 level, uint16 race, uint8 botclass, uint8 gender);
 

zone/special_attacks.cpp

@@ -287,7 +287,7 @@ void Client::OPCombatAbility(const CombatAbility_Struct *ca_atk)
 
 	// make sure were actually able to use such an attack. (Bards can throw while casting. ~Kayen confirmed on live 1/22)
 	if (
-		(spellend_timer.Enabled() && GetClass() != BARD) ||
+		(spellend_timer.Enabled() && GetClass() != Class::Bard) ||
 		IsFeared() ||
 		IsStunned() ||
 		IsMezzed() ||
@@ -420,7 +420,7 @@ void Client::OPCombatAbility(const CombatAbility_Struct *ca_atk)
 		CheckIncreaseSkill(EQ::skills::SkillFrenzy, GetTarget(), 10);
 		DoAnim(anim1HWeapon, 0, false);
 
-		if (GetClass() == BERSERKER) {
+		if (GetClass() == Class::Berserker) {
 			int chance = GetLevel() * 2 + GetSkill(EQ::skills::SkillFrenzy);
 
 			if (zone->random.Roll0(450) < chance) {
@@ -461,11 +461,11 @@ void Client::OPCombatAbility(const CombatAbility_Struct *ca_atk)
 	const uint32 allowed_kick_classes = RuleI(Combat, ExtraAllowedKickClassesBitmask);
 
 	const bool can_use_kick = (
-		class_id == WARRIOR ||
-		class_id == RANGER ||
-		class_id == MONK ||
-		class_id == BEASTLORD ||
-		class_id == BERSERKER ||
+		class_id == Class::Warrior ||
+		class_id == Class::Ranger ||
+		class_id == Class::Monk ||
+		class_id == Class::Beastlord ||
+		class_id == Class::Berserker ||
 		allowed_kick_classes & GetPlayerClassBit(class_id)
 	);
 
@@ -494,7 +494,7 @@ void Client::OPCombatAbility(const CombatAbility_Struct *ca_atk)
 		}
 	}
 
-	if (class_id == MONK) {
+	if (class_id == Class::Monk) {
 		reuse_time = MonkSpecialAttack(GetTarget(), ca_atk->m_skill) - 1 - skill_reduction;
 
 		// Live AA - Technique of Master Wu
@@ -559,7 +559,7 @@ void Client::OPCombatAbility(const CombatAbility_Struct *ca_atk)
 	if (
 		ca_atk->m_atk == 100 &&
 		ca_atk->m_skill == EQ::skills::SkillBackstab &&
-		class_id == ROGUE
+		class_id == Class::Rogue
 	) {
 		reuse_time = BackstabReuseTime - 1 - skill_reduction;
 		TryBackstab(GetTarget(), reuse_time);
@@ -1495,7 +1495,7 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
 	}
 
 	if(!IsAttackAllowed(other) ||
-		(IsCasting() && GetClass() != BARD) ||
+		(IsCasting() && GetClass() != Class::Bard) ||
 		IsSitting() ||
 		(DivineAura() && !GetGM()) ||
 		IsStunned() ||
@@ -1779,13 +1779,13 @@ void NPC::DoClassAttacks(Mob *target) {
 		int knightreuse = 1000; //lets give it a small cooldown actually.
 
 		switch(GetClass()){
-			case SHADOWKNIGHT: case SHADOWKNIGHTGM:{
+			case Class::ShadowKnight: case Class::ShadowKnightGM:{
 				if (CastSpell(SPELL_NPC_HARM_TOUCH, target->GetID())) {
 					knightreuse = HarmTouchReuseTime * 1000;
 					}
 				break;
 			}
-			case PALADIN: case PALADINGM:{
+			case Class::Paladin: case Class::PaladinGM:{
 				if(GetHPRatio() < 20) {
 					if (CastSpell(SPELL_LAY_ON_HANDS, GetID())) {
 						knightreuse = LayOnHandsReuseTime * 1000;
@@ -1822,14 +1822,14 @@ void NPC::DoClassAttacks(Mob *target) {
 	bool did_attack = false;
 	//class specific stuff...
 	switch(GetClass()) {
-		case ROGUE: case ROGUEGM:
+		case Class::Rogue: case Class::RogueGM:
 			if(level >= 10) {
 				reuse = BackstabReuseTime * 1000;
 				TryBackstab(target, reuse);
 				did_attack = true;
 			}
 			break;
-		case MONK: case MONKGM: {
+		case Class::Monk: case Class::MonkGM: {
 			uint8 satype = EQ::skills::SkillKick;
 			if (level > 29) { satype = EQ::skills::SkillFlyingKick; }
 			else if (level > 24) { satype = EQ::skills::SkillDragonPunch; }
@@ -1842,7 +1842,7 @@ void NPC::DoClassAttacks(Mob *target) {
 			did_attack = true;
 			break;
 		}
-		case WARRIOR: case WARRIORGM:{
+		case Class::Warrior: case Class::WarriorGM:{
 			if(level >= RuleI(Combat, NPCBashKickLevel)){
 				if(zone->random.Roll(75)) { //tested on live, warrior mobs both kick and bash, kick about 75% of the time, casting doesn't seem to make a difference.
 					DoAnim(animKick, 0, false);
@@ -1870,12 +1870,12 @@ void NPC::DoClassAttacks(Mob *target) {
 			}
 			break;
 		}
-		case BERSERKER: case BERSERKERGM:{
+		case Class::Berserker: case Class::BerserkerGM:{
 			int AtkRounds = 1;
 			int32 max_dmg = GetBaseSkillDamage(EQ::skills::SkillFrenzy);
 			DoAnim(anim2HSlashing, 0, false);
 
-			if (GetClass() == BERSERKER) {
+			if (GetClass() == Class::Berserker) {
 				int chance = GetLevel() * 2 + GetSkill(EQ::skills::SkillFrenzy);
 				if (zone->random.Roll0(450) < chance)
 					AtkRounds++;
@@ -1892,8 +1892,8 @@ void NPC::DoClassAttacks(Mob *target) {
 			did_attack = true;
 			break;
 		}
-		case RANGER: case RANGERGM:
-		case BEASTLORD: case BEASTLORDGM: {
+		case Class::Ranger: case Class::RangerGM:
+		case Class::Beastlord: case Class::BeastlordGM: {
 			//kick
 			if(level >= RuleI(Combat, NPCBashKickLevel)){
 				DoAnim(animKick, 0, false);
@@ -1908,9 +1908,9 @@ void NPC::DoClassAttacks(Mob *target) {
 			}
 			break;
 		}
-		case CLERIC: case CLERICGM: //clerics can bash too.
-		case SHADOWKNIGHT: case SHADOWKNIGHTGM:
-		case PALADIN: case PALADINGM:{
+		case Class::Cleric: case Class::ClericGM: //clerics can bash too.
+		case Class::ShadowKnight: case Class::ShadowKnightGM:
+		case Class::Paladin: case Class::PaladinGM:{
 			if(level >= RuleI(Combat, NPCBashKickLevel)){
 				DoAnim(animTailRake, 0, false);
 				int64 dmg = GetBaseSkillDamage(EQ::skills::SkillBash);
@@ -1957,19 +1957,19 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte)
 
 	if (skill == -1){
 		switch(GetClass()){
-		case WARRIOR:
-		case RANGER:
-		case BEASTLORD:
+		case Class::Warrior:
+		case Class::Ranger:
+		case Class::Beastlord:
 			skill_to_use = EQ::skills::SkillKick;
 			break;
-		case BERSERKER:
+		case Class::Berserker:
 			skill_to_use = EQ::skills::SkillFrenzy;
 			break;
-		case SHADOWKNIGHT:
-		case PALADIN:
+		case Class::ShadowKnight:
+		case Class::Paladin:
 			skill_to_use = EQ::skills::SkillBash;
 			break;
-		case MONK:
+		case Class::Monk:
 			if(GetLevel() >= 30)
 			{
 				skill_to_use = EQ::skills::SkillFlyingKick;
@@ -1995,7 +1995,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte)
 				skill_to_use = EQ::skills::SkillKick;
 			}
 			break;
-		case ROGUE:
+		case Class::Rogue:
 			skill_to_use = EQ::skills::SkillBackstab;
 			break;
 		}
@@ -2035,7 +2035,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte)
 		ReuseTime = (FrenzyReuseTime - 1) / HasteMod;
 
 		// bards can do riposte frenzy for some reason
-		if (!IsRiposte && GetClass() == BERSERKER) {
+		if (!IsRiposte && GetClass() == Class::Berserker) {
 			int chance = GetLevel() * 2 + GetSkill(EQ::skills::SkillFrenzy);
 			if (zone->random.Roll0(450) < chance)
 				AtkRounds++;