update switch behavior

was using very old code from pre-foss that has not been updated with the new behavior knowledge.  The code has been updated accordingly to what the client expects.

Tested that ice shurikens can now destroy the legs of the skeleton towers in crux prime.  Tested that the following weapons can still do damage to enemies and objects in the world:
surikens of ice
serratorizer
Super Morning Star
Super Dagger
elite long barrel blaster (charge and normal)
Mosaic Wand

CMakeLists.txt

@@ -1,9 +1,11 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 project(Darkflame)
 include(CTest)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) # Set CMAKE visibility policy to NEW on project and subprojects
+set(CMAKE_CXX_VISIBILITY_PRESET hidden) # Set C++ symbol visibility to default to hidden
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
 # Read variables from file
@@ -211,29 +213,29 @@ if (APPLE)
 endif()
 
 # Load all of our third party directories
-add_subdirectory(thirdparty)
+add_subdirectory(thirdparty SYSTEM)
 
 # Create our list of include directories
-set(INCLUDED_DIRECTORIES
+include_directories(
 	"dPhysics"
 
 	"dNavigation"
 
 	"dNet"
 
-	"thirdparty/magic_enum/include/magic_enum"
-	"thirdparty/raknet/Source"
-	"thirdparty/tinyxml2"
-	"thirdparty/recastnavigation"
-	"thirdparty/SQLite"
-	"thirdparty/cpplinq"
-	"thirdparty/cpp-httplib"
-	"thirdparty/MD5"
-
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
 	"tests/dGameTests/dComponentsTests"
+
+	SYSTEM "thirdparty/magic_enum/include/magic_enum"
+	SYSTEM "thirdparty/raknet/Source"
+	SYSTEM "thirdparty/tinyxml2"
+	SYSTEM "thirdparty/recastnavigation"
+	SYSTEM "thirdparty/SQLite"
+	SYSTEM "thirdparty/cpplinq"
+	SYSTEM "thirdparty/cpp-httplib"
+	SYSTEM "thirdparty/MD5"
 )
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -242,14 +244,9 @@ if(APPLE)
 	include_directories("/usr/local/include/")
 endif()
 
-# Actually include the directories from our list
-foreach(dir ${INCLUDED_DIRECTORIES})
-	include_directories(${PROJECT_SOURCE_DIR}/${dir})
-endforeach()
-
 # Add linking directories:
 if (UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Werror") # Warning flags
 endif()
 file(
 	GLOB HEADERS_DZONEMANAGER

README.md

@@ -51,7 +51,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.18**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
 
 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.

cmake/FindMariaDB.cmake

@@ -141,6 +141,6 @@ elseif(APPLE)
 endif()
 
 # Add directories to include lists
-target_include_directories(MariaDB::ConnCpp INTERFACE ${MARIADB_INCLUDE_DIR})
+target_include_directories(MariaDB::ConnCpp SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
 
 set(MariaDB_FOUND TRUE)

dCommon/GeneralUtils.h

@@ -264,8 +264,8 @@ namespace GeneralUtils {
 	 * @returns The enum entry's value in its underlying type
 	*/
 	template <Enum eType>
-	constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) noexcept {
+	constexpr std::underlying_type_t<eType> ToUnderlying(const eType entry) noexcept {
-		return static_cast<typename std::underlying_type_t<eType>>(entry);
+		return static_cast<std::underlying_type_t<eType>>(entry);
 	}
 
 	// on Windows we need to undef these or else they conflict with our numeric limits calls

dCommon/dEnums/eWaypointCommandType.h

@@ -0,0 +1,59 @@
+
+#ifndef __EWAYPOINTCOMMANDTYPES__H__
+#define __EWAYPOINTCOMMANDTYPES__H__
+
+#include <cstdint>
+
+enum class eWaypointCommandType : uint32_t {
+	INVALID,
+	BOUNCE,
+	STOP,
+	GROUP_EMOTE,
+	SET_VARIABLE,
+	CAST_SKILL,
+	EQUIP_INVENTORY,
+	UNEQUIP_INVENTORY,
+	DELAY,
+	EMOTE,
+	TELEPORT,
+	PATH_SPEED,
+	REMOVE_NPC,
+	CHANGE_WAYPOINT,
+	DELETE_SELF,
+	KILL_SELF,
+	SPAWN_OBJECT,
+	PLAY_SOUND,
+};
+
+class WaypointCommandType {
+public:
+	static eWaypointCommandType StringToWaypointCommandType(std::string commandString) {
+		const std::map<std::string, eWaypointCommandType> WaypointCommandTypeMap = {
+			{"bounce", eWaypointCommandType::BOUNCE},
+			{"stop", eWaypointCommandType::STOP},
+			{"groupemote", eWaypointCommandType::GROUP_EMOTE},
+			{"setvar", eWaypointCommandType::SET_VARIABLE},
+			{"castskill", eWaypointCommandType::CAST_SKILL},
+			{"eqInvent", eWaypointCommandType::EQUIP_INVENTORY},
+			{"unInvent", eWaypointCommandType::UNEQUIP_INVENTORY},
+			{"delay", eWaypointCommandType::DELAY},
+			{"femote", eWaypointCommandType::EMOTE},
+			{"emote", eWaypointCommandType::EMOTE},
+			{"teleport", eWaypointCommandType::TELEPORT},
+			{"pathspeed", eWaypointCommandType::PATH_SPEED},
+			{"removeNPC", eWaypointCommandType::REMOVE_NPC},
+			{"changeWP", eWaypointCommandType::CHANGE_WAYPOINT},
+			{"DeleteSelf", eWaypointCommandType::DELETE_SELF},
+			{"killself", eWaypointCommandType::KILL_SELF},
+			{"removeself", eWaypointCommandType::DELETE_SELF},
+			{"spawnOBJ", eWaypointCommandType::SPAWN_OBJECT},
+			{"playSound", eWaypointCommandType::PLAY_SOUND},
+		};
+
+		auto intermed = WaypointCommandTypeMap.find(commandString);
+		return (intermed != WaypointCommandTypeMap.end()) ? intermed->second : eWaypointCommandType::INVALID;
+	};
+};
+
+
+#endif  //!__EWAYPOINTCOMMANDTYPES__H__

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.cpp

@@ -58,7 +58,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 		CDLootTable entry;
 		uint32_t lootTableIndex = tableData.getIntField("LootTableIndex", -1);
 
-		entries[lootTableIndex].push_back(ReadRow(tableData));
+		entries[lootTableIndex].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	for (auto& [id, table] : entries) {
@@ -66,7 +66,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 	}
 }
 
-const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
+const LootTableEntries& CDLootTableTable::GetTable(const uint32_t tableId) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(tableId);
 	if (itr != entries.end()) {
@@ -79,7 +79,7 @@ const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
 
 	while (!tableData.eof()) {
 		CDLootTable entry;
-		entries[tableId].push_back(ReadRow(tableData));
+		entries[tableId].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	SortTable(entries[tableId]);

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDLootTable {
 	uint32_t itemid;                 //!< The LOT of the item
 	uint32_t LootTableIndex;         //!< The Loot Table Index
@@ -20,6 +22,5 @@ private:
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	const LootTableEntries& GetTable(uint32_t tableId);
+	const LootTableEntries& GetTable(const uint32_t tableId);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.cpp

@@ -20,7 +20,7 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionEmail");
 	while (!tableData.eof()) {
-		CDMissionEmail entry;
+		auto& entry = entries.emplace_back();
 		entry.ID = tableData.getIntField("ID", -1);
 		entry.messageType = tableData.getIntField("messageType", -1);
 		entry.notificationGroup = tableData.getIntField("notificationGroup", -1);
@@ -30,11 +30,8 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 		entry.locStatus = tableData.getIntField("locStatus", -1);
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionEmail {
 	uint32_t ID;
 	uint32_t messageType;

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.cpp

@@ -20,18 +20,15 @@ void CDMissionNPCComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionNPCComponent");
 	while (!tableData.eof()) {
-		CDMissionNPCComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.missionID = tableData.getIntField("missionID", -1);
 		entry.offersMission = tableData.getIntField("offersMission", -1) == 1 ? true : false;
 		entry.acceptsMission = tableData.getIntField("acceptsMission", -1) == 1 ? true : false;
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionNPCComponent {
 	uint32_t id;                //!< The ID
 	uint32_t missionID;         //!< The Mission ID
@@ -17,4 +19,3 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionNPCComponent> Query(std::function<bool(CDMissionNPCComponent)> predicate);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.cpp

@@ -20,7 +20,7 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionTasks");
 	while (!tableData.eof()) {
-		CDMissionTasks entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.taskType = tableData.getIntField("taskType", -1);
@@ -35,11 +35,8 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 		UNUSED(entry.localize = tableData.getIntField("localize", -1) == 1 ? true : false);
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMissionTasks)> predicate) {
@@ -51,7 +48,7 @@ std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMiss
 	return data;
 }
 
-std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(uint32_t missionID) {
+std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(const uint32_t missionID) {
 	std::vector<CDMissionTasks*> tasks;
 
 	// TODO: this should not be linear(?) and also shouldnt need to be a pointer

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionTasks {
 	uint32_t id;                //!< The Mission ID that the task belongs to
 	UNUSED(uint32_t locStatus);         //!< ???
@@ -25,7 +27,7 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionTasks> Query(std::function<bool(CDMissionTasks)> predicate);
 
-	std::vector<CDMissionTasks*> GetByMissionID(uint32_t missionID);
+	std::vector<CDMissionTasks*> GetByMissionID(const uint32_t missionID);
 
 	// TODO: Remove this and replace it with a proper lookup function.
 	const CDTable::StorageType& GetEntries() const;

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.cpp

@@ -22,7 +22,7 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Missions");
 	while (!tableData.eof()) {
-		CDMissions entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.defined_type = tableData.getStringField("defined_type", "");
 		entry.defined_subtype = tableData.getStringField("defined_subtype", "");
@@ -76,7 +76,6 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.reward_bankinventory = tableData.getIntField("reward_bankinventory", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
 	tableData.finalize();

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.h

@@ -75,4 +75,3 @@ public:
 
 	static CDMissions Default;
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.cpp

@@ -20,7 +20,7 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MovementAIComponent");
 	while (!tableData.eof()) {
-		CDMovementAIComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.MovementType = tableData.getStringField("MovementType", "");
 		entry.WanderChance = tableData.getFloatField("WanderChance", -1.0f);
@@ -30,11 +30,8 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 		entry.WanderRadius = tableData.getFloatField("WanderRadius", -1.0f);
 		entry.attachedPath = tableData.getStringField("attachedPath", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMovementAIComponent> CDMovementAIComponentTable::Query(std::function<bool(CDMovementAIComponent)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMovementAIComponent {
 	uint32_t id;
 	std::string MovementType;

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.cpp

@@ -20,17 +20,14 @@ void CDObjectSkillsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ObjectSkills");
 	while (!tableData.eof()) {
-		CDObjectSkills entry;
+		auto &entry = entries.emplace_back();
 		entry.objectTemplate = tableData.getIntField("objectTemplate", -1);
 		entry.skillID = tableData.getIntField("skillID", -1);
 		entry.castOnType = tableData.getIntField("castOnType", -1);
 		entry.AICombatWeight = tableData.getIntField("AICombatWeight", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObjectSkills)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjectSkills {
 	uint32_t objectTemplate;        //!< The LOT of the item
 	uint32_t skillID;               //!< The Skill ID of the object

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.cpp

@@ -1,7 +1,7 @@
 #include "CDObjectsTable.h"
 
 namespace {
-	CDObjects m_default;
+	CDObjects ObjDefault;
 };
 
 void CDObjectsTable::LoadValuesFromDatabase() {
@@ -20,8 +20,10 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Objects");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDObjects entry;
+		const uint32_t lot = tableData.getIntField("id", 0);
-		entry.id = tableData.getIntField("id", -1);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED_COLUMN(entry.placeable = tableData.getIntField("placeable", -1);)
 		entry.type = tableData.getStringField("type", "");
@@ -36,35 +38,34 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 		UNUSED_COLUMN(entry.gate_version = tableData.getStringField("gate_version", "");)
 		UNUSED_COLUMN(entry.HQ_valid = tableData.getIntField("HQ_valid", -1);)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
-	tableData.finalize();
+	ObjDefault.id = 0;
-
-	m_default.id = 0;
 }
 
-const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
+const CDObjects& CDObjectsTable::GetByID(const uint32_t lot) {
 	auto& entries = GetEntriesMutable();
-	const auto& it = entries.find(LOT);
+	const auto& it = entries.find(lot);
 	if (it != entries.end()) {
 		return it->second;
 	}
 
 	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Objects WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(LOT));
+	query.bind(1, static_cast<int32_t>(lot));
 
 	auto tableData = query.execQuery();
 	if (tableData.eof()) {
-		entries.insert(std::make_pair(LOT, m_default));
+		entries.emplace(lot, ObjDefault);
-		return m_default;
+		return ObjDefault;
 	}
 
 	// Now get the data
 	while (!tableData.eof()) {
-		CDObjects entry;
+		const uint32_t lot = tableData.getIntField("id", 0);
-		entry.id = tableData.getIntField("id", -1);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED(entry.placeable = tableData.getIntField("placeable", -1));
 		entry.type = tableData.getStringField("type", "");
@@ -79,17 +80,15 @@ const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 		UNUSED(entry.HQ_valid = tableData.getIntField("HQ_valid", -1));
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 
-	const auto& it2 = entries.find(LOT);
+	const auto& it2 = entries.find(lot);
 	if (it2 != entries.end()) {
 		return it2->second;
 	}
 
-	return m_default;
+	return ObjDefault;
 }
-

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjects {
 	uint32_t id;                            //!< The LOT of the object
 	std::string name;                      //!< The internal name of the object
@@ -24,6 +26,6 @@ class CDObjectsTable : public CDTable<CDObjectsTable, std::map<uint32_t, CDObjec
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by ID
-	const CDObjects& GetByID(uint32_t LOT);
+	const CDObjects& GetByID(const uint32_t lot);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.cpp

@@ -19,12 +19,11 @@ void CDPackageComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PackageComponent");
 	while (!tableData.eof()) {
-		CDPackageComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
 		entry.packageType = tableData.getIntField("packageType", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDPackageComponent {
 	uint32_t id;
 	uint32_t LootMatrixIndex;

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.cpp

@@ -4,32 +4,31 @@ void CDPhysicsComponentTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PhysicsComponent");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDPhysicsComponent entry;
+		const uint32_t componentID = tableData.getIntField("id", -1);
-		entry.id = tableData.getIntField("id", -1);
+
+		auto& entry = entries[componentID];
+		entry.id = componentID;
 		entry.bStatic = tableData.getIntField("static", -1) != 0;
 		entry.physicsAsset = tableData.getStringField("physics_asset", "");
-		UNUSED(entry->jump = tableData.getIntField("jump", -1) != 0);
+		UNUSED_COLUMN(entry.jump = tableData.getIntField("jump", -1) != 0;)
-		UNUSED(entry->doublejump = tableData.getIntField("doublejump", -1) != 0);
+		UNUSED_COLUMN(entry.doubleJump = tableData.getIntField("doublejump", -1) != 0;)
-		entry.speed = tableData.getFloatField("speed", -1);
+		entry.speed = static_cast<float>(tableData.getFloatField("speed", -1));
-		UNUSED(entry->rotSpeed = tableData.getFloatField("rotSpeed", -1));
+		UNUSED_COLUMN(entry.rotSpeed = tableData.getFloatField("rotSpeed", -1);)
-		entry.playerHeight = tableData.getFloatField("playerHeight");
+		entry.playerHeight = static_cast<float>(tableData.getFloatField("playerHeight"));
-		entry.playerRadius = tableData.getFloatField("playerRadius");
+		entry.playerRadius = static_cast<float>(tableData.getFloatField("playerRadius"));
 		entry.pcShapeType = tableData.getIntField("pcShapeType");
 		entry.collisionGroup = tableData.getIntField("collisionGroup");
-		UNUSED(entry->airSpeed = tableData.getFloatField("airSpeed"));
+		UNUSED_COLUMN(entry.airSpeed = tableData.getFloatField("airSpeed");)
-		UNUSED(entry->boundaryAsset = tableData.getStringField("boundaryAsset"));
+		UNUSED_COLUMN(entry.boundaryAsset = tableData.getStringField("boundaryAsset");)
-		UNUSED(entry->jumpAirSpeed = tableData.getFloatField("jumpAirSpeed"));
+		UNUSED_COLUMN(entry.jumpAirSpeed = tableData.getFloatField("jumpAirSpeed");)
-		UNUSED(entry->friction = tableData.getFloatField("friction"));
+		UNUSED_COLUMN(entry.friction = tableData.getFloatField("friction");)
-		UNUSED(entry->gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset"));
+		UNUSED_COLUMN(entry.gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset");)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(uint32_t componentID) {
+CDPhysicsComponent* CDPhysicsComponentTable::GetByID(const uint32_t componentID) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(componentID);
 	return itr != entries.end() ? &itr->second : nullptr;

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "CDTable.h"
+#include <cstdint>
 #include <string>
 
 struct CDPhysicsComponent {
@@ -7,7 +8,7 @@ struct CDPhysicsComponent {
 	bool bStatic;
 	std::string physicsAsset;
 	UNUSED(bool jump);
-	UNUSED(bool doublejump);
+	UNUSED(bool doubleJump);
 	float speed;
 	UNUSED(float rotSpeed);
 	float playerHeight;
@@ -26,5 +27,5 @@ public:
 	void LoadValuesFromDatabase();
 
 	static const std::string GetTableName() { return "PhysicsComponent"; };
-	CDPhysicsComponent* GetByID(uint32_t componentID);
+	CDPhysicsComponent* GetByID(const uint32_t componentID);
 };

dGame/EntityManager.cpp

@@ -418,10 +418,16 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 }
 
 void EntityManager::SerializeEntity(Entity* entity) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (!entity) return;
 	
-	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
+	EntityManager::SerializeEntity(*entity);
-		m_EntitiesToSerialize.push_back(entity->GetObjectID());
+}
+
+void EntityManager::SerializeEntity(const Entity& entity) {
+	if (entity.GetNetworkId() == 0) return;
+
+	if (std::find(m_EntitiesToSerialize.cbegin(), m_EntitiesToSerialize.cend(), entity.GetObjectID()) == m_EntitiesToSerialize.cend()) {
+		m_EntitiesToSerialize.push_back(entity.GetObjectID());
 	}
 }
 

dGame/EntityManager.h

@@ -45,6 +45,7 @@ public:
 	void ConstructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS, bool skipChecks = false);
 	void DestructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SerializeEntity(Entity* entity);
+	void SerializeEntity(const Entity& entity);
 
 	void ConstructAllEntities(const SystemAddress& sysAddr);
 	void DestructAllEntities(const SystemAddress& sysAddr);

dGame/dBehaviors/SwitchBehavior.cpp

@@ -7,9 +7,9 @@
 #include "BuffComponent.h"
 
 void SwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
-	auto state = true;
+	bool state = true;
 
-	if (this->m_imagination > 0 || !this->m_isEnemyFaction) {
+	if (m_imagination > 0 || m_targetHasBuff > 0 || m_Distance > -1.0f) {
 		if (!bitStream.Read(state)) {
 			LOG("Unable to read state from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 			return;
@@ -18,49 +18,59 @@ void SwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStre
 
 	auto* entity = Game::entityManager->GetEntity(context->originator);
 
-	if (entity == nullptr) {
+	if (!entity) return;
-		return;
-	}
 
 	auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
 
-	if (destroyableComponent == nullptr) {
+	if (destroyableComponent) {
-		return;
+		if (m_isEnemyFaction) {
+			auto* target = Game::entityManager->GetEntity(branch.target);
+			if (target) state = destroyableComponent->IsEnemy(target);
+		}
+
+		LOG_DEBUG("[%i] State: (%d), imagination: (%i) / (%f)", entity->GetLOT(), state, destroyableComponent->GetImagination(), destroyableComponent->GetMaxImagination());
 	}
 
-	LOG_DEBUG("[%i] State: (%d), imagination: (%i) / (%f)", entity->GetLOT(), state, destroyableComponent->GetImagination(), destroyableComponent->GetMaxImagination());
+	auto* behaviorToCall = state ? m_actionTrue : m_actionFalse;
-
+	behaviorToCall->Handle(context, bitStream, branch);
-	if (state) {
-		this->m_actionTrue->Handle(context, bitStream, branch);
-	} else {
-		this->m_actionFalse->Handle(context, bitStream, branch);
-	}
 }
 
 void SwitchBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
-	auto state = true;
+	bool state = true;
-
+	if (m_imagination > 0 || m_targetHasBuff > 0 || m_Distance > -1.0f) {
-	if (this->m_imagination > 0 || !this->m_isEnemyFaction) {
 		auto* entity = Game::entityManager->GetEntity(branch.target);
 
 		state = entity != nullptr;
 
-		if (state && m_targetHasBuff != 0) {
+		if (state) {
-			auto* buffComponent = entity->GetComponent<BuffComponent>();
+			if (m_targetHasBuff != 0) {
+				auto* buffComponent = entity->GetComponent<BuffComponent>();
 
-			if (buffComponent != nullptr && !buffComponent->HasBuff(m_targetHasBuff)) {
+				if (buffComponent != nullptr && !buffComponent->HasBuff(m_targetHasBuff)) {
-				state = false;
+					state = false;
+				}
+			} else if (m_imagination > 0) {
+				auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+				if (destroyableComponent && destroyableComponent->GetImagination() < m_imagination) {
+					state = false;
+				}
+			} else if (m_Distance > -1.0f) {
+				auto* originator = Game::entityManager->GetEntity(context->originator);
+
+				if (originator) {
+					const auto distance = (originator->GetPosition() - entity->GetPosition()).Length();
+
+					state = distance <= m_Distance;
+				}
 			}
 		}
 
 		bitStream.Write(state);
 	}
 
-	if (state) {
+	auto* behaviorToCall = state ? m_actionTrue : m_actionFalse;
-		this->m_actionTrue->Calculate(context, bitStream, branch);
+	behaviorToCall->Calculate(context, bitStream, branch);
-	} else {
-		this->m_actionFalse->Calculate(context, bitStream, branch);
-	}
 }
 
 void SwitchBehavior::Load() {
@@ -72,5 +82,7 @@ void SwitchBehavior::Load() {
 
 	this->m_isEnemyFaction = GetBoolean("isEnemyFaction");
 
-	this->m_targetHasBuff = GetInt("target_has_buff");
+	this->m_targetHasBuff = GetInt("target_has_buff", -1);
+
+	this->m_Distance = GetFloat("distance", -1.0f);
 }

dGame/dBehaviors/SwitchBehavior.h

@@ -14,6 +14,8 @@ public:
 
 	int32_t m_targetHasBuff;
 
+	float m_Distance;
+
 	/*
 	 * Inherited
 	 */

dGame/dComponents/AchievementVendorComponent.cpp

@@ -9,11 +9,15 @@
 #include "UserManager.h"
 #include "CDMissionsTable.h"
 
+AchievementVendorComponent::AchievementVendorComponent(Entity* parent) : VendorComponent(parent) {
+	RefreshInventory(true);
+};
+
 bool AchievementVendorComponent::SellsItem(Entity* buyer, const LOT lot) {
 	auto* missionComponent = buyer->GetComponent<MissionComponent>();
 	if (!missionComponent) return false;
 
-	if (m_PlayerPurchasableItems[buyer->GetObjectID()].contains(lot)){
+	if (m_PlayerPurchasableItems[buyer->GetObjectID()].contains(lot)) {
 		return true;
 	}
 
@@ -44,7 +48,7 @@ void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
 	}
 
 	auto* inventoryComponent = buyer->GetComponent<InventoryComponent>();
-	if (!inventoryComponent)  {
+	if (!inventoryComponent) {
 		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
 		return;
 	}
@@ -70,3 +74,8 @@ void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
 	GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_SUCCESS);
 
 }
+
+void AchievementVendorComponent::RefreshInventory(bool isCreation) {
+	SetHasStandardCostItems(true);
+	Game::entityManager->SerializeEntity(m_Parent);
+}

dGame/dComponents/AchievementVendorComponent.h

@@ -11,7 +11,9 @@ class Entity;
 class AchievementVendorComponent final : public VendorComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::ACHIEVEMENT_VENDOR;
-	AchievementVendorComponent(Entity* parent) : VendorComponent(parent) {};
+	AchievementVendorComponent(Entity* parent);
+	
+	void RefreshInventory(bool isCreation = false) override;
 	bool SellsItem(Entity* buyer, const LOT lot);
 	void Buy(Entity* buyer, LOT lot, uint32_t count);
 

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -26,7 +26,6 @@ ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Phy
 	m_SpeedMultiplier = 1;
 	m_GravityScale = 1;
 	m_DirtyCheats = false;
-	m_IgnoreMultipliers = false;
 
 	m_DirtyEquippedItemInfo = true;
 	m_PickupRadius = 0.0f;
@@ -92,31 +91,31 @@ void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bo
 		outBitStream.Write(m_ImmuneToStunInteractCount);
 	}
 
-	if (m_IgnoreMultipliers) m_DirtyCheats = false;
+	outBitStream.Write(m_DirtyCheats || bIsInitialUpdate);
-
+	if (m_DirtyCheats || bIsInitialUpdate) {
-	outBitStream.Write(m_DirtyCheats);
-	if (m_DirtyCheats) {
 		outBitStream.Write(m_GravityScale);
 		outBitStream.Write(m_SpeedMultiplier);
 
-		m_DirtyCheats = false;
+		if (!bIsInitialUpdate) m_DirtyCheats = false;
 	}
 
-	outBitStream.Write(m_DirtyEquippedItemInfo);
+	outBitStream.Write(m_DirtyEquippedItemInfo || bIsInitialUpdate);
-	if (m_DirtyEquippedItemInfo) {
+	if (m_DirtyEquippedItemInfo || bIsInitialUpdate) {
 		outBitStream.Write(m_PickupRadius);
 		outBitStream.Write(m_InJetpackMode);
-		m_DirtyEquippedItemInfo = false;
+
+		if (!bIsInitialUpdate) m_DirtyEquippedItemInfo = false;
 	}
 
-	outBitStream.Write(m_DirtyBubble);
+	outBitStream.Write(m_DirtyBubble || bIsInitialUpdate);
-	if (m_DirtyBubble) {
+	if (m_DirtyBubble || bIsInitialUpdate) {
 		outBitStream.Write(m_IsInBubble);
 		if (m_IsInBubble) {
 			outBitStream.Write(m_BubbleType);
 			outBitStream.Write(m_SpecialAnims);
 		}
-		m_DirtyBubble = false;
+
+		if (!bIsInitialUpdate) m_DirtyBubble = false;
 	}
 
 	outBitStream.Write(m_DirtyPosition || bIsInitialUpdate);
@@ -149,7 +148,8 @@ void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bo
 			outBitStream.Write(m_AngularVelocity.z);
 		}
 
-		outBitStream.Write0();
+		outBitStream.Write0(); // local_space_info, always zero for now.
+
 		if (!bIsInitialUpdate) {
 			m_DirtyPosition = false;
 			outBitStream.Write(m_IsTeleporting);

dGame/dComponents/ControllablePhysicsComponent.h

@@ -174,18 +174,6 @@ public:
 	 */
 	const float GetGravityScale() const { return m_GravityScale; }
 
-	/**
-	 * Sets the ignore multipliers value, allowing you to skip the serialization of speed and gravity multipliers
-	 * @param value whether or not to ignore multipliers
-	 */
-	void SetIgnoreMultipliers(bool value) { m_IgnoreMultipliers = value; }
-
-	/**
-	 * Returns the current ignore multipliers value
-	 * @return the current ignore multipliers value
-	 */
-	const bool GetIgnoreMultipliers() const { return m_IgnoreMultipliers; }
-
 	/**
 	 * Can make an entity static, making it unable to move around
 	 * @param value whether or not the entity is static
@@ -353,11 +341,6 @@ private:
 	 */
 	bool m_DirtyCheats;
 
-	/**
-	 * Makes it so that the speed multiplier and gravity scale are no longer serialized if false
-	 */
-	bool m_IgnoreMultipliers;
-
 	/**
 	 * Whether this entity is static, making it unable to move
 	 */

dGame/dComponents/PetComponent.h

@@ -353,7 +353,6 @@ private:
 
 	/**
 	 * Pet information loaded from the CDClientDatabase
-	 * TODO: Switch to a reference when safe to do so
 	 */
 	CDPetComponent m_PetInfo;
 };

dGame/dComponents/TriggerComponent.cpp

@@ -15,8 +15,9 @@
 #include "PlayerManager.h"
 #include "Game.h"
 #include "EntityManager.h"
+#include "MovementAIComponent.h"
 
-TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo): Component(parent) {
+TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo) : Component(parent) {
 	m_Parent = parent;
 	m_Trigger = nullptr;
 
@@ -43,7 +44,7 @@ void TriggerComponent::TriggerEvent(eTriggerEventType event, Entity* optionalTar
 }
 
 void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity* optionalTarget) {
-	auto argArray =  GeneralUtils::SplitString(command->args, ',');
+	auto argArray = GeneralUtils::SplitString(command->args, ',');
 
 	// determine targets
 	std::vector<Entity*> targetEntities = GatherTargets(command, optionalTarget);
@@ -55,107 +56,119 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 		if (!targetEntity) continue;
 
 		switch (command->id) {
-			case eTriggerCommandType::ZONE_PLAYER: break;
+		case eTriggerCommandType::ZONE_PLAYER: break;
-			case eTriggerCommandType::FIRE_EVENT:
+		case eTriggerCommandType::FIRE_EVENT:
-				HandleFireEvent(targetEntity, command->args);
+			HandleFireEvent(targetEntity, command->args);
-				break;
+			break;
-			case eTriggerCommandType::DESTROY_OBJ:
+		case eTriggerCommandType::DESTROY_OBJ:
-				HandleDestroyObject(targetEntity, command->args);
+			HandleDestroyObject(targetEntity, command->args);
-				break;
+			break;
-			case eTriggerCommandType::TOGGLE_TRIGGER:
+		case eTriggerCommandType::TOGGLE_TRIGGER:
-				HandleToggleTrigger(targetEntity, command->args);
+			HandleToggleTrigger(targetEntity, command->args);
-				break;
+			break;
-			case eTriggerCommandType::RESET_REBUILD:
+		case eTriggerCommandType::RESET_REBUILD:
-				HandleResetRebuild(targetEntity, command->args);
+			HandleResetRebuild(targetEntity, command->args);
-				break;
+			break;
-			case eTriggerCommandType::SET_PATH: break;
+		case eTriggerCommandType::SET_PATH:
-			case eTriggerCommandType::SET_PICK_TYPE: break;
+			HandleSetPath(targetEntity, argArray);
-			case eTriggerCommandType::MOVE_OBJECT:
+			break;
-				HandleMoveObject(targetEntity, argArray);
+		case eTriggerCommandType::SET_PICK_TYPE: break;
-				break;
+		case eTriggerCommandType::MOVE_OBJECT:
-			case eTriggerCommandType::ROTATE_OBJECT:
+			HandleMoveObject(targetEntity, argArray);
-				HandleRotateObject(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::ROTATE_OBJECT:
-			case eTriggerCommandType::PUSH_OBJECT:
+			HandleRotateObject(targetEntity, argArray);
-				HandlePushObject(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::PUSH_OBJECT:
-			case eTriggerCommandType::REPEL_OBJECT:
+			HandlePushObject(targetEntity, argArray);
-				HandleRepelObject(targetEntity, command->args);
+			break;
-				break;
+		case eTriggerCommandType::REPEL_OBJECT:
-			case eTriggerCommandType::SET_TIMER:
+			HandleRepelObject(targetEntity, command->args);
-				HandleSetTimer(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::SET_TIMER:
-			case eTriggerCommandType::CANCEL_TIMER:
+			HandleSetTimer(targetEntity, argArray);
-				HandleCancelTimer(targetEntity, command->args);
+			break;
-				break;
+		case eTriggerCommandType::CANCEL_TIMER:
-			case eTriggerCommandType::PLAY_CINEMATIC:
+			HandleCancelTimer(targetEntity, command->args);
-				HandlePlayCinematic(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::PLAY_CINEMATIC:
-			case eTriggerCommandType::TOGGLE_BBB:
+			HandlePlayCinematic(targetEntity, argArray);
-				HandleToggleBBB(targetEntity, command->args);
+			break;
-				break;
+		case eTriggerCommandType::TOGGLE_BBB:
-			case eTriggerCommandType::UPDATE_MISSION:
+			HandleToggleBBB(targetEntity, command->args);
-				HandleUpdateMission(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::UPDATE_MISSION:
-			case eTriggerCommandType::SET_BOUNCER_STATE: break;
+			HandleUpdateMission(targetEntity, argArray);
-			case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
+			break;
-			case eTriggerCommandType::TURN_AROUND_ON_PATH: break;
+		case eTriggerCommandType::SET_BOUNCER_STATE: break;
-			case eTriggerCommandType::GO_FORWARD_ON_PATH: break;
+		case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
-			case eTriggerCommandType::GO_BACKWARD_ON_PATH: break;
+		case eTriggerCommandType::TURN_AROUND_ON_PATH:
-			case eTriggerCommandType::STOP_PATHING: break;
+			HandleTurnAroundOnPath(targetEntity);
-			case eTriggerCommandType::START_PATHING: break;
+			break;
-			case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
+		case eTriggerCommandType::GO_FORWARD_ON_PATH:
-			case eTriggerCommandType::PLAY_EFFECT:
+			HandleGoForwardOnPath(targetEntity);
-				HandlePlayEffect(targetEntity, argArray);
+			break;
-				break;
+		case eTriggerCommandType::GO_BACKWARD_ON_PATH:
-			case eTriggerCommandType::STOP_EFFECT:
+			HandleGoBackwardOnPath(targetEntity);
-				GameMessages::SendStopFXEffect(targetEntity, true, command->args);
+			break;
-				break;
+		case eTriggerCommandType::STOP_PATHING:
-			case eTriggerCommandType::CAST_SKILL:
+			HandleStopPathing(targetEntity);
-				HandleCastSkill(targetEntity, command->args);
+			break;
-				break;
+		case eTriggerCommandType::START_PATHING:
-			case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
+			HandleStartPathing(targetEntity);
-				GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
+			break;
-				break;
+		case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
+		case eTriggerCommandType::PLAY_EFFECT:
-				HandleSetPhysicsVolumeEffect(targetEntity, argArray);
+			HandlePlayEffect(targetEntity, argArray);
-				break;
+			break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
+		case eTriggerCommandType::STOP_EFFECT:
-				HandleSetPhysicsVolumeStatus(targetEntity, command->args);
+			GameMessages::SendStopFXEffect(targetEntity, true, command->args);
-				break;
+			break;
-			case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
+		case eTriggerCommandType::CAST_SKILL:
-			case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
+			HandleCastSkill(targetEntity, command->args);
-			case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
+			break;
-				HandleActivateSpawnerNetwork(command->args);
+		case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
-				break;
+			GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
-			case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
+			break;
-				HandleDeactivateSpawnerNetwork(command->args);
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
-				break;
+			HandleSetPhysicsVolumeEffect(targetEntity, argArray);
-			case eTriggerCommandType::RESET_SPAWNER_NETWORK:
+			break;
-				HandleResetSpawnerNetwork(command->args);
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
-				break;
+			HandleSetPhysicsVolumeStatus(targetEntity, command->args);
-			case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
+			break;
-				HandleDestroySpawnerNetworkObjects(command->args);
+		case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
-				break;
+		case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
-			case eTriggerCommandType::GO_TO_WAYPOINT: break;
+		case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
-			case eTriggerCommandType::ACTIVATE_PHYSICS:
+			HandleActivateSpawnerNetwork(command->args);
-				HandleActivatePhysics(targetEntity, command->args);
+			break;
-				break;
+		case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
+			HandleDeactivateSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::RESET_SPAWNER_NETWORK:
+			HandleResetSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
+			HandleDestroySpawnerNetworkObjects(command->args);
+			break;
+		case eTriggerCommandType::GO_TO_WAYPOINT: break;
+		case eTriggerCommandType::ACTIVATE_PHYSICS:
+			HandleActivatePhysics(targetEntity, command->args);
+			break;
 			// DEPRECATED BLOCK START
-			case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::FLASH_MUSIC_CUE: break;
+		case eTriggerCommandType::FLASH_MUSIC_CUE: break;
-			case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
+		case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
-			case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
-			case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
 			// DEPRECATED BLOCK END
-			default:
+		default:
-				LOG_DEBUG("Event %i was not handled!", command->id);
+			LOG_DEBUG("Event %i was not handled!", command->id);
-				break;
+			break;
 		}
 	}
 }
@@ -164,20 +177,25 @@ std::vector<Entity*> TriggerComponent::GatherTargets(LUTriggers::Command* comman
 	std::vector<Entity*> entities = {};
 
 	if (command->target == "self") entities.push_back(m_Parent);
-	else if (command->target == "zone") { /*TODO*/ }
+	else if (command->target == "zone") {
-	else if (command->target == "target" && optionalTarget) entities.push_back(optionalTarget);
+		/*TODO*/
-	else if (command->target == "targetTeam" && optionalTarget) {
+	} else if (command->target == "target" && optionalTarget) {
+		entities.push_back(optionalTarget);
+	} else if (command->target == "targetTeam" && optionalTarget) {
 		auto* team = TeamManager::Instance()->GetTeam(optionalTarget->GetObjectID());
 		for (const auto memberId : team->members) {
 			auto* member = Game::entityManager->GetEntity(memberId);
 			if (member) entities.push_back(member);
 		}
-	} else if (command->target == "objGroup") entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "objGroup") {
-	else if (command->target == "allPlayers") {
+		entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "allPlayers") {
 		for (auto* player : PlayerManager::GetAllPlayers()) {
 			entities.push_back(player);
 		}
-	} else if (command->target == "allNPCs") { /*UNUSED*/ }
+	} else if (command->target == "allNPCs") {
+		/*UNUSED*/
+	}
 
 	return entities;
 }
@@ -186,12 +204,12 @@ void TriggerComponent::HandleFireEvent(Entity* targetEntity, std::string args) {
 	targetEntity->GetScript()->OnFireEventServerSide(targetEntity, m_Parent, args, 0, 0, 0);
 }
 
-void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args) {
 	const eKillType killType = GeneralUtils::TryParse<eKillType>(args).value_or(eKillType::VIOLENT);
 	targetEntity->Smash(m_Parent->GetObjectID(), killType);
 }
 
-void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args) {
 	auto* triggerComponent = targetEntity->GetComponent<TriggerComponent>();
 	if (!triggerComponent) {
 		LOG_DEBUG("Trigger component not found!");
@@ -200,7 +218,7 @@ void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string arg
 	triggerComponent->SetTriggerEnabled(args == "1");
 }
 
-void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args) {
 	auto* quickBuildComponent = targetEntity->GetComponent<QuickBuildComponent>();
 	if (!quickBuildComponent) {
 		LOG_DEBUG("Rebuild component not found!");
@@ -209,7 +227,7 @@ void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args
 	quickBuildComponent->ResetQuickBuild(args == "1");
 }
 
-void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	NiPoint3 position = targetEntity->GetPosition();
@@ -219,7 +237,7 @@ void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::s
 	targetEntity->SetPosition(position);
 }
 
-void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	const NiPoint3 vector = GeneralUtils::TryParse<NiPoint3>(argArray).value_or(NiPoint3Constant::ZERO);
@@ -228,7 +246,7 @@ void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std:
 	targetEntity->SetRotation(rotation);
 }
 
-void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() < 3) return;
 
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
@@ -246,7 +264,7 @@ void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::s
 }
 
 
-void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args) {
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
 		LOG_DEBUG("Phantom Physics component not found!");
@@ -270,7 +288,7 @@ void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args)
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() != 2) {
 		LOG_DEBUG("Not enough variables!");
 		return;
@@ -279,7 +297,7 @@ void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::str
 	m_Parent->AddTimer(argArray.at(0), time);
 }
 
-void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args) {
 	m_Parent->CancelTimer(args);
 }
 
@@ -327,7 +345,7 @@ void TriggerComponent::HandleUpdateMission(Entity* targetEntity, std::vector<std
 	// then we need a good way to convert this from a string to that enum
 	if (argArray.at(0) != "exploretask") return;
 	MissionComponent* missionComponent = targetEntity->GetComponent<MissionComponent>();
-	if (!missionComponent){
+	if (!missionComponent) {
 		LOG_DEBUG("Mission component not found!");
 		return;
 	}
@@ -348,7 +366,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 	GameMessages::SendPlayFXEffect(targetEntity, effectID.value(), effectType, argArray.at(0), LWOOBJID_EMPTY, priority);
 }
 
-void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args) {
 	auto* skillComponent = targetEntity->GetComponent<SkillComponent>();
 	if (!skillComponent) {
 		LOG_DEBUG("Skill component not found!");
@@ -402,25 +420,25 @@ void TriggerComponent::HandleSetPhysicsVolumeStatus(Entity* targetEntity, std::s
 	Game::entityManager->SerializeEntity(targetEntity);
 }
 
-void TriggerComponent::HandleActivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleActivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Activate();
 	}
 }
 
-void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Deactivate();
 	}
 }
 
-void TriggerComponent::HandleResetSpawnerNetwork(std::string args){
+void TriggerComponent::HandleResetSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Reset();
 	}
 }
 
-void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
+void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->DestroyAllEntities();
 	}
@@ -429,9 +447,50 @@ void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
 void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string args) {
 	if (args == "true") {
 		// TODO add physics entity if there isn't one
-	} else if (args == "false"){
+	} else if (args == "false") {
 		// TODO remove Phsyics entity if there is one
 	} else {
 		LOG_DEBUG("Invalid argument for ActivatePhysics Trigger: %s", args.c_str());
 	}
 }
+
+void TriggerComponent::HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// movementAIComponent->SetupPath(argArray.at(0));
+	if (argArray.size() >= 2) {
+		auto index = GeneralUtils::TryParse<int32_t>(argArray.at(1));
+		if (!index) return;
+		// movementAIComponent->SetPathStartingWaypointIndex(index.value());
+	}
+	if (argArray.size() >= 3 && argArray.at(2) == "1") {
+		// movementAIComponent->ReversePath();
+	}
+}
+
+void TriggerComponent::HandleTurnAroundOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoForwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoBackwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (!movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleStopPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Pause();
+}
+
+void TriggerComponent::HandleStartPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Resume();
+}

dGame/dComponents/TriggerComponent.h

@@ -44,6 +44,12 @@ private:
 	void HandleResetSpawnerNetwork(std::string args);
 	void HandleDestroySpawnerNetworkObjects(std::string args);
 	void HandleActivatePhysics(Entity* targetEntity, std::string args);
+	void HandleTurnAroundOnPath(Entity* targetEntity);
+	void HandleGoForwardOnPath(Entity* targetEntity);
+	void HandleGoBackwardOnPath(Entity* targetEntity);
+	void HandleStopPathing(Entity* targetEntity);
+	void HandleStartPathing(Entity* targetEntity);
+	void HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray);
 
 	LUTriggers::Trigger* m_Trigger;
 };

dGame/dComponents/VendorComponent.h

@@ -26,7 +26,7 @@ public:
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	void OnUse(Entity* originator) override;
-	void RefreshInventory(bool isCreation = false);
+	virtual void RefreshInventory(bool isCreation = false);
 	void SetupConstants();
 	bool SellsItem(const LOT item) const;
 	float GetBuyScalar() const { return m_BuyScalar; }

dGame/dUtilities/VanityUtilities.cpp

@@ -285,7 +285,7 @@ void ParseXml(const std::string& file) {
 				}
 
 				if (zoneID.value() != currentZoneID) {
-					LOG_DEBUG("Skipping location because it is in %i and not the current zone (%i)", zoneID.value(), currentZoneID);
+					LOG_DEBUG("Skipping (%s) %i location because it is in %i and not the current zone (%i)", name, lot, zoneID.value(), currentZoneID);
 					continue;
 				}
 

dMasterServer/MasterServer.cpp

@@ -675,7 +675,7 @@ void HandlePacket(Packet* packet) {
 
 			const auto& zone = instance->GetZoneID();
 
-			MasterPackets::SendZoneTransferResponse(Game::server, packet->systemAddress, requestID, (bool)mythranShift, zone.GetMapID(), instance->GetInstanceID(), zone.GetCloneID(), instance->GetIP(), instance->GetPort());
+			MasterPackets::SendZoneTransferResponse(Game::server, packet->systemAddress, requestID, static_cast<bool>(mythranShift), zone.GetMapID(), instance->GetInstanceID(), zone.GetCloneID(), instance->GetIP(), instance->GetPort());
 
 			break;
 		}

dNet/AuthPackets.cpp

@@ -229,7 +229,7 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
 	RakNet::BitStream loginResponse;
 	BitStreamUtils::WriteHeader(loginResponse, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
 
-	loginResponse.Write<uint8_t>(GeneralUtils::CastUnderlyingType(responseCode));
+	loginResponse.Write(responseCode);
 
 	// Event Gating
 	loginResponse.Write(LUString(Game::config->GetValue("event_1")));

dPhysics/dpGrid.cpp

@@ -26,8 +26,8 @@ dpGrid::~dpGrid() {
 
 void dpGrid::Add(dpEntity* entity) {
 	//Determine which grid cell it's in.
-	int cellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int cellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	cellX = std::clamp(cellX, 0, NUM_CELLS - 1);
@@ -42,11 +42,11 @@ void dpGrid::Add(dpEntity* entity) {
 }
 
 void dpGrid::Move(dpEntity* entity, float x, float z) {
-	int oldCellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int oldCellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
-	int cellX = (int)std::round(x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellX = static_cast<int>(std::round(x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int cellZ = (int)std::round(z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellZ = static_cast<int>(std::round(z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	cellX = std::clamp(cellX, 0, NUM_CELLS - 1);
@@ -73,8 +73,8 @@ void dpGrid::Move(dpEntity* entity, float x, float z) {
 
 void dpGrid::Delete(dpEntity* entity) {
 	if (!entity) return;
-	int oldCellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int oldCellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	oldCellX = std::clamp(oldCellX, 0, NUM_CELLS - 1);

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

@@ -29,7 +29,7 @@ void StoryBoxInteractServer::OnUse(Entity* self, Entity* user) {
 		return;
 	}
 
-	if (!self->HasVar(u"storyText") || !self->HasVar(u"altFlagID")) return;
+	if (!self->HasVar(u"storyText")) return;
 	const auto storyText = self->GetVarAsString(u"storyText");
 	if (storyText.length() > 2) {
 		auto storyValue = GeneralUtils::TryParse<uint32_t>(storyText.substr(storyText.length() - 2));

dWorldServer/WorldServer.cpp

@@ -335,7 +335,7 @@ int main(int argc, char** argv) {
 
 		// Update to the new framerate and scale all timings to said new framerate
 		if (newFrameDelta != currentFrameDelta) {
-			float_t ratioBeforeToAfter = (float)currentFrameDelta / (float)newFrameDelta;
+			float_t ratioBeforeToAfter = static_cast<float>(currentFrameDelta) / static_cast<float>(newFrameDelta);
 			currentFrameDelta = newFrameDelta;
 			currentFramerate = MS_TO_FRAMES(newFrameDelta);
 			LOG_DEBUG("Framerate for zone/instance/clone %i/%i/%i is now %i", zoneID, instanceID, cloneID, currentFramerate);
@@ -728,8 +728,8 @@ void HandleMasterPacket(Packet* packet) {
 			{
 				CBITSTREAM;
 				BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED);
-				bitStream.Write((LWOMAPID)Game::server->GetZoneID());
+				bitStream.Write<LWOMAPID>(Game::server->GetZoneID());
-				bitStream.Write((LWOINSTANCEID)instanceID);
+				bitStream.Write<LWOINSTANCEID>(instanceID);
 				Game::server->SendToMaster(bitStream);
 			}
 		}
@@ -830,8 +830,8 @@ void HandlePacket(Packet* packet) {
 
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED);
-		bitStream.Write((LWOMAPID)Game::server->GetZoneID());
+		bitStream.Write<LWOMAPID>(Game::server->GetZoneID());
-		bitStream.Write((LWOINSTANCEID)instanceID);
+		bitStream.Write<LWOINSTANCEID>(instanceID);
 		Game::server->SendToMaster(bitStream);
 	}
 

dZoneManager/Zone.cpp

@@ -17,6 +17,7 @@
 
 #include "eTriggerCommandType.h"
 #include "eTriggerEventType.h"
+#include "eWaypointCommandType.h"
 #include "dNavMesh.h"
 
 Zone::Zone(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) :
@@ -452,15 +453,23 @@ void Zone::LoadPath(std::istream& file) {
 				std::string value;
 				BinaryIO::ReadString<uint8_t>(file, value, BinaryIO::ReadType::WideString);
 
-				LDFBaseData* ldfConfig = nullptr;
 				if (path.pathType == PathType::Movement || path.pathType == PathType::Rail) {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=0:" + value);
+					// cause NetDevil puts spaces in things that don't need spaces
+					parameter.erase(std::remove_if(parameter.begin(), parameter.end(), ::isspace), parameter.end());
+					auto waypointCommand = WaypointCommandType::StringToWaypointCommandType(parameter);
+					if (waypointCommand == eWaypointCommandType::DELAY) value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
+					if (waypointCommand != eWaypointCommandType::INVALID) {
+						auto& command = waypoint.commands.emplace_back();
+						command.command = waypointCommand;
+						command.data = value;
+					} else LOG("Tried to load invalid waypoint command '%s'", parameter.c_str());
 				} else {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=" + value);
+					waypoint.config.emplace_back(LDFBaseData::DataFromString(parameter + "=" + value));
 				}
-				if (ldfConfig) waypoint.config.push_back(ldfConfig);
+
 			}
 		}
+
 		// We verify the waypoint heights against the navmesh because in many movement paths,
 		// the waypoint is located near 0 height, 
 		if (path.pathType == PathType::Movement) {

dZoneManager/Zone.h

@@ -13,6 +13,14 @@ namespace LUTriggers {
 
 class Level;
 
+enum class eWaypointCommandType : uint32_t;
+
+struct WaypointCommand {
+	eWaypointCommandType command;
+	std::string data;
+};
+
+
 struct SceneRef {
 	std::string filename;
 	uint32_t id;
@@ -69,6 +77,7 @@ struct PathWaypoint {
 	RacingPathWaypoint racing;
 	float speed;
 	std::vector<LDFBaseData*> config;
+	std::vector<WaypointCommand> commands;
 };
 
 enum class PathType : uint32_t {

tests/dCommonTests/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(DCOMMONTEST_SOURCES
 	"AMFDeserializeTests.cpp"
 	"Amf3Tests.cpp"
-	"CastUnderlyingTypeTests.cpp"
+	"ToUnderlyingTests.cpp"
 	"HeaderSkipTest.cpp"
 	"TestCDFeatureGatingTable.cpp"
 	"TestLDFFormat.cpp"

tests/dCommonTests/TestLDFFormat.cpp

@@ -27,7 +27,7 @@ TEST_F(LDFTests, LDFUTF16Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ((static_cast<LDFData<std::u16string>*>(data.get()))->GetValue(), u"IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -37,7 +37,7 @@ TEST_F(LDFTests, LDFUTF16EmptyTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -47,7 +47,7 @@ TEST_F(LDFTests, LDFUTF16ColonTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"::");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"::");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -57,7 +57,7 @@ TEST_F(LDFTests, LDFUTF16EqualsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"==");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"==");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -66,7 +66,7 @@ TEST_F(LDFTests, LDFS32Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_S32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<int32_t>*)data.get())->GetValue(), -15);
+	ASSERT_EQ(static_cast<LDFData<int32_t>*>(data.get())->GetValue(), -15);
 	ASSERT_EQ(data->GetString(), "KEY=1:-15");
 }
 TEST_F(LDFTests, LDFU32Test) {
@@ -74,7 +74,7 @@ TEST_F(LDFTests, LDFU32Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=5:15");
 }
 
@@ -83,7 +83,7 @@ TEST_F(LDFTests, LDFU32TrueTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 1);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 1);
 	ASSERT_EQ(data->GetString(), "KEY=5:1");
 }
 
@@ -92,7 +92,7 @@ TEST_F(LDFTests, LDFU32FalseTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 0);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 0);
 	ASSERT_EQ(data->GetString(), "KEY=5:0");
 }
 
@@ -103,7 +103,7 @@ TEST_F(LDFTests, LDFFloatTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_FLOAT);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<float>*)data.get())->GetValue(), 15.5f);
+	ASSERT_EQ(static_cast<LDFData<float>*>(data.get())->GetValue(), 15.5f);
 	ASSERT_EQ(data->GetString().find("KEY=3:15.5"), 0);
 }
 
@@ -112,7 +112,7 @@ TEST_F(LDFTests, LDFDoubleTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_DOUBLE);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<double>*)data.get())->GetValue(), 15.5);
+	ASSERT_EQ(static_cast<LDFData<double>*>(data.get())->GetValue(), 15.5);
 	ASSERT_EQ(data->GetString().find("KEY=4:15.5"), 0);
 }
 
@@ -122,7 +122,7 @@ TEST_F(LDFTests, LDFBoolTrueTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), true);
 	ASSERT_EQ(data->GetString(), "KEY=7:1");
 }
 
@@ -131,7 +131,7 @@ TEST_F(LDFTests, LDFBoolFalseTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), false);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), false);
 	ASSERT_EQ(data->GetString(), "KEY=7:0");
 }
 
@@ -140,7 +140,7 @@ TEST_F(LDFTests, LDFBoolIntTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), true);
 	ASSERT_EQ(data->GetString(), "KEY=7:1");
 }
 
@@ -149,7 +149,7 @@ TEST_F(LDFTests, LDFU64Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U64);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint64_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=8:15");
 }
 
@@ -158,7 +158,7 @@ TEST_F(LDFTests, LDFLWOOBJIDTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_OBJID);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint64_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=9:15");
 }
 
@@ -168,7 +168,7 @@ TEST_F(LDFTests, LDFUTF8Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -178,7 +178,7 @@ TEST_F(LDFTests, LDFUTF8EmptyTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -188,7 +188,7 @@ TEST_F(LDFTests, LDFUTF8ColonsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "::");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "::");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 TEST_F(LDFTests, LDFUTF8EqualsTest) {
@@ -197,7 +197,7 @@ TEST_F(LDFTests, LDFUTF8EqualsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "==");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "==");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 

tests/dCommonTests/ToUnderlyingTests.cpp

@@ -7,13 +7,13 @@
 #include "eWorldMessageType.h"
 
 #define ASSERT_TYPE_EQ(TYPE, ENUM)\
-	ASSERT_TRUE(typeid(TYPE) == typeid(GeneralUtils::CastUnderlyingType(static_cast<ENUM>(0))));
+	ASSERT_TRUE(typeid(TYPE) == typeid(GeneralUtils::ToUnderlying(static_cast<ENUM>(0))));
 
 #define ASSERT_TYPE_NE(TYPE, ENUM)\
-	ASSERT_FALSE(typeid(TYPE) == typeid(GeneralUtils::CastUnderlyingType(static_cast<ENUM>(0))));
+	ASSERT_FALSE(typeid(TYPE) == typeid(GeneralUtils::ToUnderlying(static_cast<ENUM>(0))));
 	
 // Verify that the underlying enum types are being cast correctly
-TEST(CastUnderlyingTypeTests, VerifyCastUnderlyingType) {
+TEST(ToUnderlyingTests, VerifyToUnderlying) {
 	ASSERT_TYPE_EQ(uint8_t, eGameMasterLevel);
 	ASSERT_TYPE_EQ(uint16_t, eGameMessageType);
 	ASSERT_TYPE_EQ(uint32_t, eWorldMessageType)

tests/dGameTests/dGameMessagesTests/GameMessageTests.cpp

@@ -87,7 +87,7 @@ TEST_F(GameMessageTests, SendBlueprintLoadItemResponse) {
 
 TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
 	auto data = ReadFromFile("addStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddStripMessage addStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_FLOAT_EQ(addStrip.GetPosition().GetX(), 50.65);
 	ASSERT_FLOAT_EQ(addStrip.GetPosition().GetY(), 178.05);
@@ -102,7 +102,7 @@ TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
 	auto data = ReadFromFile("removeStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RemoveStripMessage removeStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStripId()), 1);
 	ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStateId()), 0);
@@ -111,7 +111,7 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
 	auto data = ReadFromFile("mergeStrips");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	MergeStripsMessage mergeStrips(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(mergeStrips.GetSourceActionContext().GetStripId(), 2);
 	ASSERT_EQ(mergeStrips.GetDestinationActionContext().GetStripId(), 0);
@@ -123,7 +123,7 @@ TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
 
 TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
 	auto data = ReadFromFile("splitStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	SplitStripMessage splitStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(splitStrip.GetBehaviorId(), -1);
 
@@ -138,7 +138,7 @@ TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
 	auto data = ReadFromFile("updateStripUI");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	UpdateStripUiMessage updateStripUi(ReadArrayFromBitStream(inStream));
 	ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetX(), 116.65);
 	ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetY(), 35.35);
@@ -149,7 +149,7 @@ TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
 
 TEST_F(GameMessageTests, ControlBehaviorAddAction) {
 	auto data = ReadFromFile("addAction");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddActionMessage addAction(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(addAction.GetActionIndex(), 3);
 	ASSERT_EQ(addAction.GetActionContext().GetStripId(), 0);
@@ -163,7 +163,7 @@ TEST_F(GameMessageTests, ControlBehaviorAddAction) {
 
 TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
 	auto data = ReadFromFile("migrateActions");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	MigrateActionsMessage migrateActions(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(migrateActions.GetSrcActionIndex(), 1);
 	ASSERT_EQ(migrateActions.GetDstActionIndex(), 2);
@@ -176,7 +176,7 @@ TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
 
 TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
 	auto data = ReadFromFile("rearrangeStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RearrangeStripMessage rearrangeStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(rearrangeStrip.GetSrcActionIndex(), 2);
 	ASSERT_EQ(rearrangeStrip.GetDstActionIndex(), 1);
@@ -187,7 +187,7 @@ TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorAdd) {
 	auto data = ReadFromFile("add");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddMessage add(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(add.GetBehaviorId(), 10446);
 	ASSERT_EQ(add.GetBehaviorIndex(), 0);
@@ -195,7 +195,7 @@ TEST_F(GameMessageTests, ControlBehaviorAdd) {
 
 TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
 	auto data = ReadFromFile("removeActions");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RemoveActionsMessage removeActions(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(removeActions.GetBehaviorId(), -1);
 	ASSERT_EQ(removeActions.GetActionIndex(), 1);
@@ -205,7 +205,7 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
 
 TEST_F(GameMessageTests, ControlBehaviorRename) {
 	auto data = ReadFromFile("rename");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RenameMessage rename(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(rename.GetName(), "test");
 	ASSERT_EQ(rename.GetBehaviorId(), BehaviorMessageBase::DefaultBehaviorId);
@@ -213,7 +213,7 @@ TEST_F(GameMessageTests, ControlBehaviorRename) {
 
 TEST_F(GameMessageTests, ControlBehaviorUpdateAction) {
 	auto data = ReadFromFile("updateAction");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	UpdateActionMessage updateAction(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(updateAction.GetAction().GetType(), "FlyDown");
 	ASSERT_EQ(updateAction.GetAction().GetValueParameterName(), "Distance");

tests/dGameTests/dGameMessagesTests/LegacyGameMessageTests.cpp

@@ -2,297 +2,297 @@
 #include "eGameMessageType.h"
 
 TEST(LegacyGameMessageTests, AssertLegacyGmValues) {
-	EXPECT_EQ(eGameMessageType::TELEPORT, (eGameMessageType)19);
+	EXPECT_EQ(eGameMessageType::TELEPORT, static_cast<eGameMessageType>(19));
-	EXPECT_EQ(eGameMessageType::SET_PLAYER_CONTROL_SCHEME, (eGameMessageType)26);
+	EXPECT_EQ(eGameMessageType::SET_PLAYER_CONTROL_SCHEME, static_cast<eGameMessageType>(26));
-	EXPECT_EQ(eGameMessageType::DROP_CLIENT_LOOT, (eGameMessageType)30);
+	EXPECT_EQ(eGameMessageType::DROP_CLIENT_LOOT, static_cast<eGameMessageType>(30));
-	EXPECT_EQ(eGameMessageType::DIE, (eGameMessageType)37);
+	EXPECT_EQ(eGameMessageType::DIE, static_cast<eGameMessageType>(37));
-	EXPECT_EQ(eGameMessageType::REQUEST_DIE, (eGameMessageType)38);
+	EXPECT_EQ(eGameMessageType::REQUEST_DIE, static_cast<eGameMessageType>(38));
-	EXPECT_EQ(eGameMessageType::PLAY_EMOTE, (eGameMessageType)41);
+	EXPECT_EQ(eGameMessageType::PLAY_EMOTE, static_cast<eGameMessageType>(41));
-	EXPECT_EQ(eGameMessageType::PLAY_ANIMATION, (eGameMessageType)43);
+	EXPECT_EQ(eGameMessageType::PLAY_ANIMATION, static_cast<eGameMessageType>(43));
-	EXPECT_EQ(eGameMessageType::CONTROL_BEHAVIORS, (eGameMessageType)48);
+	EXPECT_EQ(eGameMessageType::CONTROL_BEHAVIORS, static_cast<eGameMessageType>(48));
-	EXPECT_EQ(eGameMessageType::SET_NAME, (eGameMessageType)72);
+	EXPECT_EQ(eGameMessageType::SET_NAME, static_cast<eGameMessageType>(72));
-	EXPECT_EQ(eGameMessageType::ECHO_START_SKILL, (eGameMessageType)118);
+	EXPECT_EQ(eGameMessageType::ECHO_START_SKILL, static_cast<eGameMessageType>(118));
-	EXPECT_EQ(eGameMessageType::START_SKILL, (eGameMessageType)119);
+	EXPECT_EQ(eGameMessageType::START_SKILL, static_cast<eGameMessageType>(119));
-	EXPECT_EQ(eGameMessageType::VERIFY_ACK, (eGameMessageType)121);
+	EXPECT_EQ(eGameMessageType::VERIFY_ACK, static_cast<eGameMessageType>(121));
-	EXPECT_EQ(eGameMessageType::ADD_SKILL, (eGameMessageType)127);
+	EXPECT_EQ(eGameMessageType::ADD_SKILL, static_cast<eGameMessageType>(127));
-	EXPECT_EQ(eGameMessageType::REMOVE_SKILL, (eGameMessageType)128);
+	EXPECT_EQ(eGameMessageType::REMOVE_SKILL, static_cast<eGameMessageType>(128));
-	EXPECT_EQ(eGameMessageType::SET_CURRENCY, (eGameMessageType)133);
+	EXPECT_EQ(eGameMessageType::SET_CURRENCY, static_cast<eGameMessageType>(133));
-	EXPECT_EQ(eGameMessageType::PICKUP_CURRENCY, (eGameMessageType)137);
+	EXPECT_EQ(eGameMessageType::PICKUP_CURRENCY, static_cast<eGameMessageType>(137));
-	EXPECT_EQ(eGameMessageType::PICKUP_ITEM, (eGameMessageType)139);
+	EXPECT_EQ(eGameMessageType::PICKUP_ITEM, static_cast<eGameMessageType>(139));
-	EXPECT_EQ(eGameMessageType::TEAM_PICKUP_ITEM, (eGameMessageType)140);
+	EXPECT_EQ(eGameMessageType::TEAM_PICKUP_ITEM, static_cast<eGameMessageType>(140));
-	EXPECT_EQ(eGameMessageType::PLAY_FX_EFFECT, (eGameMessageType)154);
+	EXPECT_EQ(eGameMessageType::PLAY_FX_EFFECT, static_cast<eGameMessageType>(154));
-	EXPECT_EQ(eGameMessageType::STOP_FX_EFFECT, (eGameMessageType)155);
+	EXPECT_EQ(eGameMessageType::STOP_FX_EFFECT, static_cast<eGameMessageType>(155));
-	EXPECT_EQ(eGameMessageType::REQUEST_RESURRECT, (eGameMessageType)159);
+	EXPECT_EQ(eGameMessageType::REQUEST_RESURRECT, static_cast<eGameMessageType>(159));
-	EXPECT_EQ(eGameMessageType::RESURRECT, (eGameMessageType)160);
+	EXPECT_EQ(eGameMessageType::RESURRECT, static_cast<eGameMessageType>(160));
-	EXPECT_EQ(eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE, (eGameMessageType)191);
+	EXPECT_EQ(eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE, static_cast<eGameMessageType>(191));
-	EXPECT_EQ(eGameMessageType::POP_EQUIPPED_ITEMS_STATE, (eGameMessageType)192);
+	EXPECT_EQ(eGameMessageType::POP_EQUIPPED_ITEMS_STATE, static_cast<eGameMessageType>(192));
-	EXPECT_EQ(eGameMessageType::SET_GM_LEVEL, (eGameMessageType)193);
+	EXPECT_EQ(eGameMessageType::SET_GM_LEVEL, static_cast<eGameMessageType>(193));
-	EXPECT_EQ(eGameMessageType::SET_STUNNED, (eGameMessageType)198);
+	EXPECT_EQ(eGameMessageType::SET_STUNNED, static_cast<eGameMessageType>(198));
-	EXPECT_EQ(eGameMessageType::SET_STUN_IMMUNITY, (eGameMessageType)200);
+	EXPECT_EQ(eGameMessageType::SET_STUN_IMMUNITY, static_cast<eGameMessageType>(200));
-	EXPECT_EQ(eGameMessageType::KNOCKBACK, (eGameMessageType)202);
+	EXPECT_EQ(eGameMessageType::KNOCKBACK, static_cast<eGameMessageType>(202));
-	EXPECT_EQ(eGameMessageType::REBUILD_CANCEL, (eGameMessageType)209);
+	EXPECT_EQ(eGameMessageType::REBUILD_CANCEL, static_cast<eGameMessageType>(209));
-	EXPECT_EQ(eGameMessageType::ENABLE_REBUILD, (eGameMessageType)213);
+	EXPECT_EQ(eGameMessageType::ENABLE_REBUILD, static_cast<eGameMessageType>(213));
-	EXPECT_EQ(eGameMessageType::MOVE_ITEM_IN_INVENTORY, (eGameMessageType)224);
+	EXPECT_EQ(eGameMessageType::MOVE_ITEM_IN_INVENTORY, static_cast<eGameMessageType>(224));
-	EXPECT_EQ(eGameMessageType::ADD_ITEM_TO_INVENTORY_CLIENT_SYNC, (eGameMessageType)227);
+	EXPECT_EQ(eGameMessageType::ADD_ITEM_TO_INVENTORY_CLIENT_SYNC, static_cast<eGameMessageType>(227));
-	EXPECT_EQ(eGameMessageType::REMOVE_ITEM_FROM_INVENTORY, (eGameMessageType)230);
+	EXPECT_EQ(eGameMessageType::REMOVE_ITEM_FROM_INVENTORY, static_cast<eGameMessageType>(230));
-	EXPECT_EQ(eGameMessageType::EQUIP_INVENTORY, (eGameMessageType)231);
+	EXPECT_EQ(eGameMessageType::EQUIP_INVENTORY, static_cast<eGameMessageType>(231));
-	EXPECT_EQ(eGameMessageType::UN_EQUIP_INVENTORY, (eGameMessageType)233);
+	EXPECT_EQ(eGameMessageType::UN_EQUIP_INVENTORY, static_cast<eGameMessageType>(233));
-	EXPECT_EQ(eGameMessageType::OFFER_MISSION, (eGameMessageType)248);
+	EXPECT_EQ(eGameMessageType::OFFER_MISSION, static_cast<eGameMessageType>(248));
-	EXPECT_EQ(eGameMessageType::RESPOND_TO_MISSION, (eGameMessageType)249);
+	EXPECT_EQ(eGameMessageType::RESPOND_TO_MISSION, static_cast<eGameMessageType>(249));
-	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION, (eGameMessageType)254);
+	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION, static_cast<eGameMessageType>(254));
-	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION_TASK, (eGameMessageType)255);
+	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION_TASK, static_cast<eGameMessageType>(255));
-	EXPECT_EQ(eGameMessageType::REBUILD_NOTIFY_STATE, (eGameMessageType)336);
+	EXPECT_EQ(eGameMessageType::REBUILD_NOTIFY_STATE, static_cast<eGameMessageType>(336));
-	EXPECT_EQ(eGameMessageType::TERMINATE_INTERACTION, (eGameMessageType)357);
+	EXPECT_EQ(eGameMessageType::TERMINATE_INTERACTION, static_cast<eGameMessageType>(357));
-	EXPECT_EQ(eGameMessageType::SERVER_TERMINATE_INTERACTION, (eGameMessageType)358);
+	EXPECT_EQ(eGameMessageType::SERVER_TERMINATE_INTERACTION, static_cast<eGameMessageType>(358));
-	EXPECT_EQ(eGameMessageType::REQUEST_USE, (eGameMessageType)364);
+	EXPECT_EQ(eGameMessageType::REQUEST_USE, static_cast<eGameMessageType>(364));
-	EXPECT_EQ(eGameMessageType::VENDOR_OPEN_WINDOW, (eGameMessageType)369);
+	EXPECT_EQ(eGameMessageType::VENDOR_OPEN_WINDOW, static_cast<eGameMessageType>(369));
-	EXPECT_EQ(eGameMessageType::BUY_FROM_VENDOR, (eGameMessageType)373);
+	EXPECT_EQ(eGameMessageType::BUY_FROM_VENDOR, static_cast<eGameMessageType>(373));
-	EXPECT_EQ(eGameMessageType::SELL_TO_VENDOR, (eGameMessageType)374);
+	EXPECT_EQ(eGameMessageType::SELL_TO_VENDOR, static_cast<eGameMessageType>(374));
-	EXPECT_EQ(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG, (eGameMessageType)383);
+	EXPECT_EQ(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG, static_cast<eGameMessageType>(383));
-	EXPECT_EQ(eGameMessageType::SET_INVENTORY_SIZE, (eGameMessageType)389);
+	EXPECT_EQ(eGameMessageType::SET_INVENTORY_SIZE, static_cast<eGameMessageType>(389));
-	EXPECT_EQ(eGameMessageType::ACKNOWLEDGE_POSSESSION, (eGameMessageType)391);
+	EXPECT_EQ(eGameMessageType::ACKNOWLEDGE_POSSESSION, static_cast<eGameMessageType>(391));
-	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_PARAMS, (eGameMessageType)400);
+	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_PARAMS, static_cast<eGameMessageType>(400));
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_START_STOP, (eGameMessageType)402);
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_START_STOP, static_cast<eGameMessageType>(402));
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_ENTER, (eGameMessageType)403);
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_ENTER, static_cast<eGameMessageType>(403));
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_EXIT, (eGameMessageType)404);
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_EXIT, static_cast<eGameMessageType>(404));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_ENTER, (eGameMessageType)405);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_ENTER, static_cast<eGameMessageType>(405));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_EXIT, (eGameMessageType)406);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_EXIT, static_cast<eGameMessageType>(406));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_START, (eGameMessageType)407);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_START, static_cast<eGameMessageType>(407));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_STOP, (eGameMessageType)408);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_STOP, static_cast<eGameMessageType>(408));
-	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_CLIENT_AIM_UPDATE, (eGameMessageType)409);
+	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_CLIENT_AIM_UPDATE, static_cast<eGameMessageType>(409));
-	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_FIRE, (eGameMessageType)411);
+	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_FIRE, static_cast<eGameMessageType>(411));
-	EXPECT_EQ(eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE, (eGameMessageType)416);
+	EXPECT_EQ(eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE, static_cast<eGameMessageType>(416));
-	EXPECT_EQ(eGameMessageType::VENDOR_STATUS_UPDATE, (eGameMessageType)417);
+	EXPECT_EQ(eGameMessageType::VENDOR_STATUS_UPDATE, static_cast<eGameMessageType>(417));
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE, (eGameMessageType)425);
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE, static_cast<eGameMessageType>(425));
-	EXPECT_EQ(eGameMessageType::CONSUME_CLIENT_ITEM, (eGameMessageType)427);
+	EXPECT_EQ(eGameMessageType::CONSUME_CLIENT_ITEM, static_cast<eGameMessageType>(427));
-	EXPECT_EQ(eGameMessageType::CLIENT_ITEM_CONSUMED, (eGameMessageType)428);
+	EXPECT_EQ(eGameMessageType::CLIENT_ITEM_CONSUMED, static_cast<eGameMessageType>(428));
-	EXPECT_EQ(eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION, (eGameMessageType)448);
+	EXPECT_EQ(eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION, static_cast<eGameMessageType>(448));
-	EXPECT_EQ(eGameMessageType::SET_FLAG, (eGameMessageType)471);
+	EXPECT_EQ(eGameMessageType::SET_FLAG, static_cast<eGameMessageType>(471));
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FLAG_CHANGE, (eGameMessageType)472);
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FLAG_CHANGE, static_cast<eGameMessageType>(472));
-	EXPECT_EQ(eGameMessageType::VENDOR_TRANSACTION_RESULT, (eGameMessageType)476);
+	EXPECT_EQ(eGameMessageType::VENDOR_TRANSACTION_RESULT, static_cast<eGameMessageType>(476));
-	EXPECT_EQ(eGameMessageType::HAS_BEEN_COLLECTED, (eGameMessageType)486);
+	EXPECT_EQ(eGameMessageType::HAS_BEEN_COLLECTED, static_cast<eGameMessageType>(486));
-	EXPECT_EQ(eGameMessageType::DISPLAY_CHAT_BUBBLE, (eGameMessageType)495);
+	EXPECT_EQ(eGameMessageType::DISPLAY_CHAT_BUBBLE, static_cast<eGameMessageType>(495));
-	EXPECT_EQ(eGameMessageType::SPAWN_PET, (eGameMessageType)498);
+	EXPECT_EQ(eGameMessageType::SPAWN_PET, static_cast<eGameMessageType>(498));
-	EXPECT_EQ(eGameMessageType::DESPAWN_PET, (eGameMessageType)499);
+	EXPECT_EQ(eGameMessageType::DESPAWN_PET, static_cast<eGameMessageType>(499));
-	EXPECT_EQ(eGameMessageType::PLAYER_LOADED, (eGameMessageType)505);
+	EXPECT_EQ(eGameMessageType::PLAYER_LOADED, static_cast<eGameMessageType>(505));
-	EXPECT_EQ(eGameMessageType::PLAYER_READY, (eGameMessageType)509);
+	EXPECT_EQ(eGameMessageType::PLAYER_READY, static_cast<eGameMessageType>(509));
-	EXPECT_EQ(eGameMessageType::REQUEST_LINKED_MISSION, (eGameMessageType)515);
+	EXPECT_EQ(eGameMessageType::REQUEST_LINKED_MISSION, static_cast<eGameMessageType>(515));
-	EXPECT_EQ(eGameMessageType::INVALID_ZONE_TRANSFER_LIST, (eGameMessageType)519);
+	EXPECT_EQ(eGameMessageType::INVALID_ZONE_TRANSFER_LIST, static_cast<eGameMessageType>(519));
-	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_OK, (eGameMessageType)520);
+	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_OK, static_cast<eGameMessageType>(520));
-	EXPECT_EQ(eGameMessageType::DISPLAY_MESSAGE_BOX, (eGameMessageType)529);
+	EXPECT_EQ(eGameMessageType::DISPLAY_MESSAGE_BOX, static_cast<eGameMessageType>(529));
-	EXPECT_EQ(eGameMessageType::MESSAGE_BOX_RESPOND, (eGameMessageType)530);
+	EXPECT_EQ(eGameMessageType::MESSAGE_BOX_RESPOND, static_cast<eGameMessageType>(530));
-	EXPECT_EQ(eGameMessageType::CHOICE_BOX_RESPOND, (eGameMessageType)531);
+	EXPECT_EQ(eGameMessageType::CHOICE_BOX_RESPOND, static_cast<eGameMessageType>(531));
-	EXPECT_EQ(eGameMessageType::SMASH, (eGameMessageType)537);
+	EXPECT_EQ(eGameMessageType::SMASH, static_cast<eGameMessageType>(537));
-	EXPECT_EQ(eGameMessageType::UN_SMASH, (eGameMessageType)538);
+	EXPECT_EQ(eGameMessageType::UN_SMASH, static_cast<eGameMessageType>(538));
-	EXPECT_EQ(eGameMessageType::PLACE_MODEL_RESPONSE, (eGameMessageType)547);
+	EXPECT_EQ(eGameMessageType::PLACE_MODEL_RESPONSE, static_cast<eGameMessageType>(547));
-	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_RETICULE_EFFECT, (eGameMessageType)546);
+	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_RETICULE_EFFECT, static_cast<eGameMessageType>(546));
-	EXPECT_EQ(eGameMessageType::SET_JET_PACK_MODE, (eGameMessageType)561);
+	EXPECT_EQ(eGameMessageType::SET_JET_PACK_MODE, static_cast<eGameMessageType>(561));
-	EXPECT_EQ(eGameMessageType::REGISTER_PET_ID, (eGameMessageType)565);
+	EXPECT_EQ(eGameMessageType::REGISTER_PET_ID, static_cast<eGameMessageType>(565));
-	EXPECT_EQ(eGameMessageType::REGISTER_PET_DBID, (eGameMessageType)566);
+	EXPECT_EQ(eGameMessageType::REGISTER_PET_DBID, static_cast<eGameMessageType>(566));
-	EXPECT_EQ(eGameMessageType::SHOW_ACTIVITY_COUNTDOWN, (eGameMessageType)568);
+	EXPECT_EQ(eGameMessageType::SHOW_ACTIVITY_COUNTDOWN, static_cast<eGameMessageType>(568));
-	EXPECT_EQ(eGameMessageType::START_ACTIVITY_TIME, (eGameMessageType)576);
+	EXPECT_EQ(eGameMessageType::START_ACTIVITY_TIME, static_cast<eGameMessageType>(576));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_PAUSE, (eGameMessageType)602);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_PAUSE, static_cast<eGameMessageType>(602));
-	EXPECT_EQ(eGameMessageType::USE_NON_EQUIPMENT_ITEM, (eGameMessageType)603);
+	EXPECT_EQ(eGameMessageType::USE_NON_EQUIPMENT_ITEM, static_cast<eGameMessageType>(603));
-	EXPECT_EQ(eGameMessageType::USE_ITEM_RESULT, (eGameMessageType)607);
+	EXPECT_EQ(eGameMessageType::USE_ITEM_RESULT, static_cast<eGameMessageType>(607));
-	EXPECT_EQ(eGameMessageType::COMMAND_PET, (eGameMessageType)640);
+	EXPECT_EQ(eGameMessageType::COMMAND_PET, static_cast<eGameMessageType>(640));
-	EXPECT_EQ(eGameMessageType::PET_RESPONSE, (eGameMessageType)641);
+	EXPECT_EQ(eGameMessageType::PET_RESPONSE, static_cast<eGameMessageType>(641));
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA, (eGameMessageType)648);
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA, static_cast<eGameMessageType>(648));
-	EXPECT_EQ(eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA, (eGameMessageType)649);
+	EXPECT_EQ(eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA, static_cast<eGameMessageType>(649));
-	EXPECT_EQ(eGameMessageType::NOTIFY_OBJECT, (eGameMessageType)656);
+	EXPECT_EQ(eGameMessageType::NOTIFY_OBJECT, static_cast<eGameMessageType>(656));
-	EXPECT_EQ(eGameMessageType::CLIENT_NOTIFY_PET, (eGameMessageType)659);
+	EXPECT_EQ(eGameMessageType::CLIENT_NOTIFY_PET, static_cast<eGameMessageType>(659));
-	EXPECT_EQ(eGameMessageType::NOTIFY_PET, (eGameMessageType)660);
+	EXPECT_EQ(eGameMessageType::NOTIFY_PET, static_cast<eGameMessageType>(660));
-	EXPECT_EQ(eGameMessageType::NOTIFY_PET_TAMING_MINIGAME, (eGameMessageType)661);
+	EXPECT_EQ(eGameMessageType::NOTIFY_PET_TAMING_MINIGAME, static_cast<eGameMessageType>(661));
-	EXPECT_EQ(eGameMessageType::START_SERVER_PET_MINIGAME_TIMER, (eGameMessageType)662);
+	EXPECT_EQ(eGameMessageType::START_SERVER_PET_MINIGAME_TIMER, static_cast<eGameMessageType>(662));
-	EXPECT_EQ(eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME, (eGameMessageType)663);
+	EXPECT_EQ(eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME, static_cast<eGameMessageType>(663));
-	EXPECT_EQ(eGameMessageType::PET_NAME_CHANGED, (eGameMessageType)686);
+	EXPECT_EQ(eGameMessageType::PET_NAME_CHANGED, static_cast<eGameMessageType>(686));
-	EXPECT_EQ(eGameMessageType::PET_TAMING_MINIGAME_RESULT, (eGameMessageType)667);
+	EXPECT_EQ(eGameMessageType::PET_TAMING_MINIGAME_RESULT, static_cast<eGameMessageType>(667));
-	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD_RESULT, (eGameMessageType)668);
+	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD_RESULT, static_cast<eGameMessageType>(668));
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS, (eGameMessageType)673);
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS, static_cast<eGameMessageType>(673));
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_MODEL_LOADED_ON_SERVER, (eGameMessageType)674);
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_MODEL_LOADED_ON_SERVER, static_cast<eGameMessageType>(674));
-	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF, (eGameMessageType)678);
+	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF, static_cast<eGameMessageType>(678));
-	EXPECT_EQ(eGameMessageType::DECTIVATE_BUBBLE_BUFF, (eGameMessageType)679);
+	EXPECT_EQ(eGameMessageType::DECTIVATE_BUBBLE_BUFF, static_cast<eGameMessageType>(679));
-	EXPECT_EQ(eGameMessageType::ADD_PET_TO_PLAYER, (eGameMessageType)681);
+	EXPECT_EQ(eGameMessageType::ADD_PET_TO_PLAYER, static_cast<eGameMessageType>(681));
-	EXPECT_EQ(eGameMessageType::REQUEST_SET_PET_NAME, (eGameMessageType)683);
+	EXPECT_EQ(eGameMessageType::REQUEST_SET_PET_NAME, static_cast<eGameMessageType>(683));
-	EXPECT_EQ(eGameMessageType::SET_PET_NAME, (eGameMessageType)684);
+	EXPECT_EQ(eGameMessageType::SET_PET_NAME, static_cast<eGameMessageType>(684));
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_PUZZLE_SELECTED, (eGameMessageType)675);
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_PUZZLE_SELECTED, static_cast<eGameMessageType>(675));
-	EXPECT_EQ(eGameMessageType::SHOW_PET_ACTION_BUTTON, (eGameMessageType)692);
+	EXPECT_EQ(eGameMessageType::SHOW_PET_ACTION_BUTTON, static_cast<eGameMessageType>(692));
-	EXPECT_EQ(eGameMessageType::SET_EMOTE_LOCK_STATE, (eGameMessageType)693);
+	EXPECT_EQ(eGameMessageType::SET_EMOTE_LOCK_STATE, static_cast<eGameMessageType>(693));
-	EXPECT_EQ(eGameMessageType::USE_ITEM_REQUIREMENTS_RESPONSE, (eGameMessageType)703);
+	EXPECT_EQ(eGameMessageType::USE_ITEM_REQUIREMENTS_RESPONSE, static_cast<eGameMessageType>(703));
-	EXPECT_EQ(eGameMessageType::PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT, (eGameMessageType)713);
+	EXPECT_EQ(eGameMessageType::PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT, static_cast<eGameMessageType>(713));
-	EXPECT_EQ(eGameMessageType::DOWNLOAD_PROPERTY_DATA, (eGameMessageType)716);
+	EXPECT_EQ(eGameMessageType::DOWNLOAD_PROPERTY_DATA, static_cast<eGameMessageType>(716));
-	EXPECT_EQ(eGameMessageType::QUERY_PROPERTY_DATA, (eGameMessageType)717);
+	EXPECT_EQ(eGameMessageType::QUERY_PROPERTY_DATA, static_cast<eGameMessageType>(717));
-	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_BEGIN, (eGameMessageType)724);
+	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_BEGIN, static_cast<eGameMessageType>(724));
-	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_END, (eGameMessageType)725);
+	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_END, static_cast<eGameMessageType>(725));
-	EXPECT_EQ(eGameMessageType::IS_MINIFIG_IN_A_BUBBLE, (eGameMessageType)729);
+	EXPECT_EQ(eGameMessageType::IS_MINIFIG_IN_A_BUBBLE, static_cast<eGameMessageType>(729));
-	EXPECT_EQ(eGameMessageType::START_PATHING, (eGameMessageType)733);
+	EXPECT_EQ(eGameMessageType::START_PATHING, static_cast<eGameMessageType>(733));
-	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF_FROM_SERVER, (eGameMessageType)734);
+	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF_FROM_SERVER, static_cast<eGameMessageType>(734));
-	EXPECT_EQ(eGameMessageType::DEACTIVATE_BUBBLE_BUFF_FROM_SERVER, (eGameMessageType)735);
+	EXPECT_EQ(eGameMessageType::DEACTIVATE_BUBBLE_BUFF_FROM_SERVER, static_cast<eGameMessageType>(735));
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_ZONE_OBJECT, (eGameMessageType)737);
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_ZONE_OBJECT, static_cast<eGameMessageType>(737));
-	EXPECT_EQ(eGameMessageType::UPDATE_REPUTATION, (eGameMessageType)746);
+	EXPECT_EQ(eGameMessageType::UPDATE_REPUTATION, static_cast<eGameMessageType>(746));
-	EXPECT_EQ(eGameMessageType::PROPERTY_RENTAL_RESPONSE, (eGameMessageType)750);
+	EXPECT_EQ(eGameMessageType::PROPERTY_RENTAL_RESPONSE, static_cast<eGameMessageType>(750));
-	EXPECT_EQ(eGameMessageType::REQUEST_PLATFORM_RESYNC, (eGameMessageType)760);
+	EXPECT_EQ(eGameMessageType::REQUEST_PLATFORM_RESYNC, static_cast<eGameMessageType>(760));
-	EXPECT_EQ(eGameMessageType::PLATFORM_RESYNC, (eGameMessageType)761);
+	EXPECT_EQ(eGameMessageType::PLATFORM_RESYNC, static_cast<eGameMessageType>(761));
-	EXPECT_EQ(eGameMessageType::PLAY_CINEMATIC, (eGameMessageType)762);
+	EXPECT_EQ(eGameMessageType::PLAY_CINEMATIC, static_cast<eGameMessageType>(762));
-	EXPECT_EQ(eGameMessageType::END_CINEMATIC, (eGameMessageType)763);
+	EXPECT_EQ(eGameMessageType::END_CINEMATIC, static_cast<eGameMessageType>(763));
-	EXPECT_EQ(eGameMessageType::CINEMATIC_UPDATE, (eGameMessageType)764);
+	EXPECT_EQ(eGameMessageType::CINEMATIC_UPDATE, static_cast<eGameMessageType>(764));
-	EXPECT_EQ(eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE, (eGameMessageType)767);
+	EXPECT_EQ(eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE, static_cast<eGameMessageType>(767));
-	EXPECT_EQ(eGameMessageType::SET_GHOST_REFERENCE_POSITION, (eGameMessageType)768);
+	EXPECT_EQ(eGameMessageType::SET_GHOST_REFERENCE_POSITION, static_cast<eGameMessageType>(768));
-	EXPECT_EQ(eGameMessageType::FIRE_EVENT_SERVER_SIDE, (eGameMessageType)770);
+	EXPECT_EQ(eGameMessageType::FIRE_EVENT_SERVER_SIDE, static_cast<eGameMessageType>(770));
-	EXPECT_EQ(eGameMessageType::SCRIPT_NETWORK_VAR_UPDATE, (eGameMessageType)781);
+	EXPECT_EQ(eGameMessageType::SCRIPT_NETWORK_VAR_UPDATE, static_cast<eGameMessageType>(781));
-	EXPECT_EQ(eGameMessageType::UPDATE_MODEL_FROM_CLIENT, (eGameMessageType)793);
+	EXPECT_EQ(eGameMessageType::UPDATE_MODEL_FROM_CLIENT, static_cast<eGameMessageType>(793));
-	EXPECT_EQ(eGameMessageType::DELETE_MODEL_FROM_CLIENT, (eGameMessageType)794);
+	EXPECT_EQ(eGameMessageType::DELETE_MODEL_FROM_CLIENT, static_cast<eGameMessageType>(794));
-	EXPECT_EQ(eGameMessageType::PLAY_ND_AUDIO_EMITTER, (eGameMessageType)821);
+	EXPECT_EQ(eGameMessageType::PLAY_ND_AUDIO_EMITTER, static_cast<eGameMessageType>(821));
-	EXPECT_EQ(eGameMessageType::PLAY2_D_AMBIENT_SOUND, (eGameMessageType)831);
+	EXPECT_EQ(eGameMessageType::PLAY2_D_AMBIENT_SOUND, static_cast<eGameMessageType>(831));
-	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY1, (eGameMessageType)840);
+	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY1, static_cast<eGameMessageType>(840));
-	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY2, (eGameMessageType)841);
+	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY2, static_cast<eGameMessageType>(841));
-	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_SYNC, (eGameMessageType)842);
+	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_SYNC, static_cast<eGameMessageType>(842));
-	EXPECT_EQ(eGameMessageType::PROPERTY_SELECT_QUERY, (eGameMessageType)845);
+	EXPECT_EQ(eGameMessageType::PROPERTY_SELECT_QUERY, static_cast<eGameMessageType>(845));
-	EXPECT_EQ(eGameMessageType::PARSE_CHAT_MESSAGE, (eGameMessageType)850);
+	EXPECT_EQ(eGameMessageType::PARSE_CHAT_MESSAGE, static_cast<eGameMessageType>(850));
-	EXPECT_EQ(eGameMessageType::BROADCAST_TEXT_TO_CHATBOX, (eGameMessageType)858);
+	EXPECT_EQ(eGameMessageType::BROADCAST_TEXT_TO_CHATBOX, static_cast<eGameMessageType>(858));
-	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_MANAGEMENT, (eGameMessageType)860);
+	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_MANAGEMENT, static_cast<eGameMessageType>(860));
-	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_VENDOR, (eGameMessageType)861);
+	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_VENDOR, static_cast<eGameMessageType>(861));
-	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK, (eGameMessageType)863);
+	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK, static_cast<eGameMessageType>(863));
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REQUEST, (eGameMessageType)868);
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REQUEST, static_cast<eGameMessageType>(868));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REQUEST, (eGameMessageType)869);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REQUEST, static_cast<eGameMessageType>(869));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INVITE, (eGameMessageType)870);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INVITE, static_cast<eGameMessageType>(870));
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REPLY, (eGameMessageType)871);
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REPLY, static_cast<eGameMessageType>(871));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REPLY, (eGameMessageType)872);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REPLY, static_cast<eGameMessageType>(872));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INITIAL_REPLY, (eGameMessageType)873);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INITIAL_REPLY, static_cast<eGameMessageType>(873));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_FINAL_REPLY, (eGameMessageType)874);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_FINAL_REPLY, static_cast<eGameMessageType>(874));
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_UPDATE, (eGameMessageType)875);
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_UPDATE, static_cast<eGameMessageType>(875));
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_UPDATE, (eGameMessageType)876);
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_UPDATE, static_cast<eGameMessageType>(876));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_UPDATE, (eGameMessageType)877);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_UPDATE, static_cast<eGameMessageType>(877));
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_CANCEL, (eGameMessageType)878);
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_CANCEL, static_cast<eGameMessageType>(878));
-	EXPECT_EQ(eGameMessageType::CLIENT_SIDE_TRADE_CANCEL, (eGameMessageType)879);
+	EXPECT_EQ(eGameMessageType::CLIENT_SIDE_TRADE_CANCEL, static_cast<eGameMessageType>(879));
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_ACCEPT, (eGameMessageType)880);
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_ACCEPT, static_cast<eGameMessageType>(880));
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_ACCEPT, (eGameMessageType)881);
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_ACCEPT, static_cast<eGameMessageType>(881));
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_CANCEL, (eGameMessageType)882);
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_CANCEL, static_cast<eGameMessageType>(882));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_CANCEL, (eGameMessageType)883);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_CANCEL, static_cast<eGameMessageType>(883));
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_ACCEPT, (eGameMessageType)884);
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_ACCEPT, static_cast<eGameMessageType>(884));
-	EXPECT_EQ(eGameMessageType::READY_FOR_UPDATES, (eGameMessageType)888);
+	EXPECT_EQ(eGameMessageType::READY_FOR_UPDATES, static_cast<eGameMessageType>(888));
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_OBJECT, (eGameMessageType)905);
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_OBJECT, static_cast<eGameMessageType>(905));
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_POSITION, (eGameMessageType)906);
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_POSITION, static_cast<eGameMessageType>(906));
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_ANGLE, (eGameMessageType)907);
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_ANGLE, static_cast<eGameMessageType>(907));
-	EXPECT_EQ(eGameMessageType::BOUNCER_ACTIVE_STATUS, (eGameMessageType)942);
+	EXPECT_EQ(eGameMessageType::BOUNCER_ACTIVE_STATUS, static_cast<eGameMessageType>(942));
-	EXPECT_EQ(eGameMessageType::UN_USE_BBB_MODEL, (eGameMessageType)999);
+	EXPECT_EQ(eGameMessageType::UN_USE_BBB_MODEL, static_cast<eGameMessageType>(999));
-	EXPECT_EQ(eGameMessageType::BBB_LOAD_ITEM_REQUEST, (eGameMessageType)1000);
+	EXPECT_EQ(eGameMessageType::BBB_LOAD_ITEM_REQUEST, static_cast<eGameMessageType>(1000));
-	EXPECT_EQ(eGameMessageType::BBB_SAVE_REQUEST, (eGameMessageType)1001);
+	EXPECT_EQ(eGameMessageType::BBB_SAVE_REQUEST, static_cast<eGameMessageType>(1001));
-	EXPECT_EQ(eGameMessageType::BBB_SAVE_RESPONSE, (eGameMessageType)1005);
+	EXPECT_EQ(eGameMessageType::BBB_SAVE_RESPONSE, static_cast<eGameMessageType>(1005));
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_OBJECT, (eGameMessageType)1042);
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_OBJECT, static_cast<eGameMessageType>(1042));
-	EXPECT_EQ(eGameMessageType::DISPLAY_ZONE_SUMMARY, (eGameMessageType)1043);
+	EXPECT_EQ(eGameMessageType::DISPLAY_ZONE_SUMMARY, static_cast<eGameMessageType>(1043));
-	EXPECT_EQ(eGameMessageType::ZONE_SUMMARY_DISMISSED, (eGameMessageType)1044);
+	EXPECT_EQ(eGameMessageType::ZONE_SUMMARY_DISMISSED, static_cast<eGameMessageType>(1044));
-	EXPECT_EQ(eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST, (eGameMessageType)1053);
+	EXPECT_EQ(eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST, static_cast<eGameMessageType>(1053));
-	EXPECT_EQ(eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC, (eGameMessageType)1046);
+	EXPECT_EQ(eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC, static_cast<eGameMessageType>(1046));
-	EXPECT_EQ(eGameMessageType::START_BUILDING_WITH_ITEM, (eGameMessageType)1057);
+	EXPECT_EQ(eGameMessageType::START_BUILDING_WITH_ITEM, static_cast<eGameMessageType>(1057));
-	EXPECT_EQ(eGameMessageType::START_ARRANGING_WITH_ITEM, (eGameMessageType)1061);
+	EXPECT_EQ(eGameMessageType::START_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1061));
-	EXPECT_EQ(eGameMessageType::FINISH_ARRANGING_WITH_ITEM, (eGameMessageType)1062);
+	EXPECT_EQ(eGameMessageType::FINISH_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1062));
-	EXPECT_EQ(eGameMessageType::DONE_ARRANGING_WITH_ITEM, (eGameMessageType)1063);
+	EXPECT_EQ(eGameMessageType::DONE_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1063));
-	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE, (eGameMessageType)1068);
+	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE, static_cast<eGameMessageType>(1068));
-	EXPECT_EQ(eGameMessageType::BUILD_MODE_SET, (eGameMessageType)1069);
+	EXPECT_EQ(eGameMessageType::BUILD_MODE_SET, static_cast<eGameMessageType>(1069));
-	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE_CONFIRMED, (eGameMessageType)1073);
+	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE_CONFIRMED, static_cast<eGameMessageType>(1073));
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FAILED_PRECONDITION, (eGameMessageType)1081);
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FAILED_PRECONDITION, static_cast<eGameMessageType>(1081));
-	EXPECT_EQ(eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1093);
+	EXPECT_EQ(eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1093));
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_BEGIN, (eGameMessageType)1094);
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_BEGIN, static_cast<eGameMessageType>(1094));
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_END, (eGameMessageType)1095);
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_END, static_cast<eGameMessageType>(1095));
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP, (eGameMessageType)1096);
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP, static_cast<eGameMessageType>(1096));
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_FINISH, (eGameMessageType)1097);
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_FINISH, static_cast<eGameMessageType>(1097));
-	EXPECT_EQ(eGameMessageType::REPORT_BUG, (eGameMessageType)1198);
+	EXPECT_EQ(eGameMessageType::REPORT_BUG, static_cast<eGameMessageType>(1198));
-	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_CANCELLED, (eGameMessageType)1129);
+	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_CANCELLED, static_cast<eGameMessageType>(1129));
-	EXPECT_EQ(eGameMessageType::ECHO_SYNC_SKILL, (eGameMessageType)1144);
+	EXPECT_EQ(eGameMessageType::ECHO_SYNC_SKILL, static_cast<eGameMessageType>(1144));
-	EXPECT_EQ(eGameMessageType::SYNC_SKILL, (eGameMessageType)1145);
+	EXPECT_EQ(eGameMessageType::SYNC_SKILL, static_cast<eGameMessageType>(1145));
-	EXPECT_EQ(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT, (eGameMessageType)1148);
+	EXPECT_EQ(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT, static_cast<eGameMessageType>(1148));
-	EXPECT_EQ(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT, (eGameMessageType)1151);
+	EXPECT_EQ(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT, static_cast<eGameMessageType>(1151));
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_CONVERT_MODEL, (eGameMessageType)1155);
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_CONVERT_MODEL, static_cast<eGameMessageType>(1155));
-	EXPECT_EQ(eGameMessageType::SET_PLAYER_ALLOWED_RESPAWN, (eGameMessageType)1165);
+	EXPECT_EQ(eGameMessageType::SET_PLAYER_ALLOWED_RESPAWN, static_cast<eGameMessageType>(1165));
-	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_SINGLE_CLIENT, (eGameMessageType)1184);
+	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_SINGLE_CLIENT, static_cast<eGameMessageType>(1184));
-	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_ALL_CLIENTS, (eGameMessageType)1185);
+	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_ALL_CLIENTS, static_cast<eGameMessageType>(1185));
-	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD, (eGameMessageType)1197);
+	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD, static_cast<eGameMessageType>(1197));
-	EXPECT_EQ(eGameMessageType::REQUEST_SMASH_PLAYER, (eGameMessageType)1202);
+	EXPECT_EQ(eGameMessageType::REQUEST_SMASH_PLAYER, static_cast<eGameMessageType>(1202));
-	EXPECT_EQ(eGameMessageType::FIRE_EVENT_CLIENT_SIDE, (eGameMessageType)1213);
+	EXPECT_EQ(eGameMessageType::FIRE_EVENT_CLIENT_SIDE, static_cast<eGameMessageType>(1213));
-	EXPECT_EQ(eGameMessageType::TOGGLE_GM_INVIS, (eGameMessageType)1218);
+	EXPECT_EQ(eGameMessageType::TOGGLE_GM_INVIS, static_cast<eGameMessageType>(1218));
-	EXPECT_EQ(eGameMessageType::CHANGE_OBJECT_WORLD_STATE, (eGameMessageType)1223);
+	EXPECT_EQ(eGameMessageType::CHANGE_OBJECT_WORLD_STATE, static_cast<eGameMessageType>(1223));
-	EXPECT_EQ(eGameMessageType::VEHICLE_LOCK_INPUT, (eGameMessageType)1230);
+	EXPECT_EQ(eGameMessageType::VEHICLE_LOCK_INPUT, static_cast<eGameMessageType>(1230));
-	EXPECT_EQ(eGameMessageType::VEHICLE_UNLOCK_INPUT, (eGameMessageType)1231);
+	EXPECT_EQ(eGameMessageType::VEHICLE_UNLOCK_INPUT, static_cast<eGameMessageType>(1231));
-	EXPECT_EQ(eGameMessageType::RACING_RESET_PLAYER_TO_LAST_RESET, (eGameMessageType)1252);
+	EXPECT_EQ(eGameMessageType::RACING_RESET_PLAYER_TO_LAST_RESET, static_cast<eGameMessageType>(1252));
-	EXPECT_EQ(eGameMessageType::RACING_SERVER_SET_PLAYER_LAP_AND_PLANE, (eGameMessageType)1253);
+	EXPECT_EQ(eGameMessageType::RACING_SERVER_SET_PLAYER_LAP_AND_PLANE, static_cast<eGameMessageType>(1253));
-	EXPECT_EQ(eGameMessageType::RACING_SET_PLAYER_RESET_INFO, (eGameMessageType)1254);
+	EXPECT_EQ(eGameMessageType::RACING_SET_PLAYER_RESET_INFO, static_cast<eGameMessageType>(1254));
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED, (eGameMessageType)1255);
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED, static_cast<eGameMessageType>(1255));
-	EXPECT_EQ(eGameMessageType::LOCK_NODE_ROTATION, (eGameMessageType)1260);
+	EXPECT_EQ(eGameMessageType::LOCK_NODE_ROTATION, static_cast<eGameMessageType>(1260));
-	EXPECT_EQ(eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE, (eGameMessageType)1273);
+	EXPECT_EQ(eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE, static_cast<eGameMessageType>(1273));
-	EXPECT_EQ(eGameMessageType::NOTIFY_VEHICLE_OF_RACING_OBJECT, (eGameMessageType)1276);
+	EXPECT_EQ(eGameMessageType::NOTIFY_VEHICLE_OF_RACING_OBJECT, static_cast<eGameMessageType>(1276));
-	EXPECT_EQ(eGameMessageType::SET_NAME_BILLBOARD_STATE, (eGameMessageType)1284);
+	EXPECT_EQ(eGameMessageType::SET_NAME_BILLBOARD_STATE, static_cast<eGameMessageType>(1284));
-	EXPECT_EQ(eGameMessageType::PLAYER_REACHED_RESPAWN_CHECKPOINT, (eGameMessageType)1296);
+	EXPECT_EQ(eGameMessageType::PLAYER_REACHED_RESPAWN_CHECKPOINT, static_cast<eGameMessageType>(1296));
-	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_DELETE_BASED_ON_EDIT_MODE, (eGameMessageType)1300);
+	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_DELETE_BASED_ON_EDIT_MODE, static_cast<eGameMessageType>(1300));
-	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_CREATE_BASED_ON_EDIT_MODE, (eGameMessageType)1301);
+	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_CREATE_BASED_ON_EDIT_MODE, static_cast<eGameMessageType>(1301));
-	EXPECT_EQ(eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT, (eGameMessageType)1305);
+	EXPECT_EQ(eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT, static_cast<eGameMessageType>(1305));
-	EXPECT_EQ(eGameMessageType::GET_MODELS_ON_PROPERTY, (eGameMessageType)1306);
+	EXPECT_EQ(eGameMessageType::GET_MODELS_ON_PROPERTY, static_cast<eGameMessageType>(1306));
-	EXPECT_EQ(eGameMessageType::MATCH_REQUEST, (eGameMessageType)1308);
+	EXPECT_EQ(eGameMessageType::MATCH_REQUEST, static_cast<eGameMessageType>(1308));
-	EXPECT_EQ(eGameMessageType::MATCH_RESPONSE, (eGameMessageType)1309);
+	EXPECT_EQ(eGameMessageType::MATCH_RESPONSE, static_cast<eGameMessageType>(1309));
-	EXPECT_EQ(eGameMessageType::MATCH_UPDATE, (eGameMessageType)1310);
+	EXPECT_EQ(eGameMessageType::MATCH_UPDATE, static_cast<eGameMessageType>(1310));
-	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT, (eGameMessageType)1131);
+	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT, static_cast<eGameMessageType>(1131));
-	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA, (eGameMessageType)1132);
+	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA, static_cast<eGameMessageType>(1132));
-	EXPECT_EQ(eGameMessageType::SHOW_BILLBOARD_INTERACT_ICON, (eGameMessageType)1337);
+	EXPECT_EQ(eGameMessageType::SHOW_BILLBOARD_INTERACT_ICON, static_cast<eGameMessageType>(1337));
-	EXPECT_EQ(eGameMessageType::CHANGE_IDLE_FLAGS, (eGameMessageType)1338);
+	EXPECT_EQ(eGameMessageType::CHANGE_IDLE_FLAGS, static_cast<eGameMessageType>(1338));
-	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_PASSIVE_BOOST_ACTION, (eGameMessageType)1340);
+	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1340));
-	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, (eGameMessageType)1341);
+	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1341));
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION, (eGameMessageType)1342);
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1342));
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, (eGameMessageType)1343);
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1343));
-	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_SLOWDOWN_ACTION, (eGameMessageType)1344);
+	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1344));
-	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_SLOWDOWN_ACTION, (eGameMessageType)1345);
+	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1345));
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_SLOWDOWN_ACTION, (eGameMessageType)1346);
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1346));
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_SLOWDOWN_ACTION, (eGameMessageType)1347);
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1347));
-	EXPECT_EQ(eGameMessageType::BUYBACK_FROM_VENDOR, (eGameMessageType)1350);
+	EXPECT_EQ(eGameMessageType::BUYBACK_FROM_VENDOR, static_cast<eGameMessageType>(1350));
-	EXPECT_EQ(eGameMessageType::SET_PROPERTY_ACCESS, (eGameMessageType)1366);
+	EXPECT_EQ(eGameMessageType::SET_PROPERTY_ACCESS, static_cast<eGameMessageType>(1366));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PLACED, (eGameMessageType)1369);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PLACED, static_cast<eGameMessageType>(1369));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED, (eGameMessageType)1370);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED, static_cast<eGameMessageType>(1370));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED, (eGameMessageType)1371);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED, static_cast<eGameMessageType>(1371));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED, (eGameMessageType)1372);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED, static_cast<eGameMessageType>(1372));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PICKED_UP, (eGameMessageType)1373);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PICKED_UP, static_cast<eGameMessageType>(1373));
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED, (eGameMessageType)1374);
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED, static_cast<eGameMessageType>(1374));
-	EXPECT_EQ(eGameMessageType::NOTIFY_RACING_CLIENT, (eGameMessageType)1390);
+	EXPECT_EQ(eGameMessageType::NOTIFY_RACING_CLIENT, static_cast<eGameMessageType>(1390));
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_HACK_CAR, (eGameMessageType)1391);
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_HACK_CAR, static_cast<eGameMessageType>(1391));
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_LOADED, (eGameMessageType)1392);
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_LOADED, static_cast<eGameMessageType>(1392));
-	EXPECT_EQ(eGameMessageType::RACING_CLIENT_READY, (eGameMessageType)1393);
+	EXPECT_EQ(eGameMessageType::RACING_CLIENT_READY, static_cast<eGameMessageType>(1393));
-	EXPECT_EQ(eGameMessageType::UPDATE_CHAT_MODE, (eGameMessageType)1395);
+	EXPECT_EQ(eGameMessageType::UPDATE_CHAT_MODE, static_cast<eGameMessageType>(1395));
-	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE, (eGameMessageType)1396);
+	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE, static_cast<eGameMessageType>(1396));
-	EXPECT_EQ(eGameMessageType::SET_CONSUMABLE_ITEM, (eGameMessageType)1409);
+	EXPECT_EQ(eGameMessageType::SET_CONSUMABLE_ITEM, static_cast<eGameMessageType>(1409));
-	EXPECT_EQ(eGameMessageType::SET_STATUS_IMMUNITY, (eGameMessageType)1435);
+	EXPECT_EQ(eGameMessageType::SET_STATUS_IMMUNITY, static_cast<eGameMessageType>(1435));
-	EXPECT_EQ(eGameMessageType::SET_PET_NAME_MODERATED, (eGameMessageType)1448);
+	EXPECT_EQ(eGameMessageType::SET_PET_NAME_MODERATED, static_cast<eGameMessageType>(1448));
-	EXPECT_EQ(eGameMessageType::MODIFY_LEGO_SCORE, (eGameMessageType)1459);
+	EXPECT_EQ(eGameMessageType::MODIFY_LEGO_SCORE, static_cast<eGameMessageType>(1459));
-	EXPECT_EQ(eGameMessageType::RESTORE_TO_POST_LOAD_STATS, (eGameMessageType)1468);
+	EXPECT_EQ(eGameMessageType::RESTORE_TO_POST_LOAD_STATS, static_cast<eGameMessageType>(1468));
-	EXPECT_EQ(eGameMessageType::SET_RAIL_MOVEMENT, (eGameMessageType)1471);
+	EXPECT_EQ(eGameMessageType::SET_RAIL_MOVEMENT, static_cast<eGameMessageType>(1471));
-	EXPECT_EQ(eGameMessageType::START_RAIL_MOVEMENT, (eGameMessageType)1472);
+	EXPECT_EQ(eGameMessageType::START_RAIL_MOVEMENT, static_cast<eGameMessageType>(1472));
-	EXPECT_EQ(eGameMessageType::CANCEL_RAIL_MOVEMENT, (eGameMessageType)1474);
+	EXPECT_EQ(eGameMessageType::CANCEL_RAIL_MOVEMENT, static_cast<eGameMessageType>(1474));
-	EXPECT_EQ(eGameMessageType::CLIENT_RAIL_MOVEMENT_READY, (eGameMessageType)1476);
+	EXPECT_EQ(eGameMessageType::CLIENT_RAIL_MOVEMENT_READY, static_cast<eGameMessageType>(1476));
-	EXPECT_EQ(eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION, (eGameMessageType)1477);
+	EXPECT_EQ(eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION, static_cast<eGameMessageType>(1477));
-	EXPECT_EQ(eGameMessageType::UPDATE_PLAYER_STATISTIC, (eGameMessageType)1481);
+	EXPECT_EQ(eGameMessageType::UPDATE_PLAYER_STATISTIC, static_cast<eGameMessageType>(1481));
-	EXPECT_EQ(eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED, (eGameMessageType)1498);
+	EXPECT_EQ(eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED, static_cast<eGameMessageType>(1498));
-	EXPECT_EQ(eGameMessageType::NOTIFY_NOT_ENOUGH_INV_SPACE, (eGameMessageType)1516);
+	EXPECT_EQ(eGameMessageType::NOTIFY_NOT_ENOUGH_INV_SPACE, static_cast<eGameMessageType>(1516));
-	EXPECT_EQ(eGameMessageType::TEAM_SET_LEADER, (eGameMessageType)1557);
+	EXPECT_EQ(eGameMessageType::TEAM_SET_LEADER, static_cast<eGameMessageType>(1557));
-	EXPECT_EQ(eGameMessageType::TEAM_INVITE_CONFIRM, (eGameMessageType)1558);
+	EXPECT_EQ(eGameMessageType::TEAM_INVITE_CONFIRM, static_cast<eGameMessageType>(1558));
-	EXPECT_EQ(eGameMessageType::TEAM_GET_STATUS_RESPONSE, (eGameMessageType)1559);
+	EXPECT_EQ(eGameMessageType::TEAM_GET_STATUS_RESPONSE, static_cast<eGameMessageType>(1559));
-	EXPECT_EQ(eGameMessageType::TEAM_ADD_PLAYER, (eGameMessageType)1562);
+	EXPECT_EQ(eGameMessageType::TEAM_ADD_PLAYER, static_cast<eGameMessageType>(1562));
-	EXPECT_EQ(eGameMessageType::TEAM_REMOVE_PLAYER, (eGameMessageType)1563);
+	EXPECT_EQ(eGameMessageType::TEAM_REMOVE_PLAYER, static_cast<eGameMessageType>(1563));
-	EXPECT_EQ(eGameMessageType::START_CELEBRATION_EFFECT, (eGameMessageType)1618);
+	EXPECT_EQ(eGameMessageType::START_CELEBRATION_EFFECT, static_cast<eGameMessageType>(1618));
-	EXPECT_EQ(eGameMessageType::ADD_BUFF, (eGameMessageType)1647);
+	EXPECT_EQ(eGameMessageType::ADD_BUFF, static_cast<eGameMessageType>(1647));
-	EXPECT_EQ(eGameMessageType::SERVER_DONE_LOADING_ALL_OBJECTS, (eGameMessageType)1642);
+	EXPECT_EQ(eGameMessageType::SERVER_DONE_LOADING_ALL_OBJECTS, static_cast<eGameMessageType>(1642));
-	EXPECT_EQ(eGameMessageType::PLACE_PROPERTY_MODEL, (eGameMessageType)1170);
+	EXPECT_EQ(eGameMessageType::PLACE_PROPERTY_MODEL, static_cast<eGameMessageType>(1170));
-	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER, (eGameMessageType)1606);
+	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER, static_cast<eGameMessageType>(1606));
-	EXPECT_EQ(eGameMessageType::ADD_RUN_SPEED_MODIFIER, (eGameMessageType)1505);
+	EXPECT_EQ(eGameMessageType::ADD_RUN_SPEED_MODIFIER, static_cast<eGameMessageType>(1505));
-	EXPECT_EQ(eGameMessageType::GET_HOT_PROPERTY_DATA, (eGameMessageType)1511);
+	EXPECT_EQ(eGameMessageType::GET_HOT_PROPERTY_DATA, static_cast<eGameMessageType>(1511));
-	EXPECT_EQ(eGameMessageType::SEND_HOT_PROPERTY_DATA, (eGameMessageType)1510);
+	EXPECT_EQ(eGameMessageType::SEND_HOT_PROPERTY_DATA, static_cast<eGameMessageType>(1510));
-	EXPECT_EQ(eGameMessageType::REMOVE_RUN_SPEED_MODIFIER, (eGameMessageType)1506);
+	EXPECT_EQ(eGameMessageType::REMOVE_RUN_SPEED_MODIFIER, static_cast<eGameMessageType>(1506));
-	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST, (eGameMessageType)1547);
+	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST, static_cast<eGameMessageType>(1547));
-	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_BEGIN, (eGameMessageType)1553);
+	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_BEGIN, static_cast<eGameMessageType>(1553));
-	EXPECT_EQ(eGameMessageType::SET_RESURRECT_RESTORE_VALUES, (eGameMessageType)1591);
+	EXPECT_EQ(eGameMessageType::SET_RESURRECT_RESTORE_VALUES, static_cast<eGameMessageType>(1591));
-	EXPECT_EQ(eGameMessageType::VEHICLE_STOP_BOOST, (eGameMessageType)1617);
+	EXPECT_EQ(eGameMessageType::VEHICLE_STOP_BOOST, static_cast<eGameMessageType>(1617));
-	EXPECT_EQ(eGameMessageType::REMOVE_BUFF, (eGameMessageType)1648);
+	EXPECT_EQ(eGameMessageType::REMOVE_BUFF, static_cast<eGameMessageType>(1648));
-	EXPECT_EQ(eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1666);
+	EXPECT_EQ(eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1666));
-	EXPECT_EQ(eGameMessageType::RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1667);
+	EXPECT_EQ(eGameMessageType::RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1667));
-	EXPECT_EQ(eGameMessageType::PLAYER_SET_CAMERA_CYCLING_MODE, (eGameMessageType)1676);
+	EXPECT_EQ(eGameMessageType::PLAYER_SET_CAMERA_CYCLING_MODE, static_cast<eGameMessageType>(1676));
-	EXPECT_EQ(eGameMessageType::SET_MOUNT_INVENTORY_ID, (eGameMessageType)1727);
+	EXPECT_EQ(eGameMessageType::SET_MOUNT_INVENTORY_ID, static_cast<eGameMessageType>(1727));
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE, (eGameMessageType)1734);
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE, static_cast<eGameMessageType>(1734));
-	EXPECT_EQ(eGameMessageType::NOTIFY_LEVEL_REWARDS, (eGameMessageType)1735);
+	EXPECT_EQ(eGameMessageType::NOTIFY_LEVEL_REWARDS, static_cast<eGameMessageType>(1735));
-	EXPECT_EQ(eGameMessageType::DISMOUNT_COMPLETE, (eGameMessageType)1756);
+	EXPECT_EQ(eGameMessageType::DISMOUNT_COMPLETE, static_cast<eGameMessageType>(1756));
-	EXPECT_EQ(eGameMessageType::MARK_INVENTORY_ITEM_AS_ACTIVE, (eGameMessageType)1767);
+	EXPECT_EQ(eGameMessageType::MARK_INVENTORY_ITEM_AS_ACTIVE, static_cast<eGameMessageType>(1767));
 }