From aeeb3500686f68ab8e0923535df7602045e6fb21 Mon Sep 17 00:00:00 2001
From: Alex King <89047260+Kinglykrab@users.noreply.github.com>
Date: Wed, 13 Dec 2023 18:38:45 -0500
Subject: [PATCH] [Cleanup] Cleanup classes.cpp/classes.h (#3752)

* [Cleanup] Cleanup classes.cpp/classes.h

# Notes
- Remove unused methods and cleanup logic.

* Update classes.cpp

* Final push.
---
 common/classes.cpp                | 769 ++++++++++++------------------
 common/classes.h                  | 189 ++++----
 common/inventory_profile.h        |   2 +-
 common/patches/rof2.cpp           |   8 +-
 common/patches/uf.cpp             |   6 +-
 common/ruletypes.h                |   1 +
 common/shareddb.cpp               |   8 +-
 common/spdat.cpp                  |   6 +-
 common/spdat.h                    |   2 +-
 shared_memory/skill_caps.cpp      |   2 +-
 world/client.cpp                  |  10 +-
 world/lfplist.cpp                 |   4 +-
 zone/aa.cpp                       |  34 +-
 zone/aggro.cpp                    |   8 +-
 zone/attack.cpp                   | 196 ++++----
 zone/bonuses.cpp                  |   4 +-
 zone/bot.cpp                      | 300 ++++++------
 zone/bot.h                        |   8 +-
 zone/bot_command.cpp              | 182 +++----
 zone/bot_command.h                |   2 +-
 zone/bot_database.cpp             |   6 +-
 zone/botspellsai.cpp              | 132 ++---
 zone/client.cpp                   |  68 +--
 zone/client.h                     |  14 +-
 zone/client_mods.cpp              |  58 +--
 zone/client_packet.cpp            |  74 +--
 zone/client_process.cpp           |  18 +-
 zone/effects.cpp                  |  16 +-
 zone/entity.cpp                   |  10 +-
 zone/entity.h                     |   4 +-
 zone/exp.cpp                      |  18 +-
 zone/gm_commands/find/class.cpp   |   4 +-
 zone/gm_commands/merchantshop.cpp |  12 +-
 zone/gm_commands/scribespell.cpp  |   2 +-
 zone/heal_rotation.cpp            |  10 +-
 zone/lua_general.cpp              |  93 ++--
 zone/merc.cpp                     |  14 +-
 zone/mob.cpp                      | 264 +++++-----
 zone/mob_ai.cpp                   |   4 +-
 zone/npc.cpp                      |  18 +-
 zone/npc_scale_manager.cpp        |  32 +-
 zone/petitions.cpp                |   2 +-
 zone/questmgr.cpp                 |  20 +-
 zone/questmgr.h                   |   4 +-
 zone/special_attacks.cpp          |  62 +--
 zone/spell_effects.cpp            |  66 +--
 zone/spells.cpp                   |  14 +-
 zone/tradeskills.cpp              |   4 +-
 zone/tune.cpp                     |  10 +-
 49 files changed, 1308 insertions(+), 1486 deletions(-)

diff --git a/common/classes.cpp b/common/classes.cpp
index 994eb7b31..f849a5bfd 100644
--- a/common/classes.cpp
+++ b/common/classes.cpp
@@ -15,6 +15,7 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 	*/
+#include <fmt/format.h>
 #include "../common/global_define.h"
 #include "../common/classes.h"
 #include "data_verification.h"
@@ -22,539 +23,374 @@
 const char *GetClassIDName(uint8 class_id, uint8 level)
 {
 	switch (class_id) {
-		case WARRIOR:
-			if (level >= 70) {
+		case Class::Warrior: {
+			if (level >= 75) {
+				return "Imperator";
+			} else if (level >= 70) {
 				return "Vanquisher";
-			}
-			else if (level >= 65) {
-				return "Overlord"; //Baron-Sprite: LEAVE MY CLASSES ALONE.
-			}
-			else if (level >= 60) {
+			} else if (level >= 65) {
+				return "Overlord";
+			} else if (level >= 60) {
 				return "Warlord";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Myrmidon";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Champion";
-			}
-			else {
+			} else {
 				return "Warrior";
 			}
-		case CLERIC:
-			if (level >= 70) {
+		}
+		case Class::Cleric: {
+			if (level >= 75) {
+				return "Exemplar";
+			} else if (level >= 70) {
 				return "Prelate";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Archon";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "High Priest";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Templar";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Vicar";
-			}
-			else {
+			} else {
 				return "Cleric";
 			}
-		case PALADIN:
-			if (level >= 70) {
+		}
+		case Class::Paladin: {
+			if (level >= 75) {
+				return "Holy Defender";
+			} else if (level >= 70) {
 				return "Lord";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Lord Protector";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Crusader";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Knight";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Cavalier";
-			}
-			else {
+			} else {
 				return "Paladin";
 			}
-		case RANGER:
-			if (level >= 70) {
+		}
+		case Class::Ranger: {
+			if (level >= 75) {
+				return "Huntmaster";
+			} else if (level >= 70) {
 				return "Plainswalker";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Forest Stalker";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Warder";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Outrider";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Pathfinder";
-			}
-			else {
+			} else {
 				return "Ranger";
 			}
-		case SHADOWKNIGHT:
-			if (level >= 70) {
+		}
+		case Class::ShadowKnight: {
+			if (level >= 75) {
+				return "Bloodreaver";
+			} else if (level >= 70) {
 				return "Scourge Knight";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Dread Lord";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Grave Lord";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Revenant";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Reaver";
+			} else {
+				return shadow_knight_class_name.c_str();
 			}
-			else {
-				return "Shadowknight";
-			}
-		case DRUID:
-			if (level >= 70) {
+		}
+		case Class::Druid: {
+			if (level >= 75) {
+				return "Storm Caller";
+			} else if (level >= 70) {
 				return "Natureguard";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Storm Warden";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Hierophant";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Preserver";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Wanderer";
-			}
-			else {
+			} else {
 				return "Druid";
 			}
-		case MONK:
-			if (level >= 70) {
+		}
+		case Class::Monk: {
+			if (level >= 75) {
+				return "Ashenhand";
+			} else if (level >= 70) {
 				return "Stone Fist";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Transcendent";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Grandmaster";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Master";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Disciple";
-			}
-			else {
+			} else {
 				return "Monk";
 			}
-		case BARD:
-			if (level >= 70) {
+		}
+		case Class::Bard: {
+			if (level >= 75) {
+				return "Lyricist";
+			} else if (level >= 70) {
 				return "Performer";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Maestro";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Virtuoso";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Troubadour";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Minstrel";
-			}
-			else {
+			} else {
 				return "Bard";
 			}
-		case ROGUE:
-			if (level >= 70) {
+		}
+		case Class::Rogue: {
+			if (level >= 75) {
+				return "Shadowblade";
+			} else if (level >= 70) {
 				return "Nemesis";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Deceiver";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Assassin";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Blackguard";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Rake";
-			}
-			else {
+			} else {
 				return "Rogue";
 			}
-		case SHAMAN:
-			if (level >= 70) {
+		}
+		case Class::Shaman: {
+			if (level >= 75) {
+				return "Spiritwatcher";
+			} else if (level >= 70) {
 				return "Soothsayer";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Prophet";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Oracle";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Luminary";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Mystic";
-			}
-			else {
+			} else {
 				return "Shaman";
 			}
-		case NECROMANCER:
-			if (level >= 70) {
+		}
+		case Class::Necromancer: {
+			if (level >= 75) {
+				return "Deathcaller";
+			} else if (level >= 70) {
 				return "Wraith";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Arch Lich";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Warlock";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Defiler";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Heretic";
-			}
-			else {
+			} else {
 				return "Necromancer";
 			}
-		case WIZARD:
-			if (level >= 70) {
+		}
+		case Class::Wizard: {
+			if (level >= 75) {
+				return "Pyromancer";
+			} else if (level >= 70) {
 				return "Grand Arcanist";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Arcanist";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Sorcerer";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Evoker";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Channeler";
-			}
-			else {
+			} else {
 				return "Wizard";
 			}
-		case MAGICIAN:
-			if (level >= 70) {
+		}
+		case Class::Magician: {
+			if (level >= 75) {
+				return "Grand Summoner";
+			} else if (level >= 70) {
 				return "Arch Magus";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Arch Convoker";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Arch Mage";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Conjurer";
 			}
 			if (level >= 51) {
 				return "Elementalist";
-			}
-			else {
+			} else {
 				return "Magician";
 			}
-		case ENCHANTER:
-			if (level >= 70) {
+		}
+		case Class::Enchanter: {
+			if (level >= 75) {
+				return "Entrancer";
+			} else if (level >= 70) {
 				return "Bedazzler";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Coercer";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Phantasmist";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Beguiler";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Illusionist";
-			}
-			else {
+			} else {
 				return "Enchanter";
 			}
-		case BEASTLORD:
-			if (level >= 70) {
+		}
+		case Class::Beastlord: {
+			if (level >= 75) {
+				return "Frostblood";
+			} else if (level >= 70) {
 				return "Wildblood";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Feral Lord";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Savage Lord";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Animist";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Primalist";
-			}
-			else {
+			} else {
 				return "Beastlord";
 			}
-		case BERSERKER:
-			if (level >= 70) {
+		}
+		case Class::Berserker: {
+			if (level >= 75) {
+				return "Juggernaut";
+			} else if (level >= 70) {
 				return "Ravager";
-			}
-			else if (level >= 65) {
+			} else if (level >= 65) {
 				return "Fury";
-			}
-			else if (level >= 60) {
+			} else if (level >= 60) {
 				return "Rager";
-			}
-			else if (level >= 55) {
+			} else if (level >= 55) {
 				return "Vehement";
-			}
-			else if (level >= 51) {
+			} else if (level >= 51) {
 				return "Brawler";
-			}
-			else {
+			} else {
 				return "Berserker";
 			}
-		case BANKER:
-			if (level >= 70) {
-				return "Master Banker";
-			}
-			else if (level >= 65) {
-				return "Elder Banker";
-			}
-			else if (level >= 60) {
-				return "Oldest Banker";
-			}
-			else if (level >= 55) {
-				return "Older Banker";
-			}
-			else if (level >= 51) {
-				return "Old Banker";
-			}
-			else {
-				return "Banker";
-			}
-		case WARRIORGM:
+		}
+		case Class::Banker:
+			return "Banker";
+		case Class::WarriorGM:
 			return "Warrior Guildmaster";
-		case CLERICGM:
+		case Class::ClericGM:
 			return "Cleric Guildmaster";
-		case PALADINGM:
+		case Class::PaladinGM:
 			return "Paladin Guildmaster";
-		case RANGERGM:
+		case Class::RangerGM:
 			return "Ranger Guildmaster";
-		case SHADOWKNIGHTGM:
-			return "Shadowknight Guildmaster";
-		case DRUIDGM:
+		case Class::ShadowKnightGM:
+			return fmt::format("{} Guildmaster", shadow_knight_class_name).c_str();
+		case Class::DruidGM:
 			return "Druid Guildmaster";
-		case MONKGM:
+		case Class::MonkGM:
 			return "Monk Guildmaster";
-		case BARDGM:
+		case Class::BardGM:
 			return "Bard Guildmaster";
-		case ROGUEGM:
+		case Class::RogueGM:
 			return "Rogue Guildmaster";
-		case SHAMANGM:
+		case Class::ShamanGM:
 			return "Shaman Guildmaster";
-		case NECROMANCERGM:
+		case Class::NecromancerGM:
 			return "Necromancer Guildmaster";
-		case WIZARDGM:
+		case Class::WizardGM:
 			return "Wizard Guildmaster";
-		case MAGICIANGM:
+		case Class::MagicianGM:
 			return "Magician Guildmaster";
-		case ENCHANTERGM:
+		case Class::EnchanterGM:
 			return "Enchanter Guildmaster";
-		case BEASTLORDGM:
+		case Class::BeastlordGM:
 			return "Beastlord Guildmaster";
-		case BERSERKERGM:
+		case Class::BerserkerGM:
 			return "Berserker Guildmaster";
-		case MERCHANT:
+		case Class::Merchant:
 			return "Merchant";
-		case DISCORD_MERCHANT:
+		case Class::DiscordMerchant:
 			return "Discord Merchant";
-		case ADVENTURE_RECRUITER:
+		case Class::AdventureRecruiter:
 			return "Adventure Recruiter";
-		case ADVENTURE_MERCHANT:
+		case Class::AdventureMerchant:
 			return "Adventure Merchant";
-		case LDON_TREASURE:
+		case Class::LDoNTreasure:
 			return "LDoN Treasure";
-		case TRIBUTE_MASTER:
+		case Class::TributeMaster:
 			return "Tribute Master";
-		case GUILD_TRIBUTE_MASTER:
+		case Class::GuildTributeMaster:
 			return "Guild Tribute Master";
-		case GUILD_BANKER:
+		case Class::GuildBanker:
 			return "Guild Banker";
-		case NORRATHS_KEEPERS_MERCHANT:
+		case Class::NorrathsKeepersMerchant:
 			return "Radiant Crystal Merchant";
-		case DARK_REIGN_MERCHANT:
+		case Class::DarkReignMerchant:
 			return "Ebon Crystal Merchant";
-		case FELLOWSHIP_MASTER:
+		case Class::FellowshipMaster:
 			return "Fellowship Master";
-		case ALT_CURRENCY_MERCHANT:
+		case Class::AlternateCurrencyMerchant:
 			return "Alternate Currency Merchant";
-		case MERCENARY_MASTER:
+		case Class::MercenaryLiaison:
 			return "Mercenary Liaison";
 		default:
 			return "Unknown";
 	}
 }
 
-const char *GetPlayerClassName(uint32 player_class_value, uint8 level)
+uint8 GetPlayerClassValue(uint8 class_id)
 {
-	return GetClassIDName(GetClassIDFromPlayerClassValue(player_class_value), level);
+	if (!IsPlayerClass(class_id)) {
+		return 0;
+	}
+
+	return class_id;
 }
 
-uint32 GetPlayerClassValue(uint8 class_id)
+uint16 GetPlayerClassBit(uint8 class_id)
 {
-	switch (class_id) {
-		case WARRIOR:
-		case CLERIC:
-		case PALADIN:
-		case RANGER:
-		case SHADOWKNIGHT:
-		case DRUID:
-		case MONK:
-		case BARD:
-		case ROGUE:
-		case SHAMAN:
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
-		case BEASTLORD:
-		case BERSERKER:
-			return class_id;
-		default:
-			return PLAYER_CLASS_UNKNOWN; // watch
+	if (!IsPlayerClass(class_id)) {
+		return 0;
 	}
-}
 
-uint32 GetPlayerClassBit(uint8 class_id)
-{
-	switch (class_id) {
-		case WARRIOR:
-			return PLAYER_CLASS_WARRIOR_BIT;
-		case CLERIC:
-			return PLAYER_CLASS_CLERIC_BIT;
-		case PALADIN:
-			return PLAYER_CLASS_PALADIN_BIT;
-		case RANGER:
-			return PLAYER_CLASS_RANGER_BIT;
-		case SHADOWKNIGHT:
-			return PLAYER_CLASS_SHADOWKNIGHT_BIT;
-		case DRUID:
-			return PLAYER_CLASS_DRUID_BIT;
-		case MONK:
-			return PLAYER_CLASS_MONK_BIT;
-		case BARD:
-			return PLAYER_CLASS_BARD_BIT;
-		case ROGUE:
-			return PLAYER_CLASS_ROGUE_BIT;
-		case SHAMAN:
-			return PLAYER_CLASS_SHAMAN_BIT;
-		case NECROMANCER:
-			return PLAYER_CLASS_NECROMANCER_BIT;
-		case WIZARD:
-			return PLAYER_CLASS_WIZARD_BIT;
-		case MAGICIAN:
-			return PLAYER_CLASS_MAGICIAN_BIT;
-		case ENCHANTER:
-			return PLAYER_CLASS_ENCHANTER_BIT;
-		case BEASTLORD:
-			return PLAYER_CLASS_BEASTLORD_BIT;
-		case BERSERKER:
-			return PLAYER_CLASS_BERSERKER_BIT;
-		default:
-			return PLAYER_CLASS_UNKNOWN_BIT;
-	}
-}
-
-uint8 GetClassIDFromPlayerClassValue(uint32 player_class_value)
-{
-	switch (player_class_value) {
-		case PLAYER_CLASS_WARRIOR:
-		case PLAYER_CLASS_CLERIC:
-		case PLAYER_CLASS_PALADIN:
-		case PLAYER_CLASS_RANGER:
-		case PLAYER_CLASS_SHADOWKNIGHT:
-		case PLAYER_CLASS_DRUID:
-		case PLAYER_CLASS_MONK:
-		case PLAYER_CLASS_BARD:
-		case PLAYER_CLASS_ROGUE:
-		case PLAYER_CLASS_SHAMAN:
-		case PLAYER_CLASS_NECROMANCER:
-		case PLAYER_CLASS_WIZARD:
-		case PLAYER_CLASS_MAGICIAN:
-		case PLAYER_CLASS_ENCHANTER:
-		case PLAYER_CLASS_BEASTLORD:
-		case PLAYER_CLASS_BERSERKER:
-			return player_class_value;
-		default:
-			return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit)
-{
-	switch (player_class_bit) {
-		case PLAYER_CLASS_WARRIOR_BIT:
-			return WARRIOR;
-		case PLAYER_CLASS_CLERIC_BIT:
-			return CLERIC;
-		case PLAYER_CLASS_PALADIN_BIT:
-			return PALADIN;
-		case PLAYER_CLASS_RANGER_BIT:
-			return RANGER;
-		case PLAYER_CLASS_SHADOWKNIGHT_BIT:
-			return SHADOWKNIGHT;
-		case PLAYER_CLASS_DRUID_BIT:
-			return DRUID;
-		case PLAYER_CLASS_MONK_BIT:
-			return MONK;
-		case PLAYER_CLASS_BARD_BIT:
-			return BARD;
-		case PLAYER_CLASS_ROGUE_BIT:
-			return ROGUE;
-		case PLAYER_CLASS_SHAMAN_BIT:
-			return SHAMAN;
-		case PLAYER_CLASS_NECROMANCER_BIT:
-			return NECROMANCER;
-		case PLAYER_CLASS_WIZARD_BIT:
-			return WIZARD;
-		case PLAYER_CLASS_MAGICIAN_BIT:
-			return MAGICIAN;
-		case PLAYER_CLASS_ENCHANTER_BIT:
-			return ENCHANTER;
-		case PLAYER_CLASS_BEASTLORD_BIT:
-			return BEASTLORD;
-		case PLAYER_CLASS_BERSERKER_BIT:
-			return BERSERKER;
-		default:
-			return PLAYER_CLASS_UNKNOWN; // watch
-	}
+	return player_class_bitmasks[class_id];
 }
 
 bool IsFighterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case WARRIOR:
-		case PALADIN:
-		case RANGER:
-		case SHADOWKNIGHT:
-		case MONK:
-		case BARD:
-		case ROGUE:
-		case BEASTLORD:
-		case BERSERKER:
+		case Class::Warrior:
+		case Class::Paladin:
+		case Class::Ranger:
+		case Class::ShadowKnight:
+		case Class::Monk:
+		case Class::Bard:
+		case Class::Rogue:
+		case Class::Beastlord:
+		case Class::Berserker:
 			return true;
 		default:
 			return false;
@@ -564,10 +400,10 @@ bool IsFighterClass(uint8 class_id)
 bool IsSpellFighterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case PALADIN:
-		case RANGER:
-		case SHADOWKNIGHT:
-		case BEASTLORD:
+		case Class::Paladin:
+		case Class::Ranger:
+		case Class::ShadowKnight:
+		case Class::Beastlord:
 			return true;
 		default:
 			return false;
@@ -577,11 +413,11 @@ bool IsSpellFighterClass(uint8 class_id)
 bool IsNonSpellFighterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case WARRIOR:
-		case MONK:
-		case BARD:
-		case ROGUE:
-		case BERSERKER:
+		case Class::Warrior:
+		case Class::Monk:
+		case Class::Bard:
+		case Class::Rogue:
+		case Class::Berserker:
 			return true;
 		default:
 			return false;
@@ -591,11 +427,11 @@ bool IsNonSpellFighterClass(uint8 class_id)
 bool IsHybridClass(uint8 class_id)
 {
 	switch (class_id) {
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case BARD:
-	case BEASTLORD:
+	case Class::Paladin:
+	case Class::Ranger:
+	case Class::ShadowKnight:
+	case Class::Bard:
+	case Class::Beastlord:
 		return true;
 	default:
 		return false;
@@ -605,13 +441,13 @@ bool IsHybridClass(uint8 class_id)
 bool IsCasterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			return true;
 		default:
 			return false;
@@ -621,10 +457,10 @@ bool IsCasterClass(uint8 class_id)
 bool IsINTCasterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			return true;
 		default:
 			return false;
@@ -634,11 +470,11 @@ bool IsINTCasterClass(uint8 class_id)
 bool IsHeroicINTCasterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
-		case SHADOWKNIGHT:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
+		case Class::ShadowKnight:
 			return true;
 		default:
 			return false;
@@ -648,9 +484,9 @@ bool IsHeroicINTCasterClass(uint8 class_id)
 bool IsWISCasterClass(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;
@@ -660,12 +496,12 @@ bool IsWISCasterClass(uint8 class_id)
 bool IsHeroicWISCasterClass(uint8 class_id)
 {
 	switch (class_id) {
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
-		case PALADIN:
-		case BEASTLORD:
-		case RANGER:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
+		case Class::Paladin:
+		case Class::Beastlord:
+		case Class::Ranger:
 			return true;
 		default:
 			return false;
@@ -675,11 +511,11 @@ bool IsHeroicWISCasterClass(uint8 class_id)
 bool IsPlateClass(uint8 class_id)
 {
 	switch (class_id) {
-		case WARRIOR:
-		case CLERIC:
-		case PALADIN:
-		case SHADOWKNIGHT:
-		case BARD:
+		case Class::Warrior:
+		case Class::Cleric:
+		case Class::Paladin:
+		case Class::ShadowKnight:
+		case Class::Bard:
 			return true;
 		default:
 			return false;
@@ -689,10 +525,10 @@ bool IsPlateClass(uint8 class_id)
 bool IsChainClass(uint8 class_id)
 {
 	switch (class_id) {
-		case RANGER:
-		case ROGUE:
-		case SHAMAN:
-		case BERSERKER:
+		case Class::Ranger:
+		case Class::Rogue:
+		case Class::Shaman:
+		case Class::Berserker:
 			return true;
 		default:
 			return false;
@@ -702,9 +538,9 @@ bool IsChainClass(uint8 class_id)
 bool IsLeatherClass(uint8 class_id)
 {
 	switch (class_id) {
-		case DRUID:
-		case MONK:
-		case BEASTLORD:
+		case Class::Druid:
+		case Class::Monk:
+		case Class::Beastlord:
 			return true;
 		default:
 			return false;
@@ -714,10 +550,10 @@ bool IsLeatherClass(uint8 class_id)
 bool IsClothClass(uint8 class_id)
 {
 	switch (class_id) {
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			return true;
 		default:
 			return false;
@@ -726,70 +562,57 @@ bool IsClothClass(uint8 class_id)
 
 uint8 ClassArmorType(uint8 class_id)
 {
-	switch (class_id) {
-		case WARRIOR:
-		case CLERIC:
-		case PALADIN:
-		case SHADOWKNIGHT:
-		case BARD:
-			return ARMOR_TYPE_PLATE;
-		case RANGER:
-		case ROGUE:
-		case SHAMAN:
-		case BERSERKER:
-			return ARMOR_TYPE_CHAIN;
-		case DRUID:
-		case MONK:
-		case BEASTLORD:
-			return ARMOR_TYPE_LEATHER;
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
-			return ARMOR_TYPE_CLOTH;
-		default:
-			return ARMOR_TYPE_UNKNOWN;
+	if (IsChainClass(class_id)) {
+		return ARMOR_TYPE_CHAIN;
+	} else if (IsClothClass(class_id)) {
+		return ARMOR_TYPE_CLOTH;
+	} else if (IsLeatherClass(class_id)) {
+		return ARMOR_TYPE_LEATHER;
+	} else if (IsPlateClass(class_id)) {
+		return ARMOR_TYPE_PLATE;
 	}
+
+	return ARMOR_TYPE_UNKNOWN;
 }
 
 const std::string GetPlayerClassAbbreviation(uint8 class_id)
 {
-	if (!EQ::ValueWithin(class_id, WARRIOR, BERSERKER)) {
+	if (!EQ::ValueWithin(class_id, Class::Warrior, Class::Berserker)) {
 		return std::string("UNK");
 	}
 
 	switch (class_id) {
-		case WARRIOR:
+		case Class::Warrior:
 			return "WAR";
-		case CLERIC:
+		case Class::Cleric:
 			return "CLR";
-		case PALADIN:
+		case Class::Paladin:
 			return "PAL";
-		case RANGER:
+		case Class::Ranger:
 			return "RNG";
-		case SHADOWKNIGHT:
+		case Class::ShadowKnight:
 			return "SHD";
-		case DRUID:
+		case Class::Druid:
 			return "DRU";
-		case MONK:
+		case Class::Monk:
 			return "MNK";
-		case BARD:
+		case Class::Bard:
 			return "BRD";
-		case ROGUE:
+		case Class::Rogue:
 			return "ROG";
-		case SHAMAN:
+		case Class::Shaman:
 			return "SHM";
-		case NECROMANCER:
+		case Class::Necromancer:
 			return "NEC";
-		case WIZARD:
+		case Class::Wizard:
 			return "WIZ";
-		case MAGICIAN:
+		case Class::Magician:
 			return "MAG";
-		case ENCHANTER:
+		case Class::Enchanter:
 			return "ENC";
-		case BEASTLORD:
+		case Class::Beastlord:
 			return "BST";
-		case BERSERKER:
+		case Class::Berserker:
 			return "BER";
 	}
 
@@ -797,5 +620,5 @@ const std::string GetPlayerClassAbbreviation(uint8 class_id)
 }
 
 bool IsPlayerClass(uint8 class_id) {
-	return EQ::ValueWithin(class_id, WARRIOR, BERSERKER);
+	return EQ::ValueWithin(class_id, Class::Warrior, Class::Berserker);
 }
diff --git a/common/classes.h b/common/classes.h
index a9cc7d9fc..96e5cad26 100644
--- a/common/classes.h
+++ b/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);
diff --git a/common/inventory_profile.h b/common/inventory_profile.h
index c1a82e407..4c0b29665 100644
--- a/common/inventory_profile.h
+++ b/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);
diff --git a/common/patches/rof2.cpp b/common/patches/rof2.cpp
index bf9c6a363..f62209361 100644
--- a/common/patches/rof2.cpp
+++ b/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);
diff --git a/common/patches/uf.cpp b/common/patches/uf.cpp
index a80c0eae9..a21e7eaeb 100644
--- a/common/patches/uf.cpp
+++ b/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);
diff --git a/common/ruletypes.h b/common/ruletypes.h
index 05317c819..1bc934030 100644
--- a/common/ruletypes.h
+++ b/common/ruletypes.h
@@ -305,6 +305,7 @@ RULE_BOOL(World, EnableChecksumVerification, false, "Enable or Disable the Check
 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)
diff --git a/common/shareddb.cpp b/common/shareddb.cpp
index 0e37e3917..1cdb5bf79 100644
--- a/common/shareddb.cpp
+++ b/common/shareddb.cpp
@@ -1808,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);
@@ -1848,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) {
@@ -1878,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) {
@@ -2061,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]);
diff --git a/common/spdat.cpp b/common/spdat.cpp
index bb146aa61..2b92838c3 100644
--- a/common/spdat.cpp
+++ b/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;
 	}
 
diff --git a/common/spdat.h b/common/spdat.h
index 2a7110420..b8d2619de 100644
--- a/common/spdat.h
+++ b/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
diff --git a/shared_memory/skill_caps.cpp b/shared_memory/skill_caps.cpp
index 8f11e31dd..648a0cfb5 100644
--- a/shared_memory/skill_caps.cpp
+++ b/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));
diff --git a/world/client.cpp b/world/client.cpp
index 9c31ba4c1..a6232bcb7 100644
--- a/world/client.cpp
+++ b/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:
diff --git a/world/lfplist.cpp b/world/lfplist.cpp
index 897fd9ab2..904d31261 100644
--- a/world/lfplist.cpp
+++ b/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;
diff --git a/zone/aa.cpp b/zone/aa.cpp
index b2affb44a..216428eeb 100644
--- a/zone/aa.cpp
+++ b/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;
 			}
diff --git a/zone/aggro.cpp b/zone/aggro.cpp
index e5c539485..47cffa967 100644
--- a/zone/aggro.cpp
+++ b/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;
diff --git a/zone/attack.cpp b/zone/attack.cpp
index 2827d3cbb..e5c94375c 100644
--- a/zone/attack.cpp
+++ b/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;
 	}
 
diff --git a/zone/bonuses.cpp b/zone/bonuses.cpp
index 89cdc667f..c5d5f93b9 100644
--- a/zone/bonuses.cpp
+++ b/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.
 }
 
diff --git a/zone/bot.cpp b/zone/bot.cpp
index e80ce8c7b..778b4dd46 100644
--- a/zone/bot.cpp
+++ b/zone/bot.cpp
@@ -78,10 +78,10 @@ Bot::Bot(NPCType *npcTypeData, Client* botOwner) : NPC(npcTypeData, nullptr, glm
 	SetBotCharmer(false);
 	SetPetChooser(false);
 	SetRangerAutoWeaponSelect(false);
-	SetTaunting(GetClass() == WARRIOR || GetClass() == PALADIN || GetClass() == SHADOWKNIGHT);
+	SetTaunting(GetClass() == Class::Warrior || GetClass() == Class::Paladin || GetClass() == Class::ShadowKnight);
 	SetDefaultBotStance();
 
-	SetAltOutOfCombatBehavior(GetClass() == BARD); // will need to be updated if more classes make use of this flag
+	SetAltOutOfCombatBehavior(GetClass() == Class::Bard); // will need to be updated if more classes make use of this flag
 	SetShowHelm(true);
 	SetPauseAI(false);
 
@@ -201,7 +201,7 @@ Bot::Bot(
 		);
 	}
 
-	SetTaunting((GetClass() == WARRIOR || GetClass() == PALADIN || GetClass() == SHADOWKNIGHT) && (GetBotStance() == EQ::constants::stanceAggressive));
+	SetTaunting((GetClass() == Class::Warrior || GetClass() == Class::Paladin || GetClass() == Class::ShadowKnight) && (GetBotStance() == EQ::constants::stanceAggressive));
 	SetPauseAI(false);
 
 	m_alt_combat_hate_timer.Start(250);
@@ -241,7 +241,7 @@ Bot::Bot(
 	for (int i = 0; i < MaxTimer; i++)
 		timers[i] = 0;
 
-	if (GetClass() == ROGUE) {
+	if (GetClass() == Class::Rogue) {
 		m_evade_timer.Start();
 	}
 
@@ -561,7 +561,7 @@ uint32 Bot::GetBotArcheryRange() {
 }
 
 void Bot::ChangeBotArcherWeapons(bool isArcher) {
-	if ((GetClass()==WARRIOR) || (GetClass()==PALADIN) || (GetClass()==RANGER) || (GetClass()==SHADOWKNIGHT) || (GetClass()==ROGUE)) {
+	if ((GetClass()==Class::Warrior) || (GetClass()==Class::Paladin) || (GetClass()==Class::Ranger) || (GetClass()==Class::ShadowKnight) || (GetClass()==Class::Rogue)) {
 		if (!isArcher) {
 			BotAddEquipItem(EQ::invslot::slotPrimary, GetBotItemBySlot(EQ::invslot::slotPrimary));
 			BotAddEquipItem(EQ::invslot::slotSecondary, GetBotItemBySlot(EQ::invslot::slotSecondary));
@@ -769,7 +769,7 @@ void Bot::GenerateBaseStats()
 
 	// pulling fixed values from an auto-increment field is dangerous...
 	switch (GetClass()) {
-		case WARRIOR:
+		case Class::Warrior:
 			BotSpellID = 3001;
 			Strength += 10;
 			Stamina += 20;
@@ -777,7 +777,7 @@ void Bot::GenerateBaseStats()
 			Dexterity += 10;
 			Attack += 12;
 			break;
-		case CLERIC:
+		case Class::Cleric:
 			BotSpellID = 3002;
 			Strength += 5;
 			Stamina += 5;
@@ -785,7 +785,7 @@ void Bot::GenerateBaseStats()
 			Wisdom += 30;
 			Attack += 8;
 			break;
-		case PALADIN:
+		case Class::Paladin:
 			BotSpellID = 3003;
 			Strength += 15;
 			Stamina += 5;
@@ -794,7 +794,7 @@ void Bot::GenerateBaseStats()
 			Dexterity += 5;
 			Attack += 17;
 			break;
-		case RANGER:
+		case Class::Ranger:
 			BotSpellID = 3004;
 			Strength += 15;
 			Stamina += 10;
@@ -802,7 +802,7 @@ void Bot::GenerateBaseStats()
 			Wisdom += 15;
 			Attack += 17;
 			break;
-		case SHADOWKNIGHT:
+		case Class::ShadowKnight:
 			BotSpellID = 3005;
 			Strength += 10;
 			Stamina += 15;
@@ -810,13 +810,13 @@ void Bot::GenerateBaseStats()
 			Charisma += 5;
 			Attack += 17;
 			break;
-		case DRUID:
+		case Class::Druid:
 			BotSpellID = 3006;
 			Stamina += 15;
 			Wisdom += 35;
 			Attack += 5;
 			break;
-		case MONK:
+		case Class::Monk:
 			BotSpellID = 3007;
 			Strength += 5;
 			Stamina += 15;
@@ -824,7 +824,7 @@ void Bot::GenerateBaseStats()
 			Dexterity += 15;
 			Attack += 17;
 			break;
-		case BARD:
+		case Class::Bard:
 			BotSpellID = 3008;
 			Strength += 15;
 			Dexterity += 10;
@@ -832,7 +832,7 @@ void Bot::GenerateBaseStats()
 			Intelligence += 10;
 			Attack += 17;
 			break;
-		case ROGUE:
+		case Class::Rogue:
 			BotSpellID = 3009;
 			Strength += 10;
 			Stamina += 20;
@@ -840,39 +840,39 @@ void Bot::GenerateBaseStats()
 			Dexterity += 10;
 			Attack += 12;
 			break;
-		case SHAMAN:
+		case Class::Shaman:
 			BotSpellID = 3010;
 			Stamina += 10;
 			Wisdom += 30;
 			Charisma += 10;
 			Attack += 28;
 			break;
-		case NECROMANCER:
+		case Class::Necromancer:
 			BotSpellID = 3011;
 			Dexterity += 10;
 			Agility += 10;
 			Intelligence += 30;
 			Attack += 5;
 			break;
-		case WIZARD:
+		case Class::Wizard:
 			BotSpellID = 3012;
 			Stamina += 20;
 			Intelligence += 30;
 			Attack += 5;
 			break;
-		case MAGICIAN:
+		case Class::Magician:
 			BotSpellID = 3013;
 			Stamina += 20;
 			Intelligence += 30;
 			Attack += 5;
 			break;
-		case ENCHANTER:
+		case Class::Enchanter:
 			BotSpellID = 3014;
 			Intelligence += 25;
 			Charisma += 25;
 			Attack += 5;
 			break;
-		case BEASTLORD:
+		case Class::Beastlord:
 			BotSpellID = 3015;
 			Stamina += 10;
 			Agility += 10;
@@ -881,7 +881,7 @@ void Bot::GenerateBaseStats()
 			Charisma += 5;
 			Attack += 31;
 			break;
-		case BERSERKER:
+		case Class::Berserker:
 			BotSpellID = 3016;
 			Strength += 10;
 			Stamina += 15;
@@ -1497,7 +1497,7 @@ bool Bot::LoadPet()
 	if (!bot_owner)
 		return false;
 
-	if (GetClass() == WIZARD) {
+	if (GetClass() == Class::Wizard) {
 		auto buffs_max = GetMaxBuffSlots();
 		auto my_buffs = GetBuffs();
 		if (buffs_max && my_buffs) {
@@ -1799,7 +1799,7 @@ void Bot::AI_Bot_Init()
 void Bot::SpellProcess() {
 	if (spellend_timer.Check(false))	{
 		NPC::SpellProcess();
-		if (GetClass() == BARD && casting_spell_id != 0) casting_spell_id = 0;
+		if (GetClass() == Class::Bard && casting_spell_id != 0) casting_spell_id = 0;
 	}
 }
 
@@ -1891,7 +1891,7 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) {
 	//Check for bonuses that give you a double attack chance regardless of skill (ie Bestial Frenzy/Harmonious Attack AA)
 	uint32 bonusGiveDA = (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack);
 	// If you don't have the double attack skill, return
-	if (!GetSkill(EQ::skills::SkillDoubleAttack) && !(GetClass() == BARD || GetClass() == BEASTLORD))
+	if (!GetSkill(EQ::skills::SkillDoubleAttack) && !(GetClass() == Class::Bard || GetClass() == Class::Beastlord))
 		return false;
 
 	// You start with no chance of double attacking
@@ -1941,7 +1941,7 @@ void Bot::SetGuardMode() {
 	m_GuardPoint = GetPosition();
 	SetGuardFlag();
 
-	if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+	if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 		GetPet()->StopMoving();
 	}
 }
@@ -1953,7 +1953,7 @@ void Bot::SetHoldMode() {
 
 // AI Processing for the Bot object
 
-constexpr float MAX_CASTER_DISTANCE[PLAYER_CLASS_COUNT] = {
+constexpr float MAX_CASTER_DISTANCE[Class::PLAYER_CLASS_COUNT] = {
 	0,
 	(34 * 34),
 	(24 * 24),
@@ -2111,7 +2111,7 @@ void Bot::AI_Process()
 		}
 
 		// This causes conflicts with default pet handler (bounces between targets)
-		if (NOT_PULLING_BOT && HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+		if (NOT_PULLING_BOT && HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 
 			// We don't add to hate list here because it's assumed to already be on the list
 			GetPet()->SetTarget(tar);
@@ -2156,7 +2156,7 @@ void Bot::AI_Process()
 				return;
 			}
 
-			if (AI_movement_timer->Check() && (!spellend_timer.Enabled() || GetClass() == BARD)) {
+			if (AI_movement_timer->Check() && (!spellend_timer.Enabled() || GetClass() == Class::Bard)) {
 
 				if (TryEvade(tar)) {
 					return;
@@ -2228,7 +2228,7 @@ void Bot::AI_Process()
 
 		SetTarget(nullptr);
 
-		if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
+		if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
 
 			GetPet()->WipeHateList();
 			GetPet()->SetTarget(nullptr);
@@ -2255,7 +2255,7 @@ void Bot::AI_Process()
 
 bool Bot::TryBardMovementCasts() {// Basically, bard bots get a chance to cast idle spells while moving
 
-	if (GetClass() == BARD && IsMoving() && NOT_PASSIVE && !spellend_timer.Enabled() && AI_think_timer->Check()) {
+	if (GetClass() == Class::Bard && IsMoving() && NOT_PASSIVE && !spellend_timer.Enabled() && AI_think_timer->Check()) {
 
 		AI_IdleCastCheck();
 		return true;
@@ -2265,7 +2265,7 @@ bool Bot::TryBardMovementCasts() {// Basically, bard bots get a chance to cast i
 
 bool Bot::TryNonCombatMovementChecks(Client* bot_owner, const Mob* follow_mob, glm::vec3& Goal) {// Non-engaged movement checks
 
-	if (AI_movement_timer->Check() && (!IsCasting() || GetClass() == BARD)) {
+	if (AI_movement_timer->Check() && (!IsCasting() || GetClass() == Class::Bard)) {
 		if (GUARDING) {
 			Goal = GetGuardPoint();
 		}
@@ -2311,12 +2311,12 @@ bool Bot::TryIdleChecks(float fm_distance) {
 
 		if (NOT_PASSIVE) {
 
-			if (!AI_IdleCastCheck() && !IsCasting() && GetClass() != BARD) {
+			if (!AI_IdleCastCheck() && !IsCasting() && GetClass() != Class::Bard) {
 				BotMeditate(true);
 			}
 
 		} else {
-			if (GetClass() != BARD) {
+			if (GetClass() != Class::Bard) {
 				BotMeditate(true);
 			}
 
@@ -2363,7 +2363,7 @@ bool Bot::TryAutoDefend(Client* bot_owner, float leash_distance) {
 						SetTarget(hater);
 						SetAttackingFlag();
 
-						if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+						if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 							GetPet()->AddToHateList(hater, 1);
 							GetPet()->SetTarget(hater);
 						}
@@ -2399,7 +2399,7 @@ bool Bot::TryMeditate() {
 // This code actually gets processed when we are too far away from target and have not engaged yet
 bool Bot::TryPursueTarget(float leash_distance, glm::vec3& Goal) {
 
-	if (AI_movement_timer->Check() && (!spellend_timer.Enabled() || GetClass() == BARD)) {
+	if (AI_movement_timer->Check() && (!spellend_timer.Enabled() || GetClass() == Class::Bard)) {
 		if (GetTarget() && !IsRooted()) {
 			LogAIDetail("Pursuing [{}] while engaged", GetTarget()->GetCleanName());
 			Goal = GetTarget()->GetPosition();
@@ -2410,7 +2410,7 @@ bool Bot::TryPursueTarget(float leash_distance, glm::vec3& Goal) {
 				WipeHateList();
 				SetTarget(nullptr);
 
-				if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+				if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 					GetPet()->WipeHateList();
 					GetPet()->SetTarget(nullptr);
 				}
@@ -2446,7 +2446,7 @@ bool Bot::TrySecondaryWeaponAttacks(Mob* tar, const EQ::ItemInstance* s_item) {
 		const EQ::ItemData* s_itemdata = nullptr;
 
 		// Can only dual wield without a weapon if you're a monk
-		if (s_item || (GetClass() == MONK)) {
+		if (s_item || (GetClass() == Class::Monk)) {
 
 			if (s_item) {
 				s_itemdata = s_item->GetItem();
@@ -2597,7 +2597,7 @@ bool Bot::TryEvade(Mob* tar) {
 		HasTargetReflection() &&
 		!tar->IsFeared() &&
 		!tar->IsStunned() &&
-		GetClass() == ROGUE &&
+		GetClass() == Class::Rogue &&
 		m_evade_timer.Check(false)
 	) {
 		int timer_duration = (HideReuseTime - GetSkillReuseTime(EQ::skills::SkillHide)) * 1000;
@@ -2623,7 +2623,7 @@ void Bot::CheckCombatRange(Mob* tar, float tar_distance, bool& atCombatRange, co
 	s_item= GetBotItem(EQ::invslot::slotSecondary);
 	bool behind_mob = false;
 	bool backstab_weapon = false;
-	if (GetClass() == ROGUE) {
+	if (GetClass() == Class::Rogue) {
 
 		behind_mob = BehindMob(tar, GetX(), GetY()); // Can be separated for other future use
 		backstab_weapon = p_item && p_item->GetItemBackstabDamage();
@@ -2721,9 +2721,9 @@ void Bot::CalcMeleeDistances(const Mob* tar, const EQ::ItemInstance* const& p_it
 	melee_distance_max = size_mod;
 
 	switch (GetClass()) {
-	case WARRIOR:
-	case PALADIN:
-	case SHADOWKNIGHT:
+	case Class::Warrior:
+	case Class::Paladin:
+	case Class::ShadowKnight:
 		if (p_item && p_item->GetItem()->IsType2HWeapon()) {
 			melee_distance = melee_distance_max * 0.45f;
 		}
@@ -2734,10 +2734,10 @@ void Bot::CalcMeleeDistances(const Mob* tar, const EQ::ItemInstance* const& p_it
 			melee_distance = melee_distance_max * 0.40f;
 		}
 		break;
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
+	case Class::Necromancer:
+	case Class::Wizard:
+	case Class::Magician:
+	case Class::Enchanter:
 		if (p_item && p_item->GetItem()->IsType2HWeapon()) {
 			melee_distance = melee_distance_max * 0.95f;
 		}
@@ -2745,7 +2745,7 @@ void Bot::CalcMeleeDistances(const Mob* tar, const EQ::ItemInstance* const& p_it
 			melee_distance = melee_distance_max * 0.75f;
 		}
 		break;
-	case ROGUE:
+	case Class::Rogue:
 		if (behind_mob && backstab_weapon) {
 			if (p_item->GetItem()->IsType2HWeapon()) {
 				melee_distance = melee_distance_max * 0.30f;
@@ -2860,7 +2860,7 @@ void Bot::AcquireBotTarget(Group* bot_group, Raid* raid, Client* leash_owner, fl
 				if (
 					HasPet() &&
 					(
-						GetClass() != ENCHANTER ||
+						GetClass() != Class::Enchanter ||
 						GetPet()->GetPetType() != petAnimation ||
 						GetAA(aaAnimationEmpathy) >= 2
 					)
@@ -2880,7 +2880,7 @@ void Bot::AcquireBotTarget(Group* bot_group, Raid* raid, Client* leash_owner, fl
 			if (
 				HasPet() &&
 				(
-					GetClass() != ENCHANTER ||
+					GetClass() != Class::Enchanter ||
 					GetPet()->GetPetType() != petAnimation ||
 					GetAA(aaAnimationEmpathy) >= 1
 				)
@@ -2962,7 +2962,7 @@ bool Bot::PullingFlagChecks(Client* bot_owner) {
 		SetReturningFlag();
 
 		if (HasPet() &&
-			(GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
+			(GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
 
 			GetPet()->WipeHateList();
 			GetPet()->SetTarget(nullptr);
@@ -3058,7 +3058,7 @@ bool Bot::CheckIfCasting(float fm_distance) {
 			AdvanceHealRotation(false);
 			return true;
 		}
-		else if (GetClass() != BARD) {
+		else if (GetClass() != Class::Bard) {
 
 			if (IsEngaged()) {
 				return true;
@@ -3104,7 +3104,7 @@ bool Bot::CheckIfIncapacitated() {
 }
 
 void Bot::SetBerserkState() {// Berserk updates should occur if primary AI criteria are met
-	if (GetClass() == WARRIOR || GetClass() == BERSERKER) {
+	if (GetClass() == Class::Warrior || GetClass() == Class::Berserker) {
 
 		if (!berserk && GetHP() > 0 && GetHPRatio() < 30.0f) {
 			entity_list.MessageCloseString(this, false, 200, 0, BERSERK_START, GetName());
@@ -3159,7 +3159,7 @@ void Bot::SetLeashOwnerTarget(Client* leash_owner, Client* bot_owner, float lo_d
 		IsAttackAllowed(lo_target))
 	{
 		AddToHateList(lo_target, 1);
-		if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+		if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 			GetPet()->AddToHateList(lo_target, 1);
 			GetPet()->SetTarget(lo_target);
 		}
@@ -3188,7 +3188,7 @@ void Bot::SetOwnerTarget(Client* bot_owner) {
 			AddToHateList(attack_target, 1);
 			SetTarget(attack_target);
 			SetAttackingFlag();
-			if (GetPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+			if (GetPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 				GetPet()->WipeHateList();
 				GetPet()->AddToHateList(attack_target, 1);
 				GetPet()->SetTarget(attack_target);
@@ -3227,7 +3227,7 @@ void Bot::BotPullerProcess(Client* bot_owner, Raid* raid) {
 			SetTarget(pull_target);
 			SetPullingFlag();
 			bot_owner->SetBotPulling();
-			if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
+			if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 1)) {
 
 				GetPet()->WipeHateList();
 				GetPet()->SetTarget(nullptr);
@@ -3247,7 +3247,7 @@ void Bot::SetBotGroupTarget(const Client* bot_owner, Client* leash_owner, float
 		IsAttackAllowed(bgm_target))
 	{
 		AddToHateList(bgm_target, 1);
-		if (HasPet() && (GetClass() != ENCHANTER || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
+		if (HasPet() && (GetClass() != Class::Enchanter || GetPet()->GetPetType() != petAnimation || GetAA(aaAnimationEmpathy) >= 2)) {
 			GetPet()->AddToHateList(bgm_target, 1);
 			GetPet()->SetTarget(bgm_target);
 		}
@@ -3544,7 +3544,7 @@ void Bot::LoadAndSpawnAllZonedBots(Client* bot_owner) {
 		std::vector<int> bot_class_spawn_limits;
 		std::vector<int> bot_class_spawned_count = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-		for (uint8 class_id = WARRIOR; class_id <= BERSERKER; class_id++) {
+		for (uint8 class_id = Class::Warrior; class_id <= Class::Berserker; class_id++) {
 			auto bot_class_limit = bot_owner->GetBotSpawnLimit(class_id);
 			bot_class_spawn_limits.push_back(bot_class_limit);
 		}
@@ -4731,13 +4731,13 @@ int Bot::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 (CastToNPC()->GetEquippedItemFromTextureSlot(EQ::textures::armorHands) == 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];
@@ -4783,7 +4783,7 @@ void Bot::DoRiposte(Mob* defender) {
 
 	DoubleRipChance = defender->GetAABonuses().GiveDoubleRiposte[1];
 	if (DoubleRipChance && (DoubleRipChance >= zone->random.Int(0, 100))) {
-		if (defender->GetClass() == MONK)
+		if (defender->GetClass() == Class::Monk)
 			defender->MonkSpecialAttack(this, defender->GetAABonuses().GiveDoubleRiposte[2]);
 		else if (defender->IsBot())
 			defender->CastToClient()->DoClassAttacks(this,defender->GetAABonuses().GiveDoubleRiposte[2], true);
@@ -5044,13 +5044,13 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 	if (ka_time) {
 
 		switch (GetClass()) {
-			case SHADOWKNIGHT: {
+			case Class::ShadowKnight: {
 				CastSpell(SPELL_NPC_HARM_TOUCH, target->GetID());
 				knightattack_timer.Start(HarmTouchReuseTime * 1000);
 
 				break;
 			}
-			case PALADIN: {
+			case Class::Paladin: {
 				if (GetHPRatio() < 20) {
 					CastSpell(SPELL_LAY_ON_HANDS, GetID());
 					knightattack_timer.Start(LayOnHandsReuseTime * 1000);
@@ -5083,7 +5083,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 
 	if (ma_time) {
 		switch (GetClass()) {
-		case MONK: {
+		case Class::Monk: {
 			int reuse = (MonkSpecialAttack(target, EQ::skills::SkillTigerClaw) - 1);
 
 			// Live AA - Technique of Master Wu
@@ -5148,7 +5148,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 	int reuse = (TauntReuseTime * 1000); // Same as Bash and Kick
 	bool did_attack = false;
 	switch (GetClass()) {
-		case WARRIOR:
+		case Class::Warrior:
 			if (bot_level >= RuleI(Combat, NPCBashKickLevel)) {
 				bool canBash = false;
 				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQ::invslot::slotSecondary) && m_inv.GetItem(EQ::invslot::slotSecondary)->GetItem()->ItemType == EQ::item::ItemTypeShield) || (m_inv.GetItem(EQ::invslot::slotPrimary) && m_inv.GetItem(EQ::invslot::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
@@ -5159,22 +5159,22 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 				else
 					skill_to_use = EQ::skills::SkillBash;
 			}
-		case RANGER:
-		case BEASTLORD:
+		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 CLERIC:
-		case SHADOWKNIGHT:
-		case PALADIN:
+		case Class::Cleric:
+		case Class::ShadowKnight:
+		case Class::Paladin:
 			if (bot_level >= RuleI(Combat, NPCBashKickLevel)) {
 				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQ::invslot::slotSecondary) && m_inv.GetItem(EQ::invslot::slotSecondary)->GetItem()->ItemType == EQ::item::ItemTypeShield) || (m_inv.GetItem(EQ::invslot::slotPrimary) && m_inv.GetItem(EQ::invslot::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
 					skill_to_use = EQ::skills::SkillBash;
 			}
 			break;
-		case MONK:
+		case Class::Monk:
 			if (GetLevel() >= 30) {
 				skill_to_use = EQ::skills::SkillFlyingKick;
 			}
@@ -5192,7 +5192,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 			}
 
 			break;
-		case ROGUE:
+		case Class::Rogue:
 			skill_to_use = EQ::skills::SkillBackstab;
 			break;
 	}
@@ -5600,7 +5600,7 @@ bool Bot::CastSpell(
 			ZeroCastingVars();
 		}
 
-		if (GetClass() != BARD) {
+		if (GetClass() != Class::Bard) {
 			if (
 				!IsValidSpell(spell_id) ||
 				casting_spell_id ||
@@ -5753,7 +5753,7 @@ bool Bot::DetermineSpellTargets(uint16 spell_id, Mob *&spell_target, Mob *&ae_ce
 
 bool Bot::DoCastSpell(uint16 spell_id, uint16 target_id, EQ::spells::CastingSlot slot, int32 cast_time, int32 mana_cost, uint32* oSpellWillFinish, uint32 item_slot, uint32 aa_id) {
 	bool Result = false;
-	if (GetClass() == BARD)
+	if (GetClass() == Class::Bard)
 		cast_time = 0;
 
 	Result = Mob::DoCastSpell(spell_id, target_id, slot, cast_time, mana_cost, oSpellWillFinish, item_slot, aa_id);
@@ -5851,7 +5851,7 @@ int32 Bot::GenerateBaseManaPoints() {
 }
 
 void Bot::GenerateSpecialAttacks() {
-	if (((GetClass() == MONK) || (GetClass() == WARRIOR) || (GetClass() == RANGER) || (GetClass() == BERSERKER))	&& (GetLevel() >= 60))
+	if (((GetClass() == Class::Monk) || (GetClass() == Class::Warrior) || (GetClass() == Class::Ranger) || (GetClass() == Class::Berserker))	&& (GetLevel() >= 60))
 		SetSpecialAbility(SPECATK_TRIPLE, 1);
 }
 
@@ -5874,7 +5874,7 @@ bool Bot::DoFinishedSpellSingleTarget(uint16 spell_id, Mob* spellTarget, EQ::spe
 			bool spellequal = (j == thespell);
 			bool spelltypeequal = ((spelltype == 2) || (spelltype == 16) || (spelltype == 32));
 			bool spelltypetargetequal = ((spelltype == 8) && (spells[thespell].target_type == ST_Self));
-			bool spelltypeclassequal = ((spelltype == 1024) && (GetClass() == SHAMAN));
+			bool spelltypeclassequal = ((spelltype == 1024) && (GetClass() == Class::Shaman));
 			bool slotequal = (slot == EQ::spells::CastingSlot::Item);
 			if (spellequal || slotequal) {
 				if ((spelltypeequal || spelltypetargetequal) || spelltypeclassequal || slotequal) {
@@ -5896,7 +5896,7 @@ bool Bot::DoFinishedSpellSingleTarget(uint16 spell_id, Mob* spellTarget, EQ::spe
 			if (g) {
 				for (int i = 0; i < MAX_GROUP_MEMBERS; i++) {
 					if (g->members[i]) {
-						if ((g->members[i]->GetClass() == NECROMANCER) && (IsEffectInSpell(thespell, SE_AbsorbMagicAtt) || IsEffectInSpell(thespell, SE_Rune))) {
+						if ((g->members[i]->GetClass() == Class::Necromancer) && (IsEffectInSpell(thespell, SE_AbsorbMagicAtt) || IsEffectInSpell(thespell, SE_Rune))) {
 						}
 						else
 							SpellOnTarget(thespell, g->members[i]);
@@ -5917,7 +5917,7 @@ bool Bot::DoFinishedSpellGroupTarget(uint16 spell_id, Mob* spellTarget, EQ::spel
 	bool isMainGroupMGB = false;
 	Raid* raid = entity_list.GetRaidByBotName(GetName());
 
-	if (isMainGroupMGB && (GetClass() != BARD)) {
+	if (isMainGroupMGB && (GetClass() != Class::Bard)) {
 		BotGroupSay(
 			this,
 			fmt::format(
@@ -6201,7 +6201,7 @@ int32 Bot::CalcCHA() {
 
 int32 Bot::CalcMR() {
 	MR += (itembonuses.MR + spellbonuses.MR + aabonuses.MR);
-	if (GetClass() == WARRIOR)
+	if (GetClass() == Class::Warrior)
 		MR += (GetLevel() / 2);
 
 	if (MR < 1)
@@ -6215,7 +6215,7 @@ int32 Bot::CalcMR() {
 
 int32 Bot::CalcFR() {
 	int c = GetClass();
-	if (c == RANGER) {
+	if (c == Class::Ranger) {
 		FR += 4;
 		int l = GetLevel();
 		if (l > 49)
@@ -6235,12 +6235,12 @@ int32 Bot::CalcFR() {
 
 int32 Bot::CalcDR() {
 	int c = GetClass();
-	if (c == PALADIN) {
+	if (c == Class::Paladin) {
 		DR += 8;
 		int l = GetLevel();
 		if (l > 49)
 			DR += (l - 49);
-	} else if (c == SHADOWKNIGHT) {
+	} else if (c == Class::ShadowKnight) {
 		DR += 4;
 		int l = GetLevel();
 		if (l > 49)
@@ -6259,12 +6259,12 @@ int32 Bot::CalcDR() {
 
 int32 Bot::CalcPR() {
 	int c = GetClass();
-	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)
@@ -6284,7 +6284,7 @@ int32 Bot::CalcPR() {
 
 int32 Bot::CalcCR() {
 	int c = GetClass();
-	if (c == RANGER) {
+	if (c == Class::Ranger) {
 		CR += 4;
 		int l = GetLevel();
 		if (l > 49)
@@ -6401,7 +6401,7 @@ int64 Bot::CalcManaRegen() {
 	int32 regen = 0;
 	if (IsSitting()) {
 		BuffFadeBySitModifier();
-		if (botclass != WARRIOR && botclass != MONK && botclass != ROGUE && botclass != BERSERKER) {
+		if (botclass != Class::Warrior && botclass != Class::Monk && botclass != Class::Rogue && botclass != Class::Berserker) {
 			regen = ((((GetSkill(EQ::skills::SkillMeditate) / 10) + (level - (level / 4))) / 4) + 4);
 			regen += (spellbonuses.ManaRegen + itembonuses.ManaRegen);
 		} else
@@ -6423,25 +6423,25 @@ int64 Bot::CalcManaRegen() {
 uint64 Bot::GetClassHPFactor() {
 	uint32 factor;
 	switch (GetClass()) {
-		case BEASTLORD:
-		case BERSERKER:
-		case MONK:
-		case ROGUE:
-		case SHAMAN:
+		case Class::Beastlord:
+		case Class::Berserker:
+		case Class::Monk:
+		case Class::Rogue:
+		case Class::Shaman:
 			factor = 255;
 			break;
-		case BARD:
-		case CLERIC:
+		case Class::Bard:
+		case Class::Cleric:
 			factor = 264;
 			break;
-		case SHADOWKNIGHT:
-		case PALADIN:
+		case Class::ShadowKnight:
+		case Class::Paladin:
 			factor = 288;
 			break;
-		case RANGER:
+		case Class::Ranger:
 			factor = 276;
 			break;
-		case WARRIOR:
+		case Class::Warrior:
 			factor = 300;
 			break;
 		default:
@@ -6682,46 +6682,46 @@ void Bot::UpdateGroupCastingRoles(const Group* group, bool disband)
 
 		// GroupHealer
 		switch (iter->GetClass()) {
-		case CLERIC:
+		case Class::Cleric:
 			if (!healer)
 				healer = iter;
 			else
 				switch (healer->GetClass()) {
-				case CLERIC:
+				case Class::Cleric:
 					break;
 				default:
 					healer = iter;
 				}
 
 			break;
-		case DRUID:
+		case Class::Druid:
 			if (!healer)
 				healer = iter;
 			else
 				switch (healer->GetClass()) {
-				case CLERIC:
-				case DRUID:
+				case Class::Cleric:
+				case Class::Druid:
 					break;
 				default:
 					healer = iter;
 				}
 			break;
-		case SHAMAN:
+		case Class::Shaman:
 			if (!healer)
 				healer = iter;
 			else
 				switch (healer->GetClass()) {
-				case CLERIC:
-				case DRUID:
-				case SHAMAN:
+				case Class::Cleric:
+				case Class::Druid:
+				case Class::Shaman:
 					break;
 				default:
 					healer = iter;
 				}
 			break;
-		case PALADIN:
-		case RANGER:
-		case BEASTLORD:
+		case Class::Paladin:
+		case Class::Ranger:
+		case Class::Beastlord:
 			if (!healer)
 				healer = iter;
 			break;
@@ -6731,30 +6731,30 @@ void Bot::UpdateGroupCastingRoles(const Group* group, bool disband)
 
 		// GroupSlower
 		switch (iter->GetClass()) {
-		case SHAMAN:
+		case Class::Shaman:
 			if (!slower)
 				slower = iter;
 			else
 				switch (slower->GetClass()) {
-				case SHAMAN:
+				case Class::Shaman:
 					break;
 				default:
 					slower = iter;
 				}
 			break;
-		case ENCHANTER:
+		case Class::Enchanter:
 			if (!slower)
 				slower = iter;
 			else
 				switch (slower->GetClass()) {
-				case SHAMAN:
-				case ENCHANTER:
+				case Class::Shaman:
+				case Class::Enchanter:
 					break;
 				default:
 					slower = iter;
 				}
 			break;
-		case BEASTLORD:
+		case Class::Beastlord:
 			if (!slower)
 				slower = iter;
 			break;
@@ -6985,7 +6985,7 @@ void Bot::CalcBotStats(bool showtext) {
 
 	taunt_timer.Start(1000);
 
-	if (GetClass() == MONK && GetLevel() >= 10) {
+	if (GetClass() == Class::Monk && GetLevel() >= 10) {
 		monkattack_timer.Start(1000);
 	}
 
@@ -6997,7 +6997,7 @@ void Bot::CalcBotStats(bool showtext) {
 		GetBotOwner()->Message(Chat::Yellow, "Level: %i HP: %i AC: %i Mana: %i STR: %i STA: %i DEX: %i AGI: %i INT: %i WIS: %i CHA: %i", GetLevel(), base_hp, AC, max_mana, STR, STA, DEX, AGI, INT, WIS, CHA);
 		GetBotOwner()->Message(Chat::Yellow, "Resists-- Magic: %i, Poison: %i, Fire: %i, Cold: %i, Disease: %i, Corruption: %i.",MR,PR,FR,CR,DR,Corrup);
 		// Test Code
-		if (GetClass() == BARD)
+		if (GetClass() == Class::Bard)
 			GetBotOwner()->Message(Chat::Yellow, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i",
 			GetSkill(EQ::skills::SkillBrassInstruments), GetSkill(EQ::skills::SkillPercussionInstruments), GetSkill(EQ::skills::SkillSinging), GetSkill(EQ::skills::SkillStringedInstruments), GetSkill(EQ::skills::SkillWindInstruments));
 	}
@@ -7014,7 +7014,7 @@ void Bot::CalcBotStats(bool showtext) {
 		GetBotOwner()->Message(Chat::Yellow, "Level: %i HP: %i AC: %i Mana: %i STR: %i STA: %i DEX: %i AGI: %i INT: %i WIS: %i CHA: %i", GetLevel(), max_hp, GetAC(), max_mana, GetSTR(), GetSTA(), GetDEX(), GetAGI(), GetINT(), GetWIS(), GetCHA());
 		GetBotOwner()->Message(Chat::Yellow, "Resists-- Magic: %i, Poison: %i, Fire: %i, Cold: %i, Disease: %i, Corruption: %i.",GetMR(),GetPR(),GetFR(),GetCR(),GetDR(),GetCorrup());
 		// Test Code
-		if (GetClass() == BARD) {
+		if (GetClass() == Class::Bard) {
 			GetBotOwner()->Message(Chat::Yellow, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i",
 				GetSkill(EQ::skills::SkillBrassInstruments) + GetBrassMod(),
 				GetSkill(EQ::skills::SkillPercussionInstruments) + GetPercMod(),
@@ -7057,7 +7057,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 	uint8 botCasterClass = caster->GetClass();
 
 	if (iSpellTypes == SpellType_Heal)	{
-		if (botCasterClass == CLERIC || botCasterClass == DRUID || botCasterClass == SHAMAN) {
+		if (botCasterClass == Class::Cleric || botCasterClass == Class::Druid || botCasterClass == Class::Shaman) {
 			if (caster->IsRaidGrouped()) {
 				Raid* raid = entity_list.GetRaidByBotName(caster->GetName());
 				uint32 gid = raid->GetGroup(caster->GetName());
@@ -7069,11 +7069,11 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 								if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 									return true;
 							}
-							else if ((iter->member->GetClass() == WARRIOR || iter->member->GetClass() == PALADIN || iter->member->GetClass() == SHADOWKNIGHT) && iter->member->GetHPRatio() < 95) {
+							else if ((iter->member->GetClass() == Class::Warrior || iter->member->GetClass() == Class::Paladin || iter->member->GetClass() == Class::ShadowKnight) && iter->member->GetHPRatio() < 95) {
 								if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 									return true;
 							}
-							else if (iter->member->GetClass() == ENCHANTER && iter->member->GetHPRatio() < 80) {
+							else if (iter->member->GetClass() == Class::Enchanter && iter->member->GetHPRatio() < 80) {
 								if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 									return true;
 							}
@@ -7085,7 +7085,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 						}
 
 						if (iter->member && !iter->member->qglobal && iter->member->HasPet() && iter->member->GetPet()->GetHPRatio() < 50) {
-							if (iter->member->GetPet()->GetOwner() != caster && caster->IsEngaged() && iter->member->IsCasting() && iter->member->GetClass() != ENCHANTER)
+							if (iter->member->GetPet()->GetOwner() != caster && caster->IsEngaged() && iter->member->IsCasting() && iter->member->GetClass() != Class::Enchanter)
 								continue;
 
 							if (caster->AICastSpell(iter->member->GetPet(), 100, SpellType_Heal))
@@ -7103,10 +7103,10 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 							if (g->members[i]->IsClient() && g->members[i]->GetHPRatio() < 90) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
-							} else if ((g->members[i]->GetClass() == WARRIOR || g->members[i]->GetClass() == PALADIN || g->members[i]->GetClass() == SHADOWKNIGHT) && g->members[i]->GetHPRatio() < 95) {
+							} else if ((g->members[i]->GetClass() == Class::Warrior || g->members[i]->GetClass() == Class::Paladin || g->members[i]->GetClass() == Class::ShadowKnight) && g->members[i]->GetHPRatio() < 95) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
-							} else if (g->members[i]->GetClass() == ENCHANTER && g->members[i]->GetHPRatio() < 80) {
+							} else if (g->members[i]->GetClass() == Class::Enchanter && g->members[i]->GetHPRatio() < 80) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
 							} else if (g->members[i]->GetHPRatio() < 70) {
@@ -7116,7 +7116,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 						}
 
 						if (g->members[i] && !g->members[i]->qglobal && g->members[i]->HasPet() && g->members[i]->GetPet()->GetHPRatio() < 50) {
-							if (g->members[i]->GetPet()->GetOwner() != caster && caster->IsEngaged() && g->members[i]->IsCasting() && g->members[i]->GetClass() != ENCHANTER )
+							if (g->members[i]->GetPet()->GetOwner() != caster && caster->IsEngaged() && g->members[i]->IsCasting() && g->members[i]->GetClass() != Class::Enchanter )
 								continue;
 
 							if (caster->AICastSpell(g->members[i]->GetPet(), 100, SpellType_Heal))
@@ -7127,7 +7127,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 			}
 		}
 
-		if ((botCasterClass == PALADIN || botCasterClass == BEASTLORD || botCasterClass == RANGER) && (caster->HasGroup() || caster->IsRaidGrouped())) {
+		if ((botCasterClass == Class::Paladin || botCasterClass == Class::Beastlord || botCasterClass == Class::Ranger) && (caster->HasGroup() || caster->IsRaidGrouped())) {
 			float hpRatioToHeal = 25.0f;
 			switch(caster->GetBotStance()) {
 			case EQ::constants::stanceReactive:
@@ -7156,12 +7156,12 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 									if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 										return true;
 								} else if (
-									(iter->member->GetClass() == WARRIOR || iter->member->GetClass() == PALADIN ||
-									 iter->member->GetClass() == SHADOWKNIGHT) &&
+									(iter->member->GetClass() == Class::Warrior || iter->member->GetClass() == Class::Paladin ||
+									 iter->member->GetClass() == Class::ShadowKnight) &&
 									iter->member->GetHPRatio() < hpRatioToHeal) {
 									if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 										return true;
-								} else if (iter->member->GetClass() == ENCHANTER &&
+								} else if (iter->member->GetClass() == Class::Enchanter &&
 										   iter->member->GetHPRatio() < hpRatioToHeal) {
 									if (caster->AICastSpell(iter->member, 100, SpellType_Heal))
 										return true;
@@ -7174,7 +7174,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 							if (iter->member && !iter->member->qglobal && iter->member->HasPet() &&
 								iter->member->GetPet()->GetHPRatio() < 25) {
 								if (iter->member->GetPet()->GetOwner() != caster && caster->IsEngaged() &&
-									iter->member->IsCasting() && iter->member->GetClass() != ENCHANTER)
+									iter->member->IsCasting() && iter->member->GetClass() != Class::Enchanter)
 									continue;
 
 								if (caster->AICastSpell(iter->member->GetPet(), 100, SpellType_Heal))
@@ -7191,12 +7191,12 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 							if (g->members[i]->IsClient() && g->members[i]->GetHPRatio() < hpRatioToHeal) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
-							} else if ((g->members[i]->GetClass() == WARRIOR || g->members[i]->GetClass() == PALADIN ||
-										g->members[i]->GetClass() == SHADOWKNIGHT) &&
+							} else if ((g->members[i]->GetClass() == Class::Warrior || g->members[i]->GetClass() == Class::Paladin ||
+										g->members[i]->GetClass() == Class::ShadowKnight) &&
 									   g->members[i]->GetHPRatio() < hpRatioToHeal) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
-							} else if (g->members[i]->GetClass() == ENCHANTER &&
+							} else if (g->members[i]->GetClass() == Class::Enchanter &&
 									   g->members[i]->GetHPRatio() < hpRatioToHeal) {
 								if (caster->AICastSpell(g->members[i], 100, SpellType_Heal))
 									return true;
@@ -7209,7 +7209,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 						if (g->members[i] && !g->members[i]->qglobal && g->members[i]->HasPet() &&
 							g->members[i]->GetPet()->GetHPRatio() < 25) {
 							if (g->members[i]->GetPet()->GetOwner() != caster && caster->IsEngaged() &&
-								g->members[i]->IsCasting() && g->members[i]->GetClass() != ENCHANTER)
+								g->members[i]->IsCasting() && g->members[i]->GetClass() != Class::Enchanter)
 								continue;
 
 							if (caster->AICastSpell(g->members[i]->GetPet(), 100, SpellType_Heal))
@@ -7223,7 +7223,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 
 	if (iSpellTypes == SpellType_Buff) {
 		uint8 chanceToCast = caster->IsEngaged() ? caster->GetChanceToCastBySpellType(SpellType_Buff) : 100;
-		if (botCasterClass == BARD) {
+		if (botCasterClass == Class::Bard) {
 			if (caster->AICastSpell(caster, chanceToCast, SpellType_Buff)) {
 				return true;
 			} else
@@ -7266,7 +7266,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 					if (iter->member && caster->GetNeedsCured(iter->member)) {
 						if (caster->AICastSpell(iter->member, caster->GetChanceToCastBySpellType(SpellType_Cure), SpellType_Cure))
 							return true;
-						else if (botCasterClass == BARD) {
+						else if (botCasterClass == Class::Bard) {
 							return false;
 						}
 					}
@@ -7285,7 +7285,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 					if (g->members[i] && caster->GetNeedsCured(g->members[i])) {
 						if (caster->AICastSpell(g->members[i], caster->GetChanceToCastBySpellType(SpellType_Cure), SpellType_Cure))
 							return true;
-						else if (botCasterClass == BARD)
+						else if (botCasterClass == Class::Bard)
 							return false;
 					}
 
@@ -7329,7 +7329,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 	}
 
 	if (iSpellTypes == SpellType_PreCombatBuff) {
-		if (botCasterClass == BARD || caster->IsEngaged())
+		if (botCasterClass == Class::Bard || caster->IsEngaged())
 			return false;
 
 		//added raid check
@@ -7361,7 +7361,7 @@ bool EntityList::Bot_AICheckCloseBeneficialSpells(Bot* caster, uint8 iChance, fl
 	}
 
 	if (iSpellTypes == SpellType_InCombatBuff) {
-		if (botCasterClass == BARD) {
+		if (botCasterClass == Class::Bard) {
 			if (caster->AICastSpell(caster, iChance, SpellType_InCombatBuff)) {
 				return true;
 			}
@@ -7836,16 +7836,16 @@ bool Bot::GetNeedsHateRedux(Mob *tar) {
 
 	if (tar->IsBot()) {
 		switch (tar->GetClass()) {
-		case ROGUE:
+		case Class::Rogue:
 			if (tar->CanFacestab() || tar->CastToBot()->m_evade_timer.Check(false))
 				return false;
-		case CLERIC:
-		case DRUID:
-		case SHAMAN:
-		case NECROMANCER:
-		case WIZARD:
-		case MAGICIAN:
-		case ENCHANTER:
+		case Class::Cleric:
+		case Class::Druid:
+		case Class::Shaman:
+		case Class::Necromancer:
+		case Class::Wizard:
+		case Class::Magician:
+		case Class::Enchanter:
 			return true;
 		default:
 			return false;
@@ -7874,7 +7874,7 @@ bool Bot::HasOrMayGetAggro() {
 
 void Bot::SetDefaultBotStance() {
 	EQ::constants::StanceType defaultStance = EQ::constants::stanceBalanced;
-	if (GetClass() == WARRIOR)
+	if (GetClass() == Class::Warrior)
 		defaultStance = EQ::constants::stanceAggressive;
 
 	_botStance = defaultStance;
@@ -8707,7 +8707,7 @@ float Bot::GetBotCasterMaxRange(float melee_distance_max) {// Calculate caster d
 	float caster_distance = 0.0f;
 
 	caster_distance_max = GetBotCasterRange() * GetBotCasterRange();
-	if (!GetBotCasterRange() && GetLevel() >= GetStopMeleeLevel() && GetClass() >= WARRIOR && GetClass() <= BERSERKER) {
+	if (!GetBotCasterRange() && GetLevel() >= GetStopMeleeLevel() && GetClass() >= Class::Warrior && GetClass() <= Class::Berserker) {
 		caster_distance_max = MAX_CASTER_DISTANCE[GetClass() - 1];
 	}
 	if (caster_distance_max) {
@@ -8806,4 +8806,4 @@ void Bot::AddBotStartingItems(uint16 race_id, uint8 class_id)
 	}
 }
 
-uint8 Bot::spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND] = { 0 };
+uint8 Bot::spell_casting_chances[SPELL_TYPE_COUNT][Class::PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND] = { 0 };
diff --git a/zone/bot.h b/zone/bot.h
index 2d44da05b..7e62e0e16 100644
--- a/zone/bot.h
+++ b/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);
diff --git a/zone/bot_command.cpp b/zone/bot_command.cpp
index f14386c41..cc4e8a03b 100644
--- a/zone/bot_command.cpp
+++ b/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;
diff --git a/zone/bot_command.h b/zone/bot_command.h
index 83c543108..2e2d9cc59 100644
--- a/zone/bot_command.h
+++ b/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
diff --git a/zone/bot_database.cpp b/zone/bot_database.cpp
index 4107fcf9a..43f7a6ede 100644
--- a/zone/bot_database.cpp
+++ b/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;
diff --git a/zone/botspellsai.cpp b/zone/botspellsai.cpp
index fa93bd955..ba2039fc0 100644
--- a/zone/botspellsai.cpp
+++ b/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;
 
diff --git a/zone/client.cpp b/zone/client.cpp
index 0039334c5..727e69684 100644
--- a/zone/client.cpp
+++ b/zone/client.cpp
@@ -2676,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);
@@ -2684,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));
@@ -2692,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)));
@@ -3028,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;
 						}
 
@@ -3077,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;
 						}
 
@@ -4232,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;
 	}
@@ -4849,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());
@@ -4918,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())
 		{
@@ -4961,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())
 			{
@@ -5011,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())
 			{
@@ -8603,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:
@@ -9754,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;
 		}
 
@@ -9825,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;
 		}
 
@@ -10694,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;
diff --git a/zone/client.h b/zone/client.h
index 9e8087e0e..4e4231e20 100644
--- a/zone/client.h
+++ b/zone/client.h
@@ -2045,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:
diff --git a/zone/client_mods.cpp b/zone/client_mods.cpp
index c83d253f5..3079be305 100644
--- a/zone/client_mods.cpp
+++ b/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)
diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp
index 46c1ef804..0e60a82ee 100644
--- a/zone/client_packet.cpp
+++ b/zone/client_packet.cpp
@@ -1381,7 +1381,7 @@ 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();
@@ -1592,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);
@@ -1935,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
@@ -2121,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()) {
@@ -2197,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;
@@ -2298,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;
@@ -2482,7 +2482,7 @@ void Client::Handle_OP_AltCurrencyMerchantRequest(const EQApplicationPacket *app
 			return;
 		}
 
-		if (target->GetClass() != ALT_CURRENCY_MERCHANT) {
+		if (target->GetClass() != Class::AlternateCurrencyMerchant) {
 			return;
 		}
 
@@ -2553,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;
 		}
 
@@ -2722,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;
 		}
 
@@ -2858,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;
 		}
 
@@ -2966,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);
@@ -3926,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);
@@ -4471,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);
@@ -4481,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);
@@ -5122,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;
 	}
@@ -8626,7 +8626,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;
@@ -9175,7 +9175,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;
 			}
@@ -9341,7 +9341,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 {
@@ -9413,7 +9413,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 {
@@ -9549,7 +9549,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) {
@@ -9878,7 +9878,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;
@@ -10219,7 +10219,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;
 		}
 
@@ -10594,7 +10594,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);
@@ -10625,7 +10625,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);
@@ -13531,7 +13531,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
 		return;
 	}
 
-	if (GetClass() != WARRIOR){
+	if (GetClass() != Class::Warrior){
 		return;
 	}
 
@@ -13587,7 +13587,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;
@@ -13896,7 +13896,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
@@ -14122,7 +14122,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
@@ -14229,7 +14229,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;
@@ -15545,7 +15545,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;
@@ -15572,7 +15572,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;
diff --git a/zone/client_process.cpp b/zone/client_process.cpp
index 9c5f4ba87..e045b13cf 100644
--- a/zone/client_process.cpp
+++ b/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;
 	}
diff --git a/zone/effects.cpp b/zone/effects.cpp
index c7d3ff34a..fa6e75e03 100644
--- a/zone/effects.cpp
+++ b/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
 		}
 
@@ -426,7 +426,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);
@@ -632,7 +632,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 +906,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 +921,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 +1320,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);
diff --git a/zone/entity.cpp b/zone/entity.cpp
index c4e82a4e8..bc14edb87 100644
--- a/zone/entity.cpp
+++ b/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){
diff --git a/zone/entity.h b/zone/entity.h
index 27c749efb..20a368298 100644
--- a/zone/entity.h
+++ b/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);
diff --git a/zone/exp.cpp b/zone/exp.cpp
index d95aa7f66..7f5d34ae1 100644
--- a/zone/exp.cpp
+++ b/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;
 		}
 
diff --git a/zone/gm_commands/find/class.cpp b/zone/gm_commands/find/class.cpp
index c838e0a93..2ce3b1707 100644
--- a/zone/gm_commands/find/class.cpp
+++ b/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)) {
diff --git a/zone/gm_commands/merchantshop.cpp b/zone/gm_commands/merchantshop.cpp
index 9a803f363..686fe2c27 100755
--- a/zone/gm_commands/merchantshop.cpp
+++ b/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.");
diff --git a/zone/gm_commands/scribespell.cpp b/zone/gm_commands/scribespell.cpp
index 03594464f..b3c5b3902 100755
--- a/zone/gm_commands/scribespell.cpp
+++ b/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)
diff --git a/zone/heal_rotation.cpp b/zone/heal_rotation.cpp
index ff5f2287a..66793c580 100644
--- a/zone/heal_rotation.cpp
+++ b/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;
diff --git a/zone/lua_general.cpp b/zone/lua_general.cpp
index 616376dcd..651fb28d0 100644
--- a/zone/lua_general.cpp
+++ b/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)
 		)];
 }
 
diff --git a/zone/merc.cpp b/zone/merc.cpp
index aa13d955f..16f6a8bf5 100644
--- a/zone/merc.cpp
+++ b/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;
 										}
diff --git a/zone/mob.cpp b/zone/mob.cpp
index a68889ddf..5e2a4430f 100644
--- a/zone/mob.cpp
+++ b/zone/mob.cpp
@@ -983,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;
 
@@ -1022,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:
@@ -1069,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:
@@ -1346,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;
 		}
 	}
@@ -2118,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();
@@ -2419,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);
 	}
 
@@ -2688,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();
@@ -4531,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;
@@ -4564,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;
 		}
@@ -5185,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;
 	}
@@ -7520,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)
@@ -8264,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";
diff --git a/zone/mob_ai.cpp b/zone/mob_ai.cpp
index a1c0b6837..e3e9a54c4 100644
--- a/zone/mob_ai.cpp
+++ b/zone/mob_ai.cpp
@@ -1330,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();
 					}
@@ -1382,7 +1382,7 @@ void Mob::AI_Process() {
 			}
 		}
 		if (AI_IdleCastCheck()) {
-			if (IsCasting() && GetClass() != BARD) {
+			if (IsCasting() && GetClass() != Class::Bard) {
 				StopNavigation();
 			}
 		}
diff --git a/zone/npc.cpp b/zone/npc.cpp
index 864cc99d0..5a0900295 100644
--- a/zone/npc.cpp
+++ b/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();
 		}
 	}
diff --git a/zone/npc_scale_manager.cpp b/zone/npc_scale_manager.cpp
index 5949b7e8e..39d6daa8f 100644
--- a/zone/npc_scale_manager.cpp
+++ b/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;
 			}
diff --git a/zone/petitions.cpp b/zone/petitions.cpp
index e3c04d637..1610ad82c 100644
--- a/zone/petitions.cpp
+++ b/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;
diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp
index 0c97e0a35..eab4fc95b 100644
--- a/zone/questmgr.cpp
+++ b/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;
diff --git a/zone/questmgr.h b/zone/questmgr.h
index 17b0cfb57..5ab509ed4 100644
--- a/zone/questmgr.h
+++ b/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);
 
diff --git a/zone/special_attacks.cpp b/zone/special_attacks.cpp
index 633cf4a73..6afb82143 100644
--- a/zone/special_attacks.cpp
+++ b/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++;
diff --git a/zone/spell_effects.cpp b/zone/spell_effects.cpp
index 44ab67c46..b7539c821 100644
--- a/zone/spell_effects.cpp
+++ b/zone/spell_effects.cpp
@@ -441,7 +441,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
 			case SE_CurrentMana:
 			{
 				// Bards don't get mana from effects, good or bad.
-				if(GetClass() == BARD)
+				if(GetClass() == Class::Bard)
 					break;
 				if(IsManaTapSpell(spell_id)) {
 					if(GetCasterClass() != 'N') {
@@ -478,7 +478,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
 			case SE_CurrentManaOnce:
 			{
 				// Bards don't get mana from effects, good or bad.
-				if(GetClass() == BARD)
+				if(GetClass() == Class::Bard)
 					break;
 #ifdef SPELL_EFFECT_SPAM
 				snprintf(effect_desc, _EDLEN, "Current Mana Once: %+i", effect_value);
@@ -3432,7 +3432,7 @@ int64 Mob::CalcSpellEffectValue(uint16 spell_id, int effect_id, int caster_level
 	*/
 
 	//This is checked from Mob::SpellEffects and applied to instant spells and runes.
-	if (caster && caster->GetClass() != BARD && caster->HasBaseEffectFocus()) {
+	if (caster && caster->GetClass() != Class::Bard && caster->HasBaseEffectFocus()) {
 
 		oval = effect_value;
 		int mod = caster->GetFocusEffect(focusFcBaseEffects, spell_id);
@@ -3445,7 +3445,7 @@ int64 Mob::CalcSpellEffectValue(uint16 spell_id, int effect_id, int caster_level
 	else if (caster_id && instrument_mod > 10) {
 
 		Mob* buff_caster = entity_list.GetMob(caster_id);//If targeted bard song needed to confirm caster is not bard.
-		if (buff_caster && buff_caster->GetClass() != BARD) {
+		if (buff_caster && buff_caster->GetClass() != Class::Bard) {
 			oval = effect_value;
 			effect_value = effect_value * static_cast<int>(instrument_mod) / 10;
 
@@ -3991,7 +3991,7 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
 		case SE_Charm: {
 			if (!caster || !PassCharismaCheck(caster, buff.spellid)) {
 				BuffFadeByEffect(SE_Charm);
-				
+
 				// Remove from hate list of any NPC's hate list and remove all NPCs this hate list
 				if (IsNPC()) {
 					entity_list.RemoveFromHateLists(this);
@@ -7248,7 +7248,7 @@ bool Mob::PassLimitClass(uint32 Classes_, uint16 Class_)
 		return false;
 
 	Class_ += 1;
-	for (int CurrentClass = 1; CurrentClass <= PLAYER_CLASS_COUNT; ++CurrentClass){
+	for (int CurrentClass = 1; CurrentClass <= Class::PLAYER_CLASS_COUNT; ++CurrentClass){
 		if (Classes_ % 2 == 1){
 			if (CurrentClass == Class_)
 				return true;
@@ -7481,7 +7481,7 @@ bool Mob::PassCastRestriction(int value)
 
 		case IS_CLASS_WIZARD:
 		case IS_WIZARD_USED_ON_MAGE_FIRE_PET:
-			if (GetClass() == WIZARD)
+			if (GetClass() == Class::Wizard)
 				return true;
 			break;
 
@@ -7521,12 +7521,12 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLASS_MELEE_THAT_CAN_BASH_OR_KICK_EXCEPT_BARD:
-			if ((GetClass() != BARD) && (GetClass() != ROGUE) && IsFighterClass(GetClass()))
+			if ((GetClass() != Class::Bard) && (GetClass() != Class::Rogue) && IsFighterClass(GetClass()))
 				return true;
 			break;
 
 		case IS_CLASS_PURE_MELEE:
-			if (GetClass() == ROGUE || GetClass() == WARRIOR || GetClass() == BERSERKER || GetClass() == MONK)
+			if (GetClass() == Class::Rogue || GetClass() == Class::Warrior || GetClass() == Class::Berserker || GetClass() == Class::Monk)
 				return true;
 			break;
 
@@ -7541,78 +7541,78 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLASS_WARRIOR:
-			if (GetClass() == WARRIOR)
+			if (GetClass() == Class::Warrior)
 				return true;
 			break;
 
 		case IS_CLASS_CLERIC:
-			if (GetClass() == CLERIC)
+			if (GetClass() == Class::Cleric)
 				return true;
 			break;
 
 		case IS_CLASS_PALADIN:
-			if (GetClass() == PALADIN)
+			if (GetClass() == Class::Paladin)
 				return true;
 			break;
 
 		case IS_CLASS_RANGER:
-			if (GetClass() == RANGER)
+			if (GetClass() == Class::Ranger)
 				return true;
 			break;
 
 		case IS_CLASS_SHADOWKNIGHT:
-			if (GetClass() == SHADOWKNIGHT)
+			if (GetClass() == Class::ShadowKnight)
 				return true;
 			break;
 
 		case IS_CLASS_DRUID:
-			if (GetClass() == DRUID)
+			if (GetClass() == Class::Druid)
 				return true;
 			break;
 
 		case IS_CLASS_MONK:
-			if (GetClass() == MONK)
+			if (GetClass() == Class::Monk)
 				return true;
 			break;
 
 		case IS_CLASS_BARD2:
 		case IS_CLASS_BARD:
-			if (GetClass() == BARD)
+			if (GetClass() == Class::Bard)
 				return true;
 			break;
 
 		case IS_CLASS_ROGUE:
-			if (GetClass() == ROGUE)
+			if (GetClass() == Class::Rogue)
 				return true;
 			break;
 
 		case IS_CLASS_SHAMAN:
-			if (GetClass() == SHAMAN)
+			if (GetClass() == Class::Shaman)
 				return true;
 			break;
 
 		case IS_CLASS_NECRO:
-			if (GetClass() == NECROMANCER)
+			if (GetClass() == Class::Necromancer)
 				return true;
 			break;
 
 		case IS_CLASS_MAGE:
-			if (GetClass() == MAGICIAN)
+			if (GetClass() == Class::Magician)
 				return true;
 			break;
 
 		case IS_CLASS_ENCHANTER:
-			if (GetClass() == ENCHANTER)
+			if (GetClass() == Class::Enchanter)
 				return true;
 			break;
 
 		case IS_CLASS_BEASTLORD:
-			if (GetClass() == BEASTLORD)
+			if (GetClass() == Class::Beastlord)
 				return true;
 			break;
 
 		case IS_CLASS_BERSERKER:
-			if (GetClass() == BERSERKER)
+			if (GetClass() == Class::Berserker)
 				return true;
 			break;
 
@@ -7622,7 +7622,7 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLASS_NOT_WAR_PAL_SK:
-			if ((GetClass() != WARRIOR) && (GetClass() != PALADIN) && (GetClass() != SHADOWKNIGHT))
+			if ((GetClass() != Class::Warrior) && (GetClass() != Class::Paladin) && (GetClass() != Class::ShadowKnight))
 				return true;
 			break;
 
@@ -7722,8 +7722,8 @@ bool Mob::PassCastRestriction(int value)
 		}
 
 		case IS_CLASS_CHAIN_OR_PLATE:
-			if ((GetClass() == WARRIOR) || (GetClass() == BARD) || (GetClass() == SHADOWKNIGHT) || (GetClass() == PALADIN) || (GetClass() == CLERIC)
-				|| (GetClass() == RANGER) || (GetClass() == SHAMAN) || (GetClass() == ROGUE) || (GetClass() == BERSERKER)) {
+			if ((GetClass() == Class::Warrior) || (GetClass() == Class::Bard) || (GetClass() == Class::ShadowKnight) || (GetClass() == Class::Paladin) || (GetClass() == Class::Cleric)
+				|| (GetClass() == Class::Ranger) || (GetClass() == Class::Shaman) || (GetClass() == Class::Rogue) || (GetClass() == Class::Berserker)) {
 				return true;
 			}
 			break;
@@ -7914,7 +7914,7 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLASS_WARRIOR_CASTER_PRIEST:
-			if (IsCasterClass(GetClass()) || GetClass() == WARRIOR)
+			if (IsCasterClass(GetClass()) || GetClass() == Class::Warrior)
 				return true;
 			break;
 
@@ -8082,13 +8082,13 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLEINT_AND_MALE_DRUID_ENCHANTER_MAGICIAN_NECROANCER_SHAMAN_OR_WIZARD:
-			if (IsClient() && GetGender() == MALE && (IsCasterClass(GetClass()) && GetClass() != CLERIC))
+			if (IsClient() && GetGender() == MALE && (IsCasterClass(GetClass()) && GetClass() != Class::Cleric))
 				return true;
 			break;
 
 		case IS_CLIENT_AND_MALE_BEASTLORD_BERSERKER_MONK_RANGER_OR_ROGUE:
 			if (IsClient() && GetGender() == MALE &&
-				(GetClass() == BEASTLORD || GetClass() == BERSERKER || GetClass() == MONK || GetClass() == RANGER || GetClass() == ROGUE))
+				(GetClass() == Class::Beastlord || GetClass() == Class::Berserker || GetClass() == Class::Monk || GetClass() == Class::Ranger || GetClass() == Class::Rogue))
 				return true;
 			break;
 
@@ -8098,13 +8098,13 @@ bool Mob::PassCastRestriction(int value)
 			break;
 
 		case IS_CLIENT_AND_FEMALE_DRUID_ENCHANTER_MAGICIAN_NECROANCER_SHAMAN_OR_WIZARD:
-			if (IsClient() && GetGender() == FEMALE && (IsCasterClass(GetClass()) && GetClass() != CLERIC))
+			if (IsClient() && GetGender() == FEMALE && (IsCasterClass(GetClass()) && GetClass() != Class::Cleric))
 				return true;
 			break;
 
 		case IS_CLIENT_AND_FEMALE_BEASTLORD_BERSERKER_MONK_RANGER_OR_ROGUE:
 			if (IsClient() && GetGender() == FEMALE &&
-				(GetClass() == BEASTLORD || GetClass() == BERSERKER || GetClass() == MONK || GetClass() == RANGER || GetClass() == ROGUE))
+				(GetClass() == Class::Beastlord || GetClass() == Class::Berserker || GetClass() == Class::Monk || GetClass() == Class::Ranger || GetClass() == Class::Rogue))
 				return true;
 			break;
 
@@ -8177,7 +8177,7 @@ bool Mob::PassCastRestriction(int value)
 		}
 
 		case IS_NOT_CLASS_BARD:
-			if (GetClass() != BARD)
+			if (GetClass() != Class::Bard)
 				return true;
 			break;
 
diff --git a/zone/spells.cpp b/zone/spells.cpp
index ac958e495..02da6f7a3 100644
--- a/zone/spells.cpp
+++ b/zone/spells.cpp
@@ -1094,7 +1094,7 @@ bool Client::CheckFizzle(uint16 spell_id)
 	float diff = par_skill + static_cast<float>(spells[spell_id].base_difficulty) - act_skill;
 
 	// if you have high int/wis you fizzle less, you fizzle more if you are stupid
-	if(GetClass() == BARD)
+	if(GetClass() == Class::Bard)
 	{
 		diff -= (GetCHA() - 110) / 20.0;
 	}
@@ -1381,7 +1381,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
 	Mob *spell_target = entity_list.GetMob(target_id);
 	// here we do different things if this is a bard casting a bard song from
 	// a spell bar slot
-	if(GetClass() == BARD) // bard's can move when casting any spell...
+	if(GetClass() == Class::Bard) // bard's can move when casting any spell...
 	{
 		if (IsBardSong(spell_id) && slot < CastingSlot::MaxGems) {
 			if (spells[spell_id].buff_duration == 0xFFFF) {
@@ -1938,7 +1938,7 @@ bool Mob::DetermineSpellTargets(uint16 spell_id, Mob *&spell_target, Mob *&ae_ce
 						return false;
 					}
 
-					if(spell_target->GetClass() != LDON_TREASURE)
+					if(spell_target->GetClass() != Class::LDoNTreasure)
 					{
 						LogSpells("Spell [{}] canceled: invalid target (normal)", spell_id);
 						MessageString(Chat::Red,SPELL_NEED_TAR);
@@ -2694,7 +2694,7 @@ bool Mob::SpellFinished(uint16 spell_id, Mob *spell_target, CastingSlot slot, in
 			}
 		}
 		//handle bard AA and Discipline recast timers when singing
-		if (GetClass() == BARD && spell_id != casting_spell_id && timer != 0xFFFFFFFF) {
+		if (GetClass() == Class::Bard && spell_id != casting_spell_id && timer != 0xFFFFFFFF) {
 			CastToClient()->GetPTimers().Start(timer, timer_duration);
 			LogSpells("Spell [{}]: Setting BARD custom reuse timer [{}] to [{}]", spell_id, casting_spell_timer, casting_spell_timer_duration);
 		}
@@ -3150,8 +3150,8 @@ int Mob::CheckStackConflict(uint16 spellid1, int caster_level1, uint16 spellid2,
 		if(effect1 != effect2)
 			continue;
 
-		if (IsBardOnlyStackEffect(effect1) && GetSpellLevel(spellid1, BARD) != 255 &&
-			GetSpellLevel(spellid2, BARD) != 255)
+		if (IsBardOnlyStackEffect(effect1) && GetSpellLevel(spellid1, Class::Bard) != 255 &&
+			GetSpellLevel(spellid2, Class::Bard) != 255)
 			continue;
 
 		// big ol' list according to the client, wasn't that nice!
@@ -6206,7 +6206,7 @@ bool Mob::UseBardSpellLogic(uint16 spell_id, int slot)
 	(
 		IsValidSpell(spell_id) &&
 		slot != -1 &&
-		GetClass() == BARD &&
+		GetClass() == Class::Bard &&
 		slot <= EQ::spells::SPELL_GEM_COUNT &&
 		IsBardSong(spell_id)
 	);
diff --git a/zone/tradeskills.cpp b/zone/tradeskills.cpp
index fc4635804..81c927f72 100644
--- a/zone/tradeskills.cpp
+++ b/zone/tradeskills.cpp
@@ -448,7 +448,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
 
 	//changing from a switch to string of if's since we don't need to iterate through all of the skills in the SkillType enum
 	if (spec.tradeskill == EQ::skills::SkillAlchemy) {
-		if (user_pp.class_ != SHAMAN) {
+		if (user_pp.class_ != Class::Shaman) {
 			user->Message(Chat::Red, "This tradeskill can only be performed by a shaman.");
 			auto outapp = new EQApplicationPacket(OP_TradeSkillCombine, 0);
 			user->QueuePacket(outapp);
@@ -473,7 +473,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
 		}
 	}
 	else if (spec.tradeskill == EQ::skills::SkillMakePoison) {
-		if (user_pp.class_ != ROGUE) {
+		if (user_pp.class_ != Class::Rogue) {
 			user->Message(Chat::Red, "Only rogues can mix poisons.");
 			auto outapp = new EQApplicationPacket(OP_TradeSkillCombine, 0);
 			user->QueuePacket(outapp);
diff --git a/zone/tune.cpp b/zone/tune.cpp
index a3ec9825f..68f648c4b 100644
--- a/zone/tune.cpp
+++ b/zone/tune.cpp
@@ -1068,14 +1068,14 @@ int64 Mob::TuneACSum(bool skip_caps, int ac_override, int add_ac)
 		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;
@@ -1423,7 +1423,7 @@ void Mob::TuneCommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraA
 
 	// 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)
@@ -1436,7 +1436,7 @@ void Mob::TuneCommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraA
 		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);
@@ -1461,7 +1461,7 @@ void Mob::TuneCommonOutgoingHitSuccess(Mob* defender, DamageHitInfo &hit, ExtraA
 				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;
 	}