Merge remote-tracking branch 'upstream/main' into first-draft-leaderboard-re-write

2024-09-20 01:21:32 +00:00 · 2023-05-02 15:49:23 -07:00 · 2023-05-02 15:49:23 -07:00 · b5e3bd22e3
commit b5e3bd22e3
parent 48264e2cf4 6aa90ad5b2
184 changed files with 1564 additions and 1132 deletions
--- a/README.md
+++ b/README.md
@ -245,30 +245,11 @@ To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
 * Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
 * Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
+* Next locate the line `UGCUSE3DSERVICES=7:`
+* Ensure the number after the 7 is a `0`
 * Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
 * Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.

-## Brick-By-Brick building
-Should you choose to do any brick building, you will want to have some form of a http server that returns a 404 error since we are unable to emulate live User Generated Content at the moment. If you attempt to do any brick building without a 404 server running properly, you will be unable to load into your game. Python is the easiest way to do this, but any thing that returns a 404 should work fine.
-* Note: the client hard codes this request on port 80.
-
-<font size="4">**If you do not plan on doing any Brick Building, then you can skip this step.**</font>
-
-The easiest way to do this is to install [python](https://www.python.org/downloads/).
-
-### Allowing a user to build in Brick-by-Brick mode
-Brick-By-Brick building requires `PATCHSERVERIP=0:` and `UGCSERVERIP=0:` in the `boot.cfg` to point to a HTTP server which always returns `HTTP 404 - Not Found` for all requests. This can be most easily achieved by pointing both of those variables to `localhost` while having running in the background.
-Each client must have their own 404 server running if they are using a locally hosted 404 server.
-```bash
-# If on linux run this command. Because this is run on a port below 1024, binary network permissions are needed.
-sudo python3 -m http.server 80
-
-# If on windows one of the following will work when run through Powershell or Command Prompt assuming python is installed
-python3 -m http.server 80
-python http.server 80
-py -m http.server 80
-```
-
 ## Updating your server
 To update your server to the latest version navigate to your cloned directory
 ```bash
--- a/dChatServer/ChatPacketHandler.cpp
+++ b/dChatServer/ChatPacketHandler.cpp
@ -12,6 +12,7 @@
 #include "eAddFriendResponseType.h"
 #include "RakString.h"
 #include "dConfig.h"
+#include "eObjectBits.h"

 extern PlayerContainer playerContainer;

@ -45,8 +46,8 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = res->getUInt(1);
-		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
+		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);

 		fd.isBestFriend = res->getInt(2) == 3; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		if (fd.isBestFriend) player->countOfBestFriends += 1;
@ -178,10 +179,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			bestFriendStatus = oldBestFriendStatus;

 			// Set the bits
-			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
-			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
-			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
+			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);

 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@ -336,8 +337,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}

 	// Convert friendID to LWOOBJID
-	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
+	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);

 	std::unique_ptr<sql::PreparedStatement> deletestmt(Database::CreatePreppedStmt("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
 	deletestmt->setUInt(1, static_cast<uint32_t>(playerID));
--- a/dCommon/Brick.h
+++ b/dCommon/Brick.h
@ -0,0 +1,11 @@
+#ifndef __BRICK__H__
+#define __BRICK__H__
+
+#include <cstdint>
+
+struct Brick {
+	uint32_t designerID;
+	uint32_t materialID;
+};
+
+#endif  //!__BRICK__H__
--- a/dCommon/GeneralUtils.h
+++ b/dCommon/GeneralUtils.h
@ -16,6 +16,7 @@
 #include "dLogger.h"

 enum eInventoryType : uint32_t;
+enum class eObjectBits : size_t;
 enum class eReplicaComponentType : uint32_t;

 /*!
@ -66,9 +67,9 @@ namespace GeneralUtils {

 	//! Sets a bit on a numerical value
 	template <typename T>
-	void SetBit(T& value, size_t index) {
+	inline void SetBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@ -78,9 +79,9 @@ namespace GeneralUtils {

 	//! Clears a bit on a numerical value
 	template <typename T>
-	void ClearBit(T& value, size_t index) {
+	inline void ClearBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
--- a/dCommon/LDFFormat.cpp
+++ b/dCommon/LDFFormat.cpp
@ -3,122 +3,174 @@
 // Custom Classes
 #include "GeneralUtils.h"

+#include "Game.h"
+#include "dLogger.h"
+
 // C++
-#include <sstream>
+#include <string_view>
 #include <vector>

+using LDFKey = std::string_view;
+using LDFTypeAndValue = std::string_view;
+
+using LDFType = std::string_view;
+using LDFValue = std::string_view;
+
 //! Returns a pointer to a LDFData value based on string format
-LDFBaseData* LDFBaseData::DataFromString(const std::string& format) {
+LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
+	// A valid LDF must be at least 3 characters long (=0:) is the shortest valid LDF (empty UTF-16 key with no initial value)
+	if (format.empty() || format.length() <= 2) return nullptr;
+	auto equalsPosition = format.find('=');
+	// You can have an empty key, just make sure the type and value might exist
+	if (equalsPosition == std::string::npos || equalsPosition == (format.size() - 1)) return nullptr;

-	// First, check the format
-	std::istringstream ssFormat(format);
-	std::string token;
+	std::pair<LDFKey, LDFTypeAndValue> keyValue;
+	keyValue.first = format.substr(0, equalsPosition);
+	keyValue.second = format.substr(equalsPosition + 1, format.size());

-	std::vector<std::string> keyValueArray;
-	while (std::getline(ssFormat, token, '=')) {
-		keyValueArray.push_back(token);
+	std::u16string key = GeneralUtils::ASCIIToUTF16(keyValue.first);
+
+	auto colonPosition = keyValue.second.find(':');
+
+	// If : is the first thing after an =, then this is an invalid LDF since
+	// we dont have a type to use.
+	if (colonPosition == std::string::npos || colonPosition == 0) return nullptr;
+
+	std::pair<LDFType, LDFValue> ldfTypeAndValue;
+	ldfTypeAndValue.first = keyValue.second.substr(0, colonPosition);
+	ldfTypeAndValue.second = keyValue.second.substr(colonPosition + 1, keyValue.second.size());
+
+	// Only allow empty values for string values.
+	if (ldfTypeAndValue.second.size() == 0 && !(ldfTypeAndValue.first == "0" || ldfTypeAndValue.first == "13")) return nullptr;
+
+	eLDFType type;
+	char* storage;
+	try {
+		type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
+	} catch (std::exception) {
+		Game::logger->Log("LDFFormat", "Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
+		return nullptr;
 	}

-	if (keyValueArray.size() == 2) {
-		std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
-
-		std::vector<std::string> dataArray;
-		std::istringstream ssData(keyValueArray[1]);
-		while (std::getline(ssData, token, ':')) {
-			dataArray.push_back(token);
-		}
-
-		if (dataArray.size() > 2) { // hacky fix for strings with colons in them
-			std::vector<std::string> newDataArray;
-			newDataArray.push_back(dataArray[0]);
-			std::string value = "";
-			for (size_t i = 1; i < dataArray.size(); ++i) {
-				value += dataArray[i] + ':';
-			}
-			value.pop_back(); // remove last colon
-			newDataArray.push_back(value);
-			dataArray = newDataArray;
-		}
-
-		if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
-			dataArray.push_back("");
-		}
-
-		if (dataArray.size() == 2) {
-			eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
-
+	LDFBaseData* returnValue = nullptr;
 	switch (type) {
 	case LDF_TYPE_UTF_16: {
-				std::u16string data = GeneralUtils::UTF8ToUTF16(dataArray[1]);
-				return new LDFData<std::u16string>(key, data);
+		std::u16string data = GeneralUtils::UTF8ToUTF16(ldfTypeAndValue.second);
+		returnValue = new LDFData<std::u16string>(key, data);
+		break;
 	}

 	case LDF_TYPE_S32: {
-				int32_t data = static_cast<int32_t>(stoull(dataArray[1]));
-				return new LDFData<int32_t>(key, data);
+		try {
+			int32_t data = static_cast<int32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<int32_t>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
 	}

 	case LDF_TYPE_FLOAT: {
-				float data = static_cast<float>(stof(dataArray[1]));
-				return new LDFData<float>(key, data);
+		try {
+			float data = strtof(ldfTypeAndValue.second.data(), &storage);
+			returnValue = new LDFData<float>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
 	}

 	case LDF_TYPE_DOUBLE: {
-				double data = static_cast<float>(stod(dataArray[1]));
-				return new LDFData<double>(key, data);
+		try {
+			double data = strtod(ldfTypeAndValue.second.data(), &storage);
+			returnValue = new LDFData<double>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
 	}

 	case LDF_TYPE_U32:
 	{
 		uint32_t data;

-				if (dataArray[1] == "true") {
+		if (ldfTypeAndValue.second == "true") {
 			data = 1;
-				} else if (dataArray[1] == "false") {
+		} else if (ldfTypeAndValue.second == "false") {
 			data = 0;
 		} else {
-					data = static_cast<uint32_t>(stoul(dataArray[1]));
+			try {
+				data = static_cast<uint32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
+			} catch (std::exception) {
+				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+				return nullptr;
+			}
 		}

-				return new LDFData<uint32_t>(key, data);
+		returnValue = new LDFData<uint32_t>(key, data);
+		break;
 	}

 	case LDF_TYPE_BOOLEAN: {
 		bool data;

-				if (dataArray[1] == "true") {
+		if (ldfTypeAndValue.second == "true") {
 			data = true;
-				} else if (dataArray[1] == "false") {
+		} else if (ldfTypeAndValue.second == "false") {
 			data = false;
 		} else {
-					data = static_cast<bool>(stoi(dataArray[1]));
+			try {
+				data = static_cast<bool>(strtol(ldfTypeAndValue.second.data(), &storage, 10));
+			} catch (std::exception) {
+				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+				return nullptr;
+			}
 		}

-				return new LDFData<bool>(key, data);
+		returnValue = new LDFData<bool>(key, data);
+		break;
 	}

 	case LDF_TYPE_U64: {
-				uint64_t data = static_cast<uint64_t>(stoull(dataArray[1]));
-				return new LDFData<uint64_t>(key, data);
+		try {
+			uint64_t data = static_cast<uint64_t>(strtoull(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<uint64_t>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
 	}

 	case LDF_TYPE_OBJID: {
-				LWOOBJID data = static_cast<LWOOBJID>(stoll(dataArray[1]));
-				return new LDFData<LWOOBJID>(key, data);
+		try {
+			LWOOBJID data = static_cast<LWOOBJID>(strtoll(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<LWOOBJID>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
 	}

 	case LDF_TYPE_UTF_8: {
-				std::string data = dataArray[1];
-				return new LDFData<std::string>(key, data);
+		std::string data = ldfTypeAndValue.second.data();
+		returnValue = new LDFData<std::string>(key, data);
+		break;
 	}

 	case LDF_TYPE_UNKNOWN: {
-				return nullptr;
-			}
-			}
-		}
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		break;
 	}

-	return nullptr;
-
+	default: {
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
+		break;
+	}
+	}
+	return returnValue;
 }
--- a/dCommon/LDFFormat.h
+++ b/dCommon/LDFFormat.h
@ -1,4 +1,5 @@
-#pragma once
+#ifndef __LDFFORMAT__H__
+#define __LDFFORMAT__H__

 // Custom Classes
 #include "dCommonVars.h"
@ -6,18 +7,12 @@

 // C++
 #include <string>
+#include <string_view>
 #include <sstream>

 // RakNet
+#include "BitStream.h"

-#include "../thirdparty/raknet/Source/BitStream.h"
-
-/*!
-  \file LDFFormat.hpp
-  \brief A collection of LDF format classes
- */
-
- //! An enum for LDF Data Types
 enum eLDFType {
 	LDF_TYPE_UNKNOWN = -1,          //!< Unknown data type
 	LDF_TYPE_UTF_16 = 0,            //!< UTF-16 wstring data type
@ -31,36 +26,21 @@ enum eLDFType {
 	LDF_TYPE_UTF_8 = 13,            //!< UTF-8 string data type
 };

-//! A base class for the LDF data
 class LDFBaseData {
 public:

-	//! Destructor
-	virtual ~LDFBaseData(void) {}
+	virtual ~LDFBaseData() {}

-	//! Writes the data to a packet
-	/*!
-	  \param packet The packet
-	 */
 	virtual void WriteToPacket(RakNet::BitStream* packet) = 0;

-	//! Gets the key
-	/*!
-	  \return The key
-	 */
-	virtual const std::u16string& GetKey(void) = 0;
+	virtual const std::u16string& GetKey() = 0;

-	//! Gets the value type
-	/*!
-	  \return The value type
-	 */
-	virtual eLDFType GetValueType(void) = 0;
+	virtual eLDFType GetValueType() = 0;

-	//! Gets a string from the key/value pair
-	/*!
-	  \param includeKey Whether or not to include the key in the data
-	  \param includeTypeId Whether or not to include the type id in the data
-	  \return The string representation of the data
+	/** Gets a string from the key/value pair
+	 * @param includeKey Whether or not to include the key in the data
+	 * @param includeTypeId Whether or not to include the type id in the data
+	 * @return The string representation of the data
 	 */
 	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;

@ -68,19 +48,15 @@ public:

 	virtual LDFBaseData* Copy() = 0;

-	// MARK: Functions
-
-	//! Returns a pointer to a LDFData value based on string format
-	/*!
-	  \param format The format
+	/**
+	 * Given an input string, return the data as a LDF key.
 	 */
-	static LDFBaseData* DataFromString(const std::string& format);
+	static LDFBaseData* DataFromString(const std::string_view& format);

 };

-//! A structure for an LDF key-value pair
 template<typename T>
-class LDFData : public LDFBaseData {
+class LDFData: public LDFBaseData {
 private:
 	std::u16string key;
 	T value;
@ -164,15 +140,11 @@ public:

 		if (includeKey) {
 			const std::string& sKey = GeneralUtils::UTF16ToWTF8(this->key, this->key.size());
-
-			stream << sKey << "=";
+			stream << sKey << '=';
 		}

 		if (includeTypeId) {
-			const std::string& sType = std::to_string(this->GetValueType());
-
-
-			stream << sType << ":";
+			stream << this->GetValueType() << ':';
 		}

 		const std::string& sData = this->GetValueString();
@ -234,20 +206,18 @@ inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
 	}
 }

-// MARK: String Data
-template<> inline std::string LDFData<std::u16string>::GetValueString(void) {
-	//std::string toReturn(this->value.begin(), this->value.end());
-	//return toReturn;
-
+template<> inline std::string LDFData<std::u16string>::GetValueString() {
 	return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
 }

-template<> inline std::string LDFData<int32_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<float>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<double>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint32_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<bool>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint64_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<LWOOBJID>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }

-template<> inline std::string LDFData<std::string>::GetValueString(void) { return this->value; }
+template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }
+
+#endif  //!__LDFFORMAT__H__
--- a/dCommon/dEnums/dCommonVars.h
+++ b/dCommon/dEnums/dCommonVars.h
@ -10,8 +10,6 @@

 #pragma warning (disable:4251) //Disables SQL warnings

-typedef int RESTICKET;
-
 // These are the same define, but they mean two different things in different contexts
 // so a different define to distinguish what calculation is happening will help clarity.
 #define FRAMES_TO_MS(x) 1000 / x
@ -45,23 +43,16 @@ typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
 typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
 typedef uint32_t StripId;

-typedef int32_t PetTamingPiece;             //!< Pet Taming Pieces
-
 const LWOOBJID LWOOBJID_EMPTY = 0;          //!< An empty object ID
 const LOT LOT_NULL = -1;                    //!< A null LOT
 const int32_t LOOTTYPE_NONE = 0;            //!< No loot type available
 const float SECONDARY_PRIORITY = 1.0f;      //!< Secondary Priority
-const uint32_t INVENTORY_INVALID = -1;      //!< Invalid Inventory
-const uint32_t INVENTORY_DEFAULT = -1;      //!< Default Inventory
-const uint32_t StatusChangeInfo = 0;        //!< Status Change Info (???)
 const uint32_t INVENTORY_MAX = 9999999;     //!< The Maximum Inventory Size
 const uint32_t LWOCLONEID_INVALID = -1;     //!< Invalid LWOCLONEID
 const uint16_t LWOINSTANCEID_INVALID = -1;  //!< Invalid LWOINSTANCEID
 const uint16_t LWOMAPID_INVALID = -1;       //!< Invalid LWOMAPID
 const uint64_t LWOZONEID_INVALID = 0;       //!< Invalid LWOZONEID

-typedef std::set<LWOOBJID> TSetObjID;
-
 const float PI = 3.14159f;

 //============ STRUCTS ==============
@ -164,401 +155,4 @@ public:
 	}
 };

-struct Brick {
-	uint32_t designerID;
-	uint32_t materialID;
-};
-
-//This union is used by the behavior system
-union suchar {
-	unsigned char usigned;
-	char svalue;
-};
-
-//=========== LU ENUMS ============
-
-//! An enum for object ID bits
-enum eObjectBits : int32_t {
-	OBJECT_BIT_PERSISTENT = 32,     //!< The 32 bit index
-	OBJECT_BIT_CLIENT = 46,         //!< The 46 bit index
-	OBJECT_BIT_SPAWNED = 58,        //!< The 58 bit index
-	OBJECT_BIT_CHARACTER = 60       //!< The 60 bit index
-};
-
-//! An enum for MatchUpdate types
-enum eMatchUpdate : int {
-	MATCH_UPDATE_PLAYER_JOINED = 0,
-	MATCH_UPDATE_PLAYER_LEFT = 1,
-	MATCH_UPDATE_TIME = 3,
-	MATCH_UPDATE_TIME_START_DELAY = 4,
-	MATCH_UPDATE_PLAYER_READY = 5,
-	MATCH_UPDATE_PLAYER_UNREADY = 6
-};
-
-//! An enum for camera cycling modes
-enum eCyclingMode : uint32_t {
-	ALLOW_CYCLE_TEAMMATES,
-	DISALLOW_CYCLING
-};
-
-enum eCinematicEvent : uint32_t {
-	STARTED,
-	WAYPOINT,
-	ENDED,
-};
-
-//! An enum for character creation responses
-enum eCreationResponse : uint8_t {
-	CREATION_RESPONSE_SUCCESS = 0,                  //!< The creation was successful
-	CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE,        //!< The Object ID can't be used
-	CREATION_RESPONSE_NAME_NOT_ALLOWED,             //!< The name is not allowed
-	CREATION_RESPONSE_PREDEFINED_NAME_IN_USE,       //!< The predefined name is already in use
-	CREATION_RESPONSE_CUSTOM_NAME_IN_USE            //!< The custom name is already in use
-};
-
-//! An enum for login responses
-enum eLoginResponse : uint8_t {
-	LOGIN_RESPONSE_GENERAL_FAILED = 0,
-	LOGIN_RESPONSE_SUCCESS = 1,
-	LOGIN_RESPONSE_BANNED = 2,
-	LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH = 5,
-	LOGIN_RESPONSE_WRONG_PASS_OR_USER = 6,
-	LOGIN_RESPONSE_ACCOUNT_LOCKED = 7
-};
-
-//! An enum for character rename responses
-enum eRenameResponse : uint8_t {
-	RENAME_RESPONSE_SUCCESS = 0,                    //!< The renaming was successful
-	RENAME_RESPONSE_UNKNOWN_ERROR,                  //!< There was an unknown error
-	RENAME_RESPONSE_NAME_UNAVAILABLE,               //!< The name is unavailable
-	RENAME_RESPONSE_NAME_IN_USE                     //!< The name is already in use
-};
-
-//! A replica packet type
-enum eReplicaPacketType {
-	PACKET_TYPE_CONSTRUCTION,                       //!< A construction packet
-	PACKET_TYPE_SERIALIZATION,                      //!< A serialization packet
-	PACKET_TYPE_DESTRUCTION                         //!< A destruction packet
-};
-
-//! The Behavior Types for use with the AI system
-enum eCombatBehaviorTypes : uint32_t {
-	PASSIVE = 0,                    //!< The object is passive
-	AGGRESSIVE = 1,                 //!< The object is aggressive
-	PASSIVE_TURRET = 2,             //!< The object is a passive turret
-	AGGRESSIVE_TURRET = 3           //!< The object is an aggressive turret
-};
-
-//! The Combat Role Type for use with the AI system
-enum eCombatRoleType : uint32_t {
-	MELEE = 0,                      //!< Used for melee attacks
-	RANGED = 1,                     //!< Used for range attacks
-	SUPPORT = 2                     //!< Used for support
-};
-
-//! The kill types for the Die packet
-enum eKillType : uint32_t {
-	VIOLENT,
-	SILENT
-};
-
-//! The various world states used throughout the server
-enum eObjectWorldState {
-	WORLDSTATE_INWORLD,             //!< Probably used when the object is in the world
-	WORLDSTATE_ATTACHED,            //!< Probably used when the object is attached to another object
-	WORLDSTATE_INVENTORY            //!< Probably used when the object is in an inventory
-};
-
-//! The trigger stats (???)
-enum eTriggerStat {
-	INVALID_STAT,                   //!< ???
-	HEALTH,                         //!< Probably used for health
-	ARMOR,                          //!< Probably used for armor
-	IMAGINATION                     //!< Probably used for imagination
-};
-
-//! The trigger operations (???)
-enum eTriggerOperator {
-	INVALID_OPER,                   //!< ???
-	EQUAL,                          //!< ???
-	NOT_EQUAL,                      //!< ???
-	GREATER,                        //!< ???
-	GREATER_EQUAL,                  //!< ???
-	LESS,                           //!< ???
-	LESS_EQUAL                      //!< ???
-};
-
-//! The various build types
-enum eBuildType {
-	BUILD_NOWHERE,                  //!< Used if something can't be built anywhere
-	BUILD_IN_WORLD,                 //!< Used if something can be built in the world
-	BUILD_ON_PROPERTY               //!< Used if something can be build on a property
-};
-
-//! Quickbuild fail reasons
-enum eFailReason : uint32_t {
-	REASON_NOT_GIVEN,
-	REASON_OUT_OF_IMAGINATION,
-	REASON_CANCELED_EARLY,
-	REASON_BUILD_ENDED
-};
-
-//! Terminate interaction type
-enum eTerminateType : uint32_t {
-	RANGE,
-	USER,
-	FROM_INTERACTION
-};
-
-//! The combat state
-enum eCombatState {
-	IDLE,                           //!< The AI is in an idle state
-	AGGRO,                          //!< The AI is in an aggressive state
-	TETHER,                         //!< The AI is being redrawn back to tether point
-	SPAWN,                          //!< The AI is spawning
-	DEAD                            //!< The AI is dead
-};
-
-enum eControlSceme {
-	SCHEME_A,
-	SCHEME_D,
-	SCHEME_GAMEPAD,
-	SCHEME_E,
-	SCHEME_FPS,
-	SCHEME_DRIVING,
-	SCHEME_TAMING,
-	SCHEME_MODULAR_BUILD,
-	SCHEME_WEAR_A_ROBOT //== freecam?
-};
-
-enum class eStateChangeType : uint32_t {
-	PUSH,
-	POP
-};
-
-enum eNotifyType {
-	NOTIFY_TYPE_SUCCESS,
-	NOTIFY_TYPE_QUIT,
-	NOTIFY_TYPE_FAILED,
-	NOTIFY_TYPE_BEGIN,
-	NOTIFY_TYPE_READY,
-	NOTIFY_TYPE_NAMINGPET
-};
-
-
-enum class UseItemResponse : uint32_t {
-	NoImaginationForPet = 1,
-	FailedPrecondition,
-	MountsNotAllowed
-};
-
-enum eRebuildState : uint32_t {
-	REBUILD_OPEN,
-	REBUILD_COMPLETED = 2,
-	REBUILD_RESETTING = 4,
-	REBUILD_BUILDING,
-	REBUILD_INCOMPLETE
-};
-
-/**
- * The loot source's type.
- */
-enum eLootSourceType : int32_t {
-	LOOT_SOURCE_NONE = 0,
-	LOOT_SOURCE_CHEST,
-	LOOT_SOURCE_MISSION,
-	LOOT_SOURCE_MAIL,
-	LOOT_SOURCE_CURRENCY,
-	LOOT_SOURCE_ACHIEVEMENT,
-	LOOT_SOURCE_TRADE,
-	LOOT_SOURCE_QUICKBUILD,
-	LOOT_SOURCE_DELETION,
-	LOOT_SOURCE_VENDOR,
-	LOOT_SOURCE_ACTIVITY,
-	LOOT_SOURCE_PICKUP,
-	LOOT_SOURCE_BRICK,
-	LOOT_SOURCE_PROPERTY,
-	LOOT_SOURCE_MODERATION,
-	LOOT_SOURCE_EXHIBIT,
-	LOOT_SOURCE_INVENTORY,
-	LOOT_SOURCE_CLAIMCODE,
-	LOOT_SOURCE_CONSUMPTION,
-	LOOT_SOURCE_CRAFTING,
-	LOOT_SOURCE_LEVEL_REWARD,
-	LOOT_SOURCE_RELOCATE
-};
-
-enum eGameActivities : uint32_t {
-	ACTIVITY_NONE,
-	ACTIVITY_QUICKBUILDING,
-	ACTIVITY_SHOOTING_GALLERY,
-	ACTIVITY_RACING,
-	ACTIVITY_PINBALL,
-	ACTIVITY_PET_TAMING
-};
-
-enum ePlayerFlags {
-	BTARR_TESTING = 0,
-	PLAYER_HAS_ENTERED_PET_RANCH = 1,
-	MINIMAP_UNLOCKED = 2,
-	ACTIVITY_REBUILDING_FAIL_TIME = 3,
-	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
-	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
-	HELP_WALKING_CONTROLS = 6,
-	FIRST_SMASHABLE = 7,
-	FIRST_IMAGINATION_PICKUP = 8,
-	FIRST_DAMAGE = 9,
-	FIRST_ITEM = 10,
-	FIRST_BRICK = 11,
-	FIRST_CONSUMABLE = 12,
-	FIRST_EQUIPPABLE = 13,
-	CHAT_HELP = 14,
-	FIRST_PET_TAMING_MINIGAME = 15,
-	FIRST_PET_ON_SWITCH = 16,
-	FIRST_PET_JUMPED_ON_SWITCH = 17,
-	FIRST_PET_FOUND_TREASURE = 18,
-	FIRST_PET_DUG_TREASURE = 19,
-	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
-	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
-	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
-	FIRST_EMOTE_UNLOCKED = 23,
-	GF_PIRATE_REP = 24,
-	AG_BOB_CINEMATIC_EVENT = 25,
-	HELP_JUMPING_CONTROLS = 26,
-	HELP_DOUBLE_JUMP_CONTROLS = 27,
-	HELP_CAMERA_CONTROLS = 28,
-	HELP_ROTATE_CONTROLS = 29,
-	HELP_SMASH = 30,
-	MONUMENT_INTRO_MUSIC_PLAYED = 31,
-	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
-	AG_FINISH_LINE_BUILT = 33,
-	AG_BOSS_AREA_FOUND = 34,
-	AG_LANDED_IN_BATTLEFIELD = 35,
-	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
-	MODULAR_BUILD_STARTED = 37,
-	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
-	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
-	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
-	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
-	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
-	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
-	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
-	JOINED_A_FACTION = 45,
-	VENTURE_FACTION = 46,
-	ASSEMBLY_FACTION = 47,
-	PARADOX_FACTION = 48,
-	SENTINEL_FACTION = 49,
-	LUP_WORLD_ACCESS = 50,
-	AG_FIRST_FLAG_COLLECTED = 51,
-	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
-	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
-	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
-	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
-	GF_PET_DIG_FLAG_1 = 56,
-	GF_PET_DIG_FLAG_2 = 57,
-	GF_PET_DIG_FLAG_3 = 58,
-	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
-	GF_PLAYER_FALL_DEATH = 60,
-	GF_PLAYER_CAN_GET_FLAG_1 = 61,
-	GF_PLAYER_CAN_GET_FLAG_2 = 62,
-	GF_PLAYER_CAN_GET_FLAG_3 = 63,
-	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
-	AG_FIRST_COMBAT_COMPLETE = 65,
-	AG_COMPLETE_BOB_MISSION = 66,
-	IS_NEWS_SCREEN_VISIBLE = 114,
-	NJ_GARMADON_CINEMATIC_SEEN = 125,
-	ELEPHANT_PET_3050 = 801,
-	CAT_PET_3054 = 802,
-	TRICERATOPS_PET_3195 = 803,
-	TERRIER_PET_3254 = 804,
-	SKUNK_PET_3261 = 805,
-	LION_PET_3520 = 806,
-	BUNNY_PET_3672 = 807,
-	CROCODILE_PET_3994 = 808,
-	DOBERMAN_PET_5635 = 809,
-	BUFFALO_PET_5636 = 810,
-	ROBOT_DOG_PET_5637 = 811,
-	EUROPEAN_DRAGON_PET_5639 = 812,
-	TORTOISE_PET_5640 = 813,
-	ASIAN_DRAGON_PET_5641 = 814,
-	MANTIS_PET_5642 = 815,
-	PANDA_PET_5643 = 816,
-	WARTHOG_PET_6720 = 817,
-	GOAT_PET_7638 = 818,
-	CRAB_PET_7694 = 819,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
-	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
-	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
-	AG_BATTLE_BINOC_AT_PARADOX = 1102,
-	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
-	AG_BATTLE_BINOC_AT_BECK = 1104,
-	AG_MONUMENT_BINOC_INTRO = 1105,
-	AG_MONUMENT_BINOC_OUTRO = 1106,
-	AG_LAUNCH_BINOC_INTRO = 1107,
-	AG_LAUNCH_BINOC_BISON = 1108,
-	AG_LAUNCH_BINOC_SHARK = 1109,
-	NS_BINOC_CONCERT_TRANSITION = 1201,
-	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
-	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
-	NS_BINOC_GF_LAUNCH = 1204,
-	NS_BINOC_FV_LAUNCH = 1205,
-	NS_BINOC_BRICK_ANNEX_WATER = 1206,
-	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
-	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
-	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
-	NS_BINOC_TBA = 1210,
-	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
-	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
-	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
-	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
-	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
-	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
-	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
-	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
-	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
-	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
-	PR_BINOC_AT_LAUNCH_PAD = 1251,
-	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
-	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
-	PR_BINOC_ON_BY_CROWS_NEST = 1254,
-	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
-	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
-	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
-	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
-	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
-	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
-	GF_BINOC_ON_LANDING_PAD = 1301,
-	GF_BINOC_AT_RAVINE_START = 1302,
-	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
-	GF_BINOC_AT_TURTLE_AREA = 1304,
-	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
-	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
-	GF_BINOC_IN_RACING_AREA = 1307,
-	GF_BINOC_IN_CROC_AREA = 1308,
-	GF_BINOC_IN_JAIL_AREA = 1309,
-	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
-	NT_PLINTH_REBUILD = 1919,
-	NT_FACTION_SPY_DUKE = 1974,
-	NT_FACTION_SPY_OVERBUILD = 1976,
-	NT_FACTION_SPY_HAEL = 1977,
-	NJ_EARTH_SPINJITZU = 2030,
-	NJ_LIGHTNING_SPINJITZU = 2031,
-	NJ_ICE_SPINJITZU = 2032,
-	NJ_FIRE_SPINJITZU = 2033,
-	NJ_WU_SHOW_DAILY_CHEST = 2099
-};
-
-//======== FUNC ===========
-
-template<typename T>
-inline T const& clamp(const T& val, const T& low, const T& high) {
-	if (val < low) return low;
-	else if (val > high) return high;
-
-	return val;
-}
-
 #endif  //!__DCOMMONVARS__H__
--- a/dCommon/dEnums/eBuildType.h
+++ b/dCommon/dEnums/eBuildType.h
@ -0,0 +1,12 @@
+#ifndef __EBUILDTYPE__H__
+#define __EBUILDTYPE__H__
+
+#include <cstdint>
+
+enum class eBuildType :uint32_t {
+	NOWHERE,
+	IN_WORLD,
+	ON_PROPERTY
+};
+
+#endif  //!__EBUILDTYPE__H__
--- a/dCommon/dEnums/eCharacterCreationResponse.h
+++ b/dCommon/dEnums/eCharacterCreationResponse.h
@ -0,0 +1,14 @@
+#ifndef __ECHARACTERCREATIONRESPONSE__H__
+#define __ECHARACTERCREATIONRESPONSE__H__
+
+#include <cstdint>
+
+enum class eCharacterCreationResponse : uint8_t {
+	SUCCESS = 0,
+	OBJECT_ID_UNAVAILABLE,
+	NAME_NOT_ALLOWED,
+	PREDEFINED_NAME_IN_USE,
+	CUSTOM_NAME_IN_USE
+};
+
+#endif  //!__ECHARACTERCREATIONRESPONSE__H__
--- a/dCommon/dEnums/eCinematicEvent.h
+++ b/dCommon/dEnums/eCinematicEvent.h
@ -0,0 +1,12 @@
+#ifndef __ECINEMATICEVENT__H__
+#define __ECINEMATICEVENT__H__
+
+#include <cstdint>
+
+enum class eCinematicEvent : uint32_t {
+	STARTED,
+	WAYPOINT,
+	ENDED,
+};
+
+#endif  //!__ECINEMATICEVENT__H__
--- a/dCommon/dEnums/eControlScheme.h
+++ b/dCommon/dEnums/eControlScheme.h
@ -0,0 +1,18 @@
+#ifndef __ECONTROLSCHEME__H__
+#define __ECONTROLSCHEME__H__
+
+#include <cstdint>
+
+enum class eControlScheme : uint32_t {
+	SCHEME_A,
+	SCHEME_D,
+	SCHEME_GAMEPAD,
+	SCHEME_E,
+	SCHEME_FPS,
+	SCHEME_DRIVING,
+	SCHEME_TAMING,
+	SCHEME_MODULAR_BUILD,
+	SCHEME_WEAR_A_ROBOT //== freecam?
+};
+
+#endif  //!__ECONTROLSCHEME__H__
--- a/dCommon/dEnums/eCyclingMode.h
+++ b/dCommon/dEnums/eCyclingMode.h
@ -0,0 +1,11 @@
+#ifndef __ECYCLINGMODE__H__
+#define __ECYCLINGMODE__H__
+
+#include <cstdint>
+
+enum class eCyclingMode : uint32_t {
+	ALLOW_CYCLE_TEAMMATES,
+	DISALLOW_CYCLING
+};
+
+#endif  //!__ECYCLINGMODE__H__
--- a/dCommon/dEnums/eGameActivity.h
+++ b/dCommon/dEnums/eGameActivity.h
@ -0,0 +1,15 @@
+#ifndef __EGAMEACTIVITY__H__
+#define __EGAMEACTIVITY__H__
+
+#include <cstdint>
+
+enum class eGameActivity : uint32_t {
+	NONE,
+	QUICKBUILDING,
+	SHOOTING_GALLERY,
+	RACING,
+	PINBALL,
+	PET_TAMING
+};
+
+#endif  //!__EGAMEACTIVITY__H__
--- a/dCommon/dEnums/eKillType.h
+++ b/dCommon/dEnums/eKillType.h
@ -0,0 +1,11 @@
+#ifndef __EKILLTYPE__H__
+#define __EKILLTYPE__H__
+
+#include <cstdint>
+
+enum class eKillType : uint32_t {
+	VIOLENT,
+	SILENT
+};
+
+#endif  //!__EKILLTYPE__H__
--- a/dCommon/dEnums/eLoginResponse.h
+++ b/dCommon/dEnums/eLoginResponse.h
@ -0,0 +1,24 @@
+#ifndef __ELOGINRESPONSE__H__
+#define __ELOGINRESPONSE__H__
+
+#include <cstdint>
+
+enum class eLoginResponse : uint8_t {
+	GENERAL_FAILED = 0,
+	SUCCESS,
+	BANNED,
+	// Unused 3
+	// Unused 4
+	PERMISSIONS_NOT_HIGH_ENOUGH = 5,
+	INVALID_USER,
+	ACCOUNT_LOCKED,
+	WRONG_PASS,
+	ACCOUNT_ACTIVATION_PENDING,
+	ACCOUNT_DISABLED,
+	GAME_TIME_EXPIRED,
+	FREE_TRIAL_ENDED,
+	PLAY_SCHEDULE_TIME_UP,
+	ACCOUNT_NOT_ACTIVATED
+};
+
+#endif  //!__ELOGINRESPONSE__H__
--- a/dCommon/dEnums/eLootSourceType.h
+++ b/dCommon/dEnums/eLootSourceType.h
@ -0,0 +1,31 @@
+#ifndef __ELOOTSOURCETYPE__H__
+#define __ELOOTSOURCETYPE__H__
+
+#include <cstdint>
+
+enum class eLootSourceType : uint32_t {
+	NONE = 0,
+	CHEST,
+	MISSION,
+	MAIL,
+	CURRENCY,
+	ACHIEVEMENT,
+	TRADE,
+	QUICKBUILD,
+	DELETION,
+	VENDOR,
+	ACTIVITY,
+	PICKUP,
+	BRICK,
+	PROPERTY,
+	MODERATION,
+	EXHIBIT,
+	INVENTORY,
+	CLAIMCODE,
+	CONSUMPTION,
+	CRAFTING,
+	LEVEL_REWARD,
+	RELOCATE
+};
+
+#endif  //!__ELOOTSOURCETYPE__H__
--- a/dCommon/dEnums/eMatchUpdate.h
+++ b/dCommon/dEnums/eMatchUpdate.h
@ -0,0 +1,17 @@
+#ifndef __EMATCHUPDATE__H__
+#define __EMATCHUPDATE__H__
+
+#include <cstdint>
+
+enum class eMatchUpdate : int32_t {
+	PLAYER_ADDED = 0,
+	PLAYER_REMOVED,
+	PHASE_CREATED,
+	PHASE_WAIT_READY,
+	PHASE_WAIT_START,
+	PLAYER_READY,
+	PLAYER_NOT_READY,
+	PLAYER_UPDATE
+};
+
+#endif  //!__EMATCHUPDATE__H__
--- a/dCommon/dEnums/eObjectBits.h
+++ b/dCommon/dEnums/eObjectBits.h
@ -0,0 +1,13 @@
+#ifndef __EOBJECTBITS__H__
+#define __EOBJECTBITS__H__
+
+#include <cstdint>
+
+enum class eObjectBits : size_t {
+	PERSISTENT = 32,
+	CLIENT = 46,
+	SPAWNED = 58,
+	CHARACTER = 60
+};
+
+#endif  //!__EOBJECTBITS__H__
--- a/dCommon/dEnums/eObjectWorldState.h
+++ b/dCommon/dEnums/eObjectWorldState.h
@ -0,0 +1,12 @@
+#ifndef __EOBJECTWORLDSTATE__H__
+#define __EOBJECTWORLDSTATE__H__
+
+#include <cstdint>
+
+enum class eObjectWorldState : uint32_t {
+	INWORLD,
+	ATTACHED,
+	INVENTORY
+};
+
+#endif  //!__EOBJECTWORLDSTATE__H__
--- a/dCommon/dEnums/ePetTamingNotifyType.h
+++ b/dCommon/dEnums/ePetTamingNotifyType.h
@ -0,0 +1,15 @@
+#ifndef __EPETTAMINGNOTIFYTYPE__H__
+#define __EPETTAMINGNOTIFYTYPE__H__
+
+#include <cstdint>
+
+enum class ePetTamingNotifyType : uint32_t {
+	SUCCESS,
+	QUIT,
+	FAILED,
+	BEGIN,
+	READY,
+	NAMINGPET
+};
+
+#endif  //!__EPETTAMINGNOTIFYTYPE__H__
--- a/dCommon/dEnums/ePlayerFlag.h
+++ b/dCommon/dEnums/ePlayerFlag.h
@ -0,0 +1,172 @@
+#ifndef __EPLAYERFLAG__H__
+#define __EPLAYERFLAG__H__
+
+#include <cstdint>
+
+enum ePlayerFlag : int32_t {
+	BTARR_TESTING = 0,
+	PLAYER_HAS_ENTERED_PET_RANCH = 1,
+	MINIMAP_UNLOCKED = 2,
+	ACTIVITY_REBUILDING_FAIL_TIME = 3,
+	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
+	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
+	HELP_WALKING_CONTROLS = 6,
+	FIRST_SMASHABLE = 7,
+	FIRST_IMAGINATION_PICKUP = 8,
+	FIRST_DAMAGE = 9,
+	FIRST_ITEM = 10,
+	FIRST_BRICK = 11,
+	FIRST_CONSUMABLE = 12,
+	FIRST_EQUIPPABLE = 13,
+	CHAT_HELP = 14,
+	FIRST_PET_TAMING_MINIGAME = 15,
+	FIRST_PET_ON_SWITCH = 16,
+	FIRST_PET_JUMPED_ON_SWITCH = 17,
+	FIRST_PET_FOUND_TREASURE = 18,
+	FIRST_PET_DUG_TREASURE = 19,
+	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
+	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
+	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
+	FIRST_EMOTE_UNLOCKED = 23,
+	GF_PIRATE_REP = 24,
+	AG_BOB_CINEMATIC_EVENT = 25,
+	HELP_JUMPING_CONTROLS = 26,
+	HELP_DOUBLE_JUMP_CONTROLS = 27,
+	HELP_CAMERA_CONTROLS = 28,
+	HELP_ROTATE_CONTROLS = 29,
+	HELP_SMASH = 30,
+	MONUMENT_INTRO_MUSIC_PLAYED = 31,
+	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
+	AG_FINISH_LINE_BUILT = 33,
+	AG_BOSS_AREA_FOUND = 34,
+	AG_LANDED_IN_BATTLEFIELD = 35,
+	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
+	MODULAR_BUILD_STARTED = 37,
+	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
+	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
+	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
+	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
+	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
+	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
+	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
+	JOINED_A_FACTION = 45,
+	VENTURE_FACTION = 46,
+	ASSEMBLY_FACTION = 47,
+	PARADOX_FACTION = 48,
+	SENTINEL_FACTION = 49,
+	LUP_WORLD_ACCESS = 50,
+	AG_FIRST_FLAG_COLLECTED = 51,
+	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
+	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
+	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
+	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
+	GF_PET_DIG_FLAG_1 = 56,
+	GF_PET_DIG_FLAG_2 = 57,
+	GF_PET_DIG_FLAG_3 = 58,
+	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
+	GF_PLAYER_FALL_DEATH = 60,
+	GF_PLAYER_CAN_GET_FLAG_1 = 61,
+	GF_PLAYER_CAN_GET_FLAG_2 = 62,
+	GF_PLAYER_CAN_GET_FLAG_3 = 63,
+	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
+	AG_FIRST_COMBAT_COMPLETE = 65,
+	AG_COMPLETE_BOB_MISSION = 66,
+	FIRST_MANUAL_PET_HIBERNATE = 69,
+	CAGED_SPIDER = 74,
+	IS_NEWS_SCREEN_VISIBLE = 114,
+	NJ_GARMADON_CINEMATIC_SEEN = 125,
+	EQUPPED_TRIAL_FACTION_GEAR = 126,
+	ELEPHANT_PET_3050 = 801,
+	CAT_PET_3054 = 803,
+	TRICERATOPS_PET_3195 = 806,
+	TERRIER_PET_3254 = 807,
+	SKUNK_PET_3261 = 811,
+	BUNNY_PET_3672 = 813,
+	CROCODILE_PET_3994 = 814,
+	DOBERMAN_PET_5635 = 815,
+	BUFFALO_PET_5636 = 816,
+	ROBOT_DOG_PET_5637 = 818,
+	RED_DRAGON_PET_5639 = 819,
+	TORTOISE_PET_5640 = 820,
+	GREEN_DRAGON_PET_5641 = 821,
+	PANDA_PET_5643 = 822,
+	MANTIS_PET_5642 = 823,
+	WARTHOG_PET_6720 = 824,
+	LION_PET_3520 = 825,
+	GOAT_PET_7638 = 818,
+	CRAB_PET_7694 = 827,
+	REINDEER_PET_12294 = 829,
+	STEGOSAURUS_PET_12431 = 830,
+	SABER_CAT_PET_12432 = 831,
+	GRYPHON_PET_12433 = 832,
+	ALINE_PET_12334 = 833,
+	UNKNOWN_PET = 834,
+	EARTH_DRAGON_PET_16210 = 836,
+	SKELETON_DRAGON_PET_13067 = 838,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
+	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
+	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
+	AG_BATTLE_BINOC_AT_PARADOX = 1102,
+	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
+	AG_BATTLE_BINOC_AT_BECK = 1104,
+	AG_MONUMENT_BINOC_INTRO = 1105,
+	AG_MONUMENT_BINOC_OUTRO = 1106,
+	AG_LAUNCH_BINOC_INTRO = 1107,
+	AG_LAUNCH_BINOC_BISON = 1108,
+	AG_LAUNCH_BINOC_SHARK = 1109,
+	NS_BINOC_CONCERT_TRANSITION = 1201,
+	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
+	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
+	NS_BINOC_GF_LAUNCH = 1204,
+	NS_BINOC_FV_LAUNCH = 1205,
+	NS_BINOC_BRICK_ANNEX_WATER = 1206,
+	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
+	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
+	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
+	NS_BINOC_TBA = 1210,
+	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
+	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
+	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
+	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
+	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
+	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
+	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
+	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
+	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
+	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
+	PR_BINOC_AT_LAUNCH_PAD = 1251,
+	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
+	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
+	PR_BINOC_ON_BY_CROWS_NEST = 1254,
+	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
+	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
+	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
+	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
+	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
+	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
+	GF_BINOC_ON_LANDING_PAD = 1301,
+	GF_BINOC_AT_RAVINE_START = 1302,
+	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
+	GF_BINOC_AT_TURTLE_AREA = 1304,
+	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
+	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
+	GF_BINOC_IN_RACING_AREA = 1307,
+	GF_BINOC_IN_CROC_AREA = 1308,
+	GF_BINOC_IN_JAIL_AREA = 1309,
+	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
+	NT_HEART_OF_DARKNESS = 1911,
+	NT_PLINTH_REBUILD = 1919,
+	NT_FACTION_SPY_DUKE = 1974,
+	NT_FACTION_SPY_OVERBUILD = 1976,
+	NT_FACTION_SPY_HAEL = 1977,
+	NJ_EARTH_SPINJITZU = 2030,
+	NJ_LIGHTNING_SPINJITZU = 2031,
+	NJ_ICE_SPINJITZU = 2032,
+	NJ_FIRE_SPINJITZU = 2033,
+	NJ_WU_SHOW_DAILY_CHEST = 2099
+};
+
+#endif  //!__EPLAYERFLAG__H__
--- a/dCommon/dEnums/eQuickBuildFailReason.h
+++ b/dCommon/dEnums/eQuickBuildFailReason.h
@ -0,0 +1,13 @@
+#ifndef __EQUICKBUILDFAILREASON__H__
+#define __EQUICKBUILDFAILREASON__H__
+
+#include <cstdint>
+
+enum class eQuickBuildFailReason : uint32_t {
+	NOT_GIVEN,
+	OUT_OF_IMAGINATION,
+	CANCELED_EARLY,
+	BUILD_ENDED
+};
+
+#endif  //!__EQUICKBUILDFAILREASON__H__
--- a/dCommon/dEnums/eRebuildState.h
+++ b/dCommon/dEnums/eRebuildState.h
@ -0,0 +1,15 @@
+#ifndef __EREBUILDSTATE__H__
+#define __EREBUILDSTATE__H__
+
+#include <cstdint>
+
+enum class eRebuildState : uint32_t {
+	OPEN,
+	COMPLETED = 2,
+	RESETTING = 4,
+	BUILDING,
+	INCOMPLETE
+};
+
+
+#endif  //!__EREBUILDSTATE__H__
--- a/dCommon/dEnums/eRenameResponse.h
+++ b/dCommon/dEnums/eRenameResponse.h
@ -0,0 +1,15 @@
+#ifndef __ERENAMERESPONSE__H__
+#define __ERENAMERESPONSE__H__
+
+#include <cstdint>
+
+//! An enum for character rename responses
+enum class eRenameResponse : uint8_t {
+	SUCCESS = 0,
+	UNKNOWN_ERROR,
+	NAME_UNAVAILABLE,
+	NAME_IN_USE
+};
+
+
+#endif  //!__ERENAMERESPONSE__H__
--- a/dCommon/dEnums/eReplicaPacketType.h
+++ b/dCommon/dEnums/eReplicaPacketType.h
@ -0,0 +1,12 @@
+#ifndef __EREPLICAPACKETTYPE__H__
+#define __EREPLICAPACKETTYPE__H__
+
+#include <cstdint>
+
+enum class eReplicaPacketType : uint8_t {
+	CONSTRUCTION,
+	SERIALIZATION,
+	DESTRUCTION
+};
+
+#endif  //!__EREPLICAPACKETTYPE__H__
--- a/dCommon/dEnums/eStateChangeType.h
+++ b/dCommon/dEnums/eStateChangeType.h
@ -0,0 +1,11 @@
+#ifndef __ESTATECHANGETYPE__H__
+#define __ESTATECHANGETYPE__H__
+
+#include <cstdint>
+
+enum class eStateChangeType : uint32_t {
+	PUSH,
+	POP
+};
+
+#endif  //!__ESTATECHANGETYPE__H__
--- a/dCommon/dEnums/eTerminateType.h
+++ b/dCommon/dEnums/eTerminateType.h
@ -0,0 +1,12 @@
+#ifndef __ETERMINATETYPE__H__
+#define __ETERMINATETYPE__H__
+
+#include <cstdint>
+
+enum class eTerminateType : uint32_t {
+	RANGE,
+	USER,
+	FROM_INTERACTION
+};
+
+#endif  //!__ETERMINATETYPE__H__
--- a/dCommon/dEnums/eUseItemResponse.h
+++ b/dCommon/dEnums/eUseItemResponse.h
@ -0,0 +1,12 @@
+#ifndef __EUSEITEMRESPONSE__H__
+#define __EUSEITEMRESPONSE__H__
+
+#include <cstdint>
+
+enum class eUseItemResponse : uint32_t {
+	NoImaginationForPet = 1,
+	FailedPrecondition,
+	MountsNotAllowed
+};
+
+#endif  //!__EUSEITEMRESPONSE__H__
--- a/dGame/Character.cpp
+++ b/dGame/Character.cpp
@ -18,7 +18,9 @@
 #include "InventoryComponent.h"
 #include "eMissionTaskType.h"
 #include "eMissionState.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"
+#include "ePlayerFlag.h"

 Character::Character(uint32_t id, User* parentUser) {
 	//First load the name, etc:
@ -69,8 +71,8 @@ Character::Character(uint32_t id, User* parentUser) {

 	//Set our objectID:
 	m_ObjectID = m_ID;
-	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
-	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
+	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);

 	m_ParentUser = parentUser;
 	m_OurEntity = nullptr;
@ -128,8 +130,8 @@ void Character::UpdateFromDatabase() {

 	//Set our objectID:
 	m_ObjectID = m_ID;
-	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
-	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
+	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);

 	m_OurEntity = nullptr;
 	m_BuildMode = false;
@ -361,9 +363,9 @@ void Character::SaveXMLToDatabase() {
 	}

 	// Prevents the news feed from showing up on world transfers
-	if (GetPlayerFlag(ePlayerFlags::IS_NEWS_SCREEN_VISIBLE)) {
+	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
 		auto* s = m_Doc->NewElement("s");
-		s->SetAttribute("si", ePlayerFlags::IS_NEWS_SCREEN_VISIBLE);
+		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
 		flags->LinkEndChild(s);
 	}

@ -416,7 +418,7 @@ void Character::WriteToDatabase() {
 	delete printer;
 }

-void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
+void Character::SetPlayerFlag(const int32_t flagId, const bool value) {
 	// If the flag is already set, we don't have to recalculate it
 	if (GetPlayerFlag(flagId) == value) return;

@ -463,7 +465,7 @@ void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
 	GameMessages::SendNotifyClientFlagChange(m_ObjectID, flagId, value, m_ParentUser->GetSystemAddress());
 }

-bool Character::GetPlayerFlag(const uint32_t flagId) const {
+bool Character::GetPlayerFlag(const int32_t flagId) const {
 	// Calculate the index first
 	const auto flagIndex = uint32_t(std::floor(flagId / 64));

@ -480,8 +482,8 @@ bool Character::GetPlayerFlag(const uint32_t flagId) const {

 void Character::SetRetroactiveFlags() {
 	// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
-	if (GetPlayerFlag(ePlayerFlags::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlags::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlags::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlags::SENTINEL_FACTION)) {
-		SetPlayerFlag(ePlayerFlags::JOINED_A_FACTION, true);
+	if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
+		SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
 	}
 }

@ -541,7 +543,7 @@ void Character::OnZoneLoad() {
 	if (missionComponent != nullptr) {
 		// Fix the monument race flag
 		if (missionComponent->GetMissionState(319) >= eMissionState::READY_TO_COMPLETE) {
-			SetPlayerFlag(33, true);
+			SetPlayerFlag(ePlayerFlag::AG_FINISH_LINE_BUILT, true);
 		}
 	}

@ -557,7 +559,7 @@ void Character::OnZoneLoad() {
 	 */
 	if (HasPermission(ePermissionMap::Old)) {
 		if (GetCoins() > 1000000) {
-			SetCoins(1000000, eLootSourceType::LOOT_SOURCE_NONE);
+			SetCoins(1000000, eLootSourceType::NONE);
 		}
 	}

--- a/dGame/Character.h
+++ b/dGame/Character.h
@ -16,6 +16,7 @@ struct Packet;
 class Entity;
 enum class ePermissionMap : uint64_t;
 enum class eGameMasterLevel : uint8_t;
+enum class eLootSourceType : uint32_t;

 /**
 * Meta information about a character, like their name and style
@ -414,14 +415,14 @@ public:
 	 * @param flagId the ID of the flag to set
 	 * @param value the value to set for the flag
 	 */
-	void SetPlayerFlag(uint32_t flagId, bool value);
+	void SetPlayerFlag(int32_t flagId, bool value);

 	/**
 	 * Gets the value for a certain character flag
 	 * @param flagId the ID of the flag to get a value for
 	 * @return the value of the flag given the ID (the default is false, obviously)
 	 */
-	bool GetPlayerFlag(uint32_t flagId) const;
+	bool GetPlayerFlag(int32_t flagId) const;

 	/**
 	 * Notifies the character that they're now muted
--- a/dGame/Entity.cpp
+++ b/dGame/Entity.cpp
@ -24,6 +24,7 @@
 #include "Loot.h"
 #include "eMissionTaskType.h"
 #include "eTriggerEventType.h"
+#include "eObjectBits.h"

 //Component includes:
 #include "Component.h"
@ -72,6 +73,7 @@
 #include "TriggerComponent.h"
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
+#include "eReplicaPacketType.h"

 // Table includes
 #include "CDComponentsRegistryTable.h"
@ -727,7 +729,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(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER)) {
+		if (HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER) && (m_Components.size() == 2 || (HasComponent(eReplicaComponentType::TRIGGER) && m_Components.size() == 3))) {
 			goto no_ghosting;
 		}

@ -875,7 +877,7 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
 }

 void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
-	if (packetType == PACKET_TYPE_CONSTRUCTION) {
+	if (packetType == eReplicaPacketType::CONSTRUCTION) {
 		outBitStream->Write(m_ObjectID);
 		outBitStream->Write(m_TemplateID);

@ -952,9 +954,9 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke

 		if (m_ParentEntity != nullptr || m_SpawnerID != 0) {
 			outBitStream->Write1();
-			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), OBJECT_BIT_CLIENT));
+			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
 			else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream->Write(m_SpawnerID);
-			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, OBJECT_BIT_CLIENT));
+			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
 		} else outBitStream->Write0();

 		outBitStream->Write(m_HasSpawnerNodeID);
@ -977,8 +979,8 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 	}

 	// Only serialize parent / child info should the info be dirty (changed) or if this is the construction of the entity.
-	outBitStream->Write(m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION);
-	if (m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION) {
+	outBitStream->Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
+	if (m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION) {
 		m_IsParentChildDirty = false;
 		outBitStream->Write(m_ParentEntity != nullptr);
 		if (m_ParentEntity) {
@ -1003,7 +1005,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType

 	bool destroyableSerialized = false;
 	bool bIsInitialUpdate = false;
-	if (packetType == PACKET_TYPE_CONSTRUCTION) bIsInitialUpdate = true;
+	if (packetType == eReplicaPacketType::CONSTRUCTION) bIsInitialUpdate = true;
 	unsigned int flags = 0;

 	PossessableComponent* possessableComponent;
@ -1232,6 +1234,7 @@ void Entity::Update(const float deltaTime) {
 			for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 				script->OnTimerDone(this, timerName);
 			}
+			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
 		} else {
 			timerPosition++;
 		}
@ -1622,7 +1625,7 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 					}
 				}
 			} else {
-				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::LOOT_SOURCE_PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
+				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
 			}
 		}
 	}
--- a/dGame/Entity.h
+++ b/dGame/Entity.h
@ -10,6 +10,7 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "LDFFormat.h"
+#include "eKillType.h"

 namespace Loot {
 	class Info;
@ -33,6 +34,8 @@ class EntityCallbackTimer;
 enum class eTriggerEventType;
 enum class eGameMasterLevel : uint8_t;
 enum class eReplicaComponentType : uint32_t;
+enum class eReplicaPacketType : uint8_t;
+enum class eCinematicEvent : uint32_t;

 namespace CppScripts {
 	class Script;
--- a/dGame/EntityManager.cpp
+++ b/dGame/EntityManager.cpp
@ -20,8 +20,10 @@
 #include "MessageIdentifiers.h"
 #include "dConfig.h"
 #include "eTriggerEventType.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
+#include "eReplicaPacketType.h"

 EntityManager* EntityManager::m_Address = nullptr;

@ -108,11 +110,11 @@ Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentE
 		if (!controller && info.lot != 14) {

 			// The client flags means the client should render the entity
-			id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
+			GeneralUtils::SetBit(id, eObjectBits::CLIENT);

 			// Spawned entities require the spawned flag to render
 			if (info.spawnerID != 0) {
-				id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
+				GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
 			}
 		}
 	}
@ -196,8 +198,8 @@ void EntityManager::UpdateEntities(const float deltaTime) {
 		stream.Write(static_cast<char>(ID_REPLICA_MANAGER_SERIALIZE));
 		stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));

-		entity->WriteBaseReplicaData(&stream, PACKET_TYPE_SERIALIZATION);
-		entity->WriteComponents(&stream, PACKET_TYPE_SERIALIZATION);
+		entity->WriteBaseReplicaData(&stream, eReplicaPacketType::SERIALIZATION);
+		entity->WriteComponents(&stream, eReplicaPacketType::SERIALIZATION);

 		if (entity->GetIsGhostingCandidate()) {
 			for (auto* player : Player::GetAllPlayers()) {
@ -217,9 +219,9 @@ void EntityManager::UpdateEntities(const float deltaTime) {
 		if (!entity) continue;

 		if (entity->GetScheduledKiller()) {
-			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), SILENT);
+			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), eKillType::SILENT);
 		} else {
-			entity->Smash(LWOOBJID_EMPTY, SILENT);
+			entity->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
 		}
 	}
 	m_EntitiesToKill.clear();
@ -351,8 +353,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	stream.Write(true);
 	stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));

-	entity->WriteBaseReplicaData(&stream, PACKET_TYPE_CONSTRUCTION);
-	entity->WriteComponents(&stream, PACKET_TYPE_CONSTRUCTION);
+	entity->WriteBaseReplicaData(&stream, eReplicaPacketType::CONSTRUCTION);
+	entity->WriteComponents(&stream, eReplicaPacketType::CONSTRUCTION);

 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 		if (skipChecks) {
--- a/dGame/TradingManager.cpp
+++ b/dGame/TradingManager.cpp
@ -156,21 +156,21 @@ void Trade::Complete() {
 	}

 	// Now actually do the trade.
-	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::LOOT_SOURCE_TRADE);
-	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::LOOT_SOURCE_TRADE);
+	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::TRADE);
+	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::TRADE);

 	for (const auto& tradeItem : m_ItemsA) {
 		auto* itemToRemove = inventoryA->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsA->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
+		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
 	}

 	for (const auto& tradeItem : m_ItemsB) {
 		auto* itemToRemove = inventoryB->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsB->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
+		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
 	}

 	characterA->SaveXMLToDatabase();
--- a/dGame/UserManager.cpp
+++ b/dGame/UserManager.cpp
@ -23,7 +23,10 @@
 #include "AssetManager.h"
 #include "CDClientDatabase.h"
 #include "dMessageIdentifiers.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"
+#include "eCharacterCreationResponse.h"
+#include "eRenameResponse.h"

 UserManager* UserManager::m_Address = nullptr;

@ -268,13 +271,13 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)

 	if (name != "" && !UserManager::IsNameAvailable(name)) {
 		Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
-		WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_CUSTOM_NAME_IN_USE);
+		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
 		return;
 	}

 	if (!IsNameAvailable(predefinedName)) {
 		Game::logger->Log("UserManager", "AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
-		WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_PREDEFINED_NAME_IN_USE);
+		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
 		return;
 	}

@ -293,7 +296,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)

 		if (overlapResult->next()) {
 			Game::logger->Log("UserManager", "Character object id unavailable, check objectidtracker!");
-			WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE);
+			WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
 			return;
 		}

@ -313,16 +316,16 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 			std::stringstream xml2;

 			LWOOBJID lwoidforshirt = idforshirt;
-			lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_CHARACTER);
-			lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_PERSISTENT);
+			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
 			xml2 << xmlSave1 << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";

 			std::string xmlSave2 = xml2.str();

 			ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t idforpants) {
 				LWOOBJID lwoidforpants = idforpants;
-				lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_CHARACTER);
-				lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_PERSISTENT);
+				GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
+				GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);

 				std::stringstream xml3;
 				xml3 << xmlSave2 << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
@ -369,7 +372,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 				stmt->execute();
 				delete stmt;

-				WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_SUCCESS);
+				WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 				});
 			});
@ -480,8 +483,8 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	}

 	LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet);
-	objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_CHARACTER);
-	objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_PERSISTENT);
+	GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
+	GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);

 	uint32_t charID = static_cast<uint32_t>(objectID);
 	Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID);
@ -499,10 +502,10 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)

 	if (!hasCharacter || !character) {
 		Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID());
-		WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
+		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
 	} else if (hasCharacter && character) {
 		if (newName == character->GetName()) {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_UNAVAILABLE);
+			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
 			return;
 		}

@ -516,7 +519,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				delete stmt;

 				Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
+				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			} else {
 				sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET pending_name=?, needs_rename=0, last_login=? WHERE id=? LIMIT 1");
@ -527,15 +530,15 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				delete stmt;

 				Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
+				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			}
 		} else {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_IN_USE);
+			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
 		}
 	} else {
 		Game::logger->Log("UserManager", "Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
-		WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
+		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
 	}
 }

--- a/dGame/dBehaviors/ImmunityBehavior.cpp
+++ b/dGame/dBehaviors/ImmunityBehavior.cpp
@ -7,6 +7,7 @@
 #include "dLogger.h"
 #include "DestroyableComponent.h"
 #include "ControllablePhysicsComponent.h"
+#include "eStateChangeType.h"

 void ImmunityBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	auto* target = EntityManager::Instance()->GetEntity(branch.target);
--- a/dGame/dBehaviors/ProjectileAttackBehavior.cpp
+++ b/dGame/dBehaviors/ProjectileAttackBehavior.cpp
@ -6,6 +6,7 @@
 #include "dLogger.h"
 #include "SkillComponent.h"
 #include "../dWorldServer/ObjectIDManager.h"
+#include "eObjectBits.h"

 void ProjectileAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	LWOOBJID target{};
@ -107,7 +108,7 @@ void ProjectileAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitSt
 	for (auto i = 0u; i < this->m_projectileCount; ++i) {
 		auto id = static_cast<LWOOBJID>(ObjectIDManager::Instance()->GenerateObjectID());

-		id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
+		GeneralUtils::SetBit(id, eObjectBits::SPAWNED);

 		bitStream->Write(id);

--- a/dGame/dComponents/BaseCombatAIComponent.cpp
+++ b/dGame/dComponents/BaseCombatAIComponent.cpp
@ -248,7 +248,7 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 	if (rebuild != nullptr) {
 		const auto state = rebuild->GetState();

-		if (state != REBUILD_COMPLETED) {
+		if (state != eRebuildState::COMPLETED) {
 			return;
 		}
 	}
@ -566,7 +566,7 @@ bool BaseCombatAIComponent::IsEnemy(LWOOBJID target) const {
 	if (quickbuild != nullptr) {
 		const auto state = quickbuild->GetState();

-		if (state != REBUILD_COMPLETED) {
+		if (state != eRebuildState::COMPLETED) {
 			return false;
 		}
 	}
--- a/dGame/dComponents/CharacterComponent.cpp
+++ b/dGame/dComponents/CharacterComponent.cpp
@ -15,6 +15,7 @@
 #include "Item.h"
 #include "AMFFormat.h"
 #include "eGameMasterLevel.h"
+#include "eGameActivity.h"

 CharacterComponent::CharacterComponent(Entity* parent, Character* character) : Component(parent) {
 	m_Character = character;
@ -35,7 +36,7 @@ CharacterComponent::CharacterComponent(Entity* parent, Character* character) : C
 	m_EditorLevel = m_GMLevel;
 	m_Reputation = 0;

-	m_CurrentActivity = 0;
+	m_CurrentActivity = eGameActivity::NONE;
 	m_CountryCode = 0;
 	m_LastUpdateTimestamp = std::time(nullptr);
 }
--- a/dGame/dComponents/CharacterComponent.h
+++ b/dGame/dComponents/CharacterComponent.h
@ -11,6 +11,8 @@
 #include "tinyxml2.h"
 #include "eReplicaComponentType.h"

+enum class eGameActivity : uint32_t;
+
 /**
 * The statistics that can be achieved per zone
 */
@ -112,13 +114,13 @@ public:
 	 * Gets the current activity that the character is partaking in, see ScriptedActivityComponent for more details
 	 * @return the current activity that the character is partaking in
 	 */
-	const uint32_t GetCurrentActivity() const { return m_CurrentActivity; }
+	const eGameActivity GetCurrentActivity() const { return m_CurrentActivity; }

 	/**
 	 * Set the current activity of the character, see ScriptedActivityComponent for more details
 	 * @param currentActivity the activity to set
 	 */
-	void SetCurrentActivity(uint32_t currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }
+	void SetCurrentActivity(eGameActivity currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }

 	/**
 	 * Gets if the entity is currently racing
@ -353,7 +355,7 @@ private:
 	/**
 	 * The ID of the curently active activity
 	 */
-	int m_CurrentActivity;
+	eGameActivity m_CurrentActivity;

 	/**
 	 * Whether the social info has been changed
--- a/dGame/dComponents/ControllablePhysicsComponent.cpp
+++ b/dGame/dComponents/ControllablePhysicsComponent.cpp
@ -13,6 +13,7 @@
 #include "Character.h"
 #include "dZoneManager.h"
 #include "LevelProgressionComponent.h"
+#include "eStateChangeType.h"

 ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Component(entity) {
 	m_Position = {};
--- a/dGame/dComponents/ControllablePhysicsComponent.h
+++ b/dGame/dComponents/ControllablePhysicsComponent.h
@ -14,6 +14,7 @@

 class Entity;
 class dpEntity;
+enum class eStateChangeType : uint32_t;

 /**
 * Handles the movement of controllable Entities, e.g. enemies and players
--- a/dGame/dComponents/DestroyableComponent.cpp
+++ b/dGame/dComponents/DestroyableComponent.cpp
@ -33,6 +33,8 @@
 #include "dZoneManager.h"
 #include "WorldConfig.h"
 #include "eMissionTaskType.h"
+#include "eStateChangeType.h"
+#include "eGameActivity.h"

 #include "CDComponentsRegistryTable.h"

@ -468,7 +470,7 @@ bool DestroyableComponent::IsKnockbackImmune() const {
 	auto* characterComponent = m_Parent->GetComponent<CharacterComponent>();
 	auto* inventoryComponent = m_Parent->GetComponent<InventoryComponent>();

-	if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivities::ACTIVITY_QUICKBUILDING) {
+	if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivity::QUICKBUILDING) {
 		const auto hasPassive = inventoryComponent->HasAnyPassive({
 			eItemSetPassiveAbilityID::EngineerRank2, eItemSetPassiveAbilityID::EngineerRank3,
 			eItemSetPassiveAbilityID::SummonerRank2, eItemSetPassiveAbilityID::SummonerRank3,
@ -514,7 +516,7 @@ bool DestroyableComponent::CheckValidity(const LWOOBJID target, const bool ignor
 	if (targetQuickbuild != nullptr) {
 		const auto state = targetQuickbuild->GetState();

-		if (state != REBUILD_COMPLETED) {
+		if (state != eRebuildState::COMPLETED) {
 			return false;
 		}
 	}
@ -803,7 +805,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 				coinsTotal -= coinsToLose;

 				LootGenerator::Instance().DropLoot(m_Parent, m_Parent, -1, coinsToLose, coinsToLose);
-				character->SetCoins(coinsTotal, eLootSourceType::LOOT_SOURCE_PICKUP);
+				character->SetCoins(coinsTotal, eLootSourceType::PICKUP);
 			}
 		}

@ -992,7 +994,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 		auto uscoreToLose = uscore * (EntityManager::Instance()->GetHardcoreLoseUscoreOnDeathPercent() / 100);
 		character->SetUScore(uscore - uscoreToLose);

-		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::LOOT_SOURCE_MISSION);
+		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::MISSION);

 		if (EntityManager::Instance()->GetHardcoreDropinventoryOnDeath()) {
 			//drop all items from inventory:
@ -1023,7 +1025,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 			auto coins = chars->GetCoins();

 			//lose all coins:
-			chars->SetCoins(0, eLootSourceType::LOOT_SOURCE_NONE);
+			chars->SetCoins(0, eLootSourceType::NONE);

 			//drop all coins:
 			GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, coins, m_Parent->GetPosition());
@ -1047,7 +1049,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 			int uscore = maxHealth * EntityManager::Instance()->GetHardcoreUscoreEnemiesMultiplier();

 			playerStats->SetUScore(playerStats->GetUScore() + uscore);
-			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::LOOT_SOURCE_MISSION);
+			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::MISSION);

 			EntityManager::Instance()->SerializeEntity(m_Parent);
 		}
--- a/dGame/dComponents/DestroyableComponent.h
+++ b/dGame/dComponents/DestroyableComponent.h
@ -11,6 +11,7 @@
 namespace CppScripts {
 	class Script;
 }; //! namespace CppScripts
+enum class eStateChangeType : uint32_t;

 /**
 * Represents the stats of an entity, for example its health, imagination and armor. Also handles factions, which
--- a/dGame/dComponents/InventoryComponent.cpp
+++ b/dGame/dComponents/InventoryComponent.cpp
@ -29,6 +29,8 @@
 #include "eUnequippableActiveType.h"
 #include "CppScripts.h"
 #include "eMissionTaskType.h"
+#include "eStateChangeType.h"
+#include "eUseItemResponse.h"

 #include "CDComponentsRegistryTable.h"
 #include "CDInventoryComponentTable.h"
@ -356,7 +358,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in

 			left -= delta;

-			AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);
+			AddItem(lot, delta, eLootSourceType::NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);

 			item->SetCount(item->GetCount() - delta, false, false);

@ -371,7 +373,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in

 		const auto delta = std::min<uint32_t>(item->GetCount(), count);

-		AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);
+		AddItem(lot, delta, eLootSourceType::NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);

 		item->SetCount(item->GetCount() - delta, false, false);
 	}
@ -1247,7 +1249,7 @@ void InventoryComponent::SpawnPet(Item* item) {
 	auto destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();

 	if (Game::config->GetValue("pets_take_imagination") == "1" && destroyableComponent && destroyableComponent->GetImagination() <= 0) {
-		GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), UseItemResponse::NoImaginationForPet);
+		GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
 		return;
 	}

--- a/dGame/dComponents/InventoryComponent.h
+++ b/dGame/dComponents/InventoryComponent.h
@ -21,6 +21,7 @@
 #include "PossessorComponent.h"
 #include "eInventoryType.h"
 #include "eReplicaComponentType.h"
+#include "eLootSourceType.h"

 class Entity;
 class ItemSet;
@ -99,7 +100,7 @@ public:
 	void AddItem(
 		LOT lot,
 		uint32_t count,
-		eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE,
+		eLootSourceType lootSourceType = eLootSourceType::NONE,
 		eInventoryType inventoryType = INVALID,
 		const std::vector<LDFBaseData*>& config = {},
 		LWOOBJID parent = LWOOBJID_EMPTY,
--- a/dGame/dComponents/LevelProgressionComponent.cpp
+++ b/dGame/dComponents/LevelProgressionComponent.cpp
@ -59,7 +59,7 @@ void LevelProgressionComponent::HandleLevelUp() {
 	for (auto* reward : rewards) {
 		switch (reward->rewardType) {
 		case 0:
-			inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LOOT_SOURCE_LEVEL_REWARD);
+			inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LEVEL_REWARD);
 			break;
 		case 4:
 		{
--- a/dGame/dComponents/PetComponent.cpp
+++ b/dGame/dComponents/PetComponent.cpp
@ -15,6 +15,10 @@
 #include "PetDigServer.h"
 #include "../dWorldServer/ObjectIDManager.h"
 #include "eUnequippableActiveType.h"
+#include "eTerminateType.h"
+#include "ePetTamingNotifyType.h"
+#include "eUseItemResponse.h"
+#include "ePlayerFlag.h"

 #include "Game.h"
 #include "dConfig.h"
@ -22,6 +26,7 @@
 #include "Database.h"
 #include "EntityInfo.h"
 #include "eMissionTaskType.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"

 std::unordered_map<LOT, PetComponent::PetPuzzleData> PetComponent::buildCache{};
@ -32,7 +37,7 @@ std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets{};
 * Maps all the pet lots to a flag indicating that the player has caught it. All basic pets have been guessed by ObjID
 * while the faction ones could be checked using their respective missions.
 */
-std::map<LOT, uint32_t> PetComponent::petFlags = {
+std::map<LOT, int32_t> PetComponent::petFlags = {
 		{ 3050, 801 },  // Elephant
 		{ 3054, 803 },  // Cat
 		{ 3195, 806 },  // Triceratops
@ -284,7 +289,7 @@ void PetComponent::OnUse(Entity* originator) {
 		m_Parent->GetObjectID(),
 		LWOOBJID_EMPTY,
 		true,
-		NOTIFY_TYPE_BEGIN,
+		ePetTamingNotifyType::BEGIN,
 		petPosition,
 		position,
 		rotation,
@ -296,7 +301,7 @@ void PetComponent::OnUse(Entity* originator) {
 		LWOOBJID_EMPTY,
 		originator->GetObjectID(),
 		true,
-		NOTIFY_TYPE_BEGIN,
+		ePetTamingNotifyType::BEGIN,
 		petPosition,
 		position,
 		rotation,
@ -312,7 +317,7 @@ void PetComponent::OnUse(Entity* originator) {

 	// Notify the start of a pet taming minigame
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, originator, NOTIFY_TYPE_BEGIN);
+		script->OnNotifyPetTamingMinigame(m_Parent, originator, ePetTamingNotifyType::BEGIN);
 	}
 }

@ -551,8 +556,8 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {

 	LWOOBJID petSubKey = ObjectIDManager::Instance()->GenerateRandomObjectID();

-	petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_CHARACTER);
-	petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_PERSISTENT);
+	GeneralUtils::SetBit(petSubKey, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(petSubKey, eObjectBits::PERSISTENT);

 	m_DatabaseId = petSubKey;

@ -565,7 +570,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {

 	GameMessages::SendRegisterPetDBID(m_Tamer, petSubKey, tamer->GetSystemAddress());

-	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::LOOT_SOURCE_ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
+	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
 	auto* item = inventoryComponent->FindItemBySubKey(petSubKey, MODELS);

 	if (item == nullptr) {
@ -589,7 +594,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 		LWOOBJID_EMPTY,
 		LWOOBJID_EMPTY,
 		false,
-		NOTIFY_TYPE_NAMINGPET,
+		ePetTamingNotifyType::NAMINGPET,
 		NiPoint3::ZERO,
 		NiPoint3::ZERO,
 		NiQuaternion::IDENTITY,
@ -669,7 +674,7 @@ void PetComponent::RequestSetPetName(std::u16string name) {
 		m_Parent->GetObjectID(),
 		m_Tamer,
 		false,
-		NOTIFY_TYPE_SUCCESS,
+		ePetTamingNotifyType::SUCCESS,
 		NiPoint3::ZERO,
 		NiPoint3::ZERO,
 		NiQuaternion::IDENTITY,
@ -690,7 +695,7 @@ void PetComponent::RequestSetPetName(std::u16string name) {

 	// Notify the end of a pet taming minigame
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_SUCCESS);
+		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::SUCCESS);
 	}
 }

@ -710,7 +715,7 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
 		m_Parent->GetObjectID(),
 		m_Tamer,
 		false,
-		NOTIFY_TYPE_QUIT,
+		ePetTamingNotifyType::QUIT,
 		NiPoint3::ZERO,
 		NiPoint3::ZERO,
 		NiQuaternion::IDENTITY,
@ -731,7 +736,7 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {

 	// Notify the end of a pet taming minigame
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_QUIT);
+		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::QUIT);
 	}
 }

@ -761,7 +766,7 @@ void PetComponent::ClientFailTamingMinigame() {
 		m_Parent->GetObjectID(),
 		m_Tamer,
 		false,
-		NOTIFY_TYPE_FAILED,
+		ePetTamingNotifyType::FAILED,
 		NiPoint3::ZERO,
 		NiPoint3::ZERO,
 		NiQuaternion::IDENTITY,
@ -782,7 +787,7 @@ void PetComponent::ClientFailTamingMinigame() {

 	// Notify the end of a pet taming minigame
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_FAILED);
+		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::FAILED);
 	}
 }

@ -883,7 +888,7 @@ void PetComponent::Activate(Item* item, bool registerPet, bool fromTaming) {

 	EntityManager::Instance()->SerializeEntity(m_Parent);

-	owner->GetCharacter()->SetPlayerFlag(69, true);
+	owner->GetCharacter()->SetPlayerFlag(ePlayerFlag::FIRST_MANUAL_PET_HIBERNATE, true);

 	if (registerPet) {
 		GameMessages::SendAddPetToPlayer(m_Owner, 0, GeneralUtils::UTF8ToUTF16(m_Name), m_DatabaseId, m_Parent->GetLOT(), owner->GetSystemAddress());
@ -927,7 +932,7 @@ void PetComponent::AddDrainImaginationTimer(Item* item, bool fromTaming) {
 		auto playerEntity = playerDestroyableComponent->GetParent();
 		if (!playerEntity) return;

-		GameMessages::SendUseItemRequirementsResponse(playerEntity->GetObjectID(), playerEntity->GetSystemAddress(), UseItemResponse::NoImaginationForPet);
+		GameMessages::SendUseItemRequirementsResponse(playerEntity->GetObjectID(), playerEntity->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
 	}

 	this->AddDrainImaginationTimer(item);
--- a/dGame/dComponents/PetComponent.h
+++ b/dGame/dComponents/PetComponent.h
@ -263,7 +263,7 @@ private:
 	/**
 	 * Flags that indicate that a player has tamed a pet, indexed by the LOT of the pet
 	 */
-	static std::map<LOT, uint32_t> petFlags;
+	static std::map<LOT, int32_t> petFlags;

 	/**
 	 * The ID of the component in the pet component table
--- a/dGame/dComponents/PossessorComponent.cpp
+++ b/dGame/dComponents/PossessorComponent.cpp
@ -4,6 +4,8 @@
 #include "EntityManager.h"
 #include "GameMessages.h"
 #include "eUnequippableActiveType.h"
+#include "eControlScheme.h"
+#include "eStateChangeType.h"

 PossessorComponent::PossessorComponent(Entity* parent) : Component(parent) {
 	m_Possessable = LWOOBJID_EMPTY;
@ -78,5 +80,5 @@ void PossessorComponent::Dismount(Entity* mount, bool forceDismount) {
 		if (characterComponent) characterComponent->SetIsRacing(false);
 	}
 	// Make sure we don't have wacky controls
-	GameMessages::SendSetPlayerControlScheme(m_Parent, eControlSceme::SCHEME_A);
+	GameMessages::SendSetPlayerControlScheme(m_Parent, eControlScheme::SCHEME_A);
 }
--- a/dGame/dComponents/PropertyEntranceComponent.cpp
+++ b/dGame/dComponents/PropertyEntranceComponent.cpp
@ -12,6 +12,7 @@
 #include "UserManager.h"
 #include "dLogger.h"
 #include "AMFFormat.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"

 PropertyEntranceComponent::PropertyEntranceComponent(uint32_t componentID, Entity* parent) : Component(parent) {
@ -243,8 +244,8 @@ void PropertyEntranceComponent::OnPropertyEntranceSync(Entity* entity, bool incl

 		// Convert owner char id to LWOOBJID
 		LWOOBJID ownerObjId = owner;
-		ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_CHARACTER);
-		ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_PERSISTENT);
+		GeneralUtils::SetBit(ownerObjId, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(ownerObjId, eObjectBits::PERSISTENT);

 		// Query to get friend and best friend fields
 		auto friendCheck = Database::CreatePreppedStmt("SELECT best_friend FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?)");
--- a/dGame/dComponents/PropertyManagementComponent.cpp
+++ b/dGame/dComponents/PropertyManagementComponent.cpp
@ -19,6 +19,7 @@
 #include "PropertyEntranceComponent.h"
 #include "InventoryComponent.h"
 #include "eMissionTaskType.h"
+#include "eObjectBits.h"

 #include <vector>
 #include "CppScripts.h"
@ -66,8 +67,8 @@ PropertyManagementComponent::PropertyManagementComponent(Entity* parent) : Compo
 	if (propertyEntry->next()) {
 		this->propertyId = propertyEntry->getUInt64(1);
 		this->owner = propertyEntry->getUInt64(2);
-		this->owner = GeneralUtils::SetBit(this->owner, OBJECT_BIT_CHARACTER);
-		this->owner = GeneralUtils::SetBit(this->owner, OBJECT_BIT_PERSISTENT);
+		GeneralUtils::SetBit(this->owner, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(this->owner, eObjectBits::PERSISTENT);
 		this->clone_Id = propertyEntry->getInt(2);
 		this->propertyName = propertyEntry->getString(5).c_str();
 		this->propertyDescription = propertyEntry->getString(6).c_str();
@ -372,16 +373,15 @@ void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const N
 		info.emulated = true;
 		info.emulator = EntityManager::Instance()->GetZoneControlEntity()->GetObjectID();

-		LWOOBJID id = static_cast<LWOOBJID>(persistentId) | 1ull << OBJECT_BIT_CLIENT;
-
-		info.spawnerID = id;
+		info.spawnerID = persistentId;
+		GeneralUtils::SetBit(info.spawnerID, eObjectBits::CLIENT);

 		const auto spawnerId = dZoneManager::Instance()->MakeSpawner(info);

 		auto* spawner = dZoneManager::Instance()->GetSpawner(spawnerId);

 		auto ldfModelBehavior = new LDFData<LWOOBJID>(u"modelBehaviors", 0);
-		auto userModelID = new LDFData<LWOOBJID>(u"userModelID", id);
+		auto userModelID = new LDFData<LWOOBJID>(u"userModelID", info.spawnerID);
 		auto modelType = new LDFData<int>(u"modelType", 2);
 		auto propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
 		auto componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
@ -476,7 +476,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
 		settings.push_back(propertyObjectID);
 		settings.push_back(modelType);

-		inventoryComponent->AddItem(6662, 1, eLootSourceType::LOOT_SOURCE_DELETION, eInventoryType::MODELS_IN_BBB, settings, LWOOBJID_EMPTY, false, false, spawnerId);
+		inventoryComponent->AddItem(6662, 1, eLootSourceType::DELETION, eInventoryType::MODELS_IN_BBB, settings, LWOOBJID_EMPTY, false, false, spawnerId);
 		auto* item = inventoryComponent->FindItemBySubKey(spawnerId);

 		if (item == nullptr) {
@ -498,7 +498,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
 		if (spawner != nullptr) {
 			dZoneManager::Instance()->RemoveSpawner(spawner->m_Info.spawnerID);
 		} else {
-			model->Smash(SILENT);
+			model->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
 		}

 		item->SetCount(0, true, false, false);
@ -506,7 +506,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
 		return;
 	}

-	inventoryComponent->AddItem(model->GetLOT(), 1, eLootSourceType::LOOT_SOURCE_DELETION, INVALID, {}, LWOOBJID_EMPTY, false);
+	inventoryComponent->AddItem(model->GetLOT(), 1, eLootSourceType::DELETION, INVALID, {}, LWOOBJID_EMPTY, false);

 	auto* item = inventoryComponent->FindItemByLot(model->GetLOT());

@ -551,7 +551,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
 	if (spawner != nullptr) {
 		dZoneManager::Instance()->RemoveSpawner(spawner->m_Info.spawnerID);
 	} else {
-		model->Smash(SILENT);
+		model->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
 	}
 }

@ -622,8 +622,8 @@ void PropertyManagementComponent::Load() {
 		//BBB property models need to have extra stuff set for them:
 		if (lot == 14) {
 			LWOOBJID blueprintID = lookupResult->getUInt(10);
-			blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_CHARACTER);
-			blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_PERSISTENT);
+			GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);

 			LDFBaseData* ldfBlueprintID = new LDFData<LWOOBJID>(u"blueprintid", blueprintID);
 			LDFBaseData* componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
--- a/dGame/dComponents/RacingControlComponent.cpp
+++ b/dGame/dComponents/RacingControlComponent.cpp
@ -311,7 +311,7 @@ void RacingControlComponent::OnRequestDie(Entity* player) {
 		if (!racingPlayer.noSmashOnReload) {
 			racingPlayer.smashedTimes++;
 			GameMessages::SendDie(vehicle, vehicle->GetObjectID(), LWOOBJID_EMPTY, true,
-				VIOLENT, u"", 0, 0, 90.0f, false, true, 0);
+				eKillType::VIOLENT, u"", 0, 0, 90.0f, false, true, 0);

 			auto* destroyableComponent = vehicle->GetComponent<DestroyableComponent>();
 			uint32_t respawnImagination = 0;
@ -765,7 +765,7 @@ void RacingControlComponent::Update(float deltaTime) {
 		// be smashed by death plane
 		if (vehiclePosition.y < -500) {
 			GameMessages::SendDie(vehicle, m_Parent->GetObjectID(),
-				LWOOBJID_EMPTY, true, VIOLENT, u"", 0, 0, 0,
+				LWOOBJID_EMPTY, true, eKillType::VIOLENT, u"", 0, 0, 0,
 				true, false, 0);

 			OnRequestDie(playerEntity);
--- a/dGame/dComponents/RailActivatorComponent.cpp
+++ b/dGame/dComponents/RailActivatorComponent.cpp
@ -7,6 +7,7 @@
 #include "RebuildComponent.h"
 #include "Game.h"
 #include "dLogger.h"
+#include "eStateChangeType.h"

 RailActivatorComponent::RailActivatorComponent(Entity* parent, int32_t componentID) : Component(parent) {
 	m_ComponentID = componentID;
@ -41,7 +42,7 @@ RailActivatorComponent::~RailActivatorComponent() = default;

 void RailActivatorComponent::OnUse(Entity* originator) {
 	auto* rebuildComponent = m_Parent->GetComponent<RebuildComponent>();
-	if (rebuildComponent != nullptr && rebuildComponent->GetState() != REBUILD_COMPLETED)
+	if (rebuildComponent != nullptr && rebuildComponent->GetState() != eRebuildState::COMPLETED)
 		return;

 	if (rebuildComponent != nullptr) {
--- a/dGame/dComponents/RebuildComponent.cpp
+++ b/dGame/dComponents/RebuildComponent.cpp
@ -9,6 +9,9 @@
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
 #include "eTriggerEventType.h"
+#include "eQuickBuildFailReason.h"
+#include "eTerminateType.h"
+#include "eGameActivity.h"

 #include "dServer.h"
 #include "PacketUtils.h"
@ -47,7 +50,7 @@ RebuildComponent::~RebuildComponent() {

 	Entity* builder = GetBuilder();
 	if (builder) {
-		CancelRebuild(builder, eFailReason::REASON_BUILD_ENDED, true);
+		CancelRebuild(builder, eQuickBuildFailReason::BUILD_ENDED, true);
 	}

 	DespawnActivator();
@ -66,7 +69,7 @@ void RebuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitia
 	// If build state is completed and we've already serialized once in the completed state,
 	// don't serializing this component anymore as this will cause the build to jump again.
 	// If state changes, serialization will begin again.
-	if (!m_StateDirty && m_State == REBUILD_COMPLETED) {
+	if (!m_StateDirty && m_State == eRebuildState::COMPLETED) {
 		outBitStream->Write0();
 		outBitStream->Write0();
 		return;
@ -90,7 +93,7 @@ void RebuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitia

 	outBitStream->Write1();

-	outBitStream->Write<uint32_t>(m_State);
+	outBitStream->Write(m_State);

 	outBitStream->Write(m_ShowResetEffect);
 	outBitStream->Write(m_Activator != nullptr);
@ -120,7 +123,7 @@ void RebuildComponent::Update(float deltaTime) {
 	}*/

 	switch (m_State) {
-	case REBUILD_OPEN: {
+	case eRebuildState::OPEN: {
 		SpawnActivator();
 		m_TimeBeforeDrain = 0;

@ -150,7 +153,7 @@ void RebuildComponent::Update(float deltaTime) {

 		break;
 	}
-	case REBUILD_COMPLETED: {
+	case eRebuildState::COMPLETED: {
 		m_Timer += deltaTime;

 		// For reset times < 0 this has to be handled manually
@ -172,7 +175,7 @@ void RebuildComponent::Update(float deltaTime) {
 		}
 		break;
 	}
-	case REBUILD_BUILDING:
+	case eRebuildState::BUILDING:
 	{
 		Entity* builder = GetBuilder();

@ -201,7 +204,7 @@ void RebuildComponent::Update(float deltaTime) {
 			++m_DrainedImagination;

 			if (newImagination == 0 && m_DrainedImagination < m_TakeImagination) {
-				CancelRebuild(builder, eFailReason::REASON_OUT_OF_IMAGINATION, true);
+				CancelRebuild(builder, eQuickBuildFailReason::OUT_OF_IMAGINATION, true);

 				break;
 			}
@ -213,7 +216,7 @@ void RebuildComponent::Update(float deltaTime) {

 		break;
 	}
-	case REBUILD_INCOMPLETE: {
+	case eRebuildState::INCOMPLETE: {
 		m_TimerIncomplete += deltaTime;

 		// For reset times < 0 this has to be handled manually
@ -234,12 +237,12 @@ void RebuildComponent::Update(float deltaTime) {
 		}
 		break;
 	}
-	case REBUILD_RESETTING: break;
+	case eRebuildState::RESETTING: break;
 	}
 }

 void RebuildComponent::OnUse(Entity* originator) {
-	if (GetBuilder() != nullptr || m_State == REBUILD_COMPLETED) {
+	if (GetBuilder() != nullptr || m_State == eRebuildState::COMPLETED) {
 		return;
 	}

@ -393,18 +396,18 @@ void RebuildComponent::SetRepositionPlayer(bool value) {
 }

 void RebuildComponent::StartRebuild(Entity* user) {
-	if (m_State == eRebuildState::REBUILD_OPEN || m_State == eRebuildState::REBUILD_COMPLETED || m_State == eRebuildState::REBUILD_INCOMPLETE) {
+	if (m_State == eRebuildState::OPEN || m_State == eRebuildState::COMPLETED || m_State == eRebuildState::INCOMPLETE) {
 		m_Builder = user->GetObjectID();

 		auto* character = user->GetComponent<CharacterComponent>();
-		character->SetCurrentActivity(eGameActivities::ACTIVITY_QUICKBUILDING);
+		character->SetCurrentActivity(eGameActivity::QUICKBUILDING);

 		EntityManager::Instance()->SerializeEntity(user);

-		GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_BUILDING, user->GetObjectID());
-		GameMessages::SendEnableRebuild(m_Parent, true, false, false, eFailReason::REASON_NOT_GIVEN, 0.0f, user->GetObjectID());
+		GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::BUILDING, user->GetObjectID());
+		GameMessages::SendEnableRebuild(m_Parent, true, false, false, eQuickBuildFailReason::NOT_GIVEN, 0.0f, user->GetObjectID());

-		m_State = eRebuildState::REBUILD_BUILDING;
+		m_State = eRebuildState::BUILDING;
 		m_StateDirty = true;
 		EntityManager::Instance()->SerializeEntity(m_Parent);

@ -432,7 +435,7 @@ void RebuildComponent::CompleteRebuild(Entity* user) {

 	auto* characterComponent = user->GetComponent<CharacterComponent>();
 	if (characterComponent != nullptr) {
-		characterComponent->SetCurrentActivity(eGameActivities::ACTIVITY_NONE);
+		characterComponent->SetCurrentActivity(eGameActivity::NONE);
 		characterComponent->TrackRebuildComplete();
 	} else {
 		Game::logger->Log("RebuildComponent", "Some user tried to finish the rebuild but they didn't have a character somehow.");
@ -441,13 +444,13 @@ void RebuildComponent::CompleteRebuild(Entity* user) {

 	EntityManager::Instance()->SerializeEntity(user);

-	GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_COMPLETED, user->GetObjectID());
+	GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::COMPLETED, user->GetObjectID());
 	GameMessages::SendPlayFXEffect(m_Parent, 507, u"create", "BrickFadeUpVisCompleteEffect", LWOOBJID_EMPTY, 0.4f, 1.0f, true);
-	GameMessages::SendEnableRebuild(m_Parent, false, false, true, eFailReason::REASON_NOT_GIVEN, m_ResetTime, user->GetObjectID());
+	GameMessages::SendEnableRebuild(m_Parent, false, false, true, eQuickBuildFailReason::NOT_GIVEN, m_ResetTime, user->GetObjectID());
 	GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());


-	m_State = eRebuildState::REBUILD_COMPLETED;
+	m_State = eRebuildState::COMPLETED;
 	m_StateDirty = true;
 	m_Timer = 0.0f;
 	m_DrainedImagination = 0;
@ -520,17 +523,17 @@ void RebuildComponent::CompleteRebuild(Entity* user) {
 void RebuildComponent::ResetRebuild(bool failed) {
 	Entity* builder = GetBuilder();

-	if (m_State == eRebuildState::REBUILD_BUILDING && builder) {
-		GameMessages::SendEnableRebuild(m_Parent, false, false, failed, eFailReason::REASON_NOT_GIVEN, m_ResetTime, builder->GetObjectID());
+	if (m_State == eRebuildState::BUILDING && builder) {
+		GameMessages::SendEnableRebuild(m_Parent, false, false, failed, eQuickBuildFailReason::NOT_GIVEN, m_ResetTime, builder->GetObjectID());

 		if (failed) {
 			GameMessages::SendPlayAnimation(builder, u"rebuild-fail");
 		}
 	}

-	GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_RESETTING, LWOOBJID_EMPTY);
+	GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::RESETTING, LWOOBJID_EMPTY);

-	m_State = eRebuildState::REBUILD_RESETTING;
+	m_State = eRebuildState::RESETTING;
 	m_StateDirty = true;
 	m_Timer = 0.0f;
 	m_TimerIncomplete = 0.0f;
@ -552,15 +555,15 @@ void RebuildComponent::ResetRebuild(bool failed) {
 	}
 }

-void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, bool skipChecks) {
-	if (m_State != eRebuildState::REBUILD_COMPLETED || skipChecks) {
+void RebuildComponent::CancelRebuild(Entity* entity, eQuickBuildFailReason failReason, bool skipChecks) {
+	if (m_State != eRebuildState::COMPLETED || skipChecks) {

 		m_Builder = LWOOBJID_EMPTY;

 		const auto entityID = entity != nullptr ? entity->GetObjectID() : LWOOBJID_EMPTY;

 		// Notify the client that a state has changed
-		GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_INCOMPLETE, entityID);
+		GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::INCOMPLETE, entityID);
 		GameMessages::SendEnableRebuild(m_Parent, false, true, false, failReason, m_Timer, entityID);

 		// Now terminate any interaction with the rebuild
@ -568,7 +571,7 @@ void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, boo
 		GameMessages::SendTerminateInteraction(m_Parent->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());

 		// Now update the component itself
-		m_State = eRebuildState::REBUILD_INCOMPLETE;
+		m_State = eRebuildState::INCOMPLETE;
 		m_StateDirty = true;

 		// Notify scripts and possible subscribers
@ -586,7 +589,7 @@ void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, boo

 	CharacterComponent* characterComponent = entity->GetComponent<CharacterComponent>();
 	if (characterComponent) {
-		characterComponent->SetCurrentActivity(eGameActivities::ACTIVITY_NONE);
+		characterComponent->SetCurrentActivity(eGameActivity::NONE);
 		EntityManager::Instance()->SerializeEntity(entity);
 	}
 }
--- a/dGame/dComponents/RebuildComponent.h
+++ b/dGame/dComponents/RebuildComponent.h
@ -10,8 +10,10 @@
 #include "Preconditions.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
+#include "eRebuildState.h"

 class Entity;
+enum class eQuickBuildFailReason : uint32_t;

 /**
 * Component that handles entities that can be built into other entities using the quick build mechanic. Generally
@ -215,7 +217,7 @@ public:
 	 * @param failReason the reason the rebuild was cancelled
 	 * @param skipChecks whether or not to skip the check for the rebuild not being completed
 	 */
-	void CancelRebuild(Entity* builder, eFailReason failReason, bool skipChecks = false);
+	void CancelRebuild(Entity* builder, eQuickBuildFailReason failReason, bool skipChecks = false);
 private:
 	/**
 	 * Whether or not the quickbuild state has been changed since we last serialized it.
@ -225,7 +227,7 @@ private:
 	/**
 	 * The state the rebuild is currently in
 	 */
-	eRebuildState m_State = eRebuildState::REBUILD_OPEN;
+	eRebuildState m_State = eRebuildState::OPEN;

 	/**
 	 * The time that has passed since initiating the rebuild
--- a/dGame/dComponents/RocketLaunchpadControlComponent.cpp
+++ b/dGame/dComponents/RocketLaunchpadControlComponent.cpp
@ -17,6 +17,7 @@
 #include "dServer.h"
 #include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
+#include "eObjectWorldState.h"

 RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) {
 	auto query = CDClientDatabase::CreatePreppedStmt(
@ -77,7 +78,7 @@ void RocketLaunchpadControlComponent::Launch(Entity* originator, LWOMAPID mapId,

 	GameMessages::SendFireEventClientSide(m_Parent->GetObjectID(), originator->GetSystemAddress(), u"RocketEquipped", rocket->GetId(), cloneId, -1, originator->GetObjectID());

-	GameMessages::SendChangeObjectWorldState(rocket->GetId(), WORLDSTATE_ATTACHED, UNASSIGNED_SYSTEM_ADDRESS);
+	GameMessages::SendChangeObjectWorldState(rocket->GetId(), eObjectWorldState::ATTACHED, UNASSIGNED_SYSTEM_ADDRESS);

 	EntityManager::Instance()->SerializeEntity(originator);
 }
--- a/dGame/dComponents/ScriptedActivityComponent.cpp
+++ b/dGame/dComponents/ScriptedActivityComponent.cpp
@ -21,6 +21,7 @@
 #include "dMessageIdentifiers.h"
 #include "Loot.h"
 #include "eMissionTaskType.h"
+#include "eMatchUpdate.h"

 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@ -167,9 +168,9 @@ void ScriptedActivityComponent::PlayerJoinLobby(Entity* player) {
 				}

 				std::string matchUpdate = "player=9:" + std::to_string(entity->GetObjectID()) + "\nplayerName=0:" + entity->GetCharacter()->GetName();
-				GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchUpdate, eMatchUpdate::MATCH_UPDATE_PLAYER_JOINED);
+				GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchUpdate, eMatchUpdate::PLAYER_ADDED);
 				PlayerReady(entity, joinedPlayer->ready);
-				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateJoined, eMatchUpdate::MATCH_UPDATE_PLAYER_JOINED);
+				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateJoined, eMatchUpdate::PLAYER_ADDED);
 			}
 		}
 	}
@ -185,7 +186,7 @@ void ScriptedActivityComponent::PlayerJoinLobby(Entity* player) {
 	if (m_ActivityInfo.maxTeamSize != 1 && playerLobby->players.size() >= m_ActivityInfo.minTeamSize || m_ActivityInfo.maxTeamSize == 1 && playerLobby->players.size() >= m_ActivityInfo.minTeams) {
 		// Update the joining player on the match timer
 		std::string matchTimerUpdate = "time=3:" + std::to_string(playerLobby->timer);
-		GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME);
+		GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
 	}
 }

@ -201,7 +202,7 @@ void ScriptedActivityComponent::PlayerLeave(LWOOBJID playerID) {
 					if (entity == nullptr)
 						continue;

-					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft, eMatchUpdate::MATCH_UPDATE_PLAYER_LEFT);
+					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft, eMatchUpdate::PLAYER_REMOVED);
 				}

 				delete lobby->players[i];
@ -242,7 +243,7 @@ void ScriptedActivityComponent::Update(float deltaTime) {
 						continue;

 					std::string matchTimerUpdate = "time=3:" + std::to_string(lobby->timer);
-					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME);
+					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
 				}
 			}

@ -267,7 +268,7 @@ void ScriptedActivityComponent::Update(float deltaTime) {
 				if (entity == nullptr)
 					continue;

-				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME_START_DELAY);
+				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_START);
 			}
 		}

@ -375,8 +376,8 @@ void ScriptedActivityComponent::PlayerReady(Entity* player, bool bReady) {

 				// Update players in lobby on player being ready
 				std::string matchReadyUpdate = "player=9:" + std::to_string(player->GetObjectID());
-				eMatchUpdate readyStatus = eMatchUpdate::MATCH_UPDATE_PLAYER_READY;
-				if (!bReady) readyStatus = eMatchUpdate::MATCH_UPDATE_PLAYER_UNREADY;
+				eMatchUpdate readyStatus = eMatchUpdate::PLAYER_READY;
+				if (!bReady) readyStatus = eMatchUpdate::PLAYER_NOT_READY;
 				for (LobbyPlayer* otherPlayer : lobby->players) {
 					auto* entity = otherPlayer->GetEntity();
 					if (entity == nullptr)
--- a/dGame/dComponents/SkillComponent.cpp
+++ b/dGame/dComponents/SkillComponent.cpp
@ -260,6 +260,8 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c

 	context->caster = m_Parent->GetObjectID();

+	context->skillID = skillId;
+
 	context->clientInitalized = clientInitalized;

 	context->foundTarget = target != LWOOBJID_EMPTY || ignoreTarget || clientInitalized;
--- a/dGame/dComponents/SwitchComponent.cpp
+++ b/dGame/dComponents/SwitchComponent.cpp
@ -39,7 +39,7 @@ bool SwitchComponent::GetActive() const {
 void SwitchComponent::EntityEnter(Entity* entity) {
 	if (!m_Active) {
 		if (m_Rebuild) {
-			if (m_Rebuild->GetState() != eRebuildState::REBUILD_COMPLETED) return;
+			if (m_Rebuild->GetState() != eRebuildState::COMPLETED) return;
 		}
 		m_Active = true;
 		if (!m_Parent) return;
--- a/dGame/dComponents/TriggerComponent.cpp
+++ b/dGame/dComponents/TriggerComponent.cpp
@ -83,8 +83,12 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 			case eTriggerCommandType::REPEL_OBJECT:
 				HandleRepelObject(targetEntity, command->args);
 				break;
-			case eTriggerCommandType::SET_TIMER: break;
-			case eTriggerCommandType::CANCEL_TIMER: break;
+			case eTriggerCommandType::SET_TIMER:
+				HandleSetTimer(targetEntity, argArray);
+				break;
+			case eTriggerCommandType::CANCEL_TIMER:
+				HandleCancelTimer(targetEntity, command->args);
+				break;
 			case eTriggerCommandType::PLAY_CINEMATIC:
 				HandlePlayCinematic(targetEntity, argArray);
 				break;
@ -194,7 +198,7 @@ void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string arg
 void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args){
 	auto* triggerComponent = targetEntity->GetComponent<TriggerComponent>();
 	if (!triggerComponent) {
-		Game::logger->Log("TriggerComponent::HandleToggleTrigger", "Trigger component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleToggleTrigger", "Trigger component not found!");
 		return;
 	}
 	triggerComponent->SetTriggerEnabled(args == "1");
@ -203,7 +207,7 @@ void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string arg
 void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args){
 	auto* rebuildComponent = targetEntity->GetComponent<RebuildComponent>();
 	if (!rebuildComponent) {
-		Game::logger->Log("TriggerComponent::HandleResetRebuild", "Rebuild component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleResetRebuild", "Rebuild component not found!");
 		return;
 	}
 	rebuildComponent->ResetRebuild(args == "1");
@ -233,7 +237,7 @@ void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std:
 void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray){
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
-		Game::logger->Log("TriggerComponent::HandlePushObject", "Phantom Physics component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandlePushObject", "Phantom Physics component not found!");
 		return;
 	}
 	phantomPhysicsComponent->SetPhysicsEffectActive(true);
@ -250,7 +254,7 @@ void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::s
 void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args){
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
-		Game::logger->Log("TriggerComponent::HandleRepelObject", "Phantom Physics component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleRepelObject", "Phantom Physics component not found!");
 		return;
 	}
 	float forceMultiplier;
@ -271,6 +275,20 @@ void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args)
 	EntityManager::Instance()->SerializeEntity(m_Parent);
 }

+void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray){
+	if (argArray.size() != 2) {
+		Game::logger->LogDebug("TriggerComponent::HandleSetTimer", "Not ehought variables!");
+		return;
+	}
+	float time = 0.0;
+	GeneralUtils::TryParse<float>(argArray.at(1), time);
+	m_Parent->AddTimer(argArray.at(0), time);
+}
+
+void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args){
+	m_Parent->CancelTimer(args);
+}
+
 void TriggerComponent::HandlePlayCinematic(Entity* targetEntity, std::vector<std::string> argArray) {
 	float leadIn = -1.0;
 	auto wait = eEndBehavior::RETURN;
@ -300,7 +318,7 @@ void TriggerComponent::HandlePlayCinematic(Entity* targetEntity, std::vector<std
 void TriggerComponent::HandleToggleBBB(Entity* targetEntity, std::string args) {
 	auto* character = targetEntity->GetCharacter();
 	if (!character) {
-		Game::logger->Log("TriggerComponent::HandleToggleBBB", "Character was not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleToggleBBB", "Character was not found!");
 		return;
 	}
 	bool buildMode = !(character->GetBuildMode());
@ -316,7 +334,7 @@ void TriggerComponent::HandleUpdateMission(Entity* targetEntity, std::vector<std
 	if (argArray.at(0) != "exploretask") return;
 	MissionComponent* missionComponent = targetEntity->GetComponent<MissionComponent>();
 	if (!missionComponent){
-		Game::logger->Log("TriggerComponent::HandleUpdateMission", "Mission component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleUpdateMission", "Mission component not found!");
 		return;
 	}
 	missionComponent->Progress(eMissionTaskType::EXPLORE, 0, 0, argArray.at(4));
@ -335,7 +353,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
 	auto* skillComponent = targetEntity->GetComponent<SkillComponent>();
 	if (!skillComponent) {
-		Game::logger->Log("TriggerComponent::HandleCastSkill", "Skill component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleCastSkill", "Skill component not found!");
 		return;
 	}
 	uint32_t skillId;
@ -346,7 +364,7 @@ void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
 void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::vector<std::string> argArray) {
 	auto* phantomPhysicsComponent = targetEntity->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
-		Game::logger->Log("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
 		return;
 	}
 	phantomPhysicsComponent->SetPhysicsEffectActive(true);
@ -381,7 +399,7 @@ void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::v
 void TriggerComponent::HandleSetPhysicsVolumeStatus(Entity* targetEntity, std::string args) {
 	auto* phantomPhysicsComponent = targetEntity->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
-		Game::logger->Log("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
+		Game::logger->LogDebug("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
 		return;
 	}
 	phantomPhysicsComponent->SetPhysicsEffectActive(args == "On");
--- a/dGame/dComponents/TriggerComponent.h
+++ b/dGame/dComponents/TriggerComponent.h
@ -30,6 +30,8 @@ private:
 	void HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray);
 	void HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray);
 	void HandleRepelObject(Entity* targetEntity, std::string args);
+	void HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray);
+	void HandleCancelTimer(Entity* targetEntity, std::string args);
 	void HandlePlayCinematic(Entity* targetEntity, std::vector<std::string> argArray);
 	void HandleToggleBBB(Entity* targetEntity, std::string args);
 	void HandleUpdateMission(Entity* targetEntity, std::vector<std::string> argArray);
--- a/dGame/dComponents/VehiclePhysicsComponent.cpp
+++ b/dGame/dComponents/VehiclePhysicsComponent.cpp
@ -11,6 +11,7 @@ VehiclePhysicsComponent::VehiclePhysicsComponent(Entity* parent) : Component(par
 	m_DirtyPosition = true;
 	m_DirtyVelocity = true;
 	m_DirtyAngularVelocity = true;
+	m_EndBehavior = GeneralUtils::GenerateRandomNumber<uint32_t>(0, 7);
 }

 VehiclePhysicsComponent::~VehiclePhysicsComponent() {
@ -93,7 +94,7 @@ void VehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bI
 	}

 	if (bIsInitialUpdate) {
-		outBitStream->Write<uint8_t>(5);
+		outBitStream->Write<uint8_t>(m_EndBehavior);
 		outBitStream->Write1();
 	}

--- a/dGame/dComponents/VehiclePhysicsComponent.h
+++ b/dGame/dComponents/VehiclePhysicsComponent.h
@ -109,4 +109,5 @@ private:
 	bool m_IsOnRail;

 	float m_SoftUpdate = 0;
+	uint32_t m_EndBehavior;
 };
--- a/dGame/dGameMessages/GameMessages.cpp
+++ b/dGame/dGameMessages/GameMessages.cpp
@ -34,7 +34,14 @@
 #include "eRacingTaskParam.h"
 #include "eMissionTaskType.h"
 #include "eMissionState.h"
+#include "eObjectBits.h"
 #include "eTriggerEventType.h"
+#include "eMatchUpdate.h"
+#include "eCyclingMode.h"
+#include "eCinematicEvent.h"
+#include "eQuickBuildFailReason.h"
+#include "eControlScheme.h"
+#include "eStateChangeType.h"

 #include <sstream>
 #include <future>
@ -293,9 +300,9 @@ void GameMessages::SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, cons

 	bitStream.Write(bAllowCyclingWhileDeadOnly);

-	bitStream.Write(cyclingMode != ALLOW_CYCLE_TEAMMATES);
-	if (cyclingMode != ALLOW_CYCLE_TEAMMATES) {
-		bitStream.Write<uint32_t>(cyclingMode);
+	bitStream.Write(cyclingMode != eCyclingMode::ALLOW_CYCLE_TEAMMATES);
+	if (cyclingMode != eCyclingMode::ALLOW_CYCLE_TEAMMATES) {
+		bitStream.Write(cyclingMode);
 	}

 	SEND_PACKET;
@ -439,8 +446,8 @@ void GameMessages::SendAddItemToInventoryClientSync(Entity* entity, const System
 	bitStream.Write(item->GetInfo().isBOE);
 	bitStream.Write(item->GetInfo().isBOP);

-	bitStream.Write(lootSourceType != eLootSourceType::LOOT_SOURCE_NONE); // Loot source
-	if (lootSourceType != eLootSourceType::LOOT_SOURCE_NONE) bitStream.Write(lootSourceType);
+	bitStream.Write(lootSourceType != eLootSourceType::NONE); // Loot source
+	if (lootSourceType != eLootSourceType::NONE) bitStream.Write(lootSourceType);
 	LWONameValue extraInfo;

 	auto config = item->GetConfig();
@ -488,7 +495,7 @@ void GameMessages::SendAddItemToInventoryClientSync(Entity* entity, const System
 	SEND_PACKET;
 }

-void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFlagID, bool bFlag, const SystemAddress& sysAddr) {
+void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, uint32_t iFlagID, bool bFlag, const SystemAddress& sysAddr) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -500,7 +507,7 @@ void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFla
 	SEND_PACKET;
 }

-void GameMessages::SendChangeObjectWorldState(const LWOOBJID& objectID, int state, const SystemAddress& sysAddr) {
+void GameMessages::SendChangeObjectWorldState(const LWOOBJID& objectID, eObjectWorldState state, const SystemAddress& sysAddr) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -581,8 +588,8 @@ void GameMessages::SendModifyLEGOScore(Entity* entity, const SystemAddress& sysA
 	bitStream.Write((uint16_t)GAME_MSG_MODIFY_LEGO_SCORE);
 	bitStream.Write(score);

-	bitStream.Write(sourceType != eLootSourceType::LOOT_SOURCE_NONE);
-	if (sourceType != eLootSourceType::LOOT_SOURCE_NONE) bitStream.Write(sourceType);
+	bitStream.Write(sourceType != eLootSourceType::NONE);
+	if (sourceType != eLootSourceType::NONE) bitStream.Write(sourceType);

 	SEND_PACKET;
 }
@ -742,14 +749,14 @@ void GameMessages::SendSetCurrency(Entity* entity, int64_t currency, int lootTyp
 	bitStream.Write(sourceTradeID != LWOOBJID_EMPTY);
 	if (sourceTradeID != LWOOBJID_EMPTY) bitStream.Write(sourceTradeID);

-	bitStream.Write(sourceType != LOOTTYPE_NONE);
-	if (sourceType != LOOTTYPE_NONE) bitStream.Write(sourceType);
+	bitStream.Write(sourceType != eLootSourceType::NONE);
+	if (sourceType != eLootSourceType::NONE) bitStream.Write(sourceType);

 	SystemAddress sysAddr = entity->GetSystemAddress();
 	SEND_PACKET;
 }

-void GameMessages::SendRebuildNotifyState(Entity* entity, int prevState, int state, const LWOOBJID& playerID) {
+void GameMessages::SendRebuildNotifyState(Entity* entity, eRebuildState prevState, eRebuildState state, const LWOOBJID& playerID) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -763,7 +770,7 @@ void GameMessages::SendRebuildNotifyState(Entity* entity, int prevState, int sta
 	SEND_PACKET_BROADCAST;
 }

-void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, int failReason, float duration, const LWOOBJID& playerID) {
+void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, eQuickBuildFailReason failReason, float duration, const LWOOBJID& playerID) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -774,8 +781,8 @@ void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, boo
 	bitStream.Write(fail);
 	bitStream.Write(success);

-	bitStream.Write(failReason != eFailReason::REASON_NOT_GIVEN);
-	if (failReason != eFailReason::REASON_NOT_GIVEN) bitStream.Write(failReason);
+	bitStream.Write(failReason != eQuickBuildFailReason::NOT_GIVEN);
+	if (failReason != eQuickBuildFailReason::NOT_GIVEN) bitStream.Write(failReason);

 	bitStream.Write(duration);
 	bitStream.Write(playerID);
@ -842,8 +849,8 @@ void GameMessages::SendDie(Entity* entity, const LWOOBJID& killerID, const LWOOB
 	bitStream.Write(directionRelative_AngleY);
 	bitStream.Write(directionRelative_Force);

-	bitStream.Write(killType != VIOLENT);
-	if (killType != VIOLENT) bitStream.Write(killType);
+	bitStream.Write(killType != eKillType::VIOLENT);
+	if (killType != eKillType::VIOLENT) bitStream.Write(killType);

 	bitStream.Write(killerID);

@ -1103,7 +1110,7 @@ void GameMessages::SendDropClientLoot(Entity* entity, const LWOOBJID& sourceID,
 	SEND_PACKET;
 }

-void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlSceme controlScheme) {
+void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlScheme controlScheme) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -1116,8 +1123,8 @@ void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlSceme cont
 	bitStream.Write(bDelayCamSwitchIfInCinematic);
 	bitStream.Write(bSwitchCam);

-	bitStream.Write(controlScheme != SCHEME_A);
-	if (controlScheme != SCHEME_A) bitStream.Write(controlScheme);
+	bitStream.Write(controlScheme != eControlScheme::SCHEME_A);
+	if (controlScheme != eControlScheme::SCHEME_A) bitStream.Write(controlScheme);

 	SystemAddress sysAddr = entity->GetSystemAddress();
 	SEND_PACKET;
@ -1375,7 +1382,7 @@ void GameMessages::SendUseItemResult(Entity* entity, LOT templateID, bool useIte
 	SEND_PACKET;
 }

-void GameMessages::SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, UseItemResponse itemResponse) {
+void GameMessages::SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, eUseItemResponse itemResponse) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -1448,7 +1455,7 @@ void GameMessages::SendMatchResponse(Entity* entity, const SystemAddress& sysAdd
 	SEND_PACKET;
 }

-void GameMessages::SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, int type) {
+void GameMessages::SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, eMatchUpdate type) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -2575,14 +2582,14 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream* inStream, Entity* ent
 		//We need to get a new ID for our model first:
 		ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t newID) {
 			LWOOBJID newIDL = newID;
-			newIDL = GeneralUtils::SetBit(newIDL, OBJECT_BIT_CHARACTER);
-			newIDL = GeneralUtils::SetBit(newIDL, OBJECT_BIT_PERSISTENT);
+			GeneralUtils::SetBit(newIDL, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(newIDL, eObjectBits::PERSISTENT);

 			ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t blueprintIDSmall) {
 				blueprintIDSmall = ObjectIDManager::Instance()->GenerateRandomObjectID();
 				LWOOBJID blueprintID = blueprintIDSmall;
-				blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_CHARACTER);
-				blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_PERSISTENT);
+				GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
+				GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);

 				//We need to get the propertyID: (stolen from Wincent's propertyManagementComp)
 				const auto& worldId = dZoneManager::Instance()->GetZone()->GetZoneID();
@ -2878,7 +2885,7 @@ void GameMessages::SendEndCinematic(LWOOBJID objectId, std::u16string pathName,
 void GameMessages::HandleCinematicUpdate(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
 	eCinematicEvent event;
 	if (!inStream->ReadBit()) {
-		event = STARTED;
+		event = eCinematicEvent::STARTED;
 	} else {
 		inStream->Read<eCinematicEvent>(event);
 	}
@ -3424,7 +3431,7 @@ void GameMessages::HandleClientTradeUpdate(RakNet::BitStream* inStream, Entity*

 //Pets:

-void GameMessages::SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, uint32_t notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr) {
+void GameMessages::SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, ePetTamingNotifyType notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr) {
 	CBITSTREAM;
 	CMSGHEADER;

@ -4140,7 +4147,7 @@ void GameMessages::HandleRequestDie(RakNet::BitStream* inStream, Entity* entity,
 	float directionRelativeAngleXZ;
 	float directionRelativeAngleY;
 	float directionRelativeForce;
-	int32_t killType = VIOLENT;
+	eKillType killType = eKillType::VIOLENT;
 	LWOOBJID killerID;
 	LWOOBJID lootOwnerID = LWOOBJID_EMPTY;

@ -4765,7 +4772,7 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti

 		inv->RemoveItem(tokenId, altCurrencyCost);

-		inv->AddItem(item, count, eLootSourceType::LOOT_SOURCE_VENDOR);
+		inv->AddItem(item, count, eLootSourceType::VENDOR);
 	} else {
 		float buyScalar = vend->GetBuyScalar();

@ -4785,8 +4792,8 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti
 			inv->RemoveItem(itemComp.currencyLOT, altCurrencyCost);
 		}

-		character->SetCoins(character->GetCoins() - (coinCost), eLootSourceType::LOOT_SOURCE_VENDOR);
-		inv->AddItem(item, count, eLootSourceType::LOOT_SOURCE_VENDOR);
+		character->SetCoins(character->GetCoins() - (coinCost), eLootSourceType::VENDOR);
+		inv->AddItem(item, count, eLootSourceType::VENDOR);
 	}

 	GameMessages::SendVendorTransactionResult(entity, sysAddr);
@ -4828,12 +4835,12 @@ void GameMessages::HandleSellToVendor(RakNet::BitStream* inStream, Entity* entit
 	float sellScalar = vend->GetSellScalar();
 	if (Inventory::IsValidItem(itemComp.currencyLOT)) {
 		const auto altCurrency = static_cast<uint32_t>(itemComp.altCurrencyCost * sellScalar) * count;
-		inv->AddItem(itemComp.currencyLOT, std::floor(altCurrency), eLootSourceType::LOOT_SOURCE_VENDOR); // Return alt currencies like faction tokens.
+		inv->AddItem(itemComp.currencyLOT, std::floor(altCurrency), eLootSourceType::VENDOR); // Return alt currencies like faction tokens.
 	}

 	//inv->RemoveItem(count, -1, iObjID);
 	inv->MoveItemToInventory(item, eInventoryType::VENDOR_BUYBACK, count, true, false, true);
-	character->SetCoins(std::floor(character->GetCoins() + (static_cast<uint32_t>(itemComp.baseValue * sellScalar) * count)), eLootSourceType::LOOT_SOURCE_VENDOR);
+	character->SetCoins(std::floor(character->GetCoins() + (static_cast<uint32_t>(itemComp.baseValue * sellScalar) * count)), eLootSourceType::VENDOR);
 	//EntityManager::Instance()->SerializeEntity(player); // so inventory updates
 	GameMessages::SendVendorTransactionResult(entity, sysAddr);
 }
@ -4892,7 +4899,7 @@ void GameMessages::HandleBuybackFromVendor(RakNet::BitStream* inStream, Entity*

 	//inv->RemoveItem(count, -1, iObjID);
 	inv->MoveItemToInventory(item, Inventory::FindInventoryTypeForLot(item->GetLot()), count, true, false);
-	character->SetCoins(character->GetCoins() - cost, eLootSourceType::LOOT_SOURCE_VENDOR);
+	character->SetCoins(character->GetCoins() - cost, eLootSourceType::VENDOR);
 	//EntityManager::Instance()->SerializeEntity(player); // so inventory updates
 	GameMessages::SendVendorTransactionResult(entity, sysAddr);
 }
@ -5014,7 +5021,7 @@ void GameMessages::HandleRebuildCancel(RakNet::BitStream* inStream, Entity* enti
 	RebuildComponent* rebComp = static_cast<RebuildComponent*>(entity->GetComponent(eReplicaComponentType::QUICK_BUILD));
 	if (!rebComp) return;

-	rebComp->CancelRebuild(EntityManager::Instance()->GetEntity(userID), eFailReason::REASON_CANCELED_EARLY);
+	rebComp->CancelRebuild(EntityManager::Instance()->GetEntity(userID), eQuickBuildFailReason::CANCELED_EARLY);
 }

 void GameMessages::HandleRequestUse(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
@ -5134,12 +5141,12 @@ void GameMessages::HandleModularBuildConvertModel(RakNet::BitStream* inStream, E

 	item->Disassemble(TEMP_MODELS);

-	item->SetCount(item->GetCount() - 1, false, false, true, eLootSourceType::LOOT_SOURCE_QUICKBUILD);
+	item->SetCount(item->GetCount() - 1, false, false, true, eLootSourceType::QUICKBUILD);
 }

 void GameMessages::HandleSetFlag(RakNet::BitStream* inStream, Entity* entity) {
 	bool bFlag{};
-	int iFlagID{};
+	int32_t iFlagID{};

 	inStream->Read(bFlag);
 	inStream->Read(iFlagID);
@ -5300,7 +5307,7 @@ void GameMessages::HandlePickupCurrency(RakNet::BitStream* inStream, Entity* ent

 	auto* ch = entity->GetCharacter();
 	if (entity->CanPickupCoins(currency)) {
-		ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::LOOT_SOURCE_PICKUP);
+		ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::PICKUP);
 	}
 }

@ -5614,9 +5621,9 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream* inStream, Entity*
 		config.push_back(moduleAssembly);

 		if (count == 3) {
-			inv->AddItem(6416, 1, eLootSourceType::LOOT_SOURCE_QUICKBUILD, eInventoryType::MODELS, config);
+			inv->AddItem(6416, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config);
 		} else if (count == 7) {
-			inv->AddItem(8092, 1, eLootSourceType::LOOT_SOURCE_QUICKBUILD, eInventoryType::MODELS, config);
+			inv->AddItem(8092, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config);
 		}

 		auto* missionComponent = character->GetComponent<MissionComponent>();
--- a/dGame/dGameMessages/GameMessages.h
+++ b/dGame/dGameMessages/GameMessages.h
@ -8,6 +8,9 @@
 #include "eMovementPlatformState.h"
 #include "NiPoint3.h"
 #include "eEndBehavior.h"
+#include "eCyclingMode.h"
+#include "eLootSourceType.h"
+#include "Brick.h"

 class AMFValue;
 class Entity;
@ -23,6 +26,16 @@ enum class eAnimationFlags : uint32_t;
 enum class eUnequippableActiveType;
 enum eInventoryType : uint32_t;
 enum class eGameMasterLevel : uint8_t;
+enum class eMatchUpdate : int32_t;
+enum class eKillType : uint32_t;
+enum class eObjectWorldState : uint32_t;
+enum class eTerminateType : uint32_t;
+enum class eControlScheme : uint32_t;
+enum class eStateChangeType : uint32_t;
+enum class ePetTamingNotifyType : uint32_t;
+enum class eUseItemResponse : uint32_t;
+enum class eQuickBuildFailReason : uint32_t;
+enum class eRebuildState : uint32_t;

 namespace GameMessages {
 	class PropertyDataMessage;
@ -51,8 +64,7 @@ namespace GameMessages {
 		int targetTYPE = 0
 	);

-	void SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, const SystemAddress& sysAddr,
-		bool bAllowCyclingWhileDeadOnly = true, eCyclingMode cyclingMode = ALLOW_CYCLE_TEAMMATES);
+	void SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, const SystemAddress& sysAddr, bool bAllowCyclingWhileDeadOnly = true, eCyclingMode cyclingMode = eCyclingMode::ALLOW_CYCLE_TEAMMATES);

 	void SendPlayNDAudioEmitter(Entity* entity, const SystemAddress& sysAddr, std::string audioGUID);

@ -66,9 +78,9 @@ namespace GameMessages {
 	void SendGMLevelBroadcast(const LWOOBJID& objectID, eGameMasterLevel level);
 	void SendChatModeUpdate(const LWOOBJID& objectID, eGameMasterLevel level);

-	void SendAddItemToInventoryClientSync(Entity* entity, const SystemAddress& sysAddr, Item* item, const LWOOBJID& objectID, bool showFlyingLoot, int itemCount, LWOOBJID subKey = LWOOBJID_EMPTY, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
-	void SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFlagID, bool bFlag, const SystemAddress& sysAddr);
-	void SendChangeObjectWorldState(const LWOOBJID& objectID, int state, const SystemAddress& sysAddr);
+	void SendAddItemToInventoryClientSync(Entity* entity, const SystemAddress& sysAddr, Item* item, const LWOOBJID& objectID, bool showFlyingLoot, int itemCount, LWOOBJID subKey = LWOOBJID_EMPTY, eLootSourceType lootSourceType = eLootSourceType::NONE);
+	void SendNotifyClientFlagChange(const LWOOBJID& objectID, uint32_t iFlagID, bool bFlag, const SystemAddress& sysAddr);
+	void SendChangeObjectWorldState(const LWOOBJID& objectID, eObjectWorldState state, const SystemAddress& sysAddr);

 	void SendOfferMission(const LWOOBJID& entity, const SystemAddress& sysAddr, int32_t missionID, const LWOOBJID& offererID);
 	void SendNotifyMission(Entity* entity, const SystemAddress& sysAddr, int missionID, int missionState, bool sendingRewards);
@ -86,8 +98,8 @@ namespace GameMessages {
 	void SendBroadcastTextToChatbox(Entity* entity, const SystemAddress& sysAddr, const std::u16string& attrs, const std::u16string& wsText);
 	void SendSetCurrency(Entity* entity, int64_t currency, int lootType, const LWOOBJID& sourceID, const LOT& sourceLOT, int sourceTradeID, bool overrideCurrent, eLootSourceType sourceType);

-	void SendRebuildNotifyState(Entity* entity, int prevState, int state, const LWOOBJID& playerID);
-	void SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, int failReason, float duration, const LWOOBJID& playerID);
+	void SendRebuildNotifyState(Entity* entity, eRebuildState prevState, eRebuildState state, const LWOOBJID& playerID);
+	void SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, eQuickBuildFailReason failReason, float duration, const LWOOBJID& playerID);
 	void AddActivityOwner(Entity* entity, LWOOBJID& ownerID);
 	void SendTerminateInteraction(const LWOOBJID& objectID, eTerminateType type, const LWOOBJID& terminator);

@ -104,7 +116,7 @@ namespace GameMessages {
 	void SendSetNetworkScriptVar(Entity* entity, const SystemAddress& sysAddr, std::string data);
 	void SendDropClientLoot(Entity* entity, const LWOOBJID& sourceID, LOT item, int currency, NiPoint3 spawnPos = NiPoint3::ZERO, int count = 1);

-	void SendSetPlayerControlScheme(Entity* entity, eControlSceme controlScheme);
+	void SendSetPlayerControlScheme(Entity* entity, eControlScheme controlScheme);
 	void SendPlayerReachedRespawnCheckpoint(Entity* entity, const NiPoint3& position, const NiQuaternion& rotation);

 	void SendAddSkill(Entity* entity, TSkillID skillID, int slotID);
@ -123,7 +135,7 @@ namespace GameMessages {
 	void SendMoveInventoryBatch(Entity* entity, uint32_t stackCount, int srcInv, int dstInv, const LWOOBJID& iObjID);

 	void SendMatchResponse(Entity* entity, const SystemAddress& sysAddr, int response);
-	void SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, int type);
+	void SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, eMatchUpdate type);

 	void HandleUnUseModel(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr);
 	void SendStartCelebrationEffect(Entity* entity, const SystemAddress& sysAddr, int celebrationID);
@ -350,7 +362,7 @@ namespace GameMessages {
 	void HandleClientTradeUpdate(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr);

 	//Pets:
-	void SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, uint32_t notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr);
+	void SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, ePetTamingNotifyType notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr);

 	void SendNotifyPetTamingPuzzleSelected(LWOOBJID objectId, std::vector<Brick>& bricks, const SystemAddress& sysAddr);

@ -520,7 +532,7 @@ namespace GameMessages {
 	void SendActivityPause(LWOOBJID objectId, bool pause = false, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SendStartActivityTime(LWOOBJID objectId, float_t startTime, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SendRequestActivityEnter(LWOOBJID objectId, const SystemAddress& sysAddr, bool bStart, LWOOBJID userID);
-	void SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, UseItemResponse itemResponse);
+	void SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, eUseItemResponse itemResponse);

 	// SG:

--- a/dGame/dInventory/Inventory.cpp
+++ b/dGame/dInventory/Inventory.cpp
@ -244,9 +244,9 @@ eInventoryType Inventory::FindInventoryTypeForLot(const LOT lot) {
 		return PROPERTY_DEEDS;

 	case eItemType::MODEL:
-	case eItemType::VEHICLE:
+	case eItemType::PET_INVENTORY_ITEM:
 	case eItemType::LOOT_MODEL:
-	case eItemType::LUP_MODEL:
+	case eItemType::VEHICLE:
 	case eItemType::MOUNT:
 		return MODELS;

@ -263,9 +263,8 @@ eInventoryType Inventory::FindInventoryTypeForLot(const LOT lot) {
 	case eItemType::CHEST:
 	case eItemType::EGG:
 	case eItemType::PET_FOOD:
-	case eItemType::PET_INVENTORY_ITEM:
 	case eItemType::PACKAGE:
-
+	case eItemType::LUP_MODEL:
 		return ITEMS;

 	case eItemType::QUEST_OBJECT:
--- a/dGame/dInventory/Item.cpp
+++ b/dGame/dInventory/Item.cpp
@ -16,7 +16,9 @@
 #include "AssetManager.h"
 #include "InventoryComponent.h"
 #include "Loot.h"
+#include "eObjectBits.h"
 #include "eReplicaComponentType.h"
+#include "eUseItemResponse.h"

 #include "CDBrickIDTableTable.h"
 #include "CDObjectSkillsTable.h"
@ -77,13 +79,13 @@ Item::Item(

 	LWOOBJID id = ObjectIDManager::GenerateRandomObjectID();

-	id = GeneralUtils::SetBit(id, OBJECT_BIT_CHARACTER);
-	id = GeneralUtils::SetBit(id, OBJECT_BIT_PERSISTENT);
+	GeneralUtils::SetBit(id, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(id, eObjectBits::PERSISTENT);

 	const auto type = static_cast<eItemType>(info->itemType);

 	if (type == eItemType::MOUNT) {
-		id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
+		GeneralUtils::SetBit(id, eObjectBits::CLIENT);
 	}

 	this->id = id;
@ -329,7 +331,7 @@ void Item::UseNonEquip(Item* item) {
 						}
 					}
 					if (playerInventoryComponent->HasSpaceForLoot(rolledLoot)) {
-						LootGenerator::Instance().GiveLoot(playerInventoryComponent->GetParent(), rolledLoot, eLootSourceType::LOOT_SOURCE_CONSUMPTION);
+						LootGenerator::Instance().GiveLoot(playerInventoryComponent->GetParent(), rolledLoot, eLootSourceType::CONSUMPTION);
 						item->SetCount(item->GetCount() - 1);
 					} else {
 						success = false;
@ -338,7 +340,7 @@ void Item::UseNonEquip(Item* item) {
 					GameMessages::SendUseItemRequirementsResponse(
 						playerInventoryComponent->GetParent()->GetObjectID(),
 						playerInventoryComponent->GetParent()->GetSystemAddress(),
-						UseItemResponse::FailedPrecondition
+						eUseItemResponse::FailedPrecondition
 					);
 					success = false;
 				}
@ -378,7 +380,7 @@ void Item::Disassemble(const eInventoryType inventoryType) {
 			}

 			for (const auto mod : modArray) {
-				inventory->GetComponent()->AddItem(mod, 1, eLootSourceType::LOOT_SOURCE_DELETION, inventoryType);
+				inventory->GetComponent()->AddItem(mod, 1, eLootSourceType::DELETION, inventoryType);
 			}
 		}
 	}
@ -476,7 +478,7 @@ void Item::DisassembleModel() {
 			continue;
 		}

-		GetInventory()->GetComponent()->AddItem(brickID[0].NDObjectID, 1, eLootSourceType::LOOT_SOURCE_DELETION);
+		GetInventory()->GetComponent()->AddItem(brickID[0].NDObjectID, 1, eLootSourceType::DELETION);
 	}
 }

--- a/dGame/dInventory/Item.h
+++ b/dGame/dInventory/Item.h
@ -7,6 +7,7 @@
 #include "dLogger.h"
 #include "Preconditions.h"
 #include "eInventoryType.h"
+#include "eLootSourceType.h"

 /**
 * An item that can be stored in an inventory and optionally consumed or equipped
@ -38,7 +39,7 @@ public:
 		const std::vector<LDFBaseData*>& config,
 		LWOOBJID parent,
 		LWOOBJID subKey,
-		eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE
+		eLootSourceType lootSourceType = eLootSourceType::NONE
 	);

 	/**
@ -65,7 +66,7 @@ public:
 		bool isModMoveAndEquip = false,
 		LWOOBJID subKey = LWOOBJID_EMPTY,
 		bool bound = false,
-		eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE
+		eLootSourceType lootSourceType = eLootSourceType::NONE
 	);

 	~Item();
@ -89,7 +90,7 @@ public:
 	 * @param disassemble if items were removed, this returns all the sub parts of the item individually if it had assembly part lots
 	 * @param showFlyingLoot shows flying loot to the client, if not silent
 	 */
-	void SetCount(uint32_t value, bool silent = false, bool disassemble = true, bool showFlyingLoot = true, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
+	void SetCount(uint32_t value, bool silent = false, bool disassemble = true, bool showFlyingLoot = true, eLootSourceType lootSourceType = eLootSourceType::NONE);

 	/**
 	 * Returns the number of items this item represents (e.g. for stacks)
--- a/dGame/dMission/Mission.cpp
+++ b/dGame/dMission/Mission.cpp
@ -388,7 +388,7 @@ void Mission::Catchup() {
 		}

 		if (type == eMissionTaskType::PLAYER_FLAG) {
-			for (auto target : task->GetAllTargets()) {
+			for (int32_t target : task->GetAllTargets()) {
 				const auto flag = GetUser()->GetLastUsedChar()->GetPlayerFlag(target);

 				if (!flag) {
@ -442,7 +442,7 @@ void Mission::YieldRewards() {

 	int32_t coinsToSend = 0;
 	if (info->LegoScore > 0) {
-		eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
+		eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
 		if (levelComponent->GetLevel() >= dZoneManager::Instance()->GetWorldConfig()->levelCap) {
 			// Since the character is at the level cap we reward them with coins instead of UScore.
 			coinsToSend += info->LegoScore * dZoneManager::Instance()->GetWorldConfig()->levelCapCurrencyConversion;
@ -475,11 +475,11 @@ void Mission::YieldRewards() {
 				count = 0;
 			}

-			inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT);
+			inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT);
 		}

 		if (info->reward_currency_repeatable > 0 || coinsToSend > 0) {
-			eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
+			eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
 			character->SetCoins(character->GetCoins() + info->reward_currency_repeatable + coinsToSend, lootSource);
 		}

@ -508,11 +508,11 @@ void Mission::YieldRewards() {
 			count = 0;
 		}

-		inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT);
+		inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT);
 	}

 	if (info->reward_currency > 0 || coinsToSend > 0) {
-		eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
+		eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
 		character->SetCoins(character->GetCoins() + info->reward_currency + coinsToSend, lootSource);
 	}

--- a/dGame/dUtilities/Loot.cpp
+++ b/dGame/dUtilities/Loot.cpp
@ -318,13 +318,13 @@ void LootGenerator::GiveActivityLoot(Entity* player, Entity* source, uint32_t ac
 		maxCoins = currencyTable[0].maxvalue;
 	}

-	GiveLoot(player, selectedReward->LootMatrixIndex, eLootSourceType::LOOT_SOURCE_ACTIVITY);
+	GiveLoot(player, selectedReward->LootMatrixIndex, eLootSourceType::ACTIVITY);

 	uint32_t coins = (int)(minCoins + GeneralUtils::GenerateRandomNumber<float>(0, 1) * (maxCoins - minCoins));

 	auto* character = player->GetCharacter();

-	character->SetCoins(character->GetCoins() + coins, eLootSourceType::LOOT_SOURCE_ACTIVITY);
+	character->SetCoins(character->GetCoins() + coins, eLootSourceType::ACTIVITY);
 }

 void LootGenerator::DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins) {
--- a/dGame/dUtilities/Loot.h
+++ b/dGame/dUtilities/Loot.h
@ -47,8 +47,8 @@ public:

 	std::unordered_map<LOT, int32_t> RollLootMatrix(Entity* player, uint32_t matrixIndex);
 	std::unordered_map<LOT, int32_t> RollLootMatrix(uint32_t matrixIndex);
-	void GiveLoot(Entity* player, uint32_t matrixIndex, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
-	void GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
+	void GiveLoot(Entity* player, uint32_t matrixIndex, eLootSourceType lootSourceType = eLootSourceType::NONE);
+	void GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result, eLootSourceType lootSourceType = eLootSourceType::NONE);
 	void GiveActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating = 0);
 	void DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins);
 	void DropLoot(Entity* player, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins);
--- a/dGame/dUtilities/Mail.cpp
+++ b/dGame/dUtilities/Mail.cpp
@ -259,7 +259,7 @@ void Mail::HandleSendMail(RakNet::BitStream* packet, const SystemAddress& sysAdd
 	}

 	Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::Success);
-	entity->GetCharacter()->SetCoins(entity->GetCharacter()->GetCoins() - mailCost, eLootSourceType::LOOT_SOURCE_MAIL);
+	entity->GetCharacter()->SetCoins(entity->GetCharacter()->GetCoins() - mailCost, eLootSourceType::MAIL);

 	Game::logger->Log("Mail", "Seeing if we need to remove item with ID/count/LOT: %i %i %i", itemID, attachmentCount, itemLOT);

@ -359,7 +359,7 @@ void Mail::HandleAttachmentCollect(RakNet::BitStream* packet, const SystemAddres
 		auto inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
 		if (!inv) return;

-		inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::LOOT_SOURCE_MAIL);
+		inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::MAIL);

 		Mail::SendAttachmentRemoveConfirm(sysAddr, mailID);

--- a/dGame/dUtilities/SlashCommandHandler.cpp
+++ b/dGame/dUtilities/SlashCommandHandler.cpp
@ -75,8 +75,10 @@
 #include "eMissionState.h"
 #include "TriggerComponent.h"
 #include "eServerDisconnectIdentifiers.h"
+#include "eObjectBits.h"
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
+#include "eControlScheme.h"

 #include "CDObjectsTable.h"
 #include "CDZoneTableTable.h"
@ -496,7 +498,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		const auto state = !entity->GetVar<bool>(u"freecam");
 		entity->SetVar<bool>(u"freecam", state);

-		GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlSceme>(state ? 9 : 1));
+		GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlScheme>(state ? 9 : 1));

 		ChatPackets::SendSystemMessage(sysAddr, u"Toggled freecam.");
 		return;
@ -510,7 +512,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			return;
 		}

-		GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlSceme>(scheme));
+		GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlScheme>(scheme));

 		ChatPackets::SendSystemMessage(sysAddr, u"Switched control scheme.");
 		return;
@ -652,7 +654,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	}

 	if (chatCommand == "setflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 1) {
-		uint32_t flagId;
+		int32_t flagId;

 		if (!GeneralUtils::TryParse(args[0], flagId)) {
 			ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -663,7 +665,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	}

 	if (chatCommand == "setflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 2) {
-		uint32_t flagId;
+		int32_t flagId;
 		std::string onOffFlag = args[0];
 		if (!GeneralUtils::TryParse(args[1], flagId)) {
 			ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -676,7 +678,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		entity->GetCharacter()->SetPlayerFlag(flagId, onOffFlag == "on");
 	}
 	if (chatCommand == "clearflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 1) {
-		uint32_t flagId;
+		int32_t flagId;

 		if (!GeneralUtils::TryParse(args[0], flagId)) {
 			ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -792,7 +794,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit

 			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));

-			inventory->AddItem(itemLOT, 1, eLootSourceType::LOOT_SOURCE_MODERATION);
+			inventory->AddItem(itemLOT, 1, eLootSourceType::MODERATION);
 		} else if (args.size() == 2) {
 			uint32_t itemLOT;

@ -810,7 +812,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit

 			InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));

-			inventory->AddItem(itemLOT, count, eLootSourceType::LOOT_SOURCE_MODERATION);
+			inventory->AddItem(itemLOT, count, eLootSourceType::MODERATION);
 		} else {
 			ChatPackets::SendSystemMessage(sysAddr, u"Correct usage: /gmadditem <lot>");
 		}
@ -1029,8 +1031,8 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 						accountId = result->getUInt(1);
 						characterId = result->getUInt64(2);

-						characterId = GeneralUtils::SetBit(characterId, OBJECT_BIT_CHARACTER);
-						characterId = GeneralUtils::SetBit(characterId, OBJECT_BIT_PERSISTENT);
+						GeneralUtils::SetBit(characterId, eObjectBits::CHARACTER);
+						GeneralUtils::SetBit(characterId, eObjectBits::PERSISTENT);
 					}
 				}

@ -1345,9 +1347,9 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit

 		CharacterComponent* character = entity->GetComponent<CharacterComponent>();
 		if (character) character->SetUScore(character->GetUScore() + uscore);
-		// LOOT_SOURCE_MODERATION should work but it doesn't.  Relog to see uscore changes
+		// MODERATION should work but it doesn't.  Relog to see uscore changes

-		eLootSourceType lootType = eLootSourceType::LOOT_SOURCE_MODERATION;
+		eLootSourceType lootType = eLootSourceType::MODERATION;

 		int32_t type;
 		if (args.size() >= 2 && GeneralUtils::TryParse(args[1], type)) {
@ -1465,7 +1467,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		}

 		auto* ch = entity->GetCharacter();
-		ch->SetCoins(ch->GetCoins() + money, eLootSourceType::LOOT_SOURCE_MODERATION);
+		ch->SetCoins(ch->GetCoins() + money, eLootSourceType::MODERATION);
 	}

 	if ((chatCommand == "setcurrency") && args.size() == 1 && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER) {
@ -1477,7 +1479,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		}

 		auto* ch = entity->GetCharacter();
-		ch->SetCoins(money, eLootSourceType::LOOT_SOURCE_MODERATION);
+		ch->SetCoins(money, eLootSourceType::MODERATION);
 	}

 	// Allow for this on even while not a GM, as it sometimes toggles incorrrectly.
@ -1726,7 +1728,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		std::vector<LDFBaseData*> data{};
 		data.push_back(new LDFData<int32_t>(u"reforgedLOT", reforgedItem));

-		inventoryComponent->AddItem(baseItem, 1, eLootSourceType::LOOT_SOURCE_MODERATION, eInventoryType::INVALID, data);
+		inventoryComponent->AddItem(baseItem, 1, eLootSourceType::MODERATION, eInventoryType::INVALID, data);
 	}

 	if (chatCommand == "crash" && entity->GetGMLevel() >= eGameMasterLevel::OPERATOR) {
--- a/dNet/AuthPackets.cpp
+++ b/dNet/AuthPackets.cpp
@ -22,6 +22,7 @@
 #include "Game.h"
 #include "dConfig.h"
 #include "eServerDisconnectIdentifiers.h"
+#include "eLoginResponse.h"

 void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
 	RakNet::BitStream inStream(packet->data, packet->length, false);
@ -61,7 +62,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {

 	if (res->rowsCount() == 0) {
 		server->GetLogger()->Log("AuthPackets", "No user found!");
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_WRONG_PASS_OR_USER, "", "", 2001, username);
+		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::INVALID_USER, "", "", 2001, username);
 		return;
 	}

@ -85,14 +86,14 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 	//If we aren't running in live mode, then only GMs are allowed to enter:
 	const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs");
 	if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && sqlGmLevel == 0) {
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username);
+		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username);
 		return;
 	}

 	if (Game::config->GetValue("dont_use_keys") != "1") {
 		//Check to see if we have a play key:
 		if (sqlPlayKey == 0 && sqlGmLevel == 0) {
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
+			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
 			server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but they don't have a play key.", username.c_str());
 			return;
 		}
@ -104,7 +105,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 		bool isKeyActive = false;

 		if (keyRes->rowsCount() == 0 && sqlGmLevel == 0) {
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
+			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
 			return;
 		}

@ -113,18 +114,18 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 		}

 		if (!isKeyActive && sqlGmLevel == 0) {
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username);
+			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username);
 			server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but their play key was disabled", username.c_str());
 			return;
 		}
 	}

 	if (sqlBanned) {
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_BANNED, "", "", 2001, username); return;
+		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::BANNED, "", "", 2001, username); return;
 	}

 	if (sqlLocked) {
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_ACCOUNT_LOCKED, "", "", 2001, username); return;
+		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, username); return;
 	}

 	/*
@ -170,18 +171,18 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 	}

 	if (!loginSuccess) {
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_WRONG_PASS_OR_USER, "", "", 2001, username);
+		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::WRONG_PASS, "", "", 2001, username);
 		server->GetLogger()->Log("AuthPackets", "Wrong password used");
 	} else {
 		SystemAddress system = packet->systemAddress; //Copy the sysAddr before the Packet gets destroyed from main

 		if (!server->GetIsConnectedToMaster()) {
-			AuthPackets::SendLoginResponse(server, system, LOGIN_RESPONSE_GENERAL_FAILED, "", "", 0, username);
+			AuthPackets::SendLoginResponse(server, system, eLoginResponse::GENERAL_FAILED, "", "", 0, username);
 			return;
 		}

 		ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, server, username](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) {
-			AuthPackets::SendLoginResponse(server, system, LOGIN_RESPONSE_SUCCESS, "", zoneIP, zonePort, username);
+			AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, username);
 			});
 	}
 }
--- a/dNet/AuthPackets.h
+++ b/dNet/AuthPackets.h
@ -6,6 +6,7 @@
 #include "dNetCommon.h"

 enum class ServerType : uint32_t;
+enum class eLoginResponse : uint8_t;
 class dServer;

 namespace AuthPackets {
--- a/dNet/WorldPackets.cpp
+++ b/dNet/WorldPackets.cpp
@ -15,7 +15,6 @@
 #include "CharacterComponent.h"
 #include "ZCompression.h"

-
 void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) {
 	RakNet::BitStream bitStream;
 	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_LOAD_STATIC_ZONE);
@ -89,7 +88,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
 	SEND_PACKET;
 }

-void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCreationResponse response) {
+void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
 	RakNet::BitStream bitStream;
 	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_CREATE_RESPONSE);
 	bitStream.Write(response);
--- a/dNet/WorldPackets.h
+++ b/dNet/WorldPackets.h
@ -9,11 +9,13 @@
 class User;
 struct SystemAddress;
 enum class eGameMasterLevel : uint8_t;
+enum class eCharacterCreationResponse : uint8_t;
+enum class eRenameResponse : uint8_t;

 namespace WorldPackets {
 	void SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum);
 	void SendCharacterList(const SystemAddress& sysAddr, User* user);
-	void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCreationResponse response);
+	void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
 	void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);
 	void SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response);
 	void SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift);
--- a/dScripts/02_server/Enemy/General/BaseEnemyApe.cpp
+++ b/dScripts/02_server/Enemy/General/BaseEnemyApe.cpp
@ -6,6 +6,7 @@
 #include "EntityInfo.h"
 #include "SkillComponent.h"
 #include "eAninmationFlags.h"
+#include "eStateChangeType.h"

 void BaseEnemyApe::OnStartup(Entity* self) {
 	self->SetVar<uint32_t>(u"timesStunned", 2);
@ -15,7 +16,7 @@ void BaseEnemyApe::OnStartup(Entity* self) {
 void BaseEnemyApe::OnDie(Entity* self, Entity* killer) {
 	auto* anchor = EntityManager::Instance()->GetEntity(self->GetVar<LWOOBJID>(u"QB"));
 	if (anchor != nullptr && !anchor->GetIsDead()) {
-		anchor->Smash(self->GetObjectID(), SILENT);
+		anchor->Smash(self->GetObjectID(), eKillType::SILENT);
 	}
 }

--- a/dScripts/02_server/Equipment/BootyDigServer.cpp
+++ b/dScripts/02_server/Equipment/BootyDigServer.cpp
@ -30,7 +30,7 @@ BootyDigServer::OnFireEventServerSide(Entity* self, Entity* sender, std::string
 		return;

 	if (args == "ChestReady" && (propertyOwner == std::to_string(LWOOBJID_EMPTY) || player->GetVar<bool>(u"bootyDug"))) {
-		self->Smash(self->GetObjectID(), SILENT);
+		self->Smash(self->GetObjectID(), eKillType::SILENT);
 	} else if (args == "ChestOpened") {
 		// Make sure players only dig up one booty per instance
 		player->SetVar<bool>(u"bootyDug", true);
@ -49,6 +49,6 @@ BootyDigServer::OnFireEventServerSide(Entity* self, Entity* sender, std::string
 			}
 		}
 	} else if (args == "ChestDead") {
-		self->Smash(player->GetObjectID(), SILENT);
+		self->Smash(player->GetObjectID(), eKillType::SILENT);
 	}
 }
--- a/dScripts/02_server/Map/AG/AgCagedBricksServer.cpp
+++ b/dScripts/02_server/Map/AG/AgCagedBricksServer.cpp
@ -4,6 +4,7 @@
 #include "Character.h"
 #include "EntityManager.h"
 #include "eReplicaComponentType.h"
+#include "ePlayerFlag.h"

 void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {
 	//Tell the client to spawn the baby spiderling:
@ -17,7 +18,7 @@ void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {

 	if (!character) return;

-	character->SetPlayerFlag(74, true);
+	character->SetPlayerFlag(ePlayerFlag::CAGED_SPIDER, true);

 	//Remove the maelstrom cube:
 	auto inv = static_cast<InventoryComponent*>(user->GetComponent(eReplicaComponentType::INVENTORY));
--- a/dScripts/02_server/Map/AG/NpcCowboyServer.cpp
+++ b/dScripts/02_server/Map/AG/NpcCowboyServer.cpp
@ -18,7 +18,7 @@ void NpcCowboyServer::OnMissionDialogueOK(Entity* self, Entity* target, int miss
 		missionState == eMissionState::AVAILABLE ||
 		missionState == eMissionState::COMPLETE_AVAILABLE) {
 		if (inventoryComponent->GetLotCount(14378) == 0) {
-			inventoryComponent->AddItem(14378, 1, eLootSourceType::LOOT_SOURCE_NONE);
+			inventoryComponent->AddItem(14378, 1, eLootSourceType::NONE);
 		}
 	} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
 		inventoryComponent->RemoveItem(14378, 1);
--- a/dScripts/02_server/Map/AG/NpcPirateServer.cpp
+++ b/dScripts/02_server/Map/AG/NpcPirateServer.cpp
@ -10,7 +10,7 @@ void NpcPirateServer::OnMissionDialogueOK(Entity* self, Entity* target, int miss
 		// Add or remove the lucky shovel based on whether the mission was completed or started
 		if ((missionState == eMissionState::AVAILABLE || missionState == eMissionState::COMPLETE_AVAILABLE)
 			&& luckyShovel == nullptr) {
-			inventory->AddItem(14591, 1, eLootSourceType::LOOT_SOURCE_NONE);
+			inventory->AddItem(14591, 1, eLootSourceType::NONE);
 		} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
 			inventory->RemoveItem(14591, 1);
 		}
--- a/dScripts/02_server/Map/AG/NpcWispServer.cpp
+++ b/dScripts/02_server/Map/AG/NpcWispServer.cpp
@ -19,7 +19,7 @@ void NpcWispServer::OnMissionDialogueOK(Entity* self, Entity* target, int missio
 	// For the daily we add the maelstrom vacuum if the player doesn't have it yet
 	if (missionID == 1883 && (missionState == eMissionState::AVAILABLE || missionState == eMissionState::COMPLETE_AVAILABLE)
 		&& maelstromVacuum == nullptr) {
-		inventory->AddItem(maelstromVacuumLot, 1, eLootSourceType::LOOT_SOURCE_NONE);
+		inventory->AddItem(maelstromVacuumLot, 1, eLootSourceType::NONE);
 	} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
 		inventory->RemoveItem(maelstromVacuumLot, 1);
 	}
--- a/dScripts/02_server/Map/AG/RemoveRentalGear.cpp
+++ b/dScripts/02_server/Map/AG/RemoveRentalGear.cpp
@ -4,6 +4,7 @@
 #include "eMissionState.h"
 #include "Character.h"
 #include "eReplicaComponentType.h"
+#include "ePlayerFlag.h"

 /*
 --------------------------------------------------------------
@ -36,6 +37,6 @@ void RemoveRentalGear::OnMissionDialogueOK(Entity* self, Entity* target, int mis

 		//reset the equipment flag
 		auto character = target->GetCharacter();
-		if (character) character->SetPlayerFlag(equipFlag, false);
+		if (character) character->SetPlayerFlag(ePlayerFlag::EQUPPED_TRIAL_FACTION_GEAR, false);
 	}
 }
--- a/dScripts/02_server/Map/AG/RemoveRentalGear.h
+++ b/dScripts/02_server/Map/AG/RemoveRentalGear.h
@ -7,6 +7,5 @@ class RemoveRentalGear : public CppScripts::Script {
 private:
 	int defaultMission = 768;	                            //mission to remove gearSets on completion
 	std::vector<int> gearSets = { 14359,14321,14353,14315 };	//inventory items to remove
-	int equipFlag = 126; //Set upon wearing trial faction armor for the first time in a session
 };

--- a/dScripts/02_server/Map/AM/AmBlueX.cpp
+++ b/dScripts/02_server/Map/AM/AmBlueX.cpp
@ -18,7 +18,7 @@ void AmBlueX::OnSkillEventFired(Entity* self, Entity* caster, const std::string&

 		auto* character = caster->GetCharacter();
 		if (character != nullptr) {
-			character->SetPlayerFlag(self->GetVar<int32_t>(m_FlagVariable), true);
+			character->SetPlayerFlag(self->GetVar<uint32_t>(m_FlagVariable), true);
 		}

 		EntityInfo info{};
--- a/dScripts/02_server/Map/AM/AmBridge.cpp
+++ b/dScripts/02_server/Map/AM/AmBridge.cpp
@ -24,5 +24,5 @@ void AmBridge::OnTimerDone(Entity* self, std::string timerName) {
 		return;
 	}

-	self->Smash(self->GetObjectID(), VIOLENT);
+	self->Smash(self->GetObjectID(), eKillType::VIOLENT);
 }
--- a/dScripts/02_server/Map/AM/AmDrawBridge.cpp
+++ b/dScripts/02_server/Map/AM/AmDrawBridge.cpp
@ -2,6 +2,7 @@
 #include "EntityManager.h"
 #include "GameMessages.h"
 #include "SimplePhysicsComponent.h"
+#include "eTerminateType.h"

 void AmDrawBridge::OnStartup(Entity* self) {
 	self->SetNetworkVar(u"InUse", false);
@ -25,7 +26,7 @@ void AmDrawBridge::OnUse(Entity* self, Entity* user) {

 	auto* player = user;

-	GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
+	GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
 }

 void AmDrawBridge::OnTimerDone(Entity* self, std::string timerName) {
--- a/dScripts/02_server/Map/AM/AmDropshipComputer.cpp
+++ b/dScripts/02_server/Map/AM/AmDropshipComputer.cpp
@ -12,7 +12,7 @@ void AmDropshipComputer::OnStartup(Entity* self) {
 void AmDropshipComputer::OnUse(Entity* self, Entity* user) {
 	auto* rebuildComponent = self->GetComponent<RebuildComponent>();

-	if (rebuildComponent == nullptr || rebuildComponent->GetState() != REBUILD_COMPLETED) {
+	if (rebuildComponent == nullptr || rebuildComponent->GetState() != eRebuildState::COMPLETED) {
 		return;
 	}

@ -27,7 +27,7 @@ void AmDropshipComputer::OnUse(Entity* self, Entity* user) {
 		return;
 	}

-	inventoryComponent->AddItem(m_NexusTalonDataCard, 1, eLootSourceType::LOOT_SOURCE_NONE);
+	inventoryComponent->AddItem(m_NexusTalonDataCard, 1, eLootSourceType::NONE);
 }

 void AmDropshipComputer::OnDie(Entity* self, Entity* killer) {
@ -76,7 +76,7 @@ void AmDropshipComputer::OnTimerDone(Entity* self, std::string timerName) {
 		return;
 	}

-	if (timerName == "reset" && rebuildComponent->GetState() == REBUILD_OPEN) {
-		self->Smash(self->GetObjectID(), SILENT);
+	if (timerName == "reset" && rebuildComponent->GetState() == eRebuildState::OPEN) {
+		self->Smash(self->GetObjectID(), eKillType::SILENT);
 	}
 }
--- a/dScripts/02_server/Map/AM/AmShieldGeneratorQuickbuild.cpp
+++ b/dScripts/02_server/Map/AM/AmShieldGeneratorQuickbuild.cpp
@ -176,7 +176,7 @@ void AmShieldGeneratorQuickbuild::BuffPlayers(Entity* self) {
 void AmShieldGeneratorQuickbuild::EnemyEnteredShield(Entity* self, Entity* intruder) {
 	auto* rebuildComponent = self->GetComponent<RebuildComponent>();

-	if (rebuildComponent == nullptr || rebuildComponent->GetState() != REBUILD_COMPLETED) {
+	if (rebuildComponent == nullptr || rebuildComponent->GetState() != eRebuildState::COMPLETED) {
 		return;
 	}

--- a/dScripts/02_server/Map/AM/AmSkullkinDrill.cpp
+++ b/dScripts/02_server/Map/AM/AmSkullkinDrill.cpp
@ -5,6 +5,7 @@
 #include "ProximityMonitorComponent.h"
 #include "MissionComponent.h"
 #include "EntityInfo.h"
+#include "eStateChangeType.h"

 void AmSkullkinDrill::OnStartup(Entity* self) {
 	self->SetNetworkVar(u"bIsInUse", false);
@ -246,7 +247,7 @@ void AmSkullkinDrill::OnHitOrHealResult(Entity* self, Entity* attacker, int32_t
 		}
 	}

-	self->Smash(attacker->GetObjectID(), SILENT);
+	self->Smash(attacker->GetObjectID(), eKillType::SILENT);

 	self->CancelAllTimers();

@ -264,7 +265,7 @@ void AmSkullkinDrill::OnTimerDone(Entity* self, std::string timerName) {
 		auto* child = EntityManager::Instance()->GetEntity(childID);

 		if (child != nullptr) {
-			child->Smash(self->GetObjectID(), SILENT);
+			child->Smash(self->GetObjectID(), eKillType::SILENT);
 		}

 		self->SetNetworkVar(u"bIsInUse", false);
--- a/dScripts/02_server/Map/AM/AmTeapotServer.cpp
+++ b/dScripts/02_server/Map/AM/AmTeapotServer.cpp
@ -2,6 +2,7 @@
 #include "InventoryComponent.h"
 #include "GameMessages.h"
 #include "Item.h"
+#include "eTerminateType.h"

 void AmTeapotServer::OnUse(Entity* self, Entity* user) {
 	auto* inventoryComponent = user->GetComponent<InventoryComponent>();
@ -18,5 +19,5 @@ void AmTeapotServer::OnUse(Entity* self, Entity* user) {
 		blueFlowerItem->SetCount(blueFlowerItem->GetCount() - 10);
 		inventoryComponent->AddItem(WU_S_IMAGINATION_TEA, 1);
 	}
-	GameMessages::SendTerminateInteraction(user->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
+	GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
 }
--- a/dScripts/02_server/Map/FV/ImgBrickConsoleQB.cpp
+++ b/dScripts/02_server/Map/FV/ImgBrickConsoleQB.cpp
@ -6,6 +6,7 @@
 #include "MissionComponent.h"
 #include "eMissionState.h"
 #include "InventoryComponent.h"
+#include "eTerminateType.h"

 int32_t ImgBrickConsoleQB::ResetBricks = 30;
 int32_t ImgBrickConsoleQB::ResetConsole = 60;
@ -20,7 +21,7 @@ void ImgBrickConsoleQB::OnStartup(Entity* self) {
 void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {
 	auto* rebuildComponent = self->GetComponent<RebuildComponent>();

-	if (rebuildComponent->GetState() == REBUILD_COMPLETED) {
+	if (rebuildComponent->GetState() == eRebuildState::COMPLETED) {
 		if (!self->GetNetworkVar<bool>(u"used")) {
 			const auto consoles = EntityManager::Instance()->GetEntitiesInGroup("Console");

@ -29,7 +30,7 @@ void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {
 			for (auto* console : consoles) {
 				auto* consoleRebuildComponent = console->GetComponent<RebuildComponent>();

-				if (consoleRebuildComponent->GetState() != REBUILD_COMPLETED) {
+				if (consoleRebuildComponent->GetState() != eRebuildState::COMPLETED) {
 					continue;
 				}

@ -87,7 +88,7 @@ void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {

 		self->SetNetworkVar(u"used", true);

-		GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
+		GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
 	}
 }

@ -113,7 +114,7 @@ void ImgBrickConsoleQB::SmashCanister(Entity* self) {

 	const auto canisters = EntityManager::Instance()->GetEntitiesInGroup("Canister");
 	for (auto* canister : canisters) {
-		canister->Smash(canister->GetObjectID(), VIOLENT);
+		canister->Smash(canister->GetObjectID(), eKillType::VIOLENT);
 	}

 	const auto canister = dZoneManager::Instance()->GetSpawnersByName("BrickCanister");
@ -146,7 +147,7 @@ void ImgBrickConsoleQB::OnRebuildComplete(Entity* self, Entity* target) {
 	for (auto* console : consoles) {
 		auto* consoleRebuildComponent = console->GetComponent<RebuildComponent>();

-		if (consoleRebuildComponent->GetState() != REBUILD_COMPLETED) {
+		if (consoleRebuildComponent->GetState() != eRebuildState::COMPLETED) {
 			continue;
 		}

@ -167,7 +168,7 @@ void ImgBrickConsoleQB::OnDie(Entity* self, Entity* killer) {

 	auto* rebuildComponent = self->GetComponent<RebuildComponent>();

-	if (rebuildComponent->GetState() == REBUILD_COMPLETED) {
+	if (rebuildComponent->GetState() == eRebuildState::COMPLETED) {
 		auto offFX = 0;

 		const auto location = GeneralUtils::UTF16ToWTF8(self->GetVar<std::u16string>(u"console"));
@ -228,14 +229,14 @@ void ImgBrickConsoleQB::OnTimerDone(Entity* self, std::string timerName) {
 	if (timerName == "reset") {
 		auto* rebuildComponent = self->GetComponent<RebuildComponent>();

-		if (rebuildComponent->GetState() == REBUILD_OPEN) {
-			self->Smash(self->GetObjectID(), SILENT);
+		if (rebuildComponent->GetState() == eRebuildState::OPEN) {
+			self->Smash(self->GetObjectID(), eKillType::SILENT);
 		}
 	} else if (timerName == "Die") {
 		const auto consoles = EntityManager::Instance()->GetEntitiesInGroup("Console");

 		for (auto* console : consoles) {
-			console->Smash(console->GetObjectID(), VIOLENT);
+			console->Smash(console->GetObjectID(), eKillType::VIOLENT);
 		}
 	}
 }
--- a/dScripts/02_server/Map/FV/Racing/RaceMaelstromGeiser.cpp
+++ b/dScripts/02_server/Map/FV/Racing/RaceMaelstromGeiser.cpp
@ -55,7 +55,7 @@ void RaceMaelstromGeiser::OnProximityUpdate(Entity* self, Entity* entering, std:
 	}


-	GameMessages::SendDie(vehicle, self->GetObjectID(), LWOOBJID_EMPTY, true, VIOLENT, u"", 0, 0, 0, true, false, 0);
+	GameMessages::SendDie(vehicle, self->GetObjectID(), LWOOBJID_EMPTY, true, eKillType::VIOLENT, u"", 0, 0, 0, true, false, 0);

 	auto* zoneController = dZoneManager::Instance()->GetZoneControlObject();

--- a/dScripts/02_server/Map/GF/GfCaptainsCannon.cpp
+++ b/dScripts/02_server/Map/GF/GfCaptainsCannon.cpp
@ -2,6 +2,8 @@
 #include "GameMessages.h"
 #include "EntityManager.h"
 #include "MissionComponent.h"
+#include "eTerminateType.h"
+#include "eStateChangeType.h"

 void GfCaptainsCannon::OnUse(Entity* self, Entity* user) {
 	if (self->GetVar<bool>(u"bIsInUse")) {
@ -78,6 +80,6 @@ void GfCaptainsCannon::OnTimerDone(Entity* self, std::string timerName) {
 			missionComponent->ForceProgress(601, 910, 1);
 		}

-		GameMessages::SendTerminateInteraction(playerId, FROM_INTERACTION, self->GetObjectID());
+		GameMessages::SendTerminateInteraction(playerId, eTerminateType::FROM_INTERACTION, self->GetObjectID());
 	}
 }
--- a/dScripts/02_server/Map/GF/GfTikiTorch.cpp
+++ b/dScripts/02_server/Map/GF/GfTikiTorch.cpp
@ -5,6 +5,7 @@
 #include "RenderComponent.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
+#include "eTerminateType.h"

 void GfTikiTorch::OnStartup(Entity* self) {
 	LightTorch(self);
@ -33,7 +34,7 @@ void GfTikiTorch::OnTimerDone(Entity* self, std::string timerName) {
 		Entity* player = EntityManager::Instance()->GetEntity(self->GetI64(u"userID"));

 		if (player != nullptr && player->GetCharacter()) {
-			GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
+			GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
 		}

 		self->SetBoolean(u"isInUse", false);
--- a/dScripts/02_server/Map/GF/MastTeleport.cpp
+++ b/dScripts/02_server/Map/GF/MastTeleport.cpp
@ -4,6 +4,7 @@
 #include "Preconditions.h"
 #include "eEndBehavior.h"
 #include "DestroyableComponent.h"
+#include "eStateChangeType.h"

 #ifdef _WIN32
 #define _USE_MATH_DEFINES
--- a/dScripts/02_server/Map/General/Ninjago/NjRailActivatorsServer.cpp
+++ b/dScripts/02_server/Map/General/Ninjago/NjRailActivatorsServer.cpp
@ -7,7 +7,7 @@ void NjRailActivatorsServer::OnUse(Entity* self, Entity* user) {
 	auto* rebuildComponent = self->GetComponent<RebuildComponent>();

 	// Only allow use if this is not a quick build or the quick build is built
-	if (rebuildComponent == nullptr || rebuildComponent->GetState() == REBUILD_COMPLETED) {
+	if (rebuildComponent == nullptr || rebuildComponent->GetState() == eRebuildState::COMPLETED) {
 		auto* character = user->GetCharacter();
 		if (character != nullptr) {
 			character->SetPlayerFlag(flag, true);
--- a/dScripts/02_server/Map/General/Ninjago/NjRailPostServer.cpp
+++ b/dScripts/02_server/Map/General/Ninjago/NjRailPostServer.cpp
@ -19,7 +19,7 @@ void NjRailPostServer::OnNotifyObject(Entity* self, Entity* sender, const std::s
 }

 void NjRailPostServer::OnRebuildNotifyState(Entity* self, eRebuildState state) {
-	if (state == REBUILD_COMPLETED) {
+	if (state == eRebuildState::COMPLETED) {
 		auto* relatedRail = GetRelatedRail(self);
 		if (relatedRail == nullptr)
 			return;
@ -30,7 +30,7 @@ void NjRailPostServer::OnRebuildNotifyState(Entity* self, eRebuildState state) {
 			return;

 		self->SetNetworkVar(NetworkNotActiveVariable, false);
-	} else if (state == REBUILD_RESETTING) {
+	} else if (state == eRebuildState::RESETTING) {
 		auto* relatedRail = GetRelatedRail(self);
 		if (relatedRail == nullptr)
 			return;
--- a/Show More
+++ b/Show More