Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2025-10-19 05:48:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into PetFixes

Browse Source
This commit is contained in:
jadebenn
2024-12-14 17:30:21 -06:00
parent fdd981c582 34618607c3
commit efc2cb6409
239 changed files with 124030 additions and 46555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
tests/CMakeLists.txt
View File

@@ -4,17 +4,6 @@ enable_testing()
find_package(GoogleTest REQUIRED)
include(GoogleTest)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
if(APPLE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH True)
set(CMAKE_BUILD_WITH_INSTALL_RPATH True)
set(CMAKE_INSTALL_RPATH "@executable_path")
endif()
add_custom_target(conncpp_tests
${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
# Add the subdirectories
add_subdirectory(dCommonTests)
add_subdirectory(dGameTests)

19
tests/dCommonTests/AMFDeserializeTests.cpp
View File

@@ -13,8 +13,7 @@
*/
std::unique_ptr<AMFBaseValue> ReadFromBitStream(RakNet::BitStream& bitStream) {
AMFDeserialize deserializer;
AMFBaseValue* returnValue(deserializer.Read(bitStream));
return std::unique_ptr<AMFBaseValue>{ returnValue };
return deserializer.Read(bitStream);
}
/**
@@ -176,7 +175,7 @@ TEST(dCommonTests, AMFDeserializeAMFArrayTest) {
/**
* @brief This test checks that if we recieve an unimplemented eAmf
* we correctly throw an error and can actch it.
* Yes this leaks memory.
* Yes this leaks memory.
*/
TEST(dCommonTests, AMFDeserializeUnimplementedValuesTest) {
std::vector<eAmf> unimplementedValues = {
@@ -254,7 +253,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(strips.size(), 1);
auto* stripsPosition0 = dynamic_cast<AMFArrayValue*>(strips[0]);
auto* stripsPosition0 = dynamic_cast<AMFArrayValue*>(strips[0].get());
auto* actionIndex = stripsPosition0->Get<double>("actionIndex");
@@ -272,7 +271,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(states.size(), 1);
auto* firstState = dynamic_cast<AMFArrayValue*>(states[0]);
auto* firstState = dynamic_cast<AMFArrayValue*>(states[0].get());
auto* stateID = firstState->Get<double>("id");
@@ -282,7 +281,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(stripsInState.size(), 1);
auto* firstStrip = dynamic_cast<AMFArrayValue*>(stripsInState[0]);
auto* firstStrip = dynamic_cast<AMFArrayValue*>(stripsInState[0].get());
auto& actionsInFirstStrip = firstStrip->GetArray("actions")->GetDense();
@@ -304,7 +303,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(stripId->GetValue(), 0.0f);
auto* firstAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[0]);
auto* firstAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[0].get());
auto* firstType = firstAction->Get<std::string>("Type");
@@ -314,7 +313,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(firstCallback->GetValue(), "");
auto* secondAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[1]);
auto* secondAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[1].get());
auto* secondType = secondAction->Get<std::string>("Type");
@@ -328,7 +327,7 @@ TEST(dCommonTests, AMFDeserializeLivePacketTest) {
ASSERT_EQ(secondDistance->GetValue(), 25.0f);
auto* thirdAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[2]);
auto* thirdAction = dynamic_cast<AMFArrayValue*>(actionsInFirstStrip[2].get());
auto* thirdType = thirdAction->Get<std::string>("Type");
@@ -363,7 +362,7 @@ TEST(dCommonTests, AMFBadConversionTest) {
ASSERT_EQ(result->Get<double>("BehaviorID"), nullptr);
// Does not exist in the associative portion
ASSERT_EQ(result->Get<nullptr_t>("DOES_NOT_EXIST"), nullptr);
ASSERT_EQ(result->Get<std::nullptr_t>("DOES_NOT_EXIST"), nullptr);
result->Push(true);

4
tests/dCommonTests/Amf3Tests.cpp
View File

@@ -78,7 +78,7 @@ TEST(dCommonTests, AMF3InsertionAssociativeTest) {
ASSERT_EQ(array.Get<int32_t>("Integer")->GetValueType(), eAmf::Integer);
ASSERT_EQ(array.Get<double>("Double")->GetValueType(), eAmf::Double);
ASSERT_EQ(array.GetArray("Array")->GetValueType(), eAmf::Array);
ASSERT_EQ(array.Get<nullptr_t>("Null")->GetValueType(), eAmf::Null);
ASSERT_EQ(array.Get<std::nullptr_t>("Null")->GetValueType(), eAmf::Null);
ASSERT_EQ(array.Get<std::vector<uint32_t>>("Undefined")->GetValueType(), eAmf::Undefined);
}
@@ -101,6 +101,6 @@ TEST(dCommonTests, AMF3InsertionDenseTest) {
ASSERT_EQ(array.Get<int32_t>(4)->GetValueType(), eAmf::Integer);
ASSERT_EQ(array.Get<double>(5)->GetValueType(), eAmf::Double);
ASSERT_EQ(array.GetArray(6)->GetValueType(), eAmf::Array);
ASSERT_EQ(array.Get<nullptr_t>(7)->GetValueType(), eAmf::Null);
ASSERT_EQ(array.Get<std::nullptr_t>(7)->GetValueType(), eAmf::Null);
ASSERT_EQ(array.Get<std::vector<uint32_t>>(8)->GetValueType(), eAmf::Undefined);
}

15
tests/dCommonTests/CMakeLists.txt
View File

@@ -18,18 +18,13 @@ list(APPEND DCOMMONTEST_SOURCES ${DENUMS_TESTS})
# Set our executable
add_executable(dCommonTests ${DCOMMONTEST_SOURCES})
add_dependencies(dCommonTests conncpp_tests)
# Apple needs some special linkage for the mariadb connector for tests.
# Needs to be in binary dir for ctest
if(APPLE)
add_custom_command(TARGET dCommonTests POST_BUILD
COMMAND otool ARGS -l dCommonTests
COMMAND otool ARGS -L dCommonTests
COMMAND ls
COMMAND otool ARGS -D libmariadbcpp.dylib
COMMAND install_name_tool ARGS -change libmariadbcpp.dylib @rpath/libmariadbcpp.dylib dCommonTests
COMMAND otool ARGS -L dCommonTests
WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
add_custom_target(dCommonTestsLink
${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${CMAKE_CURRENT_BINARY_DIR})
add_dependencies(dCommonTests dCommonTestsLink)
endif()
# Link needed libraries

14
tests/dCommonTests/ToUnderlyingTests.cpp
View File

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

130
tests/dCommonTests/dEnumsTests/MagicEnumTests.cpp
View File

@@ -6,8 +6,8 @@
#include "StringifiedEnum.h"
#include "Logger.h"
#include "Game.h"
#include "eGameMessageType.h"
#include "eWorldMessageType.h"
#include "MessageType/Game.h"
#include "MessageType/World.h"
#include "magic_enum.hpp"
#define ENUM_EQ(e, y, z)\
@@ -21,47 +21,47 @@
TEST(MagicEnumTest, eWorldMessageTypeTest) {
Game::logger = new Logger("./MagicEnumTest_eWorldMessageTypeTest.log", true, true);
ENUM_EQ(eWorldMessageType, 1, VALIDATION);
ENUM_EQ(eWorldMessageType, 2, CHARACTER_LIST_REQUEST);
ENUM_EQ(eWorldMessageType, 3, CHARACTER_CREATE_REQUEST);
ENUM_EQ(eWorldMessageType, 4, LOGIN_REQUEST);
ENUM_EQ(eWorldMessageType, 5, GAME_MSG);
ENUM_EQ(eWorldMessageType, 6, CHARACTER_DELETE_REQUEST);
ENUM_EQ(eWorldMessageType, 7, CHARACTER_RENAME_REQUEST);
ENUM_EQ(eWorldMessageType, 8, HAPPY_FLOWER_MODE_NOTIFY);
ENUM_EQ(eWorldMessageType, 9, SLASH_RELOAD_MAP);
ENUM_EQ(eWorldMessageType, 10, SLASH_PUSH_MAP_REQUEST);
ENUM_EQ(eWorldMessageType, 11, SLASH_PUSH_MAP);
ENUM_EQ(eWorldMessageType, 12, SLASH_PULL_MAP);
ENUM_EQ(eWorldMessageType, 13, LOCK_MAP_REQUEST);
ENUM_EQ(eWorldMessageType, 14, GENERAL_CHAT_MESSAGE);
ENUM_EQ(eWorldMessageType, 15, HTTP_MONITOR_INFO_REQUEST);
ENUM_EQ(eWorldMessageType, 16, SLASH_DEBUG_SCRIPTS);
ENUM_EQ(eWorldMessageType, 17, MODELS_CLEAR);
ENUM_EQ(eWorldMessageType, 18, EXHIBIT_INSERT_MODEL);
ENUM_EQ(eWorldMessageType, 19, LEVEL_LOAD_COMPLETE);
ENUM_EQ(eWorldMessageType, 20, TMP_GUILD_CREATE);
ENUM_EQ(eWorldMessageType, 21, ROUTE_PACKET);
ENUM_EQ(eWorldMessageType, 22, POSITION_UPDATE);
ENUM_EQ(eWorldMessageType, 23, MAIL);
ENUM_EQ(eWorldMessageType, 24, WORD_CHECK);
ENUM_EQ(eWorldMessageType, 25, STRING_CHECK);
ENUM_EQ(eWorldMessageType, 26, GET_PLAYERS_IN_ZONE);
ENUM_EQ(eWorldMessageType, 27, REQUEST_UGC_MANIFEST_INFO);
ENUM_EQ(eWorldMessageType, 28, BLUEPRINT_GET_ALL_DATA_REQUEST);
ENUM_EQ(eWorldMessageType, 29, CANCEL_MAP_QUEUE);
ENUM_EQ(eWorldMessageType, 30, HANDLE_FUNNESS);
ENUM_EQ(eWorldMessageType, 31, FAKE_PRG_CSR_MESSAGE);
ENUM_EQ(eWorldMessageType, 32, REQUEST_FREE_TRIAL_REFRESH);
ENUM_EQ(eWorldMessageType, 33, GM_SET_FREE_TRIAL_STATUS);
ENUM_EQ(eWorldMessageType, 91, UI_HELP_TOP_5);
ENUM_NE(eWorldMessageType, 37);
ENUM_NE(eWorldMessageType, 123);
ENUM_EQ(MessageType::World, 1, VALIDATION);
ENUM_EQ(MessageType::World, 2, CHARACTER_LIST_REQUEST);
ENUM_EQ(MessageType::World, 3, CHARACTER_CREATE_REQUEST);
ENUM_EQ(MessageType::World, 4, LOGIN_REQUEST);
ENUM_EQ(MessageType::World, 5, GAME_MSG);
ENUM_EQ(MessageType::World, 6, CHARACTER_DELETE_REQUEST);
ENUM_EQ(MessageType::World, 7, CHARACTER_RENAME_REQUEST);
ENUM_EQ(MessageType::World, 8, HAPPY_FLOWER_MODE_NOTIFY);
ENUM_EQ(MessageType::World, 9, SLASH_RELOAD_MAP);
ENUM_EQ(MessageType::World, 10, SLASH_PUSH_MAP_REQUEST);
ENUM_EQ(MessageType::World, 11, SLASH_PUSH_MAP);
ENUM_EQ(MessageType::World, 12, SLASH_PULL_MAP);
ENUM_EQ(MessageType::World, 13, LOCK_MAP_REQUEST);
ENUM_EQ(MessageType::World, 14, GENERAL_CHAT_MESSAGE);
ENUM_EQ(MessageType::World, 15, HTTP_MONITOR_INFO_REQUEST);
ENUM_EQ(MessageType::World, 16, SLASH_DEBUG_SCRIPTS);
ENUM_EQ(MessageType::World, 17, MODELS_CLEAR);
ENUM_EQ(MessageType::World, 18, EXHIBIT_INSERT_MODEL);
ENUM_EQ(MessageType::World, 19, LEVEL_LOAD_COMPLETE);
ENUM_EQ(MessageType::World, 20, TMP_GUILD_CREATE);
ENUM_EQ(MessageType::World, 21, ROUTE_PACKET);
ENUM_EQ(MessageType::World, 22, POSITION_UPDATE);
ENUM_EQ(MessageType::World, 23, MAIL);
ENUM_EQ(MessageType::World, 24, WORD_CHECK);
ENUM_EQ(MessageType::World, 25, STRING_CHECK);
ENUM_EQ(MessageType::World, 26, GET_PLAYERS_IN_ZONE);
ENUM_EQ(MessageType::World, 27, REQUEST_UGC_MANIFEST_INFO);
ENUM_EQ(MessageType::World, 28, BLUEPRINT_GET_ALL_DATA_REQUEST);
ENUM_EQ(MessageType::World, 29, CANCEL_MAP_QUEUE);
ENUM_EQ(MessageType::World, 30, HANDLE_FUNNESS);
ENUM_EQ(MessageType::World, 31, FAKE_PRG_CSR_MESSAGE);
ENUM_EQ(MessageType::World, 32, REQUEST_FREE_TRIAL_REFRESH);
ENUM_EQ(MessageType::World, 33, GM_SET_FREE_TRIAL_STATUS);
ENUM_EQ(MessageType::World, 91, UI_HELP_TOP_5);
ENUM_NE(MessageType::World, 37);
ENUM_NE(MessageType::World, 123);
srand(time(NULL));
auto begin = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 10000000; ++i) {
volatile auto f = StringifiedEnum::ToString(static_cast<eWorldMessageType>(i)).data();
volatile auto f = StringifiedEnum::ToString(static_cast<MessageType::World>(i)).data();
// To ensure the compiler doesn't optimize out the call, I print it at random intervals
if (rand() % 100000 == 0) LOG("%i, %s", i, f);
@@ -78,34 +78,34 @@ TEST(MagicEnumTest, eGameMessageTypeTest) {
Game::logger = new Logger("./MagicEnumTest_eGameMessageTypeTest.log", true, true);
// Only doing the first and last 10 for the sake of my sanity
ENUM_EQ(eGameMessageType, 0, GET_POSITION);
ENUM_EQ(eGameMessageType, 1, GET_ROTATION);
ENUM_EQ(eGameMessageType, 2, GET_LINEAR_VELOCITY);
ENUM_EQ(eGameMessageType, 3, GET_ANGULAR_VELOCITY);
ENUM_EQ(eGameMessageType, 4, GET_FORWARD_VELOCITY);
ENUM_EQ(eGameMessageType, 5, GET_PLAYER_FORWARD);
ENUM_EQ(eGameMessageType, 6, GET_FORWARD_VECTOR);
ENUM_EQ(eGameMessageType, 7, SET_POSITION);
ENUM_EQ(eGameMessageType, 8, SET_LOCAL_POSITION);
ENUM_EQ(eGameMessageType, 9, SET_ROTATION);
ENUM_EQ(eGameMessageType, 10, SET_LINEAR_VELOCITY);
ENUM_EQ(eGameMessageType, 1762, USE_SKILL_SET);
ENUM_EQ(eGameMessageType, 1763, SET_SKILL_SET_POSSESSOR);
ENUM_EQ(eGameMessageType, 1764, POPULATE_ACTION_BAR);
ENUM_EQ(eGameMessageType, 1765, GET_COMPONENT_TEMPLATE_ID);
ENUM_EQ(eGameMessageType, 1766, GET_POSSESSABLE_SKILL_SET);
ENUM_EQ(eGameMessageType, 1767, MARK_INVENTORY_ITEM_AS_ACTIVE);
ENUM_EQ(eGameMessageType, 1768, UPDATE_FORGED_ITEM);
ENUM_EQ(eGameMessageType, 1769, CAN_ITEMS_BE_REFORGED);
ENUM_EQ(eGameMessageType, 1771, NOTIFY_CLIENT_RAIL_START_FAILED);
ENUM_EQ(eGameMessageType, 1772, GET_IS_ON_RAIL);
ENUM_NE(eGameMessageType, 32);
ENUM_NE(eGameMessageType, 1776);
ENUM_EQ(MessageType::Game, 0, GET_POSITION);
ENUM_EQ(MessageType::Game, 1, GET_ROTATION);
ENUM_EQ(MessageType::Game, 2, GET_LINEAR_VELOCITY);
ENUM_EQ(MessageType::Game, 3, GET_ANGULAR_VELOCITY);
ENUM_EQ(MessageType::Game, 4, GET_FORWARD_VELOCITY);
ENUM_EQ(MessageType::Game, 5, GET_PLAYER_FORWARD);
ENUM_EQ(MessageType::Game, 6, GET_FORWARD_VECTOR);
ENUM_EQ(MessageType::Game, 7, SET_POSITION);
ENUM_EQ(MessageType::Game, 8, SET_LOCAL_POSITION);
ENUM_EQ(MessageType::Game, 9, SET_ROTATION);
ENUM_EQ(MessageType::Game, 10, SET_LINEAR_VELOCITY);
ENUM_EQ(MessageType::Game, 1762, USE_SKILL_SET);
ENUM_EQ(MessageType::Game, 1763, SET_SKILL_SET_POSSESSOR);
ENUM_EQ(MessageType::Game, 1764, POPULATE_ACTION_BAR);
ENUM_EQ(MessageType::Game, 1765, GET_COMPONENT_TEMPLATE_ID);
ENUM_EQ(MessageType::Game, 1766, GET_POSSESSABLE_SKILL_SET);
ENUM_EQ(MessageType::Game, 1767, MARK_INVENTORY_ITEM_AS_ACTIVE);
ENUM_EQ(MessageType::Game, 1768, UPDATE_FORGED_ITEM);
ENUM_EQ(MessageType::Game, 1769, CAN_ITEMS_BE_REFORGED);
ENUM_EQ(MessageType::Game, 1771, NOTIFY_CLIENT_RAIL_START_FAILED);
ENUM_EQ(MessageType::Game, 1772, GET_IS_ON_RAIL);
ENUM_NE(MessageType::Game, 32);
ENUM_NE(MessageType::Game, 1776);
srand(time(NULL));
auto begin = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 10000000; ++i) {
volatile auto f = StringifiedEnum::ToString(static_cast<eGameMessageType>(i)).data();
volatile auto f = StringifiedEnum::ToString(static_cast<MessageType::Game>(i)).data();
// To ensure the compiler doesn't optimize out the call, I print it at random intervals
if (rand() % 100000 == 0) LOG("%i, %s", i, f);
@@ -135,10 +135,10 @@ namespace {
TEST(MagicEnumTest, ArraysAreSorted) {
Game::logger = new Logger("./MagicEnumTest_ArraysAreSorted.log", true, true);
constexpr auto wmArray = &magic_enum::enum_entries<eWorldMessageType>();
constexpr auto wmArray = &magic_enum::enum_entries<MessageType::World>();
AssertEnumArraySorted(wmArray);
constexpr auto gmArray = &magic_enum::enum_entries<eGameMessageType>();
constexpr auto gmArray = &magic_enum::enum_entries<MessageType::Game>();
AssertEnumArraySorted(gmArray);
delete Game::logger;

11
tests/dGameTests/CMakeLists.txt
View File

@@ -9,17 +9,16 @@ add_subdirectory(dGameMessagesTests)
list(APPEND DGAMETEST_SOURCES ${DGAMEMESSAGES_TESTS})
file(COPY ${GAMEMESSAGE_TESTBITSTREAMS} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
file(COPY ${COMPONENT_TEST_DATA} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
# Add the executable. Remember to add all tests above this!
add_executable(dGameTests ${DGAMETEST_SOURCES})
add_dependencies(dGameTests conncpp_tests)
# Apple needs some special linkage for the mariadb connector for tests.
if(APPLE)
add_custom_command(TARGET dGameTests POST_BUILD
COMMAND install_name_tool ARGS -change libmariadbcpp.dylib @rpath/libmariadbcpp.dylib dGameTests
COMMAND otool ARGS -L dGameTests
WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
add_custom_target(dGameTestsLink
${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${CMAKE_CURRENT_BINARY_DIR})
add_dependencies(dGameTests dGameTestsLink)
endif()
target_link_libraries(dGameTests ${COMMON_LIBRARIES} GTest::gtest_main

10
tests/dGameTests/GameDependencies.h
View File

@@ -10,6 +10,8 @@
#include "dZoneManager.h"
#include "dConfig.h"
#include "WorldConfig.h"
#include "GameDatabase/TestSQL/TestSQLDatabase.h"
#include "Database.h"
#include <gtest/gtest.h>
class dZoneManager;
@@ -22,6 +24,7 @@ public:
~dServerMock() {};
RakNet::BitStream* GetMostRecentBitStream() { return sentBitStream; };
void Send(RakNet::BitStream& bitStream, const SystemAddress& sysAddr, bool broadcast) override { sentBitStream = &bitStream; };
void SetZoneId(unsigned int zoneId) { mZoneID = zoneId; }
};
class GameDependenciesTest : public ::testing::Test {
@@ -36,9 +39,11 @@ protected:
Game::server = new dServerMock();
Game::config = new dConfig("worldconfig.ini");
Game::entityManager = new EntityManager();
// Set up zone manager
Game::zoneManager = new dZoneManager();
Game::zoneManager->LoadZone(LWOZONEID(1, 0, 0));
Database::_setDatabase(new TestSQLDatabase()); // this new is managed by the Database
// Set up world config
auto worldConfig = new WorldConfig();
worldConfig->petFollowRadius = 10.0f;
Game::zoneManager->SetWorldConfig(worldConfig);
@@ -50,6 +55,7 @@ protected:
void TearDownDependencies() {
if (Game::server) delete Game::server;
if (Game::entityManager) delete Game::entityManager;
if (Game::zoneManager) delete Game::zoneManager;
if (Game::logger) {
Game::logger->Flush();
delete Game::logger;

6
tests/dGameTests/dComponentsTests/CMakeLists.txt
View File

@@ -2,6 +2,7 @@ set(DCOMPONENTS_TESTS
"DestroyableComponentTests.cpp"
"PetComponentTests.cpp"
"SimplePhysicsComponentTests.cpp"
"SavingTests.cpp"
)
# Get the folder name and prepend it to the files above
@@ -10,3 +11,8 @@ list(TRANSFORM DCOMPONENTS_TESTS PREPEND "${thisFolderName}/")
# Export to parent scope
set(DCOMPONENTS_TESTS ${DCOMPONENTS_TESTS} PARENT_SCOPE)
# Copy test files to testing directory
add_subdirectory(TestData)
list(TRANSFORM COMPONENT_TEST_DATA PREPEND "${thisFolderName}/")
set(COMPONENT_TEST_DATA ${COMPONENT_TEST_DATA} PARENT_SCOPE)

103
tests/dGameTests/dComponentsTests/SavingTests.cpp Normal file
View File

@@ -0,0 +1,103 @@
#include "GameDependencies.h"
#include "Character.h"
#include "Entity.h"
#include "tinyxml2.h"
#include "BuffComponent.h"
#include "CharacterComponent.h"
class SavingTest : public GameDependenciesTest {
protected:
std::unique_ptr<Entity> entity;
std::unique_ptr<Character> character;
tinyxml2::XMLDocument doc;
tinyxml2::XMLPrinter printer{ 0, true, 0 };
void SetUp() override {
SetUpDependencies();
Game::zoneManager->LoadZone(LWOZONEID(1800, 2, 0));
static_cast<dServerMock*>(Game::server)->SetZoneId(1800);
entity = std::make_unique<Entity>(1, GameDependenciesTest::info);
character = std::make_unique<Character>(1, nullptr);
doc.LoadFile("./test_xml_data.xml");
entity->SetCharacter(character.get());
character->SetEntity(entity.get());
doc.Print(&printer);
character->_setXmlData(printer.CStr());
printer.ClearBuffer();
character->_doQuickXMLDataParse();
character->LoadXmlRespawnCheckpoints();
entity->AddComponent<CharacterComponent>(character.get(), UNASSIGNED_SYSTEM_ADDRESS)->LoadFromXml(entity->GetCharacter()->GetXMLDoc());
}
void TearDown() override {
entity->SetCharacter(nullptr);
entity.reset();
character.reset();
TearDownDependencies();
}
};
TEST_F(SavingTest, CharacterComponentTest) {
// Print the original XML data
// character->GetXMLDoc().Print(&printer);
// std::string xmlDataOriginal(printer.CStr());
// printer.ClearBuffer();
// std::ofstream oldXml("./test_xml_data_original.xml");
// oldXml << xmlDataOriginal;
auto* characterComponent = entity->GetComponent<CharacterComponent>();
// Update the xml document so its been run through the saver
character->SaveXMLToDatabase();
// Reload the component and character from the now updated xml data
const auto prevTotalTime = characterComponent->GetTotalTimePlayed();
character->_doQuickXMLDataParse();
entity->AddComponent<CharacterComponent>(character.get(), UNASSIGNED_SYSTEM_ADDRESS);
characterComponent->LoadFromXml(entity->GetCharacter()->GetXMLDoc());
// Check that the buff component is the same as before which means resaving data and loading it back in didn't change anything
ASSERT_EQ("32114;69;343;13;163;2;181;2;388;252;146;24451;25;9022;41898;42186;42524;4404;0;0;0;0;0;0;0;0;0;", characterComponent->StatisticsToString());
// need a variable because the macros do not support {}
constexpr std::array<uint64_t, 4> correctCodes = { 1073741968, 0, 0, 0 };
ASSERT_EQ(correctCodes, characterComponent->GetClaimCodes());
ASSERT_EQ(1, characterComponent->m_Character->GetEyebrows());
ASSERT_EQ(2, characterComponent->m_Character->GetEyes());
ASSERT_EQ(9, characterComponent->m_Character->GetHairColor());
ASSERT_EQ(8, characterComponent->m_Character->GetHairStyle());
ASSERT_EQ(3, characterComponent->m_Character->GetPantsColor());
ASSERT_EQ(27634704, characterComponent->m_Character->GetLeftHand());
ASSERT_EQ(3, characterComponent->m_Character->GetMouth());
ASSERT_EQ(27187396, characterComponent->m_Character->GetRightHand());
ASSERT_EQ(13, characterComponent->m_Character->GetShirtColor());
ASSERT_EQ(7510, characterComponent->GetUScore());
ASSERT_EQ(300, characterComponent->GetReputation());
ASSERT_EQ(u"0:1:4719+1:4720+1:4721", characterComponent->GetLastRocketConfig());
ASSERT_EQ(prevTotalTime, characterComponent->GetTotalTimePlayed());
const std::map<LWOMAPID, ZoneStatistics> correctZoneStats =
{
{ 1000, { .m_AchievementsCollected = 0, .m_BricksCollected = 0, .m_CoinsCollected = 4, .m_EnemiesSmashed = 0, .m_QuickBuildsCompleted = 0 } },
{ 1100, { .m_AchievementsCollected = 1, .m_BricksCollected = 54, .m_CoinsCollected = 584, .m_EnemiesSmashed = 34, .m_QuickBuildsCompleted = 0 } },
{ 1101, { .m_AchievementsCollected = 7, .m_BricksCollected = 0, .m_CoinsCollected = 750, .m_EnemiesSmashed = 100, .m_QuickBuildsCompleted = 7 } },
{ 1200, { .m_AchievementsCollected = 51, .m_BricksCollected = 9, .m_CoinsCollected = 26724, .m_EnemiesSmashed = 0, .m_QuickBuildsCompleted = 3 } },
{ 1250, { .m_AchievementsCollected = 1, .m_BricksCollected = 1, .m_CoinsCollected = 158, .m_EnemiesSmashed = 15, .m_QuickBuildsCompleted = 1 } },
{ 1800, { .m_AchievementsCollected = 4, .m_BricksCollected = 5, .m_CoinsCollected = 3894, .m_EnemiesSmashed = 14, .m_QuickBuildsCompleted = 2 } },
};
ASSERT_EQ(correctZoneStats, characterComponent->GetZoneStatistics());
// Fails currently due to not reading style from xml
// Should the value be fixed, this test will fail and will match the above
// only then will this comment be removed.
ASSERT_NE(27, characterComponent->m_Character->GetShirtStyle());
}

10
tests/dGameTests/dComponentsTests/TestData/CMakeLists.txt Normal file
View File

@@ -0,0 +1,10 @@
set(COMPONENT_TEST_DATA
"test_xml_data.xml"
)
# Get the folder name and prepend it to the files above
get_filename_component(thisFolderName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
list(TRANSFORM COMPONENT_TEST_DATA PREPEND "${thisFolderName}/")
# Export our list of files
set(COMPONENT_TEST_DATA ${COMPONENT_TEST_DATA} PARENT_SCOPE)

1
tests/dGameTests/dComponentsTests/TestData/test_xml_data.xml Normal file
View File

File diff suppressed because one or more lines are too long

67
tests/dGameTests/dGameMessagesTests/GameMessageTests.cpp
View File

@@ -38,11 +38,11 @@ protected:
}
return readFile;
}
const AMFArrayValue& ReadArrayFromBitStream(RakNet::BitStream& inStream) {
std::unique_ptr<AMFArrayValue> ReadArrayFromBitStream(RakNet::BitStream& inStream) {
AMFDeserialize des;
AMFBaseValue* readArray = des.Read(inStream);
AMFBaseValue* readArray = des.Read(inStream).release();
EXPECT_EQ(readArray->GetValueType(), eAmf::Array);
return static_cast<AMFArrayValue&>(*readArray);
return std::unique_ptr<AMFArrayValue>{ static_cast<AMFArrayValue*>(readArray) };
}
};
@@ -88,7 +88,10 @@ TEST_F(GameMessageTests, SendBlueprintLoadItemResponse) {
TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
auto data = ReadFromFile("addStrip");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
AddStripMessage addStrip(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
AddStripMessage addStrip(*arr);
ASSERT_FLOAT_EQ(addStrip.GetPosition().GetX(), 50.65);
ASSERT_FLOAT_EQ(addStrip.GetPosition().GetY(), 178.05);
ASSERT_EQ(addStrip.GetActionContext().GetStripId(), 0);
@@ -103,7 +106,10 @@ TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
auto data = ReadFromFile("removeStrip");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
RemoveStripMessage removeStrip(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
RemoveStripMessage removeStrip(*arr);
ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStripId()), 1);
ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStateId()), 0);
ASSERT_EQ(removeStrip.GetBehaviorId(), BehaviorMessageBase::DefaultBehaviorId);
@@ -112,7 +118,10 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
auto data = ReadFromFile("mergeStrips");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
MergeStripsMessage mergeStrips(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
MergeStripsMessage mergeStrips(*arr);
ASSERT_EQ(mergeStrips.GetSourceActionContext().GetStripId(), 2);
ASSERT_EQ(mergeStrips.GetDestinationActionContext().GetStripId(), 0);
ASSERT_EQ(static_cast<uint32_t>(mergeStrips.GetSourceActionContext().GetStateId()), 0);
@@ -124,9 +133,11 @@ TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
auto data = ReadFromFile("splitStrip");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
SplitStripMessage splitStrip(ReadArrayFromBitStream(inStream));
ASSERT_EQ(splitStrip.GetBehaviorId(), -1);
const auto arr = ReadArrayFromBitStream(inStream);
SplitStripMessage splitStrip(*arr);
ASSERT_EQ(splitStrip.GetBehaviorId(), -1);
ASSERT_FLOAT_EQ(splitStrip.GetPosition().GetX(), 275.65);
ASSERT_FLOAT_EQ(splitStrip.GetPosition().GetY(), 28.7);
ASSERT_EQ(splitStrip.GetSourceActionContext().GetStripId(), 0);
@@ -139,7 +150,10 @@ TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
auto data = ReadFromFile("updateStripUI");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
UpdateStripUiMessage updateStripUi(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
UpdateStripUiMessage updateStripUi(*arr);
ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetX(), 116.65);
ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetY(), 35.35);
ASSERT_EQ(updateStripUi.GetActionContext().GetStripId(), 0);
@@ -150,7 +164,10 @@ TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
TEST_F(GameMessageTests, ControlBehaviorAddAction) {
auto data = ReadFromFile("addAction");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
AddActionMessage addAction(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
AddActionMessage addAction(*arr);
ASSERT_EQ(addAction.GetActionIndex(), 3);
ASSERT_EQ(addAction.GetActionContext().GetStripId(), 0);
ASSERT_EQ(static_cast<uint32_t>(addAction.GetActionContext().GetStateId()), 0);
@@ -164,7 +181,10 @@ TEST_F(GameMessageTests, ControlBehaviorAddAction) {
TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
auto data = ReadFromFile("migrateActions");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
MigrateActionsMessage migrateActions(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
MigrateActionsMessage migrateActions(*arr);
ASSERT_EQ(migrateActions.GetSrcActionIndex(), 1);
ASSERT_EQ(migrateActions.GetDstActionIndex(), 2);
ASSERT_EQ(migrateActions.GetSourceActionContext().GetStripId(), 1);
@@ -177,7 +197,10 @@ TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
auto data = ReadFromFile("rearrangeStrip");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
RearrangeStripMessage rearrangeStrip(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
RearrangeStripMessage rearrangeStrip(*arr);
ASSERT_EQ(rearrangeStrip.GetSrcActionIndex(), 2);
ASSERT_EQ(rearrangeStrip.GetDstActionIndex(), 1);
ASSERT_EQ(rearrangeStrip.GetActionContext().GetStripId(), 0);
@@ -188,7 +211,10 @@ TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
TEST_F(GameMessageTests, ControlBehaviorAdd) {
auto data = ReadFromFile("add");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
AddMessage add(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
AddMessage add(*arr);
ASSERT_EQ(add.GetBehaviorId(), 10446);
ASSERT_EQ(add.GetBehaviorIndex(), 0);
}
@@ -196,7 +222,10 @@ TEST_F(GameMessageTests, ControlBehaviorAdd) {
TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
auto data = ReadFromFile("removeActions");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
RemoveActionsMessage removeActions(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
RemoveActionsMessage removeActions(*arr);
ASSERT_EQ(removeActions.GetBehaviorId(), -1);
ASSERT_EQ(removeActions.GetActionIndex(), 1);
ASSERT_EQ(removeActions.GetActionContext().GetStripId(), 0);
@@ -206,7 +235,10 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
TEST_F(GameMessageTests, ControlBehaviorRename) {
auto data = ReadFromFile("rename");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
RenameMessage rename(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
RenameMessage rename(*arr);
ASSERT_EQ(rename.GetName(), "test");
ASSERT_EQ(rename.GetBehaviorId(), BehaviorMessageBase::DefaultBehaviorId);
}
@@ -214,7 +246,10 @@ TEST_F(GameMessageTests, ControlBehaviorRename) {
TEST_F(GameMessageTests, ControlBehaviorUpdateAction) {
auto data = ReadFromFile("updateAction");
RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
UpdateActionMessage updateAction(ReadArrayFromBitStream(inStream));
const auto arr = ReadArrayFromBitStream(inStream);
UpdateActionMessage updateAction(*arr);
ASSERT_EQ(updateAction.GetAction().GetType(), "FlyDown");
ASSERT_EQ(updateAction.GetAction().GetValueParameterName(), "Distance");
ASSERT_EQ(updateAction.GetAction().GetValueParameterString(), "");

588
tests/dGameTests/dGameMessagesTests/LegacyGameMessageTests.cpp
View File

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