Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2024-12-25 06:53:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/main' into PetFixes

Browse Source
This commit is contained in:
jadebenn 2024-03-24 11:08:08 -05:00
commit 50b207405c
17 changed files with 638 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.18) cmake_minimum_required(VERSION 3.25)
project(Darkflame) project(Darkflame)
include(CTest) include(CTest)
@ -213,29 +213,29 @@ if (APPLE)
endif() endif()
# Load all of our third party directories # Load all of our third party directories
add_subdirectory(thirdparty) add_subdirectory(thirdparty SYSTEM)
# Create our list of include directories # Create our list of include directories
set(INCLUDED_DIRECTORIES include_directories(
"dPhysics" "dPhysics"
"dNavigation" "dNavigation"
"dNet" "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"
"tests/dCommonTests" "tests/dCommonTests"
"tests/dGameTests" "tests/dGameTests"
"tests/dGameTests/dComponentsTests" "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) # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@ -244,14 +244,9 @@ if(APPLE)
include_directories("/usr/local/include/") include_directories("/usr/local/include/")
endif() endif()
# Actually include the directories from our list
foreach(dir ${INCLUDED_DIRECTORIES})
include_directories(${PROJECT_SOURCE_DIR}/${dir})
endforeach()
# Add linking directories: # Add linking directories:
if (UNIX) if (UNIX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Werror") # Warning flags
endif() endif()
file( file(
GLOB HEADERS_DZONEMANAGER GLOB HEADERS_DZONEMANAGER

2
README.md
View File

@ -51,7 +51,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
### Windows packages ### 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. 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 ### MacOS packages
Ensure you have [brew](https://brew.sh) installed. Ensure you have [brew](https://brew.sh) installed.

2
cmake/FindMariaDB.cmake
View File

@ -141,6 +141,6 @@ elseif(APPLE)
endif() endif()
# Add directories to include lists # 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) set(MariaDB_FOUND TRUE)

59
dCommon/dEnums/eWaypointCommandType.h Normal file
View File

@ -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__

26
dGame/dComponents/ControllablePhysicsComponent.cpp
View File

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

17
dGame/dComponents/ControllablePhysicsComponent.h
View File

@ -174,18 +174,6 @@ public:
*/ */
const float GetGravityScale() const { return m_GravityScale; } 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 * Can make an entity static, making it unable to move around
* @param value whether or not the entity is static * @param value whether or not the entity is static
@ -353,11 +341,6 @@ private:
*/ */
bool m_DirtyCheats; 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 * Whether this entity is static, making it unable to move
*/ */

83
dGame/dComponents/TriggerComponent.cpp
View File

@ -15,6 +15,7 @@
#include "PlayerManager.h" #include "PlayerManager.h"
#include "Game.h" #include "Game.h"
#include "EntityManager.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_Parent = parent;
@ -68,7 +69,9 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
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:
HandleSetPath(targetEntity, argArray);
break;
case eTriggerCommandType::SET_PICK_TYPE: break; case eTriggerCommandType::SET_PICK_TYPE: break;
case eTriggerCommandType::MOVE_OBJECT: case eTriggerCommandType::MOVE_OBJECT:
HandleMoveObject(targetEntity, argArray); HandleMoveObject(targetEntity, argArray);
@ -99,11 +102,21 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
break; break;
case eTriggerCommandType::SET_BOUNCER_STATE: break; case eTriggerCommandType::SET_BOUNCER_STATE: break;
case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break; case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
case eTriggerCommandType::TURN_AROUND_ON_PATH: break; case eTriggerCommandType::TURN_AROUND_ON_PATH:
case eTriggerCommandType::GO_FORWARD_ON_PATH: break; HandleTurnAroundOnPath(targetEntity);
case eTriggerCommandType::GO_BACKWARD_ON_PATH: break; break;
case eTriggerCommandType::STOP_PATHING: break; case eTriggerCommandType::GO_FORWARD_ON_PATH:
case eTriggerCommandType::START_PATHING: break; HandleGoForwardOnPath(targetEntity);
break;
case eTriggerCommandType::GO_BACKWARD_ON_PATH:
HandleGoBackwardOnPath(targetEntity);
break;
case eTriggerCommandType::STOP_PATHING:
HandleStopPathing(targetEntity);
break;
case eTriggerCommandType::START_PATHING:
HandleStartPathing(targetEntity);
break;
case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break; case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
case eTriggerCommandType::PLAY_EFFECT: case eTriggerCommandType::PLAY_EFFECT:
HandlePlayEffect(targetEntity, argArray); HandlePlayEffect(targetEntity, argArray);
@ -164,20 +177,25 @@ std::vector<Entity*> TriggerComponent::GatherTargets(LUTriggers::Command* comman
std::vector<Entity*> entities = {}; std::vector<Entity*> entities = {};
if (command->target == "self") entities.push_back(m_Parent); 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()); auto* team = TeamManager::Instance()->GetTeam(optionalTarget->GetObjectID());
for (const auto memberId : team->members) { for (const auto memberId : team->members) {
auto* member = Game::entityManager->GetEntity(memberId); auto* member = Game::entityManager->GetEntity(memberId);
if (member) entities.push_back(member); 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()) { for (auto* player : PlayerManager::GetAllPlayers()) {
entities.push_back(player); entities.push_back(player);
} }
} else if (command->target == "allNPCs") { /*UNUSED*/ } } else if (command->target == "allNPCs") {
/*UNUSED*/
}
return entities; return entities;
} }
@ -435,3 +453,44 @@ void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string a
LOG_DEBUG("Invalid argument for ActivatePhysics Trigger: %s", args.c_str()); 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();
}

6
dGame/dComponents/TriggerComponent.h
View File

@ -44,6 +44,12 @@ private:
void HandleResetSpawnerNetwork(std::string args); void HandleResetSpawnerNetwork(std::string args);
void HandleDestroySpawnerNetworkObjects(std::string args); void HandleDestroySpawnerNetworkObjects(std::string args);
void HandleActivatePhysics(Entity* targetEntity, 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; LUTriggers::Trigger* m_Trigger;
}; };

2
dMasterServer/MasterServer.cpp
View File

@ -675,7 +675,7 @@ void HandlePacket(Packet* packet) {
const auto& zone = instance->GetZoneID(); 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; break;
} }

16
dPhysics/dpGrid.cpp
View File

@ -26,8 +26,8 @@ dpGrid::~dpGrid() {
void dpGrid::Add(dpEntity* entity) { void dpGrid::Add(dpEntity* entity) {
//Determine which grid cell it's in. //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] // Clamp values to the range [0, NUM_CELLS - 1]
cellX = std::clamp(cellX, 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) { 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] // Clamp values to the range [0, NUM_CELLS - 1]
cellX = std::clamp(cellX, 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) { void dpGrid::Delete(dpEntity* entity) {
if (!entity) return; 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] // Clamp values to the range [0, NUM_CELLS - 1]
oldCellX = std::clamp(oldCellX, 0, NUM_CELLS - 1); oldCellX = std::clamp(oldCellX, 0, NUM_CELLS - 1);

2
dScripts/02_server/Map/General/StoryBoxInteractServer.cpp
View File

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

10
dWorldServer/WorldServer.cpp
View File

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

17
dZoneManager/Zone.cpp
View File

@ -17,6 +17,7 @@
#include "eTriggerCommandType.h" #include "eTriggerCommandType.h"
#include "eTriggerEventType.h" #include "eTriggerEventType.h"
#include "eWaypointCommandType.h"
#include "dNavMesh.h" #include "dNavMesh.h"
Zone::Zone(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) : Zone::Zone(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) :
@ -452,15 +453,23 @@ void Zone::LoadPath(std::istream& file) {
std::string value; std::string value;
BinaryIO::ReadString<uint8_t>(file, value, BinaryIO::ReadType::WideString); BinaryIO::ReadString<uint8_t>(file, value, BinaryIO::ReadType::WideString);
LDFBaseData* ldfConfig = nullptr;
if (path.pathType == PathType::Movement || path.pathType == PathType::Rail) { 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 { } 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, // We verify the waypoint heights against the navmesh because in many movement paths,
// the waypoint is located near 0 height, // the waypoint is located near 0 height,
if (path.pathType == PathType::Movement) { if (path.pathType == PathType::Movement) {

9
dZoneManager/Zone.h
View File

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

38
tests/dCommonTests/TestLDFFormat.cpp
View File

@ -27,7 +27,7 @@ TEST_F(LDFTests, LDFUTF16Test) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -37,7 +37,7 @@ TEST_F(LDFTests, LDFUTF16EmptyTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -47,7 +47,7 @@ TEST_F(LDFTests, LDFUTF16ColonTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -57,7 +57,7 @@ TEST_F(LDFTests, LDFUTF16EqualsTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -66,7 +66,7 @@ TEST_F(LDFTests, LDFS32Test) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_S32); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_S32);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=1:-15");
} }
TEST_F(LDFTests, LDFU32Test) { TEST_F(LDFTests, LDFU32Test) {
@ -74,7 +74,7 @@ TEST_F(LDFTests, LDFU32Test) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=5:15");
} }
@ -83,7 +83,7 @@ TEST_F(LDFTests, LDFU32TrueTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=5:1");
} }
@ -92,7 +92,7 @@ TEST_F(LDFTests, LDFU32FalseTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=5:0");
} }
@ -103,7 +103,7 @@ TEST_F(LDFTests, LDFFloatTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_FLOAT); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_FLOAT);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString().find("KEY=3:15.5"), 0);
} }
@ -112,7 +112,7 @@ TEST_F(LDFTests, LDFDoubleTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_DOUBLE); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_DOUBLE);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString().find("KEY=4:15.5"), 0);
} }
@ -122,7 +122,7 @@ TEST_F(LDFTests, LDFBoolTrueTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=7:1");
} }
@ -131,7 +131,7 @@ TEST_F(LDFTests, LDFBoolFalseTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=7:0");
} }
@ -140,7 +140,7 @@ TEST_F(LDFTests, LDFBoolIntTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=7:1");
} }
@ -149,7 +149,7 @@ TEST_F(LDFTests, LDFU64Test) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U64); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U64);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=8:15");
} }
@ -158,7 +158,7 @@ TEST_F(LDFTests, LDFLWOOBJIDTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_OBJID); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_OBJID);
ASSERT_EQ(data->GetKey(), u"KEY"); 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"); ASSERT_EQ(data->GetString(), "KEY=9:15");
} }
@ -168,7 +168,7 @@ TEST_F(LDFTests, LDFUTF8Test) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -178,7 +178,7 @@ TEST_F(LDFTests, LDFUTF8EmptyTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
@ -188,7 +188,7 @@ TEST_F(LDFTests, LDFUTF8ColonsTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }
TEST_F(LDFTests, LDFUTF8EqualsTest) { TEST_F(LDFTests, LDFUTF8EqualsTest) {
@ -197,7 +197,7 @@ TEST_F(LDFTests, LDFUTF8EqualsTest) {
ASSERT_NE(data, nullptr); ASSERT_NE(data, nullptr);
ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8); ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
ASSERT_EQ(data->GetKey(), u"KEY"); 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); ASSERT_EQ(data->GetString(), testWord);
} }

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

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

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

@ -2,297 +2,297 @@
#include "eGameMessageType.h" #include "eGameMessageType.h"
TEST(LegacyGameMessageTests, AssertLegacyGmValues) { 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));
} }