breakout the component types into a scoped enum (#1002)

* breakout the component types into a scoped enum

tested that things are the same as they were before

* fix missed rename

* fix brick-by-brick name to be crafting
because that's what it is

dCommon/GeneralUtils.h

@@ -15,6 +15,7 @@
 #include "dLogger.h"
 
 enum eInventoryType : uint32_t;
+enum class eReplicaComponentType : uint32_t;
 
 /*!
   \file GeneralUtils.hpp
@@ -181,6 +182,11 @@ namespace GeneralUtils {
 		return static_cast<eInventoryType>(std::stoul(value));
 	}
 
+	template <>
+	inline eReplicaComponentType Parse(const char* value) {
+		return static_cast<eReplicaComponentType>(std::stoul(value));
+	}
+
 	template <typename T>
 	bool TryParse(const char* value, T& dst) {
 		try {

dCommon/dEnums/dCommonVars.h

@@ -365,57 +365,6 @@ enum eNotifyType {
 	NOTIFY_TYPE_NAMINGPET
 };
 
-enum eReplicaComponentType : int32_t {
-	COMPONENT_TYPE_CONTROLLABLE_PHYSICS = 1,			//!< The ControllablePhysics Component
-	COMPONENT_TYPE_RENDER = 2,			//!< The Render Component
-	COMPONENT_TYPE_SIMPLE_PHYSICS = 3,			//!< The SimplePhysics Component
-	COMPONENT_TYPE_CHARACTER = 4,			//!< The Character Component
-	COMPONENT_TYPE_SCRIPT = 5,			//!< The Script Component
-	COMPONENT_TYPE_BOUNCER = 6,			//!< The Bouncer Component
-	COMPONENT_TYPE_BUFF = 7,			//!< The Buff Component
-	COMPONENT_TYPE_SKILL = 9,			//!< The Skill Component
-	COMPONENT_TYPE_ITEM = 11,			//!< The Item Component
-	COMPONENT_TYPE_VENDOR = 16,			//!< The Vendor Component
-	COMPONENT_TYPE_INVENTORY = 17,			//!< The Inventory Component
-	COMPONENT_TYPE_SHOOTING_GALLERY = 19,			//!< The Shooting Gallery Component
-	COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS = 20,			//!< The RigidBodyPhantomPhysics Component
-	COMPONENT_TYPE_COLLECTIBLE = 23,			//!< The Collectible Component
-	COMPONENT_TYPE_MOVING_PLATFORM = 25,			//!< The MovingPlatform Component
-	COMPONENT_TYPE_PET = 26,			//!< The Pet Component
-	COMPONENT_TYPE_VEHICLE_PHYSICS = 30,			//!< The VehiclePhysics Component
-	COMPONENT_TYPE_MOVEMENT_AI = 31,			//!< The MovementAI Component
-	COMPONENT_TYPE_PROPERTY = 36,			//!< The Property Component
-	COMPONENT_TYPE_SCRIPTED_ACTIVITY = 39,			//!< The ScriptedActivity Component
-	COMPONENT_TYPE_PHANTOM_PHYSICS = 40,			//!< The PhantomPhysics Component
-	COMPONENT_TYPE_MODEL = 42,			//!< The Model Component
-	COMPONENT_TYPE_PROPERTY_ENTRANCE = 43,			//!< The PhantomPhysics Component
-	COMPONENT_TYPE_PROPERTY_MANAGEMENT = 45,			//!< The PropertyManagement Component
-	COMPONENT_TYPE_REBUILD = 48,			//!< The Rebuild Component
-	COMPONENT_TYPE_SWITCH = 49,			//!< The Switch Component
-	COMPONENT_TYPE_ZONE_CONTROL = 50,			//!< The ZoneControl Component
-	COMPONENT_TYPE_PACKAGE = 53,			//!< The Package Component
-	COMPONENT_TYPE_PLAYER_FLAG = 58,			//!< The PlayerFlag Component
-	COMPONENT_TYPE_BASE_COMBAT_AI = 60,			//!< The BaseCombatAI Component
-	COMPONENT_TYPE_MODULE_ASSEMBLY = 61,			//!< The ModuleAssembly Component
-	COMPONENT_TYPE_PROPERTY_VENDOR = 65,			//!< The PropertyVendor Component
-	COMPONENT_TYPE_ROCKET_LAUNCH = 67,			//!< The RocketLaunch Component
-	COMPONENT_TYPE_TRIGGER = 69,
-	COMPONENT_TYPE_RACING_CONTROL = 71,			//!< The RacingControl Component
-	COMPONENT_TYPE_MISSION_OFFER = 73,			//!< The MissionOffer Component
-	COMPONENT_TYPE_EXHIBIT = 75,			//!< The Exhibit Component
-	COMPONENT_TYPE_RACING_STATS = 74,			//!< The Racing Stats Component
-	COMPONENT_TYPE_SOUND_TRIGGER = 77,			//!< The Sound Trigger Component
-	COMPONENT_TYPE_PROXIMITY_MONITOR = 78,			//!< The Proximity Monitor Component
-	COMPONENT_TYPE_MISSION = 84,			//!< The Mission Component
-	COMPONENT_TYPE_ROCKET_LAUNCH_LUP = 97,			//!< The LUP Launchpad Componen
-	COMPONENT_TYPE_RAIL_ACTIVATOR = 104,			//!< The Rail Activator Component
-	COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT = 106,			//!< The Player Forced Movement Component
-	COMPONENT_TYPE_POSSESSABLE = 108,			//!< The Possessable Component
-	COMPONENT_TYPE_LEVEL_PROGRESSION = 109,			//!< The Level Progression Component
-	COMPONENT_TYPE_POSSESSOR = 110,			//!< The Possessor Component
-	COMPONENT_TYPE_BUILD_BORDER = 114,			//!< The Build Border Component
-	COMPONENT_TYPE_DESTROYABLE = 1000,			//!< The Destroyable Component
-};
 
 enum class UseItemResponse : uint32_t {
 	NoImaginationForPet = 1,

dCommon/dEnums/eReplicaComponentType.h

@@ -0,0 +1,127 @@
+#ifndef __EREPLICACOMPONENTTYPE__H__
+#define __EREPLICACOMPONENTTYPE__H__
+
+#include <cstdint>
+
+enum class eReplicaComponentType : uint32_t {
+	INVALID = 0,
+	CONTROLLABLE_PHYSICS,
+	RENDER,
+	SIMPLE_PHYSICS,
+	CHARACTER,
+	SCRIPT,
+	BOUNCER,
+	BUFF, // buff is really 98, this is DESTROYABLE
+	GHOST,
+	SKILL,
+	SPAWNER,
+	ITEM,
+	REBUILD,
+	REBUILD_START,
+	REBUILD_ACTIVATOR,
+	ICON_ONLY,
+	VENDOR,
+	INVENTORY,
+	PROJECTILE_PHYSICS,
+	SHOOTING_GALLERY,
+	RIGID_BODY_PHANTOM_PHYSICS,
+	DROP_EFFECT,
+	CHEST,
+	COLLECTIBLE,
+	BLUEPRINT,
+	MOVING_PLATFORM,
+	PET,
+	PLATFORM_BOUNDARY,
+	MODULE,
+	ARCADE,
+	VEHICLE_PHYSICS, // Havok demo based
+	MOVEMENT_AI,
+	EXHIBIT,
+	OVERHEAD_ICON,
+	PET_CONTROL,
+	MINIFIG,
+	PROPERTY,
+	PET_CREATOR,
+	MODEL_BUILDER,
+	SCRIPTED_ACTIVITY,
+	PHANTOM_PHYSICS,
+	SPRINGPAD,
+	MODEL,
+	PROPERTY_ENTRANCE,
+	FX,
+	PROPERTY_MANAGEMENT,
+	VEHICLE_PHYSICS_NEW, // internal physics based on havok
+	PHYSICS_SYSTEM,
+	QUICK_BUILD,
+	SWITCH,
+	ZONE_CONTROL, // Minigame
+	CHANGLING,
+	CHOICE_BUILD,
+	PACKAGE,
+	SOUND_REPEATER,
+	SOUND_AMBIENT_2D,
+	SOUND_AMBIENT_3D,
+	PRECONDITION,
+	PLAYER_FLAG,
+	CUSTOM_BUILD_ASSEMBLY,
+	BASE_COMBAT_AI,
+	MODULE_ASSEMBLY,
+	SHOWCASE_MODEL_HANDLER,
+	RACING_MODULE,
+	GENERIC_ACTIVATOR,
+	PROPERTY_VENDOR,
+	HF_LIGHT_DIRECTION_GADGET,
+	ROCKET_LAUNCH,
+	ROCKET_LANDING,
+	TRIGGER,
+	DROPPED_LOOT,
+	RACING_CONTROL,
+	FACTION_TRIGGER,
+	MISSION_OFFER,
+	RACING_STATS,
+	LUP_EXHIBIT,
+	BBB,
+	SOUND_TRIGGER,
+	PROXIMITY_MONITOR,
+	RACING_SOUND_TRIGGER,
+	CHAT,
+	FRIENDS_LIST,
+	GUILD,
+	LOCAL_SYSTEM,
+	MISSION,
+	MUTABLE_MODEL_BEHAVIORS,
+	PATHFINDING,
+	PET_TAMING_CONTROL,
+	PROPERTY_EDITOR,
+	SKINNED_RENDER,
+	SLASH_COMMAND,
+	STATUS_EFFECT,
+	TEAMS,
+	TEXT_EFFECT,
+	TRADE,
+	USER_CONTROL,
+	IGNORE_LIST,
+	ROCKET_LAUNCH_LUP,
+	BUFF_REAL, // the real buff component, should just be name BUFF
+	INTERACTION_MANAGER,
+	DONATION_VENDOR,
+	COMBAT_MEDIATOR,
+	COMMENDATION_VENDOR,
+	UNKNOWN_103,
+	RAIL_ACTIVATOR,
+	ROLLER,
+	PLAYER_FORCED_MOVEMENT,
+	CRAFTING,
+	POSSESSABLE,
+	LEVEL_PROGRESSION,
+	POSSESSOR,
+	MOUNT_CONTROL,
+	UNKNOWN_112,
+	PROPERTY_PLAQUE,
+	BUILD_BORDER,
+	UNKOWN_115,
+	CULLING_PLANE,
+	DESTROYABLE = 1000 // Actually 7
+};
+
+#endif  //!__EREPLICACOMPONENTTYPE__H__

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -1,4 +1,5 @@
 #include "CDComponentsRegistryTable.h"
+#include "eReplicaComponentType.h"
 
 #define CDCLIENT_CACHE_ALL
 
@@ -25,7 +26,7 @@ CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
 	while (!tableData.eof()) {
 		CDComponentsRegistry entry;
 		entry.id = tableData.getIntField("id", -1);
-		entry.component_type = tableData.getIntField("component_type", -1);
+		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
 		entry.component_id = tableData.getIntField("component_id", -1);
 
 		this->mappedEntries.insert_or_assign(((uint64_t)entry.component_type) << 32 | ((uint64_t)entry.id), entry.component_id);
@@ -63,7 +64,7 @@ std::string CDComponentsRegistryTable::GetName(void) const {
 	return "ComponentsRegistry";
 }
 
-int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue) {
+int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue) {
 	const auto& iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
 
 	if (iter == this->mappedEntries.end()) {

dDatabase/Tables/CDComponentsRegistryTable.h

@@ -7,11 +7,11 @@
   \file CDComponentsRegistryTable.hpp
   \brief Contains data for the ComponentsRegistry table
  */
-
+enum class eReplicaComponentType : uint32_t;
  //! ComponentsRegistry Entry Struct
 struct CDComponentsRegistry {
 	unsigned int id;                    //!< The LOT is used as the ID
-	unsigned int component_type;        //!< See ComponentTypes enum for values
+	eReplicaComponentType component_type;        //!< See ComponentTypes enum for values
 	unsigned int component_id;          //!< The ID used within the component's table (0 may either mean it's non-networked, or that the ID is actually 0
 };
 
@@ -36,5 +36,5 @@ public:
 	 */
 	std::string GetName(void) const override;
 
-	int32_t GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue = 0);
+	int32_t GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue = 0);
 };

dGame/Entity.cpp

@@ -70,6 +70,7 @@
 #include "RailActivatorComponent.h"
 #include "LUPExhibitComponent.h"
 #include "TriggerComponent.h"
+#include "eReplicaComponentType.h"
 
 Entity::Entity(const LWOOBJID& objectID, EntityInfo info, Entity* parentEntity) {
 	m_ObjectID = objectID;
@@ -135,7 +136,7 @@ void Entity::Initialize() {
 
 	const auto triggerInfo = GetVarAsString(u"trigger_id");
 
-	if (!triggerInfo.empty()) m_Components.emplace(COMPONENT_TYPE_TRIGGER, new TriggerComponent(this, triggerInfo));
+	if (!triggerInfo.empty()) m_Components.emplace(eReplicaComponentType::TRIGGER, new TriggerComponent(this, triggerInfo));
 
 	/**
 	 * Setup groups
@@ -164,23 +165,23 @@ void Entity::Initialize() {
 	 */
 
 	if (m_TemplateID == 14) {
-		const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SIMPLE_PHYSICS);
+		const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SIMPLE_PHYSICS);
 
 		SimplePhysicsComponent* comp = new SimplePhysicsComponent(simplePhysicsComponentID, this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SIMPLE_PHYSICS, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SIMPLE_PHYSICS, comp));
 
 		ModelComponent* modelcomp = new ModelComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MODEL, modelcomp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, modelcomp));
 
 		RenderComponent* render = new RenderComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RENDER, render));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RENDER, render));
 
 		auto destroyableComponent = new DestroyableComponent(this);
 		destroyableComponent->SetHealth(1);
 		destroyableComponent->SetMaxHealth(1.0f);
 		destroyableComponent->SetFaction(-1, true);
 		destroyableComponent->SetIsSmashable(true);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_DESTROYABLE, destroyableComponent));
+		m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, destroyableComponent));
 		// We have all our components.
 		return;
 	}
@@ -193,47 +194,47 @@ void Entity::Initialize() {
 
 	if (GetParentUser()) {
 		auto missions = new MissionComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MISSION, missions));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MISSION, missions));
 		missions->LoadFromXml(m_Character->GetXMLDoc());
 	}
 
-	uint32_t petComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PET);
+	uint32_t petComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PET);
 	if (petComponentId > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_PET, new PetComponent(this, petComponentId)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::PET, new PetComponent(this, petComponentId)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_ZONE_CONTROL) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ZONE_CONTROL) > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_ZONE_CONTROL, nullptr));
+		m_Components.insert(std::make_pair(eReplicaComponentType::ZONE_CONTROL, nullptr));
 	}
 
-	uint32_t possessableComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_POSSESSABLE);
+	uint32_t possessableComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::POSSESSABLE);
 	if (possessableComponentId > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_POSSESSABLE, new PossessableComponent(this, possessableComponentId)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::POSSESSABLE, new PossessableComponent(this, possessableComponentId)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_MODULE_ASSEMBLY) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODULE_ASSEMBLY) > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MODULE_ASSEMBLY, new ModuleAssemblyComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODULE_ASSEMBLY, new ModuleAssemblyComponent(this)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_RACING_STATS) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_STATS) > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RACING_STATS, nullptr));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RACING_STATS, nullptr));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_EXHIBIT, -1) >= 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::LUP_EXHIBIT, -1) >= 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_EXHIBIT, new LUPExhibitComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::LUP_EXHIBIT, new LUPExhibitComponent(this)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_RACING_CONTROL) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL) > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RACING_CONTROL, new RacingControlComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RACING_CONTROL, new RacingControlComponent(this)));
 	}
 
-	const auto propertyEntranceComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PROPERTY_ENTRANCE);
+	const auto propertyEntranceComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_ENTRANCE);
 	if (propertyEntranceComponentID > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_PROPERTY_ENTRANCE,
+		m_Components.insert(std::make_pair(eReplicaComponentType::PROPERTY_ENTRANCE,
 			new PropertyEntranceComponent(propertyEntranceComponentID, this)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_CONTROLLABLE_PHYSICS) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CONTROLLABLE_PHYSICS) > 0) {
 		ControllablePhysicsComponent* controllablePhysics = new ControllablePhysicsComponent(this);
 
 		if (m_Character) {
@@ -268,61 +269,61 @@ void Entity::Initialize() {
 			controllablePhysics->SetRotation(m_DefaultRotation);
 		}
 
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_CONTROLLABLE_PHYSICS, controllablePhysics));
+		m_Components.insert(std::make_pair(eReplicaComponentType::CONTROLLABLE_PHYSICS, controllablePhysics));
 	}
 
 	// If an entity is marked a phantom, simple physics is made into phantom phyics.
 	bool markedAsPhantom = GetVar<bool>(u"markedAsPhantom");
 
-	const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SIMPLE_PHYSICS);
+	const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SIMPLE_PHYSICS);
 	if (!markedAsPhantom && simplePhysicsComponentID > 0) {
 		SimplePhysicsComponent* comp = new SimplePhysicsComponent(simplePhysicsComponentID, this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SIMPLE_PHYSICS, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SIMPLE_PHYSICS, comp));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS) > 0) {
 		RigidbodyPhantomPhysicsComponent* comp = new RigidbodyPhantomPhysicsComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS, comp));
 	}
 
-	if (markedAsPhantom || compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PHANTOM_PHYSICS) > 0) {
+	if (markedAsPhantom || compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PHANTOM_PHYSICS) > 0) {
 		PhantomPhysicsComponent* phantomPhysics = new PhantomPhysicsComponent(this);
 		phantomPhysics->SetPhysicsEffectActive(false);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_PHANTOM_PHYSICS, phantomPhysics));
+		m_Components.insert(std::make_pair(eReplicaComponentType::PHANTOM_PHYSICS, phantomPhysics));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_VEHICLE_PHYSICS) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::VEHICLE_PHYSICS) > 0) {
 		VehiclePhysicsComponent* vehiclePhysicsComponent = new VehiclePhysicsComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_VEHICLE_PHYSICS, vehiclePhysicsComponent));
+		m_Components.insert(std::make_pair(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent));
 		vehiclePhysicsComponent->SetPosition(m_DefaultPosition);
 		vehiclePhysicsComponent->SetRotation(m_DefaultRotation);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SOUND_TRIGGER, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SOUND_TRIGGER, -1) != -1) {
 		auto* comp = new SoundTriggerComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SOUND_TRIGGER, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SOUND_TRIGGER, comp));
 	}
 
 	//Also check for the collectible id:
 	m_CollectibleID = GetVarAs<int32_t>(u"collectible_id");
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_BUFF) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUFF) > 0) {
 		BuffComponent* comp = new BuffComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_BUFF, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::BUFF, comp));
 	}
 
-	int collectibleComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_COLLECTIBLE);
+	int collectibleComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::COLLECTIBLE);
 
 	if (collectibleComponentID > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_COLLECTIBLE, nullptr));
+		m_Components.insert(std::make_pair(eReplicaComponentType::COLLECTIBLE, nullptr));
 	}
 
 	/**
 	 * Multiple components require the destructible component.
 	 */
 
-	int buffComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_BUFF);
+	int buffComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUFF);
-	int rebuildComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_REBUILD);
+	int rebuildComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::QUICK_BUILD);
 
 	int componentID = 0;
 	if (collectibleComponentID > 0) componentID = collectibleComponentID;
@@ -341,7 +342,7 @@ void Entity::Initialize() {
 				std::vector<CDDestructibleComponent> destCompData = destCompTable->Query([=](CDDestructibleComponent entry) { return (entry.id == componentID); });
 
 				if (destCompData.size() > 0) {
-					if (HasComponent(COMPONENT_TYPE_RACING_STATS)) {
+					if (HasComponent(eReplicaComponentType::RACING_STATS)) {
 						destCompData[0].imagination = 60;
 					}
 
@@ -385,8 +386,8 @@ void Entity::Initialize() {
 				comp->AddFaction(6); //Smashables
 
 				// A race car has 60 imagination, other entities defaults to 0.
-				comp->SetImagination(HasComponent(COMPONENT_TYPE_RACING_STATS) ? 60 : 0);
+				comp->SetImagination(HasComponent(eReplicaComponentType::RACING_STATS) ? 60 : 0);
-				comp->SetMaxImagination(HasComponent(COMPONENT_TYPE_RACING_STATS) ? 60 : 0);
+				comp->SetMaxImagination(HasComponent(eReplicaComponentType::RACING_STATS) ? 60 : 0);
 			}
 		}
 
@@ -404,35 +405,35 @@ void Entity::Initialize() {
 			}
 		}
 
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_DESTROYABLE, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, comp));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_CHARACTER) > 0 || m_Character) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CHARACTER) > 0 || m_Character) {
 		// Character Component always has a possessor, level, and forced movement components
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_POSSESSOR, new PossessorComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::POSSESSOR, new PossessorComponent(this)));
 
 		// load in the xml for the level
 		auto* levelComp = new LevelProgressionComponent(this);
 		levelComp->LoadFromXml(m_Character->GetXMLDoc());
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_LEVEL_PROGRESSION, levelComp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::LEVEL_PROGRESSION, levelComp));
 
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT, new PlayerForcedMovementComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, new PlayerForcedMovementComponent(this)));
 
 		CharacterComponent* charComp = new CharacterComponent(this, m_Character);
 		charComp->LoadFromXml(m_Character->GetXMLDoc());
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_CHARACTER, charComp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::CHARACTER, charComp));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_INVENTORY) > 0 || m_Character) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY) > 0 || m_Character) {
 		InventoryComponent* comp = nullptr;
 		if (m_Character) comp = new InventoryComponent(this, m_Character->GetXMLDoc());
 		else comp = new InventoryComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_INVENTORY, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::INVENTORY, comp));
 	}
 	// if this component exists, then we initialize it. it's value is always 0
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_ROCKET_LAUNCH_LUP, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ROCKET_LAUNCH_LUP, -1) != -1) {
 		auto comp = new RocketLaunchLupComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_ROCKET_LAUNCH_LUP, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::ROCKET_LAUNCH_LUP, comp));
 	}
 
 	/**
@@ -440,7 +441,7 @@ void Entity::Initialize() {
 	 */
 
 	CDScriptComponentTable* scriptCompTable = CDClientManager::Instance()->GetTable<CDScriptComponentTable>("ScriptComponent");
-	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SCRIPT, -1);
+	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SCRIPT, -1);
 
 	std::string scriptName = "";
 	bool client = false;
@@ -483,7 +484,7 @@ void Entity::Initialize() {
 	}
 
 	if (!scriptName.empty() || client || m_Character || scriptComponentID >= 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SCRIPT, new ScriptComponent(this, scriptName, true, client && scriptName.empty())));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPT, new ScriptComponent(this, scriptName, true, client && scriptName.empty())));
 	}
 
 	// ZoneControl script
@@ -497,24 +498,24 @@ void Entity::Initialize() {
 			CDScriptComponent zoneScriptData = scriptCompTable->GetByID(zoneScriptID);
 
 			ScriptComponent* comp = new ScriptComponent(this, zoneScriptData.script_name, true);
-			m_Components.insert(std::make_pair(COMPONENT_TYPE_SCRIPT, comp));
+			m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPT, comp));
 		}
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SKILL, -1) != -1 || m_Character) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SKILL, -1) != -1 || m_Character) {
 		SkillComponent* comp = new SkillComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SKILL, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SKILL, comp));
 	}
 
-	const auto combatAiId = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_BASE_COMBAT_AI);
+	const auto combatAiId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BASE_COMBAT_AI);
 	if (combatAiId > 0) {
 		BaseCombatAIComponent* comp = new BaseCombatAIComponent(this, combatAiId);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_BASE_COMBAT_AI, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::BASE_COMBAT_AI, comp));
 	}
 
-	if (int componentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_REBUILD) > 0) {
+	if (int componentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::QUICK_BUILD) > 0) {
 		RebuildComponent* comp = new RebuildComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_REBUILD, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::QUICK_BUILD, comp));
 
 		CDRebuildComponentTable* rebCompTable = CDClientManager::Instance()->GetTable<CDRebuildComponentTable>("RebuildComponent");
 		std::vector<CDRebuildComponent> rebCompData = rebCompTable->Query([=](CDRebuildComponent entry) { return (entry.id == rebuildComponentID); });
@@ -554,87 +555,87 @@ void Entity::Initialize() {
 		}
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SWITCH, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SWITCH, -1) != -1) {
 		SwitchComponent* comp = new SwitchComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SWITCH, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SWITCH, comp));
 	}
 
-	if ((compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_VENDOR) > 0)) {
+	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::VENDOR) > 0)) {
 		VendorComponent* comp = new VendorComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_VENDOR, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::VENDOR, comp));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PROPERTY_VENDOR, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_VENDOR, -1) != -1) {
 		auto* component = new PropertyVendorComponent(this);
-		m_Components.insert_or_assign(COMPONENT_TYPE_PROPERTY_VENDOR, component);
+		m_Components.insert_or_assign(eReplicaComponentType::PROPERTY_VENDOR, component);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PROPERTY_MANAGEMENT, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_MANAGEMENT, -1) != -1) {
 		auto* component = new PropertyManagementComponent(this);
-		m_Components.insert_or_assign(COMPONENT_TYPE_PROPERTY_MANAGEMENT, component);
+		m_Components.insert_or_assign(eReplicaComponentType::PROPERTY_MANAGEMENT, component);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_BOUNCER, -1) != -1) { // you have to determine it like this because all bouncers have a componentID of 0
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BOUNCER, -1) != -1) { // you have to determine it like this because all bouncers have a componentID of 0
 		BouncerComponent* comp = new BouncerComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_BOUNCER, comp));
+		m_Components.insert(std::make_pair(eReplicaComponentType::BOUNCER, comp));
 	}
 
-	if ((compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_RENDER) > 0 && m_TemplateID != 2365) || m_Character) {
+	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RENDER) > 0 && m_TemplateID != 2365) || m_Character) {
 		RenderComponent* render = new RenderComponent(this);
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RENDER, render));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RENDER, render));
 	}
 
-	if ((compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_MISSION_OFFER) > 0) || m_Character) {
+	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MISSION_OFFER) > 0) || m_Character) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MISSION_OFFER, new MissionOfferComponent(this, m_TemplateID)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MISSION_OFFER, new MissionOfferComponent(this, m_TemplateID)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_BUILD_BORDER, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUILD_BORDER, -1) != -1) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_BUILD_BORDER, new BuildBorderComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::BUILD_BORDER, new BuildBorderComponent(this)));
 	}
 
 	// Scripted activity component
-	int scriptedActivityID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+	int scriptedActivityID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SCRIPTED_ACTIVITY);
 	if ((scriptedActivityID > 0)) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SCRIPTED_ACTIVITY, new ScriptedActivityComponent(this, scriptedActivityID)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPTED_ACTIVITY, new ScriptedActivityComponent(this, scriptedActivityID)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MODEL, new ModelComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, new ModelComponent(this)));
-		if (m_Components.find(COMPONENT_TYPE_DESTROYABLE) == m_Components.end()) {
+		if (m_Components.find(eReplicaComponentType::DESTROYABLE) == m_Components.end()) {
 			auto destroyableComponent = new DestroyableComponent(this);
 			destroyableComponent->SetHealth(1);
 			destroyableComponent->SetMaxHealth(1.0f);
 			destroyableComponent->SetFaction(-1, true);
 			destroyableComponent->SetIsSmashable(true);
-			m_Components.insert(std::make_pair(COMPONENT_TYPE_DESTROYABLE, destroyableComponent));
+			m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, destroyableComponent));
 		}
 	}
 
 	PetComponent* petComponent;
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_ITEM) > 0 && !TryGetComponent(COMPONENT_TYPE_PET, petComponent) && !HasComponent(COMPONENT_TYPE_MODEL)) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0 && !TryGetComponent(eReplicaComponentType::PET, petComponent) && !HasComponent(eReplicaComponentType::MODEL)) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_ITEM, nullptr));
+		m_Components.insert(std::make_pair(eReplicaComponentType::ITEM, nullptr));
 	}
 
 	// Shooting gallery component
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_SHOOTING_GALLERY) > 0) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SHOOTING_GALLERY) > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_SHOOTING_GALLERY, new ShootingGalleryComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::SHOOTING_GALLERY, new ShootingGalleryComponent(this)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PROPERTY, -1) != -1) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY, -1) != -1) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_PROPERTY, new PropertyComponent(this)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::PROPERTY, new PropertyComponent(this)));
 	}
 
-	const int rocketId = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_ROCKET_LAUNCH);
+	const int rocketId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ROCKET_LAUNCH);
 	if ((rocketId > 0)) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_ROCKET_LAUNCH, new RocketLaunchpadControlComponent(this, rocketId)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::ROCKET_LAUNCH, new RocketLaunchpadControlComponent(this, rocketId)));
 	}
 
-	const int32_t railComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_RAIL_ACTIVATOR);
+	const int32_t railComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RAIL_ACTIVATOR);
 	if (railComponentID > 0) {
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_RAIL_ACTIVATOR, new RailActivatorComponent(this, railComponentID)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::RAIL_ACTIVATOR, new RailActivatorComponent(this, railComponentID)));
 	}
 
-	int movementAIID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_MOVEMENT_AI);
+	int movementAIID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVEMENT_AI);
 	if (movementAIID > 0) {
 		CDMovementAIComponentTable* moveAITable = CDClientManager::Instance()->GetTable<CDMovementAIComponentTable>("MovementAIComponent");
 		std::vector<CDMovementAIComponent> moveAIComp = moveAITable->Query([=](CDMovementAIComponent entry) {return (entry.id == movementAIID); });
@@ -659,7 +660,7 @@ void Entity::Initialize() {
 				}
 			}
 
-			m_Components.insert(std::make_pair(COMPONENT_TYPE_MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
+			m_Components.insert(std::make_pair(eReplicaComponentType::MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
 		}
 	} else if (petComponentId > 0 || combatAiId > 0 && GetComponent<BaseCombatAIComponent>()->GetTetherSpeed() > 0) {
 		MovementAIInfo moveInfo = MovementAIInfo();
@@ -670,7 +671,7 @@ void Entity::Initialize() {
 		moveInfo.wanderDelayMax = 5;
 		moveInfo.wanderDelayMin = 2;
 
-		m_Components.insert(std::make_pair(COMPONENT_TYPE_MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
+		m_Components.insert(std::make_pair(eReplicaComponentType::MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
 	}
 
 	std::string pathName = GetVarAsString(u"attached_path");
@@ -681,7 +682,7 @@ void Entity::Initialize() {
 		// if we have a moving platform path, then we need a moving platform component
 		if (path->pathType == PathType::MovingPlatform) {
 			MovingPlatformComponent* plat = new MovingPlatformComponent(this, pathName);
-			m_Components.insert(std::make_pair(COMPONENT_TYPE_MOVING_PLATFORM, plat));
+			m_Components.insert(std::make_pair(eReplicaComponentType::MOVING_PLATFORM, plat));
 		// else if we are a movement path
 		} /*else if (path->pathType == PathType::Movement) {
 			auto movementAIcomp = GetComponent<MovementAIComponent>();
@@ -693,14 +694,14 @@ void Entity::Initialize() {
 		}*/
 	}
 
-	int proximityMonitorID = compRegistryTable->GetByIDAndType(m_TemplateID, COMPONENT_TYPE_PROXIMITY_MONITOR);
+	int proximityMonitorID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROXIMITY_MONITOR);
 	if (proximityMonitorID > 0) {
 		CDProximityMonitorComponentTable* proxCompTable = CDClientManager::Instance()->GetTable<CDProximityMonitorComponentTable>("ProximityMonitorComponent");
 		std::vector<CDProximityMonitorComponent> proxCompData = proxCompTable->Query([=](CDProximityMonitorComponent entry) { return (entry.id == proximityMonitorID); });
 		if (proxCompData.size() > 0) {
 			std::vector<std::string> proximityStr = GeneralUtils::SplitString(proxCompData[0].Proximities, ',');
 			ProximityMonitorComponent* comp = new ProximityMonitorComponent(this, std::stoi(proximityStr[0]), std::stoi(proximityStr[1]));
-			m_Components.insert(std::make_pair(COMPONENT_TYPE_PROXIMITY_MONITOR, comp));
+			m_Components.insert(std::make_pair(eReplicaComponentType::PROXIMITY_MONITOR, comp));
 		}
 	}
 
@@ -713,7 +714,7 @@ void Entity::Initialize() {
 
 	if (!m_Character && EntityManager::Instance()->GetGhostingEnabled()) {
 		// Don't ghost what is likely large scene elements
-		if (m_Components.size() == 2 && HasComponent(COMPONENT_TYPE_SIMPLE_PHYSICS) && HasComponent(COMPONENT_TYPE_RENDER)) {
+		if (m_Components.size() == 2 && HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER)) {
 			goto no_ghosting;
 		}
 
@@ -725,14 +726,14 @@ void Entity::Initialize() {
 		 */
 		if (
 			!EntityManager::IsExcludedFromGhosting(GetLOT()) &&
-			!HasComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY) &&
+			!HasComponent(eReplicaComponentType::SCRIPTED_ACTIVITY) &&
-			!HasComponent(COMPONENT_TYPE_MOVING_PLATFORM) &&
+			!HasComponent(eReplicaComponentType::MOVING_PLATFORM) &&
-			!HasComponent(COMPONENT_TYPE_PHANTOM_PHYSICS) &&
+			!HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) &&
-			!HasComponent(COMPONENT_TYPE_PROPERTY) &&
+			!HasComponent(eReplicaComponentType::PROPERTY) &&
-			!HasComponent(COMPONENT_TYPE_RACING_CONTROL) &&
+			!HasComponent(eReplicaComponentType::RACING_CONTROL) &&
-			!HasComponent(COMPONENT_TYPE_VEHICLE_PHYSICS)
+			!HasComponent(eReplicaComponentType::VEHICLE_PHYSICS)
 			)
-			//if (HasComponent(COMPONENT_TYPE_BASE_COMBAT_AI))
+			//if (HasComponent(eReplicaComponentType::BASE_COMBAT_AI))
 		{
 			m_IsGhostingCandidate = true;
 		}
@@ -742,7 +743,7 @@ void Entity::Initialize() {
 		}
 
 		// Special case for collectibles in Ninjago
-		if (HasComponent(COMPONENT_TYPE_COLLECTIBLE) && Game::server->GetZoneID() == 2000) {
+		if (HasComponent(eReplicaComponentType::COLLECTIBLE) && Game::server->GetZoneID() == 2000) {
 			m_IsGhostingCandidate = true;
 		}
 	}
@@ -777,7 +778,7 @@ User* Entity::GetParentUser() const {
 	return static_cast<const Player*>(this)->GetParentUser();
 }
 
-Component* Entity::GetComponent(int32_t componentID) const {
+Component* Entity::GetComponent(eReplicaComponentType componentID) const {
 	const auto& index = m_Components.find(componentID);
 
 	if (index == m_Components.end()) {
@@ -787,11 +788,11 @@ Component* Entity::GetComponent(int32_t componentID) const {
 	return index->second;
 }
 
-bool Entity::HasComponent(const int32_t componentId) const {
+bool Entity::HasComponent(const eReplicaComponentType componentId) const {
 	return m_Components.find(componentId) != m_Components.end();
 }
 
-void Entity::AddComponent(const int32_t componentId, Component* component) {
+void Entity::AddComponent(const eReplicaComponentType componentId, Component* component) {
 	if (HasComponent(componentId)) {
 		return;
 	}
@@ -801,8 +802,8 @@ void Entity::AddComponent(const int32_t componentId, Component* component) {
 
 std::vector<ScriptComponent*> Entity::GetScriptComponents() {
 	std::vector<ScriptComponent*> comps;
-	for (std::pair<int32_t, void*> p : m_Components) {
+	for (std::pair<eReplicaComponentType, void*> p : m_Components) {
-		if (p.first == COMPONENT_TYPE_SCRIPT) {
+		if (p.first == eReplicaComponentType::SCRIPT) {
 			comps.push_back(static_cast<ScriptComponent*>(p.second));
 		}
 	}
@@ -830,7 +831,7 @@ void Entity::SetProximityRadius(float proxRadius, std::string name) {
 	ProximityMonitorComponent* proxMon = GetComponent<ProximityMonitorComponent>();
 	if (!proxMon) {
 		proxMon = new ProximityMonitorComponent(this);
-		m_Components.insert_or_assign(COMPONENT_TYPE_PROXIMITY_MONITOR, proxMon);
+		m_Components.insert_or_assign(eReplicaComponentType::PROXIMITY_MONITOR, proxMon);
 	}
 	proxMon->SetProximityRadius(proxRadius, name);
 }
@@ -839,7 +840,7 @@ void Entity::SetProximityRadius(dpEntity* entity, std::string name) {
 	ProximityMonitorComponent* proxMon = GetComponent<ProximityMonitorComponent>();
 	if (!proxMon) {
 		proxMon = new ProximityMonitorComponent(this);
-		m_Components.insert_or_assign(COMPONENT_TYPE_PROXIMITY_MONITOR, proxMon);
+		m_Components.insert_or_assign(eReplicaComponentType::PROXIMITY_MONITOR, proxMon);
 	}
 	proxMon->SetProximityRadius(entity, name);
 }
@@ -927,7 +928,7 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 		}
 
 		TriggerComponent* triggerComponent;
-		if (TryGetComponent(COMPONENT_TYPE_TRIGGER, triggerComponent)) {
+		if (TryGetComponent(eReplicaComponentType::TRIGGER, triggerComponent)) {
 			// has trigger component, check to see if we have events to handle
 			auto* trigger = triggerComponent->GetTrigger();
 			outBitStream->Write<bool>(trigger && trigger->events.size() > 0);
@@ -993,59 +994,59 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	unsigned int flags = 0;
 
 	PossessableComponent* possessableComponent;
-	if (TryGetComponent(COMPONENT_TYPE_POSSESSABLE, possessableComponent)) {
+	if (TryGetComponent(eReplicaComponentType::POSSESSABLE, possessableComponent)) {
 		possessableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ModuleAssemblyComponent* moduleAssemblyComponent;
-	if (TryGetComponent(COMPONENT_TYPE_MODULE_ASSEMBLY, moduleAssemblyComponent)) {
+	if (TryGetComponent(eReplicaComponentType::MODULE_ASSEMBLY, moduleAssemblyComponent)) {
 		moduleAssemblyComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ControllablePhysicsComponent* controllablePhysicsComponent;
-	if (TryGetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS, controllablePhysicsComponent)) {
+	if (TryGetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS, controllablePhysicsComponent)) {
 		controllablePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SimplePhysicsComponent* simplePhysicsComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SIMPLE_PHYSICS, simplePhysicsComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SIMPLE_PHYSICS, simplePhysicsComponent)) {
 		simplePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RigidbodyPhantomPhysicsComponent* rigidbodyPhantomPhysics;
-	if (TryGetComponent(COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS, rigidbodyPhantomPhysics)) {
+	if (TryGetComponent(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS, rigidbodyPhantomPhysics)) {
 		rigidbodyPhantomPhysics->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	VehiclePhysicsComponent* vehiclePhysicsComponent;
-	if (TryGetComponent(COMPONENT_TYPE_VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
+	if (TryGetComponent(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
 		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	PhantomPhysicsComponent* phantomPhysicsComponent;
-	if (TryGetComponent(COMPONENT_TYPE_PHANTOM_PHYSICS, phantomPhysicsComponent)) {
+	if (TryGetComponent(eReplicaComponentType::PHANTOM_PHYSICS, phantomPhysicsComponent)) {
 		phantomPhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SoundTriggerComponent* soundTriggerComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SOUND_TRIGGER, soundTriggerComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SOUND_TRIGGER, soundTriggerComponent)) {
 		soundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BuffComponent* buffComponent;
-	if (TryGetComponent(COMPONENT_TYPE_BUFF, buffComponent)) {
+	if (TryGetComponent(eReplicaComponentType::BUFF, buffComponent)) {
 		buffComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 
 		DestroyableComponent* destroyableComponent;
-		if (TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent)) {
+		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
 			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
 	}
 
-	if (HasComponent(COMPONENT_TYPE_COLLECTIBLE)) {
+	if (HasComponent(eReplicaComponentType::COLLECTIBLE)) {
 		DestroyableComponent* destroyableComponent;
-		if (TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
+		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
 			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
@@ -1053,15 +1054,15 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	}
 
 	PetComponent* petComponent;
-	if (TryGetComponent(COMPONENT_TYPE_PET, petComponent)) {
+	if (TryGetComponent(eReplicaComponentType::PET, petComponent)) {
 		petComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	CharacterComponent* characterComponent;
-	if (TryGetComponent(COMPONENT_TYPE_CHARACTER, characterComponent)) {
+	if (TryGetComponent(eReplicaComponentType::CHARACTER, characterComponent)) {
 
 		PossessorComponent* possessorComponent;
-		if (TryGetComponent(COMPONENT_TYPE_POSSESSOR, possessorComponent)) {
+		if (TryGetComponent(eReplicaComponentType::POSSESSOR, possessorComponent)) {
 			possessorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
@@ -1069,7 +1070,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		}
 
 		LevelProgressionComponent* levelProgressionComponent;
-		if (TryGetComponent(COMPONENT_TYPE_LEVEL_PROGRESSION, levelProgressionComponent)) {
+		if (TryGetComponent(eReplicaComponentType::LEVEL_PROGRESSION, levelProgressionComponent)) {
 			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
@@ -1077,7 +1078,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		}
 
 		PlayerForcedMovementComponent* playerForcedMovementComponent;
-		if (TryGetComponent(COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT, playerForcedMovementComponent)) {
+		if (TryGetComponent(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, playerForcedMovementComponent)) {
 			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
@@ -1087,34 +1088,34 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		characterComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	if (HasComponent(COMPONENT_TYPE_ITEM)) {
+	if (HasComponent(eReplicaComponentType::ITEM)) {
 		outBitStream->Write0();
 	}
 
 	InventoryComponent* inventoryComponent;
-	if (TryGetComponent(COMPONENT_TYPE_INVENTORY, inventoryComponent)) {
+	if (TryGetComponent(eReplicaComponentType::INVENTORY, inventoryComponent)) {
 		inventoryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ScriptComponent* scriptComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SCRIPT, scriptComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SCRIPT, scriptComponent)) {
 		scriptComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SkillComponent* skillComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SKILL, skillComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SKILL, skillComponent)) {
 		skillComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BaseCombatAIComponent* baseCombatAiComponent;
-	if (TryGetComponent(COMPONENT_TYPE_BASE_COMBAT_AI, baseCombatAiComponent)) {
+	if (TryGetComponent(eReplicaComponentType::BASE_COMBAT_AI, baseCombatAiComponent)) {
 		baseCombatAiComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RebuildComponent* rebuildComponent;
-	if (TryGetComponent(COMPONENT_TYPE_REBUILD, rebuildComponent)) {
+	if (TryGetComponent(eReplicaComponentType::QUICK_BUILD, rebuildComponent)) {
 		DestroyableComponent* destroyableComponent;
-		if (TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
+		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
 			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
@@ -1122,64 +1123,64 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	}
 
 	MovingPlatformComponent* movingPlatformComponent;
-	if (TryGetComponent(COMPONENT_TYPE_MOVING_PLATFORM, movingPlatformComponent)) {
+	if (TryGetComponent(eReplicaComponentType::MOVING_PLATFORM, movingPlatformComponent)) {
 		movingPlatformComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SwitchComponent* switchComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SWITCH, switchComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SWITCH, switchComponent)) {
 		switchComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	VendorComponent* vendorComponent;
-	if (TryGetComponent(COMPONENT_TYPE_VENDOR, vendorComponent)) {
+	if (TryGetComponent(eReplicaComponentType::VENDOR, vendorComponent)) {
 		vendorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BouncerComponent* bouncerComponent;
-	if (TryGetComponent(COMPONENT_TYPE_BOUNCER, bouncerComponent)) {
+	if (TryGetComponent(eReplicaComponentType::BOUNCER, bouncerComponent)) {
 		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ScriptedActivityComponent* scriptedActivityComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY, scriptedActivityComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY, scriptedActivityComponent)) {
 		scriptedActivityComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ShootingGalleryComponent* shootingGalleryComponent;
-	if (TryGetComponent(COMPONENT_TYPE_SHOOTING_GALLERY, shootingGalleryComponent)) {
+	if (TryGetComponent(eReplicaComponentType::SHOOTING_GALLERY, shootingGalleryComponent)) {
 		shootingGalleryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RacingControlComponent* racingControlComponent;
-	if (TryGetComponent(COMPONENT_TYPE_RACING_CONTROL, racingControlComponent)) {
+	if (TryGetComponent(eReplicaComponentType::RACING_CONTROL, racingControlComponent)) {
 		racingControlComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	LUPExhibitComponent* lupExhibitComponent;
-	if (TryGetComponent(COMPONENT_TYPE_EXHIBIT, lupExhibitComponent)) {
+	if (TryGetComponent(eReplicaComponentType::LUP_EXHIBIT, lupExhibitComponent)) {
 		lupExhibitComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ModelComponent* modelComponent;
-	if (TryGetComponent(COMPONENT_TYPE_MODEL, modelComponent)) {
+	if (TryGetComponent(eReplicaComponentType::MODEL, modelComponent)) {
 		modelComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RenderComponent* renderComponent;
-	if (TryGetComponent(COMPONENT_TYPE_RENDER, renderComponent)) {
+	if (TryGetComponent(eReplicaComponentType::RENDER, renderComponent)) {
 		renderComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	if (modelComponent) {
 		DestroyableComponent* destroyableComponent;
-		if (TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
+		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
 			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 			destroyableSerialized = true;
 		}
 	}
 
-	if (HasComponent(COMPONENT_TYPE_ZONE_CONTROL)) {
+	if (HasComponent(eReplicaComponentType::ZONE_CONTROL)) {
 		outBitStream->Write<uint32_t>(0x40000000);
 	}
 

dGame/Entity.h

@@ -31,6 +31,7 @@ class Item;
 class Character;
 class EntityCallbackTimer;
 enum class eTriggerEventType;
+enum class eReplicaComponentType : uint32_t;
 
 namespace CppScripts {
 	class Script;
@@ -131,17 +132,17 @@ public:
 	 * Component management
 	 */
 
-	Component* GetComponent(int32_t componentID) const;
+	Component* GetComponent(eReplicaComponentType componentID) const;
 
 	template<typename T>
 	T* GetComponent() const;
 
 	template<typename T>
-	bool TryGetComponent(int32_t componentId, T*& component) const;
+	bool TryGetComponent(eReplicaComponentType componentId, T*& component) const;
 
-	bool HasComponent(int32_t componentId) const;
+	bool HasComponent(eReplicaComponentType componentId) const;
 
-	void AddComponent(int32_t componentId, Component* component);
+	void AddComponent(eReplicaComponentType componentId, Component* component);
 
 	std::vector<ScriptComponent*> GetScriptComponents();
 
@@ -164,7 +165,7 @@ public:
 	void AddToGroup(const std::string& group);
 	bool IsPlayer() const;
 
-	std::unordered_map<int32_t, Component*>& GetComponents() { return m_Components; } // TODO: Remove
+	std::unordered_map<eReplicaComponentType, Component*>& GetComponents() { return m_Components; } // TODO: Remove
 
 	void WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
 	void WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
@@ -314,7 +315,7 @@ protected:
 	std::vector<std::function<void()>> m_DieCallbacks;
 	std::vector<std::function<void(Entity* target)>> m_PhantomCollisionCallbacks;
 
-	std::unordered_map<int32_t, Component*> m_Components; //The int is the ID of the component
+	std::unordered_map<eReplicaComponentType, Component*> m_Components;
 	std::vector<EntityTimer*> m_Timers;
 	std::vector<EntityTimer*> m_PendingTimers;
 	std::vector<EntityCallbackTimer*> m_CallbackTimers;
@@ -344,7 +345,7 @@ protected:
  */
 
 template<typename T>
-bool Entity::TryGetComponent(const int32_t componentId, T*& component) const {
+bool Entity::TryGetComponent(const eReplicaComponentType componentId, T*& component) const {
 	const auto& index = m_Components.find(componentId);
 
 	if (index == m_Components.end()) {

dGame/EntityManager.cpp

@@ -20,6 +20,7 @@
 #include "MessageIdentifiers.h"
 #include "dConfig.h"
 #include "eTriggerEventType.h"
+#include "eReplicaComponentType.h"
 
 EntityManager* EntityManager::m_Address = nullptr;
 
@@ -268,10 +269,10 @@ std::vector<Entity*> EntityManager::GetEntitiesInGroup(const std::string& group)
 	return entitiesInGroup;
 }
 
-std::vector<Entity*> EntityManager::GetEntitiesByComponent(const int componentType) const {
+std::vector<Entity*> EntityManager::GetEntitiesByComponent(const eReplicaComponentType componentType) const {
 	std::vector<Entity*> withComp;
 	for (const auto& entity : m_Entities) {
-		if (componentType != -1 && !entity.second->HasComponent(componentType)) continue;
+		if (componentType != eReplicaComponentType::INVALID && !entity.second->HasComponent(componentType)) continue;
 
 		withComp.push_back(entity.second);
 	}

dGame/EntityManager.h

@@ -11,6 +11,7 @@ class Entity;
 class EntityInfo;
 class Player;
 class User;
+enum class eReplicaComponentType : uint32_t;
 
 struct SystemAddress;
 
@@ -35,7 +36,7 @@ public:
 	void DestroyEntity(Entity* entity);
 	Entity* GetEntity(const LWOOBJID& objectId) const;
 	std::vector<Entity*> GetEntitiesInGroup(const std::string& group);
-	std::vector<Entity*> GetEntitiesByComponent(int componentType) const;
+	std::vector<Entity*> GetEntitiesByComponent(eReplicaComponentType componentType) const;
 	std::vector<Entity*> GetEntitiesByLOT(const LOT& lot) const;
 	Entity* GetZoneControlEntity() const;
 

dGame/Player.cpp

@@ -16,6 +16,7 @@
 #include "User.h"
 #include "CppScripts.h"
 #include "Loot.h"
+#include "eReplicaComponentType.h"
 
 std::vector<Player*> Player::m_Players = {};
 
@@ -223,7 +224,7 @@ Player* Player::GetPlayer(const SystemAddress& sysAddr) {
 }
 
 Player* Player::GetPlayer(const std::string& name) {
-	const auto characters = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CHARACTER);
+	const auto characters = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
 
 	for (auto* character : characters) {
 		if (!character->IsPlayer()) continue;
@@ -289,7 +290,7 @@ Player::~Player() {
 			script->OnPlayerExit(zoneControl, this);
 		}
 
-		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
 				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {

dGame/dBehaviors/BehaviorContext.cpp

@@ -15,6 +15,7 @@
 #include "EchoSyncSkill.h"
 #include "PhantomPhysicsComponent.h"
 #include "RebuildComponent.h"
+#include "eReplicaComponentType.h"
 
 BehaviorSyncEntry::BehaviorSyncEntry() {
 }
@@ -311,13 +312,13 @@ std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, in
 		}
 	}
 
-	if (ignoreFaction || includeFaction || (!entity->HasComponent(COMPONENT_TYPE_PHANTOM_PHYSICS) && targets.empty())) {
+	if (ignoreFaction || includeFaction || (!entity->HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) && targets.empty())) {
 		DestroyableComponent* destroyableComponent;
-		if (!entity->TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent)) {
+		if (!entity->TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
 			return targets;
 		}
 
-		auto entities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS);
+		auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS);
 		for (auto* candidate : entities) {
 			const auto id = candidate->GetObjectID();
 

dGame/dBehaviors/HealBehavior.cpp

@@ -4,6 +4,7 @@
 #include "dLogger.h"
 #include "EntityManager.h"
 #include "DestroyableComponent.h"
+#include "eReplicaComponentType.h"
 
 
 void HealBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_stream, const BehaviorBranchContext branch) {
@@ -15,7 +16,7 @@ void HealBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_strea
 		return;
 	}
 
-	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 
 	if (destroyable == nullptr) {
 		Game::logger->Log("HealBehavior", "Failed to find destroyable component for %(llu)!", branch.target);

dGame/dBehaviors/RepairBehavior.cpp

@@ -5,6 +5,7 @@
 #include "EntityManager.h"
 #include "dLogger.h"
 #include "Game.h"
+#include "eReplicaComponentType.h"
 
 void RepairBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_stream, const BehaviorBranchContext branch) {
 	auto* entity = EntityManager::Instance()->GetEntity(branch.target);
@@ -15,7 +16,7 @@ void RepairBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_str
 		return;
 	}
 
-	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 
 	if (destroyable == nullptr) {
 		Game::logger->Log("RepairBehavior", "Failed to find destroyable component for %(llu)!", branch.target);

dGame/dBehaviors/SpawnBehavior.cpp

@@ -9,6 +9,7 @@
 #include "RebuildComponent.h"
 #include "Entity.h"
 #include "EntityInfo.h"
+#include "eReplicaComponentType.h"
 
 void SpawnBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	auto* origin = EntityManager::Instance()->GetEntity(context->originator);
@@ -86,7 +87,7 @@ void SpawnBehavior::Timer(BehaviorContext* context, const BehaviorBranchContext
 		return;
 	}
 
-	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 
 	if (destroyable == nullptr) {
 		entity->Smash(context->originator);

dGame/dBehaviors/StunBehavior.cpp

@@ -7,6 +7,7 @@
 #include "Game.h"
 #include "dLogger.h"
 #include "DestroyableComponent.h"
+#include "eReplicaComponentType.h"
 
 
 void StunBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
@@ -32,7 +33,7 @@ void StunBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream
 	 * If our target is an enemy we can go ahead and stun it.
 	 */
 
-	auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(target->GetComponent(COMPONENT_TYPE_BASE_COMBAT_AI));
+	auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(target->GetComponent(eReplicaComponentType::BASE_COMBAT_AI));
 
 	if (combatAiComponent == nullptr) {
 		return;
@@ -55,7 +56,7 @@ void StunBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStr
 		 * See if we can stun ourselves
 		 */
 
-		auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(self->GetComponent(COMPONENT_TYPE_BASE_COMBAT_AI));
+		auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(self->GetComponent(eReplicaComponentType::BASE_COMBAT_AI));
 
 		if (combatAiComponent == nullptr) {
 			return;
@@ -90,7 +91,7 @@ void StunBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStr
 	 * If our target is an enemy we can go ahead and stun it.
 	 */
 
-	auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(target->GetComponent(COMPONENT_TYPE_BASE_COMBAT_AI));
+	auto* combatAiComponent = static_cast<BaseCombatAIComponent*>(target->GetComponent(eReplicaComponentType::BASE_COMBAT_AI));
 
 	if (combatAiComponent == nullptr) {
 		return;

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -106,7 +106,7 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	int32_t collisionGroup = (COLLISION_GROUP_DYNAMIC | COLLISION_GROUP_ENEMY);
 
 	CDComponentsRegistryTable* componentRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-	auto componentID = componentRegistryTable->GetByIDAndType(parent->GetLOT(), COMPONENT_TYPE_CONTROLLABLE_PHYSICS);
+	auto componentID = componentRegistryTable->GetByIDAndType(parent->GetLOT(), eReplicaComponentType::CONTROLLABLE_PHYSICS);
 
 	CDPhysicsComponentTable* physicsComponentTable = CDClientManager::Instance()->GetTable<CDPhysicsComponentTable>("PhysicsComponent");
 

dGame/dComponents/BaseCombatAIComponent.h

@@ -8,6 +8,7 @@
 #include "dpWorld.h"
 #include "dpEntity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 #include <vector>
 #include <map>
@@ -46,7 +47,7 @@ struct AiSkillEntry
  */
 class BaseCombatAIComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_BASE_COMBAT_AI;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::BASE_COMBAT_AI;
 
 	BaseCombatAIComponent(Entity* parentEntity, uint32_t id);
 	~BaseCombatAIComponent() override;
@@ -245,7 +246,7 @@ private:
 
 	/**
 	 * @brief Sets the AiState and prepares the entity for serialization next frame.
-	 * 
+	 *
 	 */
 	void SetAiState(AiState newState);
 
@@ -377,7 +378,7 @@ private:
 
 	/**
 	 * Whether or not the Component has dirty information and should update next frame
-	 * 
+	 *
 	 */
 	bool m_DirtyStateOrTarget = false;
 

dGame/dComponents/BouncerComponent.h

@@ -5,13 +5,14 @@
 #include "RakNetTypes.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Attached to bouncer entities, allowing other entities to bounce off of it
  */
 class BouncerComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_BOUNCER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::BOUNCER;
 
 	BouncerComponent(Entity* parentEntity);
 	~BouncerComponent() override;

dGame/dComponents/BuffComponent.h

@@ -7,6 +7,7 @@
 #include <unordered_map>
 #include <map>
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -41,7 +42,7 @@ struct Buff
  */
 class BuffComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_BUFF;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::BUFF;
 
 	explicit BuffComponent(Entity* parent);
 

dGame/dComponents/BuildBorderComponent.h

@@ -9,13 +9,14 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
  /**
   * Component for the build border, allowing the user to start building when interacting with it
   */
 class BuildBorderComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_BUILD_BORDER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::BUILD_BORDER;
 
 	BuildBorderComponent(Entity* parent);
 	~BuildBorderComponent() override;

dGame/dComponents/CharacterComponent.h

@@ -9,6 +9,7 @@
 #include <string>
 #include "CDMissionsTable.h"
 #include "tinyxml2.h"
+#include "eReplicaComponentType.h"
 
 /**
  * The statistics that can be achieved per zone
@@ -59,7 +60,7 @@ enum StatisticID {
  */
 class CharacterComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_CHARACTER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::CHARACTER;
 
 	CharacterComponent(Entity* parent, Character* character);
 	~CharacterComponent() override;

dGame/dComponents/ControllablePhysicsComponent.h

@@ -10,6 +10,7 @@
 #include "dpCollisionChecks.h"
 #include "PhantomPhysicsComponent.h"
 #include "eBubbleType.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 class dpEntity;
@@ -19,7 +20,7 @@ class dpEntity;
  */
 class ControllablePhysicsComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_CONTROLLABLE_PHYSICS;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::CONTROLLABLE_PHYSICS;
 
 	ControllablePhysicsComponent(Entity* entity);
 	~ControllablePhysicsComponent() override;

dGame/dComponents/DestroyableComponent.cpp

@@ -76,9 +76,9 @@ DestroyableComponent::~DestroyableComponent() {
 void DestroyableComponent::Reinitialize(LOT templateID) {
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 
-	int32_t buffComponentID = compRegistryTable->GetByIDAndType(templateID, COMPONENT_TYPE_BUFF);
+	int32_t buffComponentID = compRegistryTable->GetByIDAndType(templateID, eReplicaComponentType::BUFF);
-	int32_t collectibleComponentID = compRegistryTable->GetByIDAndType(templateID, COMPONENT_TYPE_COLLECTIBLE);
+	int32_t collectibleComponentID = compRegistryTable->GetByIDAndType(templateID, eReplicaComponentType::COLLECTIBLE);
-	int32_t rebuildComponentID = compRegistryTable->GetByIDAndType(templateID, COMPONENT_TYPE_REBUILD);
+	int32_t rebuildComponentID = compRegistryTable->GetByIDAndType(templateID, eReplicaComponentType::QUICK_BUILD);
 
 	int32_t componentID = 0;
 	if (collectibleComponentID > 0) componentID = collectibleComponentID;
@@ -810,7 +810,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 			script->OnPlayerDied(zoneControl, m_Parent);
 		}
 
-		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
 				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {

dGame/dComponents/DestroyableComponent.h

@@ -6,6 +6,7 @@
 #include "tinyxml2.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 namespace CppScripts {
 	class Script;
@@ -17,7 +18,7 @@ namespace CppScripts {
  */
 class DestroyableComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_DESTROYABLE;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::DESTROYABLE;
 
 	DestroyableComponent(Entity* parentEntity);
 	~DestroyableComponent() override;

dGame/dComponents/InventoryComponent.cpp

@@ -48,7 +48,7 @@ InventoryComponent::InventoryComponent(Entity* parent, tinyxml2::XMLDocument* do
 	}
 
 	auto* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-	const auto componentId = compRegistryTable->GetByIDAndType(lot, COMPONENT_TYPE_INVENTORY);
+	const auto componentId = compRegistryTable->GetByIDAndType(lot, eReplicaComponentType::INVENTORY);
 
 	auto* inventoryComponentTable = CDClientManager::Instance()->GetTable<CDInventoryComponentTable>("InventoryComponent");
 	auto items = inventoryComponentTable->Query([=](const CDInventoryComponent entry) { return entry.id == componentId; });
@@ -181,7 +181,7 @@ void InventoryComponent::AddItem(
 		inventoryType = Inventory::FindInventoryTypeForLot(lot);
 	}
 
-	auto* missions = static_cast<MissionComponent*>(this->m_Parent->GetComponent(COMPONENT_TYPE_MISSION));
+	auto* missions = static_cast<MissionComponent*>(this->m_Parent->GetComponent(eReplicaComponentType::MISSION));
 
 	auto* inventory = GetInventory(inventoryType);
 
@@ -818,7 +818,7 @@ void InventoryComponent::EquipItem(Item* item, const bool skipChecks) {
 	if (character != nullptr && !skipChecks) {
 		// Hacky proximity rocket
 		if (item->GetLot() == 6416) {
-			const auto rocketLauchPads = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_ROCKET_LAUNCH);
+			const auto rocketLauchPads = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::ROCKET_LAUNCH);
 
 			const auto position = m_Parent->GetPosition();
 
@@ -914,7 +914,7 @@ void InventoryComponent::UnEquipItem(Item* item) {
 void InventoryComponent::EquipScripts(Item* equippedItem) {
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 	if (!compRegistryTable) return;
-	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(equippedItem->GetLot(), COMPONENT_TYPE_SCRIPT, -1);
+	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(equippedItem->GetLot(), eReplicaComponentType::SCRIPT, -1);
 	if (scriptComponentID > -1) {
 		CDScriptComponentTable* scriptCompTable = CDClientManager::Instance()->GetTable<CDScriptComponentTable>("ScriptComponent");
 		CDScriptComponent scriptCompData = scriptCompTable->GetByID(scriptComponentID);
@@ -929,7 +929,7 @@ void InventoryComponent::EquipScripts(Item* equippedItem) {
 void InventoryComponent::UnequipScripts(Item* unequippedItem) {
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 	if (!compRegistryTable) return;
-	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(unequippedItem->GetLot(), COMPONENT_TYPE_SCRIPT, -1);
+	int32_t scriptComponentID = compRegistryTable->GetByIDAndType(unequippedItem->GetLot(), eReplicaComponentType::SCRIPT, -1);
 	if (scriptComponentID > -1) {
 		CDScriptComponentTable* scriptCompTable = CDClientManager::Instance()->GetTable<CDScriptComponentTable>("ScriptComponent");
 		CDScriptComponent scriptCompData = scriptCompTable->GetByID(scriptComponentID);
@@ -1331,7 +1331,7 @@ std::vector<uint32_t> InventoryComponent::FindBuffs(Item* item, bool castOnEquip
 		return entry.objectTemplate == static_cast<unsigned int>(item->GetLot());
 		});
 
-	auto* missions = static_cast<MissionComponent*>(m_Parent->GetComponent(COMPONENT_TYPE_MISSION));
+	auto* missions = static_cast<MissionComponent*>(m_Parent->GetComponent(eReplicaComponentType::MISSION));
 
 	for (const auto& result : results) {
 		if (result.castOnType == 1) {

dGame/dComponents/InventoryComponent.h

@@ -20,6 +20,7 @@
 #include "eItemSetPassiveAbilityID.h"
 #include "PossessorComponent.h"
 #include "eInventoryType.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 class ItemSet;
@@ -36,7 +37,7 @@ enum class eItemType : int32_t;
 class InventoryComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_INVENTORY;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::INVENTORY;
 	explicit InventoryComponent(Entity* parent, tinyxml2::XMLDocument* document = nullptr);
 
 	void Update(float deltaTime) override;

dGame/dComponents/LUPExhibitComponent.h

@@ -2,6 +2,7 @@
 
 #include "Component.h"
 #include "Entity.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that handles the LOT that is shown in the LUP exhibit in the LUP world. Works by setting a timer and
@@ -10,7 +11,7 @@
 class LUPExhibitComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_EXHIBIT;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::EXHIBIT;
 
 	LUPExhibitComponent(Entity* parent);
 	~LUPExhibitComponent();

dGame/dComponents/LevelProgressionComponent.h

@@ -4,6 +4,7 @@
 #include "GameMessages.h"
 #include "Component.h"
 #include "eCharacterVersion.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that handles level progression and serilization.
@@ -12,7 +13,7 @@
 
 class LevelProgressionComponent : public Component {
 public:
-	static const uint32_t ComponentType = eReplicaComponentType::COMPONENT_TYPE_LEVEL_PROGRESSION;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::LEVEL_PROGRESSION;
 
 	/**
 	 * Constructor for this component

dGame/dComponents/MissionComponent.h

@@ -16,6 +16,7 @@
 #include "CDClientManager.h"
 #include "CDMissionsTable.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class AchievementCacheKey;
 
@@ -26,7 +27,7 @@ class AchievementCacheKey;
 class MissionComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MISSION;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MISSION;
 
 	explicit MissionComponent(Entity* parent);
 	~MissionComponent() override;

dGame/dComponents/MissionOfferComponent.cpp

@@ -40,7 +40,7 @@ bool OfferedMission::GetAcceptMission() const {
 MissionOfferComponent::MissionOfferComponent(Entity* parent, const LOT parentLot) : Component(parent) {
 	auto* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 
-	auto value = compRegistryTable->GetByIDAndType(parentLot, COMPONENT_TYPE_MISSION_OFFER, -1);
+	auto value = compRegistryTable->GetByIDAndType(parentLot, eReplicaComponentType::MISSION_OFFER, -1);
 
 	if (value != -1) {
 		const uint32_t componentId = value;
@@ -77,7 +77,7 @@ void MissionOfferComponent::OnUse(Entity* originator) {
 
 void MissionOfferComponent::OfferMissions(Entity* entity, const uint32_t specifiedMissionId) {
 	// First, get the entity's MissionComponent. If there is not one, then we cannot offer missions to this entity.
-	auto* missionComponent = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+	auto* missionComponent = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 
 	if (!missionComponent) {
 		Game::logger->Log("MissionOfferComponent", "Unable to get mission component for Entity %llu", entity->GetObjectID());

dGame/dComponents/MissionOfferComponent.h

@@ -10,6 +10,7 @@
 #include "Component.h"
 #include <vector>
 #include <stdint.h>
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -60,7 +61,7 @@ private:
  */
 class MissionOfferComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MISSION_OFFER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MISSION_OFFER;
 
 	MissionOfferComponent(Entity* parent, LOT parentLot);
 	~MissionOfferComponent() override;

dGame/dComponents/ModelComponent.cpp

@@ -10,7 +10,7 @@ ModelComponent::ModelComponent(Entity* parent) : Component(parent) {
 
 void ModelComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags) {
 	// ItemComponent Serialization.  Pets do not get this serialization.
-	if (!m_Parent->HasComponent(COMPONENT_TYPE_PET)) {
+	if (!m_Parent->HasComponent(eReplicaComponentType::PET)) {
 		outBitStream->Write1();
 		outBitStream->Write<LWOOBJID>(m_userModelID != LWOOBJID_EMPTY ? m_userModelID : m_Parent->GetObjectID());
 		outBitStream->Write<int>(0);

dGame/dComponents/ModelComponent.h

@@ -4,6 +4,7 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -12,7 +13,7 @@ class Entity;
  */
 class ModelComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MODEL;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MODEL;
 
 	ModelComponent(Entity* parent);
 

dGame/dComponents/ModuleAssemblyComponent.h

@@ -3,6 +3,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that belongs to an object that may be modularly built, like cars and rockets. Note that this is not the
@@ -11,7 +12,7 @@
  */
 class ModuleAssemblyComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MODULE_ASSEMBLY;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MODULE_ASSEMBLY;
 
 	ModuleAssemblyComponent(Entity* MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
 	~ModuleAssemblyComponent() override;

dGame/dComponents/MovementAIComponent.cpp

@@ -19,7 +19,7 @@ MovementAIComponent::MovementAIComponent(Entity* parent, MovementAIInfo info) :
 
 	m_BaseCombatAI = nullptr;
 
-	m_BaseCombatAI = reinterpret_cast<BaseCombatAIComponent*>(m_Parent->GetComponent(COMPONENT_TYPE_BASE_COMBAT_AI));
+	m_BaseCombatAI = reinterpret_cast<BaseCombatAIComponent*>(m_Parent->GetComponent(eReplicaComponentType::BASE_COMBAT_AI));
 
 	//Try and fix the insane values:
 	if (m_Info.wanderRadius > 5.0f) m_Info.wanderRadius = m_Info.wanderRadius * 0.5f;
@@ -286,7 +286,7 @@ float MovementAIComponent::GetBaseSpeed(LOT lot) {
 	int32_t componentID;
 	CDPhysicsComponent* physicsComponent = nullptr;
 
-	componentID = componentRegistryTable->GetByIDAndType(lot, COMPONENT_TYPE_CONTROLLABLE_PHYSICS, -1);
+	componentID = componentRegistryTable->GetByIDAndType(lot, eReplicaComponentType::CONTROLLABLE_PHYSICS, -1);
 
 	if (componentID != -1) {
 		physicsComponent = physicsComponentTable->GetByID(componentID);
@@ -294,7 +294,7 @@ float MovementAIComponent::GetBaseSpeed(LOT lot) {
 		goto foundComponent;
 	}
 
-	componentID = componentRegistryTable->GetByIDAndType(lot, COMPONENT_TYPE_SIMPLE_PHYSICS, -1);
+	componentID = componentRegistryTable->GetByIDAndType(lot, eReplicaComponentType::SIMPLE_PHYSICS, -1);
 
 	if (componentID != -1) {
 		physicsComponent = physicsComponentTable->GetByID(componentID);

dGame/dComponents/MovementAIComponent.h

@@ -13,6 +13,7 @@
 #include "Game.h"
 #include "dLogger.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 #include <vector>
 
 class ControllablePhysicsComponent;
@@ -56,7 +57,7 @@ struct MovementAIInfo {
  */
 class MovementAIComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MOVEMENT_AI;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MOVEMENT_AI;
 
 	MovementAIComponent(Entity* parentEntity, MovementAIInfo info);
 	~MovementAIComponent() override;

dGame/dComponents/MovingPlatformComponent.h

@@ -14,6 +14,7 @@
 #include "EntityManager.h"
 #include "Component.h"
 #include "eMovementPlatformState.h"
+#include "eReplicaComponentType.h"
 
 class Path;
 
@@ -105,7 +106,7 @@ public:
  */
 class MovingPlatformComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_MOVING_PLATFORM;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::MOVING_PLATFORM;
 
 	MovingPlatformComponent(Entity* parent, const std::string& pathName);
 	~MovingPlatformComponent() override;

dGame/dComponents/PetComponent.h

@@ -4,6 +4,7 @@
 #include "MovementAIComponent.h"
 #include "Component.h"
 #include "Preconditions.h"
+#include "eReplicaComponentType.h"
 
 enum class PetAbilityType
 {
@@ -20,7 +21,7 @@ enum class PetAbilityType
 class PetComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PET;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PET;
 
 	explicit PetComponent(Entity* parentEntity, uint32_t componentId);
 	~PetComponent() override;

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -144,7 +144,7 @@ PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : Component(par
 
 	if (!m_HasCreatedPhysics) {
 		CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), COMPONENT_TYPE_PHANTOM_PHYSICS);
+		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), eReplicaComponentType::PHANTOM_PHYSICS);
 
 		CDPhysicsComponentTable* physComp = CDClientManager::Instance()->GetTable<CDPhysicsComponentTable>("PhysicsComponent");
 
@@ -254,7 +254,7 @@ void PhantomPhysicsComponent::CreatePhysics() {
 		z = m_Parent->GetVar<float>(u"primitiveModelValueZ");
 	} else {
 		CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), COMPONENT_TYPE_PHANTOM_PHYSICS);
+		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), eReplicaComponentType::PHANTOM_PHYSICS);
 
 		CDPhysicsComponentTable* physComp = CDClientManager::Instance()->GetTable<CDPhysicsComponentTable>("PhysicsComponent");
 

dGame/dComponents/PhantomPhysicsComponent.h

@@ -12,6 +12,7 @@
 #include "CppScripts.h"
 #include "InvalidScript.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class LDFBaseData;
 class Entity;
@@ -25,7 +26,7 @@ class dpEntity;
  */
 class PhantomPhysicsComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PHANTOM_PHYSICS;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PHANTOM_PHYSICS;
 
 	PhantomPhysicsComponent(Entity* parent);
 	~PhantomPhysicsComponent() override;

dGame/dComponents/PlayerForcedMovementComponent.h

@@ -2,6 +2,7 @@
 
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that handles player forced movement
@@ -9,7 +10,7 @@
  */
 class PlayerForcedMovementComponent : public Component {
 public:
-	static const uint32_t ComponentType = eReplicaComponentType::COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PLAYER_FORCED_MOVEMENT;
 
 	/**
 	 * Constructor for this component

dGame/dComponents/PossessableComponent.h

@@ -6,6 +6,7 @@
 #include "Item.h"
 #include "PossessorComponent.h"
 #include "eAninmationFlags.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Represents an entity that can be controlled by some other entity, generally used by cars to indicate that some
@@ -13,7 +14,7 @@
  */
 class PossessableComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_POSSESSABLE;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::POSSESSABLE;
 
 	PossessableComponent(Entity* parentEntity, uint32_t componentId);
 

dGame/dComponents/PossessorComponent.h

@@ -3,6 +3,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 // possession types
 enum class ePossessionType : uint8_t {
@@ -17,7 +18,7 @@ enum class ePossessionType : uint8_t {
  */
 class PossessorComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_POSSESSOR;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::POSSESSOR;
 
 	PossessorComponent(Entity* parent);
 	~PossessorComponent() override;

dGame/dComponents/PropertyComponent.h

@@ -9,6 +9,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 struct PropertyState {
 	LWOOBJID ownerID;
@@ -21,7 +22,7 @@ struct PropertyState {
  */
 class PropertyComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PROPERTY;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PROPERTY;
 	explicit PropertyComponent(Entity* parentEntity);
 	~PropertyComponent() override;
 	[[nodiscard]] PropertyState* GetPropertyState() const { return m_PropertyState; };

dGame/dComponents/PropertyEntranceComponent.h

@@ -6,13 +6,14 @@
 #include "Entity.h"
 #include "EntityManager.h"
 #include "GameMessages.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Represents the launch pad that's used to select and browse properties
  */
 class PropertyEntranceComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PROPERTY_ENTRANCE;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PROPERTY_ENTRANCE;
 	explicit PropertyEntranceComponent(uint32_t componentID, Entity* parent);
 
 	/**

dGame/dComponents/PropertyManagementComponent.cpp

@@ -255,7 +255,7 @@ void PropertyManagementComponent::OnStartBuilding() {
 
 	LWOMAPID zoneId = 1100;
 
-	const auto entrance = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_PROPERTY_ENTRANCE);
+	const auto entrance = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::PROPERTY_ENTRANCE);
 
 	originalPrivacyOption = privacyOption;
 

dGame/dComponents/PropertyManagementComponent.h

@@ -3,6 +3,7 @@
 #include <chrono>
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Information regarding which players may visit this property
@@ -31,7 +32,7 @@ enum class PropertyPrivacyOption
 class PropertyManagementComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PROPERTY_MANAGEMENT;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PROPERTY_MANAGEMENT;
 	PropertyManagementComponent(Entity* parent);
 	static PropertyManagementComponent* Instance();
 

dGame/dComponents/PropertyVendorComponent.h

@@ -2,6 +2,7 @@
 
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * The property guard that stands on a property before it's claimed, allows entities to attempt claiming this property.
@@ -9,7 +10,7 @@
 class PropertyVendorComponent : public Component
 {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PROPERTY_VENDOR;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PROPERTY_VENDOR;
 	explicit PropertyVendorComponent(Entity* parent);
 
 	/**

dGame/dComponents/ProximityMonitorComponent.h

@@ -11,6 +11,7 @@
 #include "dpWorld.h"
 #include "dpEntity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
  /**
   * Utility component for detecting how close entities are to named proximities for this entity. Allows you to store
@@ -18,7 +19,7 @@
   */
 class ProximityMonitorComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PROXIMITY_MONITOR;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PROXIMITY_MONITOR;
 
 	ProximityMonitorComponent(Entity* parentEntity, int smallRadius = -1, int largeRadius = -1);
 	~ProximityMonitorComponent() override;

dGame/dComponents/RacingControlComponent.h

@@ -7,6 +7,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
  /**
   * Information for each player in the race
@@ -104,7 +105,7 @@ struct RacingPlayerInfo {
  */
 class RacingControlComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_RACING_CONTROL;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::RACING_CONTROL;
 
 	RacingControlComponent(Entity* parentEntity);
 	~RacingControlComponent();

dGame/dComponents/RailActivatorComponent.h

@@ -4,6 +4,7 @@
 #include <string>
 #include "dCommonVars.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that handles the traveling using rails, e.g. the ninjago posts that can be used to travel using Spinjitzu.
@@ -14,7 +15,7 @@ public:
 	explicit RailActivatorComponent(Entity* parent, int32_t componentID);
 	~RailActivatorComponent() override;
 
-	static const uint32_t ComponentType = COMPONENT_TYPE_RAIL_ACTIVATOR;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::RAIL_ACTIVATOR;
 
 	/**
 	 * Handles the OnUse event from some entity, initiates the rail movement

dGame/dComponents/RebuildComponent.cpp

@@ -53,7 +53,7 @@ RebuildComponent::~RebuildComponent() {
 }
 
 void RebuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags) {
-	if (m_Parent->GetComponent(COMPONENT_TYPE_DESTROYABLE) == nullptr) {
+	if (m_Parent->GetComponent(eReplicaComponentType::DESTROYABLE) == nullptr) {
 		if (bIsInitialUpdate) {
 			outBitStream->Write(false);
 		}

dGame/dComponents/RebuildComponent.h

@@ -9,6 +9,7 @@
 #include "ScriptedActivityComponent.h"
 #include "Preconditions.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -19,7 +20,7 @@ class Entity;
  */
 class RebuildComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_REBUILD;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::QUICK_BUILD;
 
 	RebuildComponent(Entity* entity);
 	~RebuildComponent() override;

dGame/dComponents/RenderComponent.cpp

@@ -22,7 +22,7 @@ RenderComponent::RenderComponent(Entity* parent) : Component(parent) {
 	/*
 	auto* table = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 
-	const auto entry = table->GetByIDAndType(parent->GetLOT(), COMPONENT_TYPE_RENDER);
+	const auto entry = table->GetByIDAndType(parent->GetLOT(), eReplicaComponentType::RENDER);
 
 	std::stringstream query;
 

dGame/dComponents/RenderComponent.h

@@ -8,6 +8,7 @@
 
 #include "AMFFormat.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -55,7 +56,7 @@ struct Effect {
  */
 class RenderComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_RENDER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::RENDER;
 
 	RenderComponent(Entity* entity);
 	~RenderComponent() override;

dGame/dComponents/RigidbodyPhantomPhysicsComponent.h

@@ -11,6 +11,7 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
  /**
   * Component that handles rigid bodies that can be interacted with, mostly client-side rendered. An example is the
@@ -18,7 +19,7 @@
   */
 class RigidbodyPhantomPhysicsComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_PHANTOM_PHYSICS;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::PHANTOM_PHYSICS;
 
 	RigidbodyPhantomPhysicsComponent(Entity* parent);
 	~RigidbodyPhantomPhysicsComponent() override;

dGame/dComponents/RocketLaunchLupComponent.h

@@ -3,6 +3,7 @@
 #include "Entity.h"
 #include "GameMessages.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Component that handles the LUP/WBL rocket launchpad that can be interacted with to travel to WBL worlds.
@@ -10,7 +11,7 @@
  */
 class RocketLaunchLupComponent : public Component {
 public:
-	static const uint32_t ComponentType = eReplicaComponentType::COMPONENT_TYPE_ROCKET_LAUNCH_LUP;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::ROCKET_LAUNCH_LUP;
 
 	/**
 	 * Constructor for this component, builds the m_LUPWorlds vector

dGame/dComponents/RocketLaunchpadControlComponent.h

@@ -9,6 +9,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class PreconditionExpression;
 
@@ -17,7 +18,7 @@ class PreconditionExpression;
  */
 class RocketLaunchpadControlComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_ROCKET_LAUNCH;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::ROCKET_LAUNCH;
 
 	RocketLaunchpadControlComponent(Entity* parent, int rocketId);
 	~RocketLaunchpadControlComponent() override;

dGame/dComponents/ScriptedActivityComponent.cpp

@@ -137,7 +137,7 @@ void ScriptedActivityComponent::PlayerJoin(Entity* player) {
 }
 
 void ScriptedActivityComponent::PlayerJoinLobby(Entity* player) {
-	if (!m_Parent->HasComponent(COMPONENT_TYPE_REBUILD))
+	if (!m_Parent->HasComponent(eReplicaComponentType::QUICK_BUILD))
 		GameMessages::SendMatchResponse(player, player->GetSystemAddress(), 0); // tell the client they joined a lobby
 	LobbyPlayer* newLobbyPlayer = new LobbyPlayer();
 	newLobbyPlayer->entityID = player->GetObjectID();

dGame/dComponents/ScriptedActivityComponent.h

@@ -11,6 +11,7 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
  /**
   * Represents an instance of an activity, having participants and score
@@ -153,7 +154,7 @@ struct ActivityPlayer {
  */
 class ScriptedActivityComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SCRIPTED_ACTIVITY;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SCRIPTED_ACTIVITY;
 
 	ScriptedActivityComponent(Entity* parent, int activityID);
 	~ScriptedActivityComponent() override;

dGame/dComponents/ShootingGalleryComponent.h

@@ -3,6 +3,7 @@
 #include "NiPoint3.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Parameters for the shooting gallery that change during playtime
@@ -72,7 +73,7 @@ struct StaticShootingGalleryParams {
  */
 class ShootingGalleryComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SHOOTING_GALLERY;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SHOOTING_GALLERY;
 
 	explicit ShootingGalleryComponent(Entity* parent);
 	~ShootingGalleryComponent();

dGame/dComponents/SimplePhysicsComponent.h

@@ -11,6 +11,7 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -27,7 +28,7 @@ enum class eClimbableType : int32_t {
  */
 class SimplePhysicsComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SIMPLE_PHYSICS;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SIMPLE_PHYSICS;
 
 	SimplePhysicsComponent(uint32_t componentID, Entity* parent);
 	~SimplePhysicsComponent() override;

dGame/dComponents/SkillComponent.cpp

@@ -128,7 +128,7 @@ void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, Behav
 }
 
 void SkillComponent::Update(const float deltaTime) {
-	if (!m_Parent->HasComponent(COMPONENT_TYPE_BASE_COMBAT_AI) && m_Parent->GetLOT() != 1) {
+	if (!m_Parent->HasComponent(eReplicaComponentType::BASE_COMBAT_AI) && m_Parent->GetLOT() != 1) {
 		CalculateUpdate(deltaTime);
 	}
 

dGame/dComponents/SkillComponent.h

@@ -13,6 +13,7 @@
 #include "Component.h"
 #include "Entity.h"
 #include "dLogger.h"
+#include "eReplicaComponentType.h"
 
 struct ProjectileSyncEntry {
 	LWOOBJID id = LWOOBJID_EMPTY;
@@ -58,7 +59,7 @@ struct SkillExecutionResult {
  */
 class SkillComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SKILL;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SKILL;
 
 	explicit SkillComponent(Entity* parent);
 	~SkillComponent() override;

dGame/dComponents/SoundTriggerComponent.h

@@ -3,6 +3,7 @@
 #include "Entity.h"
 #include "GUID.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Music that should be played by the client
@@ -19,7 +20,7 @@ struct MusicCue {
  */
 class SoundTriggerComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SOUND_TRIGGER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SOUND_TRIGGER;
 
 	explicit SoundTriggerComponent(Entity* parent);
 	~SoundTriggerComponent() override;

dGame/dComponents/SwitchComponent.h

@@ -9,13 +9,14 @@
 #include "BouncerComponent.h"
 #include <algorithm>
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * A component for switches in game, including pet triggered switches.
  */
 class SwitchComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SWITCH;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SWITCH;
 
 	SwitchComponent(Entity* parent);
 	~SwitchComponent() override;

dGame/dComponents/TriggerComponent.h

@@ -2,6 +2,7 @@
 #define __TRIGGERCOMPONENT__H__
 
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 namespace LUTriggers {
 	struct Trigger;
@@ -10,7 +11,7 @@ namespace LUTriggers {
 
 class TriggerComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_TRIGGER;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::TRIGGER;
 
 	explicit TriggerComponent(Entity* parent, const std::string triggerInfo);
 

dGame/dComponents/VehiclePhysicsComponent.h

@@ -3,13 +3,14 @@
 #include "BitStream.h"
 #include "Entity.h"
 #include "Component.h"
+#include "eReplicaComponentType.h"
 
 /**
  * Physics component for vehicles.
  */
 class VehiclePhysicsComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_VEHICLE_PHYSICS;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::VEHICLE_PHYSICS;
 
 	VehiclePhysicsComponent(Entity* parentEntity);
 	~VehiclePhysicsComponent() override;

dGame/dComponents/VendorComponent.cpp

@@ -119,7 +119,7 @@ void VendorComponent::RefreshInventory(bool isCreation) {
 
 void VendorComponent::SetupConstants() {
 	auto* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-	int componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), COMPONENT_TYPE_VENDOR);
+	int componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), eReplicaComponentType::VENDOR);
 
 	auto* vendorComponentTable = CDClientManager::Instance()->GetTable<CDVendorComponentTable>("VendorComponent");
 	std::vector<CDVendorComponent> vendorComps = vendorComponentTable->Query([=](CDVendorComponent entry) { return (entry.id == componentID); });

dGame/dComponents/VendorComponent.h

@@ -7,13 +7,14 @@
 #include "Entity.h"
 #include "GameMessages.h"
 #include "RakNetTypes.h"
+#include "eReplicaComponentType.h"
 
 /**
  * A component for vendor NPCs. A vendor sells items to the player.
  */
 class VendorComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_VENDOR;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::VENDOR;
 
 	VendorComponent(Entity* parent);
 	~VendorComponent() override;

dGame/dGameMessages/GameMessageHandler.cpp

@@ -32,6 +32,7 @@
 #include "EchoStartSkill.h"
 #include "EchoSyncSkill.h"
 #include "eMissionTaskType.h"
+#include "eReplicaComponentType.h"
 
 using namespace std;
 
@@ -122,7 +123,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		destroyable->SetImagination(destroyable->GetImagination());
 		EntityManager::Instance()->SerializeEntity(entity);
 
-		std::vector<Entity*> racingControllers = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_RACING_CONTROL);
+		std::vector<Entity*> racingControllers = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::RACING_CONTROL);
 		for (Entity* racingController : racingControllers) {
 			auto* racingComponent = racingController->GetComponent<RacingControlComponent>();
 			if (racingComponent != nullptr) {
@@ -135,7 +136,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 			script->OnPlayerLoaded(zoneControl, player);
 		}
 
-		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPT);
+		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPT);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
 				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {
@@ -241,7 +242,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 
 	case GAME_MSG_REQUEST_RESURRECT: {
 		GameMessages::SendResurrect(entity);
-		/*auto* dest = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		/*auto* dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			dest->SetHealth(4);
 			dest->SetArmor(0);

dGame/dGameMessages/GameMessages.cpp

@@ -80,6 +80,7 @@
 #include "eBlueprintSaveResponseType.h"
 #include "eAninmationFlags.h"
 #include "AMFFormat_BitStream.h"
+#include "eReplicaComponentType.h"
 
 void GameMessages::SendFireEventClientSide(const LWOOBJID& objectID, const SystemAddress& sysAddr, std::u16string args, const LWOOBJID& object, int64_t param1, int param2, const LWOOBJID& sender) {
 	CBITSTREAM;
@@ -914,7 +915,7 @@ void GameMessages::SendSetJetPackMode(Entity* entity, bool use, bool bypassCheck
 }
 
 void GameMessages::SendResurrect(Entity* entity) {
-	DestroyableComponent* dest = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+	DestroyableComponent* dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 
 	if (dest != nullptr && entity->GetLOT() == 1) {
 		auto* levelComponent = entity->GetComponent<LevelProgressionComponent>();
@@ -924,7 +925,7 @@ void GameMessages::SendResurrect(Entity* entity) {
 		}
 	}
 
-	auto cont = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+	auto cont = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 	if (cont && entity->GetLOT() == 1) {
 		cont->SetPosition(entity->GetRespawnPosition());
 		cont->SetRotation(entity->GetRespawnRotation());
@@ -1121,7 +1122,7 @@ void GameMessages::SendPlayerReachedRespawnCheckpoint(Entity* entity, const NiPo
 	bitStream.Write(position.y);
 	bitStream.Write(position.z);
 
-	auto con = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+	auto con = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 	if (con) {
 		auto rot = con->GetRotation();
 		bitStream.Write(rot.x);
@@ -1256,7 +1257,7 @@ void GameMessages::SendVendorStatusUpdate(Entity* entity, const SystemAddress& s
 	CBITSTREAM;
 	CMSGHEADER;
 
-	VendorComponent* vendor = static_cast<VendorComponent*>(entity->GetComponent(COMPONENT_TYPE_VENDOR));
+	VendorComponent* vendor = static_cast<VendorComponent*>(entity->GetComponent(eReplicaComponentType::VENDOR));
 	if (!vendor) return;
 
 	std::map<LOT, int> vendorItems = vendor->GetInventory();
@@ -1378,7 +1379,7 @@ void GameMessages::SendMoveInventoryBatch(Entity* entity, uint32_t stackCount, i
 	CBITSTREAM;
 	CMSGHEADER;
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	Item* itemStack = inv->FindItemById(iObjID);
@@ -1682,7 +1683,7 @@ void GameMessages::HandleActivityStateChangeRequest(RakNet::BitStream* inStream,
 
 	Game::logger->Log("Activity State Change", "%s [%i, %i] from %i to %i", GeneralUtils::UTF16ToWTF8(stringValue).c_str(), value1, value2, entity->GetLOT(), assosiate != nullptr ? assosiate->GetLOT() : 0);
 
-	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SHOOTING_GALLERY);
+	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SHOOTING_GALLERY);
 	for (Entity* scriptEntity : scriptedActs) {
 		scriptEntity->OnActivityStateChangeRequest(objectID, value1, value2, stringValue);
 	}
@@ -2211,24 +2212,24 @@ void GameMessages::HandleQueryPropertyData(RakNet::BitStream* inStream, Entity*
 	Game::logger->Log("HandleQueryPropertyData", "Entity (%i) requesting data", entity->GetLOT());
 
 	/*
-	auto entites = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_PROPERTY_VENDOR);
+	auto entites = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::PROPERTY_VENDOR);
 
 	entity = entites[0];
 	*/
 
-	auto* propertyVendorComponent = static_cast<PropertyVendorComponent*>(entity->GetComponent(COMPONENT_TYPE_PROPERTY_VENDOR));
+	auto* propertyVendorComponent = static_cast<PropertyVendorComponent*>(entity->GetComponent(eReplicaComponentType::PROPERTY_VENDOR));
 
 	if (propertyVendorComponent != nullptr) {
 		propertyVendorComponent->OnQueryPropertyData(entity, sysAddr);
 	}
 
 	/*
-	entites = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_PROPERTY_MANAGEMENT);
+	entites = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::PROPERTY_MANAGEMENT);
 
 	entity = entites[0];
 	*/
 
-	auto* propertyManagerComponent = static_cast<PropertyManagementComponent*>(entity->GetComponent(COMPONENT_TYPE_PROPERTY_MANAGEMENT));
+	auto* propertyManagerComponent = static_cast<PropertyManagementComponent*>(entity->GetComponent(eReplicaComponentType::PROPERTY_MANAGEMENT));
 
 	if (propertyManagerComponent != nullptr) {
 		propertyManagerComponent->OnQueryPropertyData(entity, sysAddr);
@@ -2272,7 +2273,7 @@ void GameMessages::HandleSetBuildMode(RakNet::BitStream* inStream, Entity* entit
 }
 
 void GameMessages::HandleStartBuildingWithItem(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
-	if (!entity->HasComponent(COMPONENT_TYPE_PROPERTY_MANAGEMENT)) {
+	if (!entity->HasComponent(eReplicaComponentType::PROPERTY_MANAGEMENT)) {
 		return;
 	}
 
@@ -2901,7 +2902,7 @@ void GameMessages::HandleCinematicUpdate(RakNet::BitStream* inStream, Entity* en
 		inStream->Read<int32_t>(waypoint);
 	}
 
-	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPT);
+	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPT);
 	for (Entity* scriptEntity : scriptedActs) {
 		scriptEntity->OnCinematicUpdate(scriptEntity, entity, event, pathName, pathTime, overallTime, waypoint);
 	}
@@ -3868,7 +3869,7 @@ void GameMessages::HandleMessageBoxResponse(RakNet::BitStream* inStream, Entity*
 		racingControlComponent->HandleMessageBoxResponse(userEntity, GeneralUtils::UTF16ToWTF8(identifier));
 	}
 
-	for (auto* shootingGallery : EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SHOOTING_GALLERY)) {
+	for (auto* shootingGallery : EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SHOOTING_GALLERY)) {
 		shootingGallery->OnMessageBoxResponse(userEntity, iButton, identifier, userData);
 	}
 }
@@ -4665,7 +4666,7 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti
 	Entity* player = EntityManager::Instance()->GetEntity(user->GetLoggedInChar());
 	if (!player) return;
 
-	auto* propertyVendorComponent = static_cast<PropertyVendorComponent*>(entity->GetComponent(COMPONENT_TYPE_PROPERTY_VENDOR));
+	auto* propertyVendorComponent = static_cast<PropertyVendorComponent*>(entity->GetComponent(eReplicaComponentType::PROPERTY_VENDOR));
 
 	if (propertyVendorComponent != nullptr) {
 		propertyVendorComponent->OnBuyFromVendor(player, bConfirmed, item, count);
@@ -4675,16 +4676,16 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti
 
 	const auto isCommendationVendor = entity->GetLOT() == 13806;
 
-	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(COMPONENT_TYPE_VENDOR));
+	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(eReplicaComponentType::VENDOR));
 	if (!vend && !isCommendationVendor) return;
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 	CDItemComponentTable* itemComponentTable = CDClientManager::Instance()->GetTable<CDItemComponentTable>("ItemComponent");
 
-	int itemCompID = compRegistryTable->GetByIDAndType(item, COMPONENT_TYPE_ITEM);
+	int itemCompID = compRegistryTable->GetByIDAndType(item, eReplicaComponentType::ITEM);
 	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
 
 	Character* character = player->GetCharacter();
@@ -4764,10 +4765,10 @@ void GameMessages::HandleSellToVendor(RakNet::BitStream* inStream, Entity* entit
 	if (!player) return;
 	Character* character = player->GetCharacter();
 	if (!character) return;
-	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
-	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(COMPONENT_TYPE_VENDOR));
+	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(eReplicaComponentType::VENDOR));
 	if (!vend) return;
 
 	Item* item = inv->FindItemById(iObjID);
@@ -4776,7 +4777,7 @@ void GameMessages::HandleSellToVendor(RakNet::BitStream* inStream, Entity* entit
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 	CDItemComponentTable* itemComponentTable = CDClientManager::Instance()->GetTable<CDItemComponentTable>("ItemComponent");
 
-	int itemCompID = compRegistryTable->GetByIDAndType(item->GetLot(), COMPONENT_TYPE_ITEM);
+	int itemCompID = compRegistryTable->GetByIDAndType(item->GetLot(), eReplicaComponentType::ITEM);
 	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
 
 	// Items with a base value of 0 or max int are special items that should not be sold if they're not sub items
@@ -4814,10 +4815,10 @@ void GameMessages::HandleBuybackFromVendor(RakNet::BitStream* inStream, Entity*
 	if (!player) return;
 	Character* character = player->GetCharacter();
 	if (!character) return;
-	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
-	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(COMPONENT_TYPE_VENDOR));
+	VendorComponent* vend = static_cast<VendorComponent*>(entity->GetComponent(eReplicaComponentType::VENDOR));
 	if (!vend) return;
 
 	Item* item = inv->FindItemById(iObjID);
@@ -4826,7 +4827,7 @@ void GameMessages::HandleBuybackFromVendor(RakNet::BitStream* inStream, Entity*
 	CDComponentsRegistryTable* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 	CDItemComponentTable* itemComponentTable = CDClientManager::Instance()->GetTable<CDItemComponentTable>("ItemComponent");
 
-	int itemCompID = compRegistryTable->GetByIDAndType(item->GetLot(), COMPONENT_TYPE_ITEM);
+	int itemCompID = compRegistryTable->GetByIDAndType(item->GetLot(), eReplicaComponentType::ITEM);
 	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
 
 	float sellScalar = vend->GetSellScalar();
@@ -4968,7 +4969,7 @@ void GameMessages::HandleRebuildCancel(RakNet::BitStream* inStream, Entity* enti
 	inStream->Read(bEarlyRelease);
 	inStream->Read(userID);
 
-	RebuildComponent* rebComp = static_cast<RebuildComponent*>(entity->GetComponent(COMPONENT_TYPE_REBUILD));
+	RebuildComponent* rebComp = static_cast<RebuildComponent*>(entity->GetComponent(eReplicaComponentType::QUICK_BUILD));
 	if (!rebComp) return;
 
 	rebComp->CancelRebuild(EntityManager::Instance()->GetEntity(userID), eFailReason::REASON_CANCELED_EARLY);
@@ -5001,7 +5002,7 @@ void GameMessages::HandleRequestUse(RakNet::BitStream* inStream, Entity* entity,
 
 	if (bIsMultiInteractUse) {
 		if (multiInteractType == 0) {
-			auto* missionOfferComponent = static_cast<MissionOfferComponent*>(interactedObject->GetComponent(COMPONENT_TYPE_MISSION_OFFER));
+			auto* missionOfferComponent = static_cast<MissionOfferComponent*>(interactedObject->GetComponent(eReplicaComponentType::MISSION_OFFER));
 
 			if (missionOfferComponent != nullptr) {
 				missionOfferComponent->OfferMissions(entity, multiInteractID);
@@ -5014,7 +5015,7 @@ void GameMessages::HandleRequestUse(RakNet::BitStream* inStream, Entity* entity,
 	}
 
 	//Perform use task if possible:
-	auto missionComponent = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+	auto missionComponent = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 
 	if (missionComponent == nullptr) return;
 
@@ -5050,7 +5051,7 @@ void GameMessages::HandlePlayEmote(RakNet::BitStream* inStream, Entity* entity)
 		}
 	} else {
 		Game::logger->LogDebug("GameMessages", "Target ID is empty, using backup");
-		const auto scriptedEntities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPT);
+		const auto scriptedEntities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPT);
 
 		const auto& referencePoint = entity->GetPosition();
 
@@ -5080,7 +5081,7 @@ void GameMessages::HandleModularBuildConvertModel(RakNet::BitStream* inStream, E
 	if (!user) return;
 	Entity* character = EntityManager::Instance()->GetEntity(user->GetLoggedInChar());
 	if (!character) return;
-	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	auto* item = inv->FindItemById(modelID);
@@ -5123,7 +5124,7 @@ void GameMessages::HandleRespondToMission(RakNet::BitStream* inStream, Entity* e
 	inStream->Read(isDefaultReward);
 	if (isDefaultReward) inStream->Read(reward);
 
-	MissionComponent* missionComponent = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+	MissionComponent* missionComponent = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 	if (!missionComponent) {
 		Game::logger->Log("GameMessages", "Unable to get mission component for entity %llu to handle RespondToMission", playerID);
 		return;
@@ -5166,7 +5167,7 @@ void GameMessages::HandleMissionDialogOK(RakNet::BitStream* inStream, Entity* en
 	}
 
 	// Get the player's mission component
-	MissionComponent* missionComponent = static_cast<MissionComponent*>(player->GetComponent(COMPONENT_TYPE_MISSION));
+	MissionComponent* missionComponent = static_cast<MissionComponent*>(player->GetComponent(eReplicaComponentType::MISSION));
 	if (!missionComponent) {
 		Game::logger->Log("GameMessages", "Unable to get mission component for entity %llu to handle MissionDialogueOK", player->GetObjectID());
 		return;
@@ -5190,7 +5191,7 @@ void GameMessages::HandleRequestLinkedMission(RakNet::BitStream* inStream, Entit
 
 	auto* player = EntityManager::Instance()->GetEntity(playerId);
 
-	auto* missionOfferComponent = static_cast<MissionOfferComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION_OFFER));
+	auto* missionOfferComponent = static_cast<MissionOfferComponent*>(entity->GetComponent(eReplicaComponentType::MISSION_OFFER));
 
 	if (missionOfferComponent != nullptr) {
 		missionOfferComponent->OfferMissions(player, 0);
@@ -5204,7 +5205,7 @@ void GameMessages::HandleHasBeenCollected(RakNet::BitStream* inStream, Entity* e
 	Entity* player = EntityManager::Instance()->GetEntity(playerID);
 	if (!player || !entity || entity->GetCollectibleID() == 0) return;
 
-	MissionComponent* missionComponent = static_cast<MissionComponent*>(player->GetComponent(COMPONENT_TYPE_MISSION));
+	MissionComponent* missionComponent = static_cast<MissionComponent*>(player->GetComponent(eReplicaComponentType::MISSION));
 	if (missionComponent) {
 		missionComponent->Progress(eMissionTaskType::COLLECTION, entity->GetLOT(), entity->GetObjectID());
 	}
@@ -5307,7 +5308,7 @@ void GameMessages::HandleEquipItem(RakNet::BitStream* inStream, Entity* entity)
 	inStream->Read(immediate); //twice?
 	inStream->Read(objectID);
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	Item* item = inv->FindItemById(objectID);
@@ -5326,7 +5327,7 @@ void GameMessages::HandleUnequipItem(RakNet::BitStream* inStream, Entity* entity
 	inStream->Read(immediate);
 	inStream->Read(objectID);
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	auto* item = inv->FindItemById(objectID);
@@ -5401,7 +5402,7 @@ void GameMessages::HandleRemoveItemFromInventory(RakNet::BitStream* inStream, En
 	inStream->Read(iTradeIDIsDefault);
 	if (iTradeIDIsDefault) inStream->Read(iTradeID);
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	auto* item = inv->FindItemById(iObjID);
@@ -5444,7 +5445,7 @@ void GameMessages::HandleMoveItemInInventory(RakNet::BitStream* inStream, Entity
 	inStream->Read(responseCode);
 	inStream->Read(slot);
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	auto* item = inv->FindItemById(iObjID);
@@ -5521,7 +5522,7 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream* inStream, Entity*
 	if (!user) return;
 	Entity* character = EntityManager::Instance()->GetEntity(user->GetLoggedInChar());
 	if (!character) return;
-	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	Game::logger->Log("GameMessages", "Build finished");
@@ -5586,7 +5587,7 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream* inStream, Entity*
 		}
 	}
 
-	ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(COMPONENT_TYPE_SCRIPT));
+	ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(eReplicaComponentType::SCRIPT));
 
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(entity)) {
 		script->OnModularBuildExit(entity, character, count >= 3, modList);
@@ -5609,7 +5610,7 @@ void GameMessages::HandleDoneArrangingWithItem(RakNet::BitStream* inStream, Enti
 	if (!user) return;
 	Entity* character = EntityManager::Instance()->GetEntity(user->GetLoggedInChar());
 	if (!character) return;
-	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	/**
@@ -5660,7 +5661,7 @@ void GameMessages::HandleDoneArrangingWithItem(RakNet::BitStream* inStream, Enti
 	*/
 
 	if (PropertyManagementComponent::Instance() != nullptr) {
-		const auto& buildAreas = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_BUILD_BORDER);
+		const auto& buildAreas = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::BUILD_BORDER);
 
 		const auto& entities = EntityManager::Instance()->GetEntitiesInGroup("PropertyPlaque");
 
@@ -5727,7 +5728,7 @@ void GameMessages::HandleModularBuildMoveAndEquip(RakNet::BitStream* inStream, E
 
 	inStream->Read(templateID);
 
-	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(character->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 
 	auto* item = inv->FindItemByLot(templateID, TEMP_MODELS);
@@ -5768,7 +5769,7 @@ void GameMessages::HandleResurrect(RakNet::BitStream* inStream, Entity* entity)
 		script->OnPlayerResurrected(zoneControl, entity);
 	}
 
-	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 	for (Entity* scriptEntity : scriptedActs) {
 		if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
 			for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {
@@ -5779,13 +5780,13 @@ void GameMessages::HandleResurrect(RakNet::BitStream* inStream, Entity* entity)
 }
 
 void GameMessages::HandlePushEquippedItemsState(RakNet::BitStream* inStream, Entity* entity) {
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 	inv->PushEquippedItems();
 }
 
 void GameMessages::HandlePopEquippedItemsState(RakNet::BitStream* inStream, Entity* entity) {
-	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	InventoryComponent* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	if (!inv) return;
 	inv->PopEquippedItems();
 	EntityManager::Instance()->SerializeEntity(entity); // so it updates on client side
@@ -5797,7 +5798,7 @@ void GameMessages::HandleClientItemConsumed(RakNet::BitStream* inStream, Entity*
 
 	inStream->Read(itemConsumed);
 
-	auto* inventory = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 
 	if (inventory == nullptr) {
 		return;
@@ -5811,7 +5812,7 @@ void GameMessages::HandleClientItemConsumed(RakNet::BitStream* inStream, Entity*
 
 	item->Consume();
 
-	auto* missions = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+	auto* missions = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 	if (missions != nullptr) {
 		missions->Progress(eMissionTaskType::USE_ITEM, itemLot);
 	}
@@ -5823,7 +5824,7 @@ void GameMessages::HandleUseNonEquipmentItem(RakNet::BitStream* inStream, Entity
 
 	inStream->Read(itemConsumed);
 
-	auto* inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto* inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 
 	if (!inv) return;
 
@@ -5854,11 +5855,11 @@ void GameMessages::HandleMatchRequest(RakNet::BitStream* inStream, Entity* entit
 	inStream->Read(type);
 	inStream->Read(value);
 
-	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+	std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 	if (type == 0) { // join
 		if (value != 0) {
 			for (Entity* scriptedAct : scriptedActs) {
-				ScriptedActivityComponent* comp = static_cast<ScriptedActivityComponent*>(scriptedAct->GetComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY));
+				ScriptedActivityComponent* comp = static_cast<ScriptedActivityComponent*>(scriptedAct->GetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY));
 				if (!comp) continue;
 				if (comp->GetActivityID() == value) {
 					comp->PlayerJoin(entity);
@@ -5869,7 +5870,7 @@ void GameMessages::HandleMatchRequest(RakNet::BitStream* inStream, Entity* entit
 		}
 	} else if (type == 1) { // ready/unready
 		for (Entity* scriptedAct : scriptedActs) {
-			ScriptedActivityComponent* comp = static_cast<ScriptedActivityComponent*>(scriptedAct->GetComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY));
+			ScriptedActivityComponent* comp = static_cast<ScriptedActivityComponent*>(scriptedAct->GetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY));
 			if (!comp) continue;
 			if (comp->PlayerIsInQueue(entity)) {
 				comp->PlayerReady(entity, value);
@@ -5987,7 +5988,7 @@ void GameMessages::HandleReportBug(RakNet::BitStream* inStream, Entity* entity)
 
 void
 GameMessages::HandleClientRailMovementReady(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
-	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_RAIL_ACTIVATOR);
+	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::RAIL_ACTIVATOR);
 	for (const auto* possibleRail : possibleRails) {
 		const auto* rail = possibleRail->GetComponent<RailActivatorComponent>();
 		if (rail != nullptr) {
@@ -5999,7 +6000,7 @@ GameMessages::HandleClientRailMovementReady(RakNet::BitStream* inStream, Entity*
 void GameMessages::HandleCancelRailMovement(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
 	const auto immediate = inStream->ReadBit();
 
-	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_RAIL_ACTIVATOR);
+	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::RAIL_ACTIVATOR);
 	for (const auto* possibleRail : possibleRails) {
 		auto* rail = possibleRail->GetComponent<RailActivatorComponent>();
 		if (rail != nullptr) {
@@ -6023,7 +6024,7 @@ void GameMessages::HandlePlayerRailArrivedNotification(RakNet::BitStream* inStre
 	int32_t waypointNumber;
 	inStream->Read(waypointNumber);
 
-	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_RAIL_ACTIVATOR);
+	const auto possibleRails = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::RAIL_ACTIVATOR);
 	for (auto* possibleRail : possibleRails) {
 		for (CppScripts::Script* script : CppScripts::GetEntityScripts(possibleRail)) {
 			script->OnPlayerRailArrived(possibleRail, entity, pathName, waypointNumber);

dGame/dInventory/Inventory.cpp

@@ -4,6 +4,7 @@
 #include "Item.h"
 #include "InventoryComponent.h"
 #include "eItemType.h"
+#include "eReplicaComponentType.h"
 
 std::vector<LOT> Inventory::m_GameMasterRestrictedItems = {
 		1727, // GM Only - JetPack
@@ -277,7 +278,7 @@ const CDItemComponent& Inventory::FindItemComponent(const LOT lot) {
 
 	auto* itemComponents = CDClientManager::Instance()->GetTable<CDItemComponentTable>("ItemComponent");
 
-	const auto componentId = registry->GetByIDAndType(lot, COMPONENT_TYPE_ITEM);
+	const auto componentId = registry->GetByIDAndType(lot, eReplicaComponentType::ITEM);
 
 	if (componentId == 0) {
 		Game::logger->Log("Inventory", "Failed to find item component for (%i)!", lot);
@@ -293,7 +294,7 @@ const CDItemComponent& Inventory::FindItemComponent(const LOT lot) {
 bool Inventory::IsValidItem(const LOT lot) {
 	auto* registry = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 
-	const auto componentId = registry->GetByIDAndType(lot, COMPONENT_TYPE_ITEM);
+	const auto componentId = registry->GetByIDAndType(lot, eReplicaComponentType::ITEM);
 
 	return componentId != 0;
 }

dGame/dInventory/Item.cpp

@@ -16,6 +16,7 @@
 #include "AssetManager.h"
 #include "InventoryComponent.h"
 #include "Loot.h"
+#include "eReplicaComponentType.h"
 
 Item::Item(const LWOOBJID id, const LOT lot, Inventory* inventory, const uint32_t slot, const uint32_t count, const bool bound, const std::vector<LDFBaseData*>& config, const LWOOBJID parent, LWOOBJID subKey, eLootSourceType lootSourceType) {
 	if (!Inventory::IsValidItem(lot)) {
@@ -297,7 +298,7 @@ void Item::UseNonEquip(Item* item) {
 		auto inventory = item->GetInventory();
 		if (inventory && inventory->GetType() == eInventoryType::ITEMS) {
 			auto* compRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
-			const auto packageComponentId = compRegistryTable->GetByIDAndType(lot, COMPONENT_TYPE_PACKAGE);
+			const auto packageComponentId = compRegistryTable->GetByIDAndType(lot, eReplicaComponentType::PACKAGE);
 
 			if (packageComponentId == 0) return;
 
@@ -381,7 +382,7 @@ void Item::Disassemble(const eInventoryType inventoryType) {
 void Item::DisassembleModel() {
 	auto* table = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
 
-	const auto componentId = table->GetByIDAndType(GetLot(), COMPONENT_TYPE_RENDER);
+	const auto componentId = table->GetByIDAndType(GetLot(), eReplicaComponentType::RENDER);
 
 	auto query = CDClientDatabase::CreatePreppedStmt(
 		"SELECT render_asset FROM RenderComponent WHERE id = ?;");

dGame/dMission/Mission.cpp

@@ -23,7 +23,7 @@
 #include "eMissionState.h"
 #include "eMissionTaskType.h"
 #include "eMissionLockState.h"
-
+#include "eReplicaComponentType.h"
 
 Mission::Mission(MissionComponent* missionComponent, const uint32_t missionId) {
 	m_MissionComponent = missionComponent;
@@ -370,7 +370,7 @@ void Mission::CheckCompletion() {
 void Mission::Catchup() {
 	auto* entity = GetAssociate();
 
-	auto* inventory = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 
 	for (auto* task : m_Tasks) {
 		const auto type = task->GetType();

dGame/dMission/MissionTask.cpp

@@ -14,6 +14,7 @@
 #include "InventoryComponent.h"
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
+#include "eReplicaComponentType.h"
 
 MissionTask::MissionTask(Mission* mission, CDMissionTasks* info, uint32_t mask) {
 	this->info = info;
@@ -237,7 +238,7 @@ void MissionTask::Progress(int32_t value, LWOOBJID associate, const std::string&
 			break;
 		}
 
-		activity = static_cast<ScriptedActivityComponent*>(entity->GetComponent(COMPONENT_TYPE_REBUILD));
+		activity = static_cast<ScriptedActivityComponent*>(entity->GetComponent(eReplicaComponentType::QUICK_BUILD));
 		if (activity == nullptr) {
 			break;
 		}

dGame/dUtilities/Loot.cpp

@@ -14,7 +14,7 @@
 #include "InventoryComponent.h"
 #include "MissionComponent.h"
 #include "eMissionState.h"
-
+#include "eReplicaComponentType.h"
 
 LootGenerator::LootGenerator() {
 	CDLootTableTable* lootTableTable = CDClientManager::Instance()->GetTable<CDLootTableTable>("LootTable");
@@ -38,7 +38,7 @@ LootGenerator::LootGenerator() {
 	uniqueItems.erase(std::unique(uniqueItems.begin(), uniqueItems.end()), uniqueItems.end());
 
 	for (const uint32_t itemID : uniqueItems) {
-		uint32_t itemComponentID = componentsRegistryTable->GetByIDAndType(itemID, COMPONENT_TYPE_ITEM);
+		uint32_t itemComponentID = componentsRegistryTable->GetByIDAndType(itemID, eReplicaComponentType::ITEM);
 		const CDItemComponent& item = itemComponentTable->GetItemComponentByID(itemComponentID);
 
 		m_ItemRarities.insert({ itemID, item.rarity });

dGame/dUtilities/Mail.cpp

@@ -25,6 +25,7 @@
 #include "dZoneManager.h"
 #include "WorldConfig.h"
 #include "eMissionTaskType.h"
+#include "eReplicaComponentType.h"
 
 void Mail::SendMail(const Entity* recipient, const std::string& subject, const std::string& body, const LOT attachment,
 	const uint16_t attachmentCount) {
@@ -196,7 +197,7 @@ void Mail::HandleSendMail(RakNet::BitStream* packet, const SystemAddress& sysAdd
 	//Inventory::InventoryType itemType;
 	int mailCost = dZoneManager::Instance()->GetWorldConfig()->mailBaseFee;
 	int stackSize = 0;
-	auto inv = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 	Item* item = nullptr;
 
 	if (itemID > 0 && attachmentCount > 0 && inv) {
@@ -355,7 +356,7 @@ void Mail::HandleAttachmentCollect(RakNet::BitStream* packet, const SystemAddres
 			attachmentCount = res->getInt(2);
 		}
 
-		auto inv = static_cast<InventoryComponent*>(player->GetComponent(COMPONENT_TYPE_INVENTORY));
+		auto inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
 		if (!inv) return;
 
 		inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::LOOT_SOURCE_MAIL);

dGame/dUtilities/SlashCommandHandler.cpp

@@ -75,6 +75,7 @@
 #include "eMissionState.h"
 #include "TriggerComponent.h"
 #include "eServerDisconnectIdentifiers.h"
+#include "eReplicaComponentType.h"
 
 void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entity* entity, const SystemAddress& sysAddr) {
 	std::string chatCommand;
@@ -561,7 +562,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			return;
 		}
 
-		InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+		InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 		if (inventory) {
 			auto* items = inventory->GetInventory(ITEMS);
 
@@ -611,7 +612,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			return;
 		}
 
-		auto comp = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+		auto comp = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 		if (comp) comp->AcceptMission(missionID, true);
 		return;
 	}
@@ -626,7 +627,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			return;
 		}
 
-		auto comp = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+		auto comp = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 		if (comp) comp->CompleteMission(missionID, true);
 		return;
 	}
@@ -676,7 +677,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			return;
 		}
 
-		auto* comp = static_cast<MissionComponent*>(entity->GetComponent(COMPONENT_TYPE_MISSION));
+		auto* comp = static_cast<MissionComponent*>(entity->GetComponent(eReplicaComponentType::MISSION));
 
 		if (comp == nullptr) {
 			return;
@@ -753,7 +754,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	}
 
 	if (chatCommand == "getnavmeshheight" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER) {
-		auto control = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+		auto control = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 		if (!control) return;
 
 		float y = dpWorld::Instance().GetNavMesh()->GetHeightAtPoint(control->GetPosition());
@@ -770,7 +771,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 				return;
 			}
 
-			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 
 			inventory->AddItem(itemLOT, 1, eLootSourceType::LOOT_SOURCE_MODERATION);
 		} else if (args.size() == 2) {
@@ -788,7 +789,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 				return;
 			}
 
-			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(COMPONENT_TYPE_INVENTORY));
+			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
 
 			inventory->AddItem(itemLOT, count, eLootSourceType::LOOT_SOURCE_MODERATION);
 		} else {
@@ -934,7 +935,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	if (chatCommand == "tpall" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER) {
 		const auto pos = entity->GetPosition();
 
-		const auto characters = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CHARACTER);
+		const auto characters = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
 
 		for (auto* character : characters) {
 			GameMessages::SendTeleport(character->GetObjectID(), pos, NiQuaternion(), character->GetSystemAddress());
@@ -1153,7 +1154,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	//-------------------------------------------------
 
 	if (chatCommand == "buffme" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER) {
-		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			dest->SetHealth(999);
 			dest->SetMaxHealth(999.0f);
@@ -1177,7 +1178,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	}
 
 	if (chatCommand == "buffmed" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER) {
-		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			dest->SetHealth(9);
 			dest->SetMaxHealth(9.0f);
@@ -1191,7 +1192,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 	if (chatCommand == "refillstats" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER) {
 
-		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		auto dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			dest->SetHealth((int)dest->GetMaxHealth());
 			dest->SetArmor((int)dest->GetMaxArmor());
@@ -1224,7 +1225,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	}
 
 	if (chatCommand == "spawn" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER && args.size() >= 1) {
-		ControllablePhysicsComponent* comp = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+		ControllablePhysicsComponent* comp = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 		if (!comp) return;
 
 		uint32_t lot;
@@ -1655,18 +1656,18 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 	if (chatCommand == "spawnphysicsverts" && entity->GetGMLevel() >= 6) {
 		//Go tell physics to spawn all the vertices:
-		auto entities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_PHANTOM_PHYSICS);
+		auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::PHANTOM_PHYSICS);
 		for (auto en : entities) {
-			auto phys = static_cast<PhantomPhysicsComponent*>(en->GetComponent(COMPONENT_TYPE_PHANTOM_PHYSICS));
+			auto phys = static_cast<PhantomPhysicsComponent*>(en->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
 			if (phys)
 				phys->SpawnVertices();
 		}
 	}
 
 	if (chatCommand == "reportproxphys" && entity->GetGMLevel() >= 6) {
-		auto entities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_PROXIMITY_MONITOR);
+		auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::PROXIMITY_MONITOR);
 		for (auto en : entities) {
-			auto phys = static_cast<ProximityMonitorComponent*>(en->GetComponent(COMPONENT_TYPE_PROXIMITY_MONITOR));
+			auto phys = static_cast<ProximityMonitorComponent*>(en->GetComponent(eReplicaComponentType::PROXIMITY_MONITOR));
 			if (phys) {
 				for (auto prox : phys->GetProximitiesData()) {
 					if (!prox.second) continue;
@@ -1760,7 +1761,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		Game::config->ReloadConfig();
 		VanityUtilities::SpawnVanity();
 		dpWorld::Instance().Reload();
-		auto entities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPTED_ACTIVITY);
+		auto entities = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (auto entity : entities) {
 			auto* scriptedActivityComponent = entity->GetComponent<ScriptedActivityComponent>();
 			if (!scriptedActivityComponent) continue;
@@ -1839,14 +1840,14 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	if (chatCommand == "inspect" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER && args.size() >= 1) {
 		Entity* closest = nullptr;
 
-		int32_t component;
+		eReplicaComponentType component;
 
 		std::u16string ldf;
 
 		bool isLDF = false;
 
 		if (!GeneralUtils::TryParse(args[0], component)) {
-			component = -1;
+			component = eReplicaComponentType::INVALID;
 
 			ldf = GeneralUtils::UTF8ToUTF16(args[0]);
 
@@ -1906,7 +1907,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 			std::stringstream stream;
 
-			stream << "Component [" << std::to_string(id) << "]";
+			stream << "Component [" << std::to_string(static_cast<uint32_t>(id)) << "]";
 
 			ChatPackets::SendSystemMessage(sysAddr, GeneralUtils::ASCIIToUTF16(stream.str()));
 		}

dNet/ClientPackets.cpp

@@ -32,7 +32,7 @@
 #include "CharacterComponent.h"
 #include "Database.h"
 #include "dMessageIdentifiers.h"
-
+#include "eReplicaComponentType.h"
 
 void ClientPackets::HandleChatMessage(const SystemAddress& sysAddr, Packet* packet) {
 	User* user = UserManager::Instance()->GetUser(sysAddr);
@@ -89,7 +89,7 @@ void ClientPackets::HandleClientPositionUpdate(const SystemAddress& sysAddr, Pac
 	Entity* entity = EntityManager::Instance()->GetEntity(user->GetLastUsedChar()->GetObjectID());
 	if (!entity) return;
 
-	ControllablePhysicsComponent* comp = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+	ControllablePhysicsComponent* comp = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 	if (!comp) return;
 
 	/*

dScripts/02_server/Enemy/AG/BossSpiderQueenEnemyServer.cpp

@@ -13,6 +13,7 @@
 
 #include "GameMessages.h"
 #include "SkillComponent.h"
+#include "eReplicaComponentType.h"
 
 #include <vector>
 
@@ -27,9 +28,9 @@ void BossSpiderQueenEnemyServer::OnStartup(Entity* self) {
 	//self:SetStatusImmunity{ StateChangeType = "PUSH", bImmuneToPullToPoint = true, bImmuneToKnockback = true, bImmuneToInterrupt = true }
 
 	//Get our components:
-	destroyable = static_cast<DestroyableComponent*>(self->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+	destroyable = static_cast<DestroyableComponent*>(self->GetComponent(eReplicaComponentType::DESTROYABLE));
-	controllable = static_cast<ControllablePhysicsComponent*>(self->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+	controllable = static_cast<ControllablePhysicsComponent*>(self->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
-	combat = static_cast<BaseCombatAIComponent*>(self->GetComponent(COMPONENT_TYPE_BASE_COMBAT_AI));
+	combat = static_cast<BaseCombatAIComponent*>(self->GetComponent(eReplicaComponentType::BASE_COMBAT_AI));
 
 	if (!destroyable || !controllable) return;
 
@@ -397,7 +398,7 @@ void BossSpiderQueenEnemyServer::RapidFireShooterManager(Entity* self) {
 
 void BossSpiderQueenEnemyServer::RunRapidFireShooter(Entity* self) {
 	/*
-	const auto targets = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CHARACTER);
+	const auto targets = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
 	*/
 
 	const auto targets = self->GetTargetsInPhantom();

dScripts/02_server/Enemy/General/BaseEnemyMech.cpp

@@ -6,6 +6,7 @@
 #include "EntityInfo.h"
 #include "GeneralUtils.h"
 #include "DestroyableComponent.h"
+#include "eReplicaComponentType.h"
 
 void BaseEnemyMech::OnStartup(Entity* self) {
 	auto* destroyableComponent = self->GetComponent<DestroyableComponent>();
@@ -15,7 +16,7 @@ void BaseEnemyMech::OnStartup(Entity* self) {
 }
 
 void BaseEnemyMech::OnDie(Entity* self, Entity* killer) {
-	ControllablePhysicsComponent* controlPhys = static_cast<ControllablePhysicsComponent*>(self->GetComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS));
+	ControllablePhysicsComponent* controlPhys = static_cast<ControllablePhysicsComponent*>(self->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
 	if (!controlPhys) return;
 
 	NiPoint3 newLoc = { controlPhys->GetPosition().x, dpWorld::Instance().GetNavMesh()->GetHeightAtPoint(controlPhys->GetPosition()), controlPhys->GetPosition().z };

dScripts/02_server/Map/AG/AgCagedBricksServer.cpp

@@ -3,6 +3,7 @@
 #include "GameMessages.h"
 #include "Character.h"
 #include "EntityManager.h"
+#include "eReplicaComponentType.h"
 
 void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {
 	//Tell the client to spawn the baby spiderling:
@@ -19,7 +20,7 @@ void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {
 	character->SetPlayerFlag(74, true);
 
 	//Remove the maelstrom cube:
-	auto inv = static_cast<InventoryComponent*>(user->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto inv = static_cast<InventoryComponent*>(user->GetComponent(eReplicaComponentType::INVENTORY));
 
 	if (inv) {
 		inv->RemoveItem(14553, 1);

dScripts/02_server/Map/AG/AgLaserSensorServer.cpp

@@ -5,10 +5,11 @@
 #include "EntityManager.h"
 #include "AgMonumentLaserServer.h"
 #include "EntityManager.h"
+#include "eReplicaComponentType.h"
 
 void AgLaserSensorServer::OnStartup(Entity* self) {
 
-	PhantomPhysicsComponent* physComp = static_cast<PhantomPhysicsComponent*>(self->GetComponent(COMPONENT_TYPE_PHANTOM_PHYSICS));
+	PhantomPhysicsComponent* physComp = static_cast<PhantomPhysicsComponent*>(self->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
 	physComp->SetPhysicsEffectActive(true);
 	physComp->SetEffectType(2); // repulse (prolly should make definitions of these are in Entity.cpp)
 	physComp->SetDirectionalMultiplier(static_cast<float>(m_RepelForce));
@@ -25,7 +26,7 @@ void AgLaserSensorServer::OnCollisionPhantom(Entity* self, Entity* target) {
 
 	Entity* laser = nullptr;
 
-	for (auto script : EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_SCRIPT)) {
+	for (auto script : EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPT)) {
 
 		AgMonumentLaserServer* hasLaser = (AgMonumentLaserServer*)script;
 

dScripts/02_server/Map/AG/NpcNjAssistantServer.cpp

@@ -4,6 +4,7 @@
 #include "MissionComponent.h"
 #include "Item.h"
 #include "eMissionState.h"
+#include "eReplicaComponentType.h"
 
 void NpcNjAssistantServer::OnMissionDialogueOK(Entity* self, Entity* target, int missionID, eMissionState missionState) {
 	if (missionID != mailMission) return;
@@ -11,7 +12,7 @@ void NpcNjAssistantServer::OnMissionDialogueOK(Entity* self, Entity* target, int
 	if (missionState == eMissionState::COMPLETE || missionState == eMissionState::READY_TO_COMPLETE) {
 		GameMessages::SendNotifyClientObject(self->GetObjectID(), u"switch", 0, 0, LWOOBJID_EMPTY, "", target->GetSystemAddress());
 
-		auto* inv = static_cast<InventoryComponent*>(target->GetComponent(COMPONENT_TYPE_INVENTORY));
+		auto* inv = static_cast<InventoryComponent*>(target->GetComponent(eReplicaComponentType::INVENTORY));
 
 		// If we are ready to complete our missions, we take the kit from you:
 		if (inv && missionState == eMissionState::READY_TO_COMPLETE) {
@@ -22,7 +23,7 @@ void NpcNjAssistantServer::OnMissionDialogueOK(Entity* self, Entity* target, int
 			}
 		}
 	} else if (missionState == eMissionState::AVAILABLE) {
-		auto* missionComponent = static_cast<MissionComponent*>(target->GetComponent(COMPONENT_TYPE_MISSION));
+		auto* missionComponent = static_cast<MissionComponent*>(target->GetComponent(eReplicaComponentType::MISSION));
 		missionComponent->CompleteMission(mailAchievement, true);
 	}
 }

dScripts/02_server/Map/AG/RemoveRentalGear.cpp

@@ -3,6 +3,7 @@
 #include "Item.h"
 #include "eMissionState.h"
 #include "Character.h"
+#include "eReplicaComponentType.h"
 
 /*
 --------------------------------------------------------------
@@ -21,7 +22,7 @@ void RemoveRentalGear::OnMissionDialogueOK(Entity* self, Entity* target, int mis
 	if (missionID != defaultMission && missionID != 313) return;
 
 	if (missionState == eMissionState::COMPLETE || missionState == eMissionState::READY_TO_COMPLETE) {
-		auto inv = static_cast<InventoryComponent*>(target->GetComponent(COMPONENT_TYPE_INVENTORY));
+		auto inv = static_cast<InventoryComponent*>(target->GetComponent(eReplicaComponentType::INVENTORY));
 		if (!inv) return;
 
 		//remove the inventory items

dScripts/02_server/Map/FV/FvCandle.cpp

@@ -1,11 +1,12 @@
 #include "FvCandle.h"
 #include "MissionComponent.h"
 #include "RenderComponent.h"
+#include "eReplicaComponentType.h"
 
 std::vector<int32_t> FvCandle::m_Missions = { 850, 1431, 1529, 1566, 1603 };
 
 void FvCandle::OnStartup(Entity* self) {
-	auto* render = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* render = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 	if (render == nullptr)
 		return;
 
@@ -22,7 +23,7 @@ void FvCandle::BlowOutCandle(Entity* self, Entity* blower) {
 	if (self->GetBoolean(u"AmHit"))
 		return;
 
-	auto* render = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* render = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 	if (render == nullptr)
 		return;
 
@@ -46,7 +47,7 @@ void FvCandle::BlowOutCandle(Entity* self, Entity* blower) {
 void FvCandle::OnTimerDone(Entity* self, std::string timerName) {
 	self->SetBoolean(u"AmHit", false);
 
-	auto* render = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* render = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 	if (render == nullptr)
 		return;
 

dScripts/02_server/Map/GF/GfTikiTorch.cpp

@@ -4,6 +4,7 @@
 #include "MissionComponent.h"
 #include "RenderComponent.h"
 #include "eMissionTaskType.h"
+#include "eReplicaComponentType.h"
 
 void GfTikiTorch::OnStartup(Entity* self) {
 	LightTorch(self);
@@ -42,7 +43,7 @@ void GfTikiTorch::OnTimerDone(Entity* self, std::string timerName) {
 }
 
 void GfTikiTorch::LightTorch(Entity* self) {
-	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 	if (renderComponent == nullptr)
 		return;
 

dScripts/02_server/Map/General/TokenConsoleServer.cpp

@@ -2,11 +2,12 @@
 #include "InventoryComponent.h"
 #include "GameMessages.h"
 #include "Character.h"
+#include "eReplicaComponentType.h"
 
 //2021-05-03 - max - added script, omitted some parts related to inheritance in lua which we don't need
 
 void TokenConsoleServer::OnUse(Entity* self, Entity* user) {
-	auto* inv = static_cast<InventoryComponent*>(user->GetComponent(COMPONENT_TYPE_INVENTORY));
+	auto* inv = static_cast<InventoryComponent*>(user->GetComponent(eReplicaComponentType::INVENTORY));
 
 	//make sure the user has the required amount of infected bricks
 	if (inv && inv->GetLotCount(6194) >= bricksToTake) {

dScripts/02_server/Map/General/TouchMissionUpdateServer.cpp

@@ -4,6 +4,7 @@
 #include "GameMessages.h"
 #include "MissionComponent.h"
 #include "eMissionState.h"
+#include "eReplicaComponentType.h"
 
 void TouchMissionUpdateServer::OnStartup(Entity* self) {
 	self->SetProximityRadius(20, "touchCheck"); // Those does not have a collider for some reason?
@@ -16,7 +17,7 @@ void TouchMissionUpdateServer::OnCollisionPhantom(Entity* self, Entity* target)
 		return;
 	}
 
-	auto* missionComponent = static_cast<MissionComponent*>(target->GetComponent(COMPONENT_TYPE_MISSION));
+	auto* missionComponent = static_cast<MissionComponent*>(target->GetComponent(eReplicaComponentType::MISSION));
 
 	if (missionComponent == nullptr) {
 		return;

dScripts/02_server/Map/Property/AG_Small/EnemySpiderSpawner.cpp

@@ -3,6 +3,7 @@
 #include "EntityManager.h"
 #include "EntityInfo.h"
 #include "DestroyableComponent.h"
+#include "eReplicaComponentType.h"
 
 //----------------------------------------------
 //--Initiate egg hatching on call
@@ -14,7 +15,7 @@ void EnemySpiderSpawner::OnFireEventServerSide(Entity* self, Entity* sender, std
 		GameMessages::SendPlayFXEffect(self->GetObjectID(), 2856, u"maelstrom", "test", LWOOBJID_EMPTY, 1.0f, 1.0f, true);
 
 		// Make indestructible
-		auto dest = static_cast<DestroyableComponent*>(self->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		auto dest = static_cast<DestroyableComponent*>(self->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			dest->SetFaction(-1);
 		}

dScripts/02_server/Map/Property/AG_Small/ZoneAgProperty.cpp

@@ -7,6 +7,7 @@
 #include "RenderComponent.h"
 #include "MissionComponent.h"
 #include "eMissionState.h"
+#include "eReplicaComponentType.h"
 
 void ZoneAgProperty::SetGameVariables(Entity* self) {
 	self->SetVar<std::string>(GuardGroup, "Guard");
@@ -256,7 +257,7 @@ void ZoneAgProperty::BaseTimerDone(Entity* self, const std::string& timerName) {
 		DeactivateSpawner(self->GetVar<std::string>(SpiderScreamSpawner));
 		DestroySpawner(self->GetVar<std::string>(SpiderScreamSpawner));
 
-		for (auto* player : EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CHARACTER)) {
+		for (auto* player : EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CHARACTER)) {
 			GameMessages::SendStop2DAmbientSound(player, true, GUIDMaelstrom);
 			GameMessages::SendPlay2DAmbientSound(player, GUIDPeaceful);
 		}

dScripts/02_server/Map/SS/SsModularBuildServer.cpp

@@ -1,12 +1,13 @@
 #include "SsModularBuildServer.h"
 #include "MissionComponent.h"
 #include "eMissionState.h"
+#include "eReplicaComponentType.h"
 
 void SsModularBuildServer::OnModularBuildExit(Entity* self, Entity* player, bool bCompleted, std::vector<LOT> modules) {
 	int missionNum = 1732;
 
 	if (bCompleted) {
-		MissionComponent* mission = static_cast<MissionComponent*>(player->GetComponent(COMPONENT_TYPE_MISSION));
+		MissionComponent* mission = static_cast<MissionComponent*>(player->GetComponent(eReplicaComponentType::MISSION));
 		Mission* rocketMission = mission->GetMission(missionNum);
 
 		if (rocketMission->GetMissionState() == eMissionState::ACTIVE) {

dScripts/NtFactionSpyServer.cpp

@@ -5,6 +5,7 @@
 #include "GameMessages.h"
 #include "MissionComponent.h"
 #include "eMissionState.h"
+#include "eReplicaComponentType.h"
 
 void NtFactionSpyServer::OnStartup(Entity* self) {
 	SetVariables(self);
@@ -13,7 +14,7 @@ void NtFactionSpyServer::OnStartup(Entity* self) {
 	auto* proximityMonitor = self->GetComponent<ProximityMonitorComponent>();
 	if (proximityMonitor == nullptr) {
 		proximityMonitor = new ProximityMonitorComponent(self, -1, -1);
-		self->AddComponent(COMPONENT_TYPE_PROXIMITY_MONITOR, proximityMonitor);
+		self->AddComponent(eReplicaComponentType::PROXIMITY_MONITOR, proximityMonitor);
 	}
 
 	proximityMonitor->SetProximityRadius(self->GetVar<float_t>(m_SpyProximityVariable), m_ProximityName);

dScripts/ScriptComponent.h

@@ -9,6 +9,7 @@
 #include "CppScripts.h"
 #include "Component.h"
 #include <string>
+#include "eReplicaComponentType.h"
 
 class Entity;
 
@@ -18,7 +19,7 @@ class Entity;
  */
 class ScriptComponent : public Component {
 public:
-	static const uint32_t ComponentType = COMPONENT_TYPE_SCRIPT;
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::SCRIPT;
 
 	ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client = false);
 	~ScriptComponent() override;

dScripts/ai/AG/AgFans.cpp

@@ -4,6 +4,7 @@
 #include "GameMessages.h"
 #include "PhantomPhysicsComponent.h"
 #include "RenderComponent.h"
+#include "eReplicaComponentType.h"
 
 void AgFans::OnStartup(Entity* self) {
 	self->SetVar<bool>(u"alive", true);
@@ -11,7 +12,7 @@ void AgFans::OnStartup(Entity* self) {
 
 	ToggleFX(self, false);
 
-	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 
 	if (renderComponent == nullptr) {
 		return;
@@ -24,7 +25,7 @@ void AgFans::ToggleFX(Entity* self, bool hit) {
 	std::string fanGroup = self->GetGroups()[0];
 	std::vector<Entity*> fanVolumes = EntityManager::Instance()->GetEntitiesInGroup(fanGroup);
 
-	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* renderComponent = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 
 	if (renderComponent == nullptr) {
 		return;
@@ -39,7 +40,7 @@ void AgFans::ToggleFX(Entity* self, bool hit) {
 		self->SetVar<bool>(u"on", false);
 
 		for (Entity* volume : fanVolumes) {
-			PhantomPhysicsComponent* volumePhys = static_cast<PhantomPhysicsComponent*>(volume->GetComponent(COMPONENT_TYPE_PHANTOM_PHYSICS));
+			PhantomPhysicsComponent* volumePhys = static_cast<PhantomPhysicsComponent*>(volume->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
 			if (!volumePhys) continue;
 			volumePhys->SetPhysicsEffectActive(false);
 			EntityManager::Instance()->SerializeEntity(volume);
@@ -55,7 +56,7 @@ void AgFans::ToggleFX(Entity* self, bool hit) {
 		self->SetVar<bool>(u"on", true);
 
 		for (Entity* volume : fanVolumes) {
-			PhantomPhysicsComponent* volumePhys = static_cast<PhantomPhysicsComponent*>(volume->GetComponent(COMPONENT_TYPE_PHANTOM_PHYSICS));
+			PhantomPhysicsComponent* volumePhys = static_cast<PhantomPhysicsComponent*>(volume->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
 			if (!volumePhys) continue;
 			volumePhys->SetPhysicsEffectActive(true);
 			EntityManager::Instance()->SerializeEntity(volume);

dScripts/ai/AG/AgImagSmashable.cpp

@@ -4,12 +4,13 @@
 #include "GameMessages.h"
 #include "EntityInfo.h"
 #include "DestroyableComponent.h"
+#include "eReplicaComponentType.h"
 
 void AgImagSmashable::OnDie(Entity* self, Entity* killer) {
 	bool maxImagGreaterThanZero = false;
 
 	if (killer) {
-		DestroyableComponent* dest = static_cast<DestroyableComponent*>(killer->GetComponent(COMPONENT_TYPE_DESTROYABLE));
+		DestroyableComponent* dest = static_cast<DestroyableComponent*>(killer->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
 			maxImagGreaterThanZero = dest->GetMaxImagination() > 0;
 		}

dScripts/ai/AG/AgJetEffectServer.cpp

@@ -2,6 +2,7 @@
 #include "GameMessages.h"
 #include "EntityManager.h"
 #include "SkillComponent.h"
+#include "eReplicaComponentType.h"
 
 void AgJetEffectServer::OnUse(Entity* self, Entity* user) {
 	if (inUse) {
@@ -86,12 +87,12 @@ void AgJetEffectServer::OnTimerDone(Entity* self, std::string timerName) {
 
 		auto* mortar = entities[selected];
 
-		Game::logger->Log("AgJetEffectServer", "Mortar (%i) (&d)", mortar->GetLOT(), mortar->HasComponent(COMPONENT_TYPE_SKILL));
+		Game::logger->Log("AgJetEffectServer", "Mortar (%i) (&d)", mortar->GetLOT(), mortar->HasComponent(eReplicaComponentType::SKILL));
 
 		mortar->SetOwnerOverride(builder);
 
 		SkillComponent* skillComponent;
-		if (!mortar->TryGetComponent(COMPONENT_TYPE_SKILL, skillComponent)) {
+		if (!mortar->TryGetComponent(eReplicaComponentType::SKILL, skillComponent)) {
 			return;
 		}
 

dScripts/ai/AG/AgStromlingProperty.cpp

@@ -1,5 +1,6 @@
 #include "AgStromlingProperty.h"
 #include "MovementAIComponent.h"
+#include "eReplicaComponentType.h"
 
 void AgStromlingProperty::OnStartup(Entity* self) {
 	auto movementInfo = MovementAIInfo{
@@ -12,5 +13,5 @@ void AgStromlingProperty::OnStartup(Entity* self) {
 	};
 
 	auto* movementAIComponent = new MovementAIComponent(self, movementInfo);
-	self->AddComponent(COMPONENT_TYPE_MOVEMENT_AI, movementAIComponent);
+	self->AddComponent(eReplicaComponentType::MOVEMENT_AI, movementAIComponent);
 }

dScripts/ai/GF/GfCampfire.cpp

@@ -4,13 +4,14 @@
 #include "MissionComponent.h"
 #include "RenderComponent.h"
 #include "EntityManager.h"
+#include "eReplicaComponentType.h"
 
 void GfCampfire::OnStartup(Entity* self) {
 	self->SetI32(u"counter", static_cast<int32_t>(0));
 	self->SetProximityRadius(2.0f, "placeholder");
 	self->SetBoolean(u"isBurning", true);
 
-	auto* render = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+	auto* render = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 	if (render == nullptr)
 		return;
 
@@ -20,7 +21,7 @@ void GfCampfire::OnStartup(Entity* self) {
 void GfCampfire::OnFireEventServerSide(Entity* self, Entity* sender, std::string args, int32_t param1, int32_t param2,
 	int32_t param3) {
 	if (args == "physicsReady") {
-		auto* render = static_cast<RenderComponent*>(self->GetComponent(COMPONENT_TYPE_RENDER));
+		auto* render = static_cast<RenderComponent*>(self->GetComponent(eReplicaComponentType::RENDER));
 
 		render->PlayEffect(295, u"running", "Burn");
 	}