diff --git a/dAuthServer/AuthServer.cpp b/dAuthServer/AuthServer.cpp index f5090495..ddec32db 100644 --- a/dAuthServer/AuthServer.cpp +++ b/dAuthServer/AuthServer.cpp @@ -15,10 +15,13 @@ //RakNet includes: #include "RakNetDefines.h" +#include //Auth includes: #include "AuthPackets.h" -#include "dMessageIdentifiers.h" +#include "eConnectionType.h" +#include "eServerMessageType.h" +#include "eAuthMessageType.h" #include "Game.h" namespace Game { @@ -169,12 +172,12 @@ dLogger* SetupLogger() { void HandlePacket(Packet* packet) { if (packet->data[0] == ID_USER_PACKET_ENUM) { - if (packet->data[1] == SERVER) { - if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) { + if (static_cast(packet->data[1]) == eConnectionType::SERVER) { + if (static_cast(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) { AuthPackets::HandleHandshake(Game::server, packet); } - } else if (packet->data[1] == AUTH) { - if (packet->data[3] == MSG_AUTH_LOGIN_REQUEST) { + } else if (static_cast(packet->data[1]) == eConnectionType::AUTH) { + if (static_cast(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) { AuthPackets::HandleLoginRequest(Game::server, packet); } } diff --git a/dChatServer/ChatPacketHandler.cpp b/dChatServer/ChatPacketHandler.cpp index a0d508cb..9b5ca761 100644 --- a/dChatServer/ChatPacketHandler.cpp +++ b/dChatServer/ChatPacketHandler.cpp @@ -3,7 +3,6 @@ #include "Database.h" #include #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "Game.h" #include "dServer.h" #include "GeneralUtils.h" @@ -13,6 +12,11 @@ #include "RakString.h" #include "dConfig.h" #include "eObjectBits.h" +#include "eConnectionType.h" +#include "eChatMessageType.h" +#include "eChatInternalMessageType.h" +#include "eClientMessageType.h" +#include "eGameMessageType.h" extern PlayerContainer playerContainer; @@ -72,11 +76,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) { //Now, we need to send the friendlist to the server they came from: CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(playerID); //portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE); bitStream.Write(0); bitStream.Write(1); //Length of packet -- just writing one as it doesn't matter, client skips it. bitStream.Write((uint16_t)friends.size()); @@ -413,10 +417,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) { const auto otherName = std::string(otherMember->playerName.c_str()); CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(otherMember->playerID); - PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); bitStream.Write(otherMember->playerID); bitStream.Write(8); bitStream.Write(69); @@ -452,10 +456,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) { //To the sender: { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(goonA->playerID); - PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); bitStream.Write(goonA->playerID); bitStream.Write(7); bitStream.Write(69); @@ -475,10 +479,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) { //To the receiver: { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(goonB->playerID); - PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); bitStream.Write(goonA->playerID); bitStream.Write(7); bitStream.Write(69); @@ -717,11 +721,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) { void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE); PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream); bitStream.Write(sender->playerID); @@ -732,14 +736,14 @@ void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_INVITE_CONFIRM); + bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM); bitStream.Write(bLeaderIsFreeTrial); bitStream.Write(i64LeaderID); @@ -759,14 +763,14 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_GET_STATUS_RESPONSE); + bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE); bitStream.Write(i64LeaderID); bitStream.Write(i64LeaderZoneID); @@ -784,14 +788,14 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_LEADER); + bitStream.Write(eGameMessageType::TEAM_SET_LEADER); bitStream.Write(i64PlayerID); @@ -801,14 +805,14 @@ void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64Play void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_ADD_PLAYER); + bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER); bitStream.Write(bIsFreeTrial); bitStream.Write(bLocal); @@ -830,14 +834,14 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_REMOVE_PLAYER); + bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER); bitStream.Write(bDisband); bitStream.Write(bIsKicked); @@ -856,14 +860,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: CMSGHEADER; bitStream.Write(receiver->playerID); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_OFF_WORLD_FLAG); + bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG); bitStream.Write(i64PlayerID); if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) { @@ -890,11 +894,11 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla [bool] - is FTP*/ CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(friendData->playerID); //portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY); bitStream.Write(notifyType); std::string playerName = playerData->playerName.c_str(); @@ -929,11 +933,11 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send } CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST); PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream); bitStream.Write(0); // This is a BFF flag however this is unused in live and does not have an implementation client side. @@ -945,11 +949,11 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen if (!receiver || !sender) return; CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); // Portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE); bitStream.Write(responseCode); // For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver. bitStream.Write(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS); @@ -970,11 +974,11 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers if (!receiver) return; CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); bitStream.Write(receiver->playerID); //portion that will get routed: - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE); bitStream.Write(isSuccessful); //isOnline PacketUtils::WritePacketWString(personToRemove, 33, &bitStream); diff --git a/dChatServer/ChatServer.cpp b/dChatServer/ChatServer.cpp index a75c4d51..3e3ddfd3 100644 --- a/dChatServer/ChatServer.cpp +++ b/dChatServer/ChatServer.cpp @@ -9,19 +9,23 @@ #include "dLogger.h" #include "Database.h" #include "dConfig.h" -#include "dMessageIdentifiers.h" #include "dChatFilter.h" #include "Diagnostics.h" #include "AssetManager.h" #include "BinaryPathFinder.h" - +#include "eConnectionType.h" #include "PlayerContainer.h" #include "ChatPacketHandler.h" +#include "eChatMessageType.h" +#include "eChatInternalMessageType.h" +#include "eWorldMessageType.h" #include "Game.h" //RakNet includes: #include "RakNetDefines.h" +#include + namespace Game { dLogger* logger = nullptr; dServer* server = nullptr; @@ -68,7 +72,7 @@ int main(int argc, char** argv) { Game::assetManager = new AssetManager(clientPath); } catch (std::runtime_error& ex) { Game::logger->Log("ChatServer", "Got an error while setting up assets: %s", ex.what()); - + return EXIT_FAILURE; } @@ -199,25 +203,25 @@ void HandlePacket(Packet* packet) { Game::logger->Log("ChatServer", "A server is connecting, awaiting user list."); } - if (packet->data[1] == CHAT_INTERNAL) { - switch (packet->data[3]) { - case MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION: + if (static_cast(packet->data[1]) == eConnectionType::CHAT_INTERNAL) { + switch (static_cast(packet->data[3])) { + case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION: playerContainer.InsertPlayer(packet); break; - case MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION: + case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION: playerContainer.RemovePlayer(packet); break; - case MSG_CHAT_INTERNAL_MUTE_UPDATE: + case eChatInternalMessageType::MUTE_UPDATE: playerContainer.MuteUpdate(packet); break; - case MSG_CHAT_INTERNAL_CREATE_TEAM: + case eChatInternalMessageType::CREATE_TEAM: playerContainer.CreateTeamServer(packet); break; - case MSG_CHAT_INTERNAL_ANNOUNCEMENT: { + case eChatInternalMessageType::ANNOUNCEMENT: { //we just forward this packet to every connected server CINSTREAM; Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin @@ -229,67 +233,67 @@ void HandlePacket(Packet* packet) { } } - if (packet->data[1] == CHAT) { - switch (packet->data[3]) { - case MSG_CHAT_GET_FRIENDS_LIST: + if (static_cast(packet->data[1]) == eConnectionType::CHAT) { + switch (static_cast(packet->data[3])) { + case eChatMessageType::GET_FRIENDS_LIST: ChatPacketHandler::HandleFriendlistRequest(packet); break; - case MSG_CHAT_GET_IGNORE_LIST: + case eChatMessageType::GET_IGNORE_LIST: Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now."); break; - case MSG_CHAT_TEAM_GET_STATUS: + case eChatMessageType::TEAM_GET_STATUS: ChatPacketHandler::HandleTeamStatusRequest(packet); break; - case MSG_CHAT_ADD_FRIEND_REQUEST: + case eChatMessageType::ADD_FRIEND_REQUEST: //this involves someone sending the initial request, the response is below, response as in from the other player. //We basically just check to see if this player is online or not and route the packet. ChatPacketHandler::HandleFriendRequest(packet); break; - case MSG_CHAT_ADD_FRIEND_RESPONSE: + case eChatMessageType::ADD_FRIEND_RESPONSE: //This isn't the response a server sent, rather it is a player's response to a received request. //Here, we'll actually have to add them to eachother's friend lists depending on the response code. ChatPacketHandler::HandleFriendResponse(packet); break; - case MSG_CHAT_REMOVE_FRIEND: + case eChatMessageType::REMOVE_FRIEND: ChatPacketHandler::HandleRemoveFriend(packet); break; - case MSG_CHAT_GENERAL_CHAT_MESSAGE: + case eChatMessageType::GENERAL_CHAT_MESSAGE: ChatPacketHandler::HandleChatMessage(packet); break; - case MSG_CHAT_PRIVATE_CHAT_MESSAGE: + case eChatMessageType::PRIVATE_CHAT_MESSAGE: //This message is supposed to be echo'd to both the sender and the receiver //BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up. ChatPacketHandler::HandlePrivateChatMessage(packet); break; - case MSG_CHAT_TEAM_INVITE: + case eChatMessageType::TEAM_INVITE: ChatPacketHandler::HandleTeamInvite(packet); break; - case MSG_CHAT_TEAM_INVITE_RESPONSE: + case eChatMessageType::TEAM_INVITE_RESPONSE: ChatPacketHandler::HandleTeamInviteResponse(packet); break; - case MSG_CHAT_TEAM_LEAVE: + case eChatMessageType::TEAM_LEAVE: ChatPacketHandler::HandleTeamLeave(packet); break; - case MSG_CHAT_TEAM_SET_LEADER: + case eChatMessageType::TEAM_SET_LEADER: ChatPacketHandler::HandleTeamPromote(packet); break; - case MSG_CHAT_TEAM_KICK: + case eChatMessageType::TEAM_KICK: ChatPacketHandler::HandleTeamKick(packet); break; - case MSG_CHAT_TEAM_SET_LOOT: + case eChatMessageType::TEAM_SET_LOOT: ChatPacketHandler::HandleTeamLootOption(packet); break; @@ -298,9 +302,9 @@ void HandlePacket(Packet* packet) { } } - if (packet->data[1] == WORLD) { - switch (packet->data[3]) { - case MSG_WORLD_CLIENT_ROUTE_PACKET: { + if (static_cast(packet->data[1]) == eConnectionType::WORLD) { + switch (static_cast(packet->data[3])) { + case eWorldMessageType::ROUTE_PACKET: { Game::logger->Log("ChatServer", "Routing packet from world"); break; } diff --git a/dChatServer/PlayerContainer.cpp b/dChatServer/PlayerContainer.cpp index 6bf3ccd1..dcc9ebb9 100644 --- a/dChatServer/PlayerContainer.cpp +++ b/dChatServer/PlayerContainer.cpp @@ -6,9 +6,10 @@ #include "dLogger.h" #include "ChatPacketHandler.h" #include "GeneralUtils.h" -#include "dMessageIdentifiers.h" #include "PacketUtils.h" #include "Database.h" +#include "eConnectionType.h" +#include "eChatInternalMessageType.h" PlayerContainer::PlayerContainer() { } @@ -149,7 +150,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) { void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE); bitStream.Write(player); bitStream.Write(time); @@ -348,7 +349,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) { void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE); bitStream.Write(team->teamID); bitStream.Write(deleteTeam); diff --git a/dCommon/dEnums/dCommonVars.h b/dCommon/dEnums/dCommonVars.h index 26201c3d..e11866f1 100644 --- a/dCommon/dEnums/dCommonVars.h +++ b/dCommon/dEnums/dCommonVars.h @@ -7,6 +7,8 @@ #include #include #include "BitStream.h" +#include "eConnectionType.h" +#include "eClientMessageType.h" #pragma warning (disable:4251) //Disables SQL warnings @@ -28,7 +30,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate); #define CBITSTREAM RakNet::BitStream bitStream; #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false); -#define CMSGHEADER PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GAME_MSG); +#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false); #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true); diff --git a/dCommon/dEnums/dMessageIdentifiers.h b/dCommon/dEnums/dMessageIdentifiers.h deleted file mode 100644 index 7c810a2d..00000000 --- a/dCommon/dEnums/dMessageIdentifiers.h +++ /dev/null @@ -1,564 +0,0 @@ -#pragma once -#include "MessageIdentifiers.h" - -enum CONNECTION_TYPE { - SERVER = 0, //!< Means it is used throughout all servers - AUTH, //!< Means it is sent from the client authentication - CHAT, //!< Means it is sent from and to the chat server - CHAT_INTERNAL, //!< Unused - We can potentially use this in the future for various things - WORLD, //!< Means it is sent from the client world - CLIENT, //!< Means it is sent to the client from the world server - MASTER //!< Means it is sent to and from the master server -}; - -//! The Internal Server Packet Identifiers -enum SERVER { - MSG_SERVER_VERSION_CONFIRM = 0, /*!< Sent during a handshake to confirm the server/client version */ - MSG_SERVER_DISCONNECT_NOTIFY, /*!< Sent when a user disconnected */ - MSG_SERVER_GENERAL_NOTIFY /*!< A general notification */ -}; - -//! The Internal Authentication Packet Identifiers -enum AUTH { - MSG_AUTH_LOGIN_REQUEST = 0, /*!< Sent from the client when a user logs in */ - MSG_AUTH_LOGOUT_REQUEST, /*!< Sent from the client when a user logs out */ - MSG_AUTH_CREATE_NEW_ACCOUNT_REQUEST, /*!< Sent from the client when a user creates a new account */ - MSG_AUTH_LEGOINTERFACE_AUTH_RESPONSE, /*!< Unknown */ - MSG_AUTH_SESSIONKEY_RECEIVED_CONFIRM, /*!< Sent when the server recieved the session key (?) */ - MSG_AUTH_RUNTIME_CONFIG /*!< Unknown */ -}; - -//! The Internal Chat Packet Identifiers -enum CHAT { - MSG_CHAT_LOGIN_SESSION_NOTIFY = 0, /*!< When a user logs in */ - MSG_CHAT_GENERAL_CHAT_MESSAGE, /*!< Used for global chat messages */ - MSG_CHAT_PRIVATE_CHAT_MESSAGE, /*!< Used for private chat messages */ - MSG_CHAT_USER_CHANNEL_CHAT_MESSAGE, /*!< Unknown */ - MSG_CHAT_WORLD_DISCONNECT_REQUEST, /*!< Unknown */ - MSG_CHAT_WORLD_PROXIMITY_RESPONSE, /*!< Unknown */ - MSG_CHAT_WORLD_PARCEL_RESPONSE, /*!< Unknown */ - MSG_CHAT_ADD_FRIEND_REQUEST, /*!< When the client requests to add a friend */ - MSG_CHAT_ADD_FRIEND_RESPONSE, /*!< Sent from the server when the client adds a friend */ - MSG_CHAT_REMOVE_FRIEND, /*!< When the client removes a friend */ - MSG_CHAT_GET_FRIENDS_LIST, /*!< Sent when the client requests a user's friends list */ - MSG_CHAT_ADD_IGNORE, /*!< Sent when the client adds a friend to the "ignore" list */ - MSG_CHAT_REMOVE_IGNORE, /*!< Sent when the client removes a friend from the "ignore" list */ - MSG_CHAT_GET_IGNORE_LIST, /*!< Sent when the client requests a user's ignored list */ - MSG_CHAT_TEAM_MISSED_INVITE_CHECK, /*!< Unknown (Something with an unresponded-to friend request probably) */ - MSG_CHAT_TEAM_INVITE, /*!< When the client invites a user to a team */ - MSG_CHAT_TEAM_INVITE_RESPONSE, /*!< Sent from the server when the client invites someone to the team */ - MSG_CHAT_TEAM_KICK, /*!< Sent when the client kicks a member from a team */ - MSG_CHAT_TEAM_LEAVE, /*!< Sent when the client leaves a team */ - MSG_CHAT_TEAM_SET_LOOT, /*!< Unknown (Something to do with team loot) */ - MSG_CHAT_TEAM_SET_LEADER, /*!< Unknown (Probably sets the team leader or something) */ - MSG_CHAT_TEAM_GET_STATUS, /*!< Check to see if we are in a team or not, sent on world join */ - MSG_CHAT_GUILD_CREATE, /*!< Guild Creation */ - MSG_CHAT_GUILD_INVITE, /*!< Guild Invitation */ - MSG_CHAT_GUILD_INVITE_RESPONSE, /*!< Guild Invite Response */ - MSG_CHAT_GUILD_LEAVE, /*!< Guild Leave */ - MSG_CHAT_GUILD_KICK, /*!< Guild Kick */ - MSG_CHAT_GUILD_GET_STATUS, /*!< Guild Get Status */ - MSG_CHAT_GUILD_GET_ALL, /*!< Guild Get All */ - MSG_CHAT_SHOW_ALL, - MSG_CHAT_BLUEPRINT_MODERATED, - MSG_CHAT_BLUEPRINT_MODEL_READY, - MSG_CHAT_PROPERTY_READY_FOR_APPROVAL, - MSG_CHAT_PROPERTY_MODERATION_CHANGED, - MSG_CHAT_PROPERTY_BUILDMODE_CHANGED, - MSG_CHAT_PROPERTY_BUILDMODE_CHANGED_REPORT, - MSG_CHAT_MAIL, - MSG_CHAT_WORLD_INSTANCE_LOCATION_REQUEST, - MSG_CHAT_REPUTATION_UPDATE, - MSG_CHAT_SEND_CANNED_TEXT, - MSG_CHAT_GMLEVEL_UPDATE, - MSG_CHAT_CHARACTER_NAME_CHANGE_REQUEST, - MSG_CHAT_CSR_REQUEST, - MSG_CHAT_CSR_REPLY, - MSG_CHAT_GM_KICK, - MSG_CHAT_GM_ANNOUNCE, - MSG_CHAT_GM_MUTE, - MSG_CHAT_ACTIVITY_UPDATE, - MSG_CHAT_WORLD_ROUTE_PACKET, - MSG_CHAT_GET_ZONE_POPULATIONS, - MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE, - MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE_PRIVATE, - MSG_CHAT_MATCH_REQUEST, - MSG_CHAT_UGCMANIFEST_REPORT_MISSING_FILE, - MSG_CHAT_UGCMANIFEST_REPORT_DONE_FILE, - MSG_CHAT_UGCMANIFEST_REPORT_DONE_BLUEPRINT, - MSG_CHAT_UGCC_REQUEST, - MSG_CHAT_WHO, - MSG_CHAT_WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE, - MSG_CHAT_ACHIEVEMENT_NOTIFY, - MSG_CHAT_GM_CLOSE_PRIVATE_CHAT_WINDOW, - MSG_CHAT_UNEXPECTED_DISCONNECT, - MSG_CHAT_PLAYER_READY, - MSG_CHAT_GET_DONATION_TOTAL, - MSG_CHAT_UPDATE_DONATION, - MSG_CHAT_PRG_CSR_COMMAND, - MSG_CHAT_HEARTBEAT_REQUEST_FROM_WORLD, - MSG_CHAT_UPDATE_FREE_TRIAL_STATUS -}; - -//! Used for packets related to chatting -enum CHAT_INTERNAL { - MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION = 0, - MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION, - MSG_CHAT_INTERNAL_ADD_FRIEND, - MSG_CHAT_INTERNAL_ADD_BEST_FRIEND, - MSG_CHAT_INTERNAL_ADD_TO_TEAM, - MSG_CHAT_INTERNAL_ADD_BLOCK, - MSG_CHAT_INTERNAL_REMOVE_FRIEND, - MSG_CHAT_INTERNAL_REMOVE_BLOCK, - MSG_CHAT_INTERNAL_REMOVE_FROM_TEAM, - MSG_CHAT_INTERNAL_DELETE_TEAM, - MSG_CHAT_INTERNAL_REPORT, - MSG_CHAT_INTERNAL_PRIVATE_CHAT, - MSG_CHAT_INTERNAL_PRIVATE_CHAT_RESPONSE, - MSG_CHAT_INTERNAL_ANNOUNCEMENT, - MSG_CHAT_INTERNAL_MAIL_COUNT_UPDATE, - MSG_CHAT_INTERNAL_MAIL_SEND_NOTIFY, - MSG_CHAT_INTERNAL_REQUEST_USER_LIST, - MSG_CHAT_INTERNAL_FRIEND_LIST, - MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER, - MSG_CHAT_INTERNAL_TEAM_UPDATE, - MSG_CHAT_INTERNAL_MUTE_UPDATE, - MSG_CHAT_INTERNAL_CREATE_TEAM, -}; - -//! Used for packets send to the world -enum WORLD { - MSG_WORLD_CLIENT_VALIDATION = 1, // Session info - MSG_WORLD_CLIENT_CHARACTER_LIST_REQUEST, - MSG_WORLD_CLIENT_CHARACTER_CREATE_REQUEST, - MSG_WORLD_CLIENT_LOGIN_REQUEST, // Character selected - MSG_WORLD_CLIENT_GAME_MSG, - MSG_WORLD_CLIENT_CHARACTER_DELETE_REQUEST, - MSG_WORLD_CLIENT_CHARACTER_RENAME_REQUEST, - MSG_WORLD_CLIENT_HAPPY_FLOWER_MODE_NOTIFY, - MSG_WORLD_CLIENT_SLASH_RELOAD_MAP, // Reload map cmp - MSG_WORLD_CLIENT_SLASH_PUSH_MAP_REQUEST, // Push map req cmd - MSG_WORLD_CLIENT_SLASH_PUSH_MAP, // Push map cmd - MSG_WORLD_CLIENT_SLASH_PULL_MAP, // Pull map cmd - MSG_WORLD_CLIENT_LOCK_MAP_REQUEST, - MSG_WORLD_CLIENT_GENERAL_CHAT_MESSAGE, // General chat message - MSG_WORLD_CLIENT_HTTP_MONITOR_INFO_REQUEST, - MSG_WORLD_CLIENT_SLASH_DEBUG_SCRIPTS, // Debug scripts cmd - MSG_WORLD_CLIENT_MODELS_CLEAR, - MSG_WORLD_CLIENT_EXHIBIT_INSERT_MODEL, - MSG_WORLD_CLIENT_LEVEL_LOAD_COMPLETE, // Character data request - MSG_WORLD_CLIENT_TMP_GUILD_CREATE, - MSG_WORLD_CLIENT_ROUTE_PACKET, // Social? - MSG_WORLD_CLIENT_POSITION_UPDATE, - MSG_WORLD_CLIENT_MAIL, - MSG_WORLD_CLIENT_WORD_CHECK, // Whitelist word check - MSG_WORLD_CLIENT_STRING_CHECK, // Whitelist string check - MSG_WORLD_CLIENT_GET_PLAYERS_IN_ZONE, - MSG_WORLD_CLIENT_REQUEST_UGC_MANIFEST_INFO, - MSG_WORLD_CLIENT_BLUEPRINT_GET_ALL_DATA_REQUEST, - MSG_WORLD_CLIENT_CANCEL_MAP_QUEUE, - MSG_WORLD_CLIENT_HANDLE_FUNNESS, - MSG_WORLD_CLIENT_FAKE_PRG_CSR_MESSAGE, - MSG_WORLD_CLIENT_REQUEST_FREE_TRIAL_REFRESH, - MSG_WORLD_CLIENT_GM_SET_FREE_TRIAL_STATUS -}; - -//! An enum for packets sent to the client -enum CLIENT { - MSG_CLIENT_LOGIN_RESPONSE = 0, - MSG_CLIENT_LOGOUT_RESPONSE, - MSG_CLIENT_LOAD_STATIC_ZONE, - MSG_CLIENT_CREATE_OBJECT, - MSG_CLIENT_CREATE_CHARACTER, - MSG_CLIENT_CREATE_CHARACTER_EXTENDED, - MSG_CLIENT_CHARACTER_LIST_RESPONSE, - MSG_CLIENT_CHARACTER_CREATE_RESPONSE, - MSG_CLIENT_CHARACTER_RENAME_RESPONSE, - MSG_CLIENT_CHAT_CONNECT_RESPONSE, - MSG_CLIENT_AUTH_ACCOUNT_CREATE_RESPONSE, - MSG_CLIENT_DELETE_CHARACTER_RESPONSE, - MSG_CLIENT_GAME_MSG, - MSG_CLIENT_CONNECT_CHAT, - MSG_CLIENT_TRANSFER_TO_WORLD, - MSG_CLIENT_IMPENDING_RELOAD_NOTIFY, - MSG_CLIENT_MAKE_GM_RESPONSE, - MSG_CLIENT_HTTP_MONITOR_INFO_RESPONSE, - MSG_CLIENT_SLASH_PUSH_MAP_RESPONSE, - MSG_CLIENT_SLASH_PULL_MAP_RESPONSE, - MSG_CLIENT_SLASH_LOCK_MAP_RESPONSE, - MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE, - MSG_CLIENT_BLUEPRINT_LUP_SAVE_RESPONSE, - MSG_CLIENT_BLUEPRINT_LOAD_RESPONSE_ITEMID, - MSG_CLIENT_BLUEPRINT_GET_ALL_DATA_RESPONSE, - MSG_CLIENT_MODEL_INSTANTIATE_RESPONSE, - MSG_CLIENT_DEBUG_OUTPUT, - MSG_CLIENT_ADD_FRIEND_REQUEST, - MSG_CLIENT_ADD_FRIEND_RESPONSE, - MSG_CLIENT_REMOVE_FRIEND_RESPONSE, - MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE, - MSG_CLIENT_UPDATE_FRIEND_NOTIFY, - MSG_CLIENT_ADD_IGNORE_RESPONSE, - MSG_CLIENT_REMOVE_IGNORE_RESPONSE, - MSG_CLIENT_GET_IGNORE_LIST_RESPONSE, - MSG_CLIENT_TEAM_INVITE, - MSG_CLIENT_TEAM_INVITE_INITIAL_RESPONSE, - MSG_CLIENT_GUILD_CREATE_RESPONSE, - MSG_CLIENT_GUILD_GET_STATUS_RESPONSE, - MSG_CLIENT_GUILD_INVITE, - MSG_CLIENT_GUILD_INVITE_INITIAL_RESPONSE, - MSG_CLIENT_GUILD_INVITE_FINAL_RESPONSE, - MSG_CLIENT_GUILD_INVITE_CONFIRM, - MSG_CLIENT_GUILD_ADD_PLAYER, - MSG_CLIENT_GUILD_REMOVE_PLAYER, - MSG_CLIENT_GUILD_LOGIN_LOGOUT, - MSG_CLIENT_GUILD_RANK_CHANGE, - MSG_CLIENT_GUILD_DATA, - MSG_CLIENT_GUILD_STATUS, - MSG_CLIENT_MAIL, - MSG_CLIENT_DB_PROXY_RESULT, - MSG_CLIENT_SHOW_ALL_RESPONSE, - MSG_CLIENT_WHO_RESPONSE, - MSG_CLIENT_SEND_CANNED_TEXT, - MSG_CLIENT_UPDATE_CHARACTER_NAME, - MSG_CLIENT_SET_NETWORK_SIMULATOR, - MSG_CLIENT_INVALID_CHAT_MESSAGE, - MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE, - MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE_PRIVATE, - MSG_CLIENT_CHAT_MODERATION_STRING, - MSG_CLIENT_UGC_MANIFEST_RESPONSE, - MSG_CLIENT_IN_LOGIN_QUEUE, - MSG_CLIENT_SERVER_STATES, - MSG_CLIENT_GM_CLOSE_TARGET_CHAT_WINDOW, - MSG_CLIENT_GENERAL_TEXT_FOR_LOCALIZATION, - MSG_CLIENT_UPDATE_FREE_TRIAL_STATUS, - MSG_CLIENT_UGC_DOWNLOAD_FAILED = 120 -}; - -//! Used for packets sent to the master server -enum MASTER { - MSG_MASTER_REQUEST_PERSISTENT_ID = 1, - MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE, - MSG_MASTER_REQUEST_ZONE_TRANSFER, - MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE, - MSG_MASTER_SERVER_INFO, - MSG_MASTER_REQUEST_SESSION_KEY, - MSG_MASTER_SET_SESSION_KEY, - MSG_MASTER_SESSION_KEY_RESPONSE, - MSG_MASTER_PLAYER_ADDED, - MSG_MASTER_PLAYER_REMOVED, - - MSG_MASTER_CREATE_PRIVATE_ZONE, - MSG_MASTER_REQUEST_PRIVATE_ZONE, - - MSG_MASTER_WORLD_READY, - MSG_MASTER_PREP_ZONE, - - MSG_MASTER_SHUTDOWN, - MSG_MASTER_SHUTDOWN_RESPONSE, - MSG_MASTER_SHUTDOWN_IMMEDIATE, - - MSG_MASTER_SHUTDOWN_UNIVERSE, - - MSG_MASTER_AFFIRM_TRANSFER_REQUEST, - MSG_MASTER_AFFIRM_TRANSFER_RESPONSE, - - MSG_MASTER_NEW_SESSION_ALERT -}; - -//! The Game messages -enum GAME_MSG : unsigned short { - GAME_MSG_TELEPORT = 19, - GAME_MSG_SET_PLAYER_CONTROL_SCHEME = 26, - GAME_MSG_DROP_CLIENT_LOOT = 30, - GAME_MSG_DIE = 37, - GAME_MSG_REQUEST_DIE = 38, - GAME_MSG_PLAY_EMOTE = 41, - GAME_MSG_PLAY_ANIMATION = 43, - GAME_MSG_CONTROL_BEHAVIOR = 48, - GAME_MSG_SET_NAME = 72, - GAME_MSG_ECHO_START_SKILL = 118, - GAME_MSG_START_SKILL = 119, - GAME_MSG_VERIFY_ACK = 121, - GAME_MSG_ADD_SKILL = 127, - GAME_MSG_REMOVE_SKILL = 128, - GAME_MSG_SET_CURRENCY = 133, - GAME_MSG_PICKUP_CURRENCY = 137, - GAME_MSG_PICKUP_ITEM = 139, - GAME_MSG_TEAM_PICKUP_ITEM = 140, - GAME_MSG_PLAY_FX_EFFECT = 154, - GAME_MSG_STOP_FX_EFFECT = 155, - GAME_MSG_REQUEST_RESURRECT = 159, - GAME_MSG_RESURRECT = 160, - GAME_MSG_PUSH_EQUIPPED_ITEMS_STATE = 191, - GAME_MSG_POP_EQUIPPED_ITEMS_STATE = 192, - GAME_MSG_SET_GM_LEVEL = 193, - GAME_MSG_SET_STUNNED = 198, - GAME_MSG_SET_STUN_IMMUNITY = 200, - GAME_MSG_KNOCKBACK = 202, - GAME_MSG_REBUILD_CANCEL = 209, - GAME_MSG_ENABLE_REBUILD = 213, - GAME_MSG_MOVE_ITEM_IN_INVENTORY = 224, - GAME_MSG_ADD_ITEM_TO_INVENTORY_CLIENT_SYNC = 227, - GAME_MSG_REMOVE_ITEM_FROM_INVENTORY = 230, - GAME_MSG_EQUIP_ITEM = 231, - GAME_MSG_UN_EQUIP_ITEM = 233, - GAME_MSG_OFFER_MISSION = 248, - GAME_MSG_RESPOND_TO_MISSION = 249, - GAME_MSG_NOTIFY_MISSION = 254, - GAME_MSG_NOTIFY_MISSION_TASK = 255, - GAME_MSG_REBUILD_NOTIFY_STATE = 336, - GAME_MSG_TERMINATE_INTERACTION = 357, - GAME_MSG_SERVER_TERMINATE_INTERACTION = 358, - GAME_MSG_REQUEST_USE = 364, - GAME_MSG_VENDOR_OPEN_WINDOW = 369, - GAME_MSG_BUY_FROM_VENDOR = 373, - GAME_MSG_SELL_TO_VENDOR = 374, - GAME_MSG_TEAM_SET_OFF_WORLD_FLAG = 383, - GAME_MSG_SET_INVENTORY_SIZE = 389, - GAME_MSG_ACKNOWLEDGE_POSSESSION = 391, - GAME_MSG_SET_SHOOTING_GALLERY_PARAMS = 400, - GAME_MSG_REQUEST_ACTIVITY_START_STOP = 402, - GAME_MSG_REQUEST_ACTIVITY_ENTER = 403, - GAME_MSG_REQUEST_ACTIVITY_EXIT = 404, - GAME_MSG_ACTIVITY_ENTER = 405, - GAME_MSG_ACTIVITY_EXIT = 406, - GAME_MSG_ACTIVITY_START = 407, - GAME_MSG_ACTIVITY_STOP = 408, - GAME_MSG_SHOOTING_GALLERY_CLIENT_AIM_UPDATE = 409, - GAME_MSG_SHOOTING_GALLERY_FIRE = 411, - GAME_MSG_REQUEST_VENDOR_STATUS_UPDATE = 416, - GAME_MSG_VENDOR_STATUS_UPDATE = 417, - GAME_MSG_NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE = 425, - GAME_MSG_CONSUME_CLIENT_ITEM = 427, - GAME_MSG_CLIENT_ITEM_CONSUMED = 428, - GAME_MSG_UPDATE_SHOOTING_GALLERY_ROTATION = 448, - GAME_MSG_SET_FLAG = 471, - GAME_MSG_NOTIFY_CLIENT_FLAG_CHANGE = 472, - GAME_MSG_VENDOR_TRANSACTION_RESULT = 476, - GAME_MSG_HAS_BEEN_COLLECTED = 486, - GAME_MSG_DISPLAY_CHAT_BUBBLE = 495, - GAME_MSG_SPAWN_PET = 498, - GAME_MSG_DESPAWN_PET = 499, - GAME_MSG_PLAYER_LOADED = 505, - GAME_MSG_PLAYER_READY = 509, - GAME_MSG_REQUEST_LINKED_MISSION = 515, - GAME_MSG_INVALID_ZONE_TRANSFER_LIST = 519, - GAME_MSG_MISSION_DIALOGUE_OK = 520, - GAME_MSG_DISPLAY_MESSAGE_BOX = 529, - GAME_MSG_MESSAGE_BOX_RESPOND = 530, - GAME_MSG_CHOICE_BOX_RESPOND = 531, - GAME_MSG_SMASH = 537, - GAME_MSG_UNSMASH = 538, - GAME_MSG_SET_SHOOTING_GALLERY_RETICULE_EFFECT = 548, - GAME_MSG_PLACE_MODEL_RESPONSE = 0x223, - GAME_MSG_SET_JET_PACK_MODE = 561, - GAME_MSG_REGISTER_PET_ID = 565, - GAME_MSG_REGISTER_PET_DBID = 566, - GAME_MSG_SHOW_ACTIVITY_COUNTDOWN = 568, - GAME_MSG_START_ACTIVITY_TIME = 576, - GAME_MSG_ACTIVITY_PAUSE = 602, - GAME_MSG_USE_NON_EQUIPMENT_ITEM = 603, - GAME_MSG_USE_ITEM_RESULT = 607, - GAME_MSG_COMMAND_PET = 640, - GAME_MSG_PET_RESPONSE = 641, - GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 648, - GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 649, - GAME_MSG_NOTIFY_OBJECT = 656, - GAME_MSG_CLIENT_NOTIFY_PET = 659, - GAME_MSG_NOTIFY_PET = 660, - GAME_MSG_NOTIFY_PET_TAMING_MINIGAME = 661, - GAME_MSG_START_SERVER_PET_MINIGAME_TIMER = 662, - GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME = 663, - GAME_MSG_PET_NAME_CHANGED = 686, - GAME_MSG_PET_TAMING_MINIGAME_RESULT = 667, - GAME_MSG_PET_TAMING_TRY_BUILD_RESULT = 668, - GAME_MSG_NOTIFY_TAMING_BUILD_SUCCESS = 673, - GAME_MSG_NOTIFY_TAMING_MODEL_LOADED_ON_SERVER = 674, - GAME_MSG_ACTIVATE_BUBBLE_BUFF = 678, - GAME_MSG_DEACTIVATE_BUBBLE_BUFF = 679, - GAME_MSG_ADD_PET_TO_PLAYER = 681, - GAME_MSG_REQUEST_SET_PET_NAME = 683, - GAME_MSG_SET_PET_NAME = 684, - GAME_MSG_NOTIFY_PET_TAMING_PUZZLE_SELECTED = 675, - GAME_MSG_SHOW_PET_ACTION_BUTTON = 692, - GAME_MSG_SET_EMOTE_LOCK_STATE = 693, - GAME_MSG_USE_ITEM_REQUIREMENTS_RESPONSE = 703, - GAME_MSG_PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT = 713, - GAME_MSG_DOWNLOAD_PROPERTY_DATA = 716, - GAME_MSG_QUERY_PROPERTY_DATA = 717, - GAME_MSG_PROPERTY_EDITOR_BEGIN = 724, - GAME_MSG_PROPERTY_EDITOR_END = 725, - GAME_MSG_IS_MINIFIG_IN_A_BUBBLE = 729, - GAME_MSG_START_PATHING = 733, - GAME_MSG_ACTIVATE_BUBBLE_BUFF_FROM_SERVER = 734, - GAME_MSG_DEACTIVATE_BUBBLE_BUFF_FROM_SERVER = 735, - GAME_MSG_NOTIFY_CLIENT_ZONE_OBJECT = 737, - GAME_MSG_UPDATE_REPUTATION = 746, - GAME_MSG_PROPERTY_RENTAL_RESPONSE = 750, - GAME_MSG_REQUEST_PLATFORM_RESYNC = 760, - GAME_MSG_PLATFORM_RESYNC = 761, - GAME_MSG_PLAY_CINEMATIC = 762, - GAME_MSG_END_CINEMATIC = 763, - GAME_MSG_CINEMATIC_UPDATE = 764, - GAME_MSG_TOGGLE_GHOST_REFERENCE_OVERRIDE = 767, - GAME_MSG_SET_GHOST_REFERENCE_POSITION = 768, - GAME_MSG_FIRE_EVENT_SERVER_SIDE = 770, - GAME_MSG_SET_NETWORK_SCRIPT_VAR = 781, - GAME_MSG_UPDATE_MODEL_FROM_CLIENT = 793, - GAME_MSG_DELETE_MODEL_FROM_CLIENT = 794, - GAME_MSG_PLAY_ND_AUDIO_EMITTER = 821, - GAME_MSG_PLAY2_DAMBIENT_SOUND = 831, - GAME_MSG_ENTER_PROPERTY1 = 840, - GAME_MSG_ENTER_PROPERTY2 = 841, - GAME_MSG_PROPERTY_ENTRANCE_SYNC = 842, - GAME_MSG_PROPERTY_SELECT_QUERY = 845, - GAME_MSG_PARSE_CHAT_MESSAGE = 850, - GAME_MSG_BROADCAST_TEXT_TO_CHATBOX = 858, - GAME_MSG_OPEN_PROPERTY_MANAGEMENT = 860, - GAME_MSG_OPEN_PROPERTY_VENDOR = 861, - GAME_MSG_UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK = 863, - GAME_MSG_CLIENT_TRADE_REQUEST = 868, - GAME_MSG_SERVER_TRADE_REQUEST = 869, - GAME_MSG_SERVER_TRADE_INVITE = 870, - GAME_MSG_CLIENT_TRADE_REPLY = 871, - GAME_MSG_SERVER_TRADE_REPLY = 872, - GAME_MSG_SERVER_TRADE_INITIAL_REPLY = 873, - GAME_MSG_SERVER_TRADE_FINAL_REPLY = 874, - GAME_MSG_CLIENT_TRADE_UPDATE = 875, - GAME_MSG_SERVER_SIDE_TRADE_UPDATE = 876, - GAME_MSG_SERVER_TRADE_UPDATE = 877, - GAME_MSG_CLIENT_TRADE_CANCEL = 878, - GAME_MSG_CLIENT_SIDE_TRADE_CANCEL = 879, - GAME_MSG_CLIENT_TRADE_ACCEPT = 880, - GAME_MSG_SERVER_SIDE_TRADE_ACCEPT = 881, - GAME_MSG_SERVER_SIDE_TRADE_CANCEL = 882, - GAME_MSG_SERVER_TRADE_CANCEL = 883, - GAME_MSG_SERVER_TRADE_ACCEPT = 884, - GAME_MSG_READY_FOR_UPDATES = 888, - GAME_MSG_ORIENT_TO_OBJECT = 905, - GAME_MSG_ORIENT_TO_POSITION = 906, - GAME_MSG_ORIENT_TO_ANGLE = 907, - GAME_MSG_BOUNCER_ACTIVE_STATUS = 942, - GAME_MSG_UN_USE_BBB_MODEL = 999, - GAME_MSG_BBB_LOAD_ITEM_REQUEST = 1000, - GAME_MSG_BBB_SAVE_REQUEST = 1001, - GAME_MSG_BBB_SAVE_RESPONSE = 1006, - GAME_MSG_NOTIFY_CLIENT_OBJECT = 1042, - GAME_MSG_DISPLAY_ZONE_SUMMARY = 1043, - GAME_MSG_ZONE_SUMMARY_DISMISSED = 1044, - GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST = 1053, - GAME_MSG_MODIFY_PLAYER_ZONE_STATISTIC = 1046, - GAME_MSG_START_BUILDING_WITH_ITEM = 1057, - GAME_MSG_START_ARRANGING_WITH_ITEM = 1061, - GAME_MSG_FINISH_ARRANGING_WITH_ITEM = 1062, - GAME_MSG_DONE_ARRANGING_WITH_ITEM = 1063, - GAME_MSG_SET_BUILD_MODE = 1068, - GAME_MSG_BUILD_MODE_SET = 1069, - GAME_MSG_SET_BUILD_MODE_CONFIRMED = 1073, - GAME_MSG_NOTIFY_CLIENT_FAILED_PRECONDITION = 1081, - GAME_MSG_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1093, - GAME_MSG_MODULAR_BUILD_BEGIN = 1094, - GAME_MSG_MODULAR_BUILD_END = 1095, - GAME_MSG_MODULAR_BUILD_MOVE_AND_EQUIP = 1096, - GAME_MSG_MODULAR_BUILD_FINISH = 1097, - GAME_MSG_REPORT_BUG = 1198, - GAME_MSG_MISSION_DIALOGUE_CANCELLED = 1129, - GAME_MSG_ECHO_SYNC_SKILL = 1144, - GAME_MSG_SYNC_SKILL = 1145, - GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT = 1148, - GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT = 1151, - GAME_MSG_MODULAR_BUILD_CONVERT_MODEL = 1155, - GAME_MSG_SET_PLAYER_ALLOWED_RESPAWN = 1165, - GAME_MSG_UI_MESSAGE_SERVER_TO_SINGLE_CLIENT = 1184, - GAME_MSG_UI_MESSAGE_SERVER_TO_ALL_CLIENTS = 1185, - GAME_MSG_PET_TAMING_TRY_BUILD = 1197, - GAME_MSG_REQUEST_SMASH_PLAYER = 1202, - GAME_MSG_FIRE_EVENT_CLIENT_SIDE = 1213, - GAME_MSG_TOGGLE_GM_INVIS = 1218, - GAME_MSG_CHANGE_OBJECT_WORLD_STATE = 1223, - GAME_MSG_VEHICLE_LOCK_INPUT = 1230, - GAME_MSG_VEHICLE_UNLOCK_INPUT = 1231, - GAME_MSG_RACING_RESET_PLAYER_TO_LAST_RESET = 1252, - GAME_MSG_RACING_SERVER_SET_PLAYER_LAP_AND_PLANE = 1253, - GAME_MSG_RACING_SET_PLAYER_RESET_INFO = 1254, - GAME_MSG_RACING_PLAYER_INFO_RESET_FINISHED = 1255, - GAME_MSG_LOCK_NODE_ROTATION = 1260, - GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE = 1273, - GAME_MSG_NOTIFY_VEHICLE_OF_RACING_OBJECT = 1276, - GAME_MSG_SET_NAME_BILLBOARD_STATE = 1284, - GAME_MSG_PLAYER_REACHED_RESPAWN_CHECKPOINT = 1296, - GAME_MSG_HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE = 1300, - GAME_MSG_HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE = 1301, - GAME_MSG_PROPERTY_CONTENTS_FROM_CLIENT = 1305, - GAME_MSG_GET_MODELS_ON_PROPERTY = 1306, - GAME_MSG_MATCH_REQUEST = 1308, - GAME_MSG_MATCH_RESPONSE = 1309, - GAME_MSG_MATCH_UPDATE = 1310, - GAME_MSG_MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT = 1131, - GAME_MSG_MODULE_ASSEMBLY_QUERY_DATA = 1132, - GAME_MSG_SHOW_BILLBOARD_INTERACT_ICON = 1337, - GAME_MSG_CHANGE_IDLE_FLAGS = 1338, - GAME_MSG_VEHICLE_ADD_PASSIVE_BOOST_ACTION = 1340, - GAME_MSG_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION = 1341, - GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION = 1342, - GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION = 1343, - GAME_MSG_VEHICLE_ADD_SLOWDOWN_ACTION = 1344, - GAME_MSG_VEHICLE_REMOVE_SLOWDOWN_ACTION = 1345, - GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_SLOWDOWN_ACTION = 1346, - GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_SLOWDOWN_ACTION = 1347, - GAME_MSG_BUYBACK_FROM_VENDOR = 1350, - GAME_MSG_SET_PROPERTY_ACCESS = 1366, - GAME_MSG_ZONE_PROPERTY_MODEL_PLACED = 1369, - GAME_MSG_ZONE_PROPERTY_MODEL_ROTATED = 1370, - GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED = 1371, - GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED = 1372, - GAME_MSG_ZONE_PROPERTY_MODEL_PICKED_UP = 1373, - GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED = 1374, - GAME_MSG_NOTIFY_RACING_CLIENT = 1390, - GAME_MSG_RACING_PLAYER_HACK_CAR = 1391, - GAME_MSG_RACING_PLAYER_LOADED = 1392, - GAME_MSG_RACING_CLIENT_READY = 1393, - GAME_MSG_UPDATE_CHAT_MODE = 1395, - GAME_MSG_VEHICLE_NOTIFY_FINISHED_RACE = 1396, - GAME_MSG_SET_CONSUMABLE_ITEM = 1409, - GAME_MSG_SET_STATUS_IMMUNITY = 1435, - GAME_MSG_SET_PET_NAME_MODERATED = 1448, - GAME_MSG_MODIFY_LEGO_SCORE = 1459, - GAME_MSG_RESTORE_TO_POST_LOAD_STATS = 1468, - GAME_MSG_SET_RAIL_MOVEMENT = 1471, - GAME_MSG_START_RAIL_MOVEMENT = 1472, - GAME_MSG_CANCEL_RAIL_MOVEMENT = 1474, - GAME_MSG_CLIENT_RAIL_MOVEMENT_READY = 1476, - GAME_MSG_PLAYER_RAIL_ARRIVED_NOTIFICATION = 1477, - GAME_MSG_UPDATE_PLAYER_STATISTIC = 1481, - GAME_MSG_MODULAR_ASSEMBLY_NIF_COMPLETED = 1498, - GAME_MSG_NOTIFY_NOT_ENOUGH_INV_SPACE = 1516, - GAME_MSG_TEAM_SET_LEADER = 0x0615, - GAME_MSG_TEAM_INVITE_CONFIRM = 0x0616, - GAME_MSG_TEAM_GET_STATUS_RESPONSE = 0x0617, - GAME_MSG_TEAM_ADD_PLAYER = 0x061a, - GAME_MSG_TEAM_REMOVE_PLAYER = 0x061b, - GAME_MSG_START_CELEBRATION_EFFECT = 1618, - GAME_MSG_ADD_BUFF = 1647, - GAME_MSG_SERVER_DONE_LOADING_ALL_OBJECTS = 1642, - GAME_MSG_PLACE_PROPERTY_MODEL = 1170, - GAME_MSG_VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER = 1606, - GAME_MSG_ADD_RUN_SPEED_MODIFIER = 1505, - GAME_MSG_HANDLE_HOT_PROPERTY_DATA = 1511, - GAME_MSG_SEND_HOT_PROPERTY_DATA = 1510, - GAME_MSG_REMOVE_RUN_SPEED_MODIFIER = 1506, - GAME_MSG_UPDATE_PROPERTY_PERFORMANCE_COST = 1547, - GAME_MSG_PROPERTY_ENTRANCE_BEGIN = 1553, - GAME_MSG_SET_RESURRECT_RESTORE_VALUES = 1591, - GAME_MSG_VEHICLE_STOP_BOOST = 1617, - GAME_MSG_REMOVE_BUFF = 1648, - GAME_MSG_REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1666, - GAME_MSG_RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1667, - GAME_MSG_PLAYER_SET_CAMERA_CYCLING_MODE = 1676, - GAME_MSG_SET_MOUNT_INVENTORY_ID = 1726, - GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE = 1734, - GAME_MSG_NOTIFY_LEVEL_REWARDS = 1735, - GAME_MSG_DISMOUNT_COMPLETE = 1756, - GAME_MSG_MARK_INVENTORY_ITEM_AS_ACTIVE = 1767, - END -}; diff --git a/dCommon/dEnums/eAuthMessageType.h b/dCommon/dEnums/eAuthMessageType.h new file mode 100644 index 00000000..ecc17a37 --- /dev/null +++ b/dCommon/dEnums/eAuthMessageType.h @@ -0,0 +1,15 @@ +#ifndef __EAUTHMESSAGETYPE__H__ +#define __EAUTHMESSAGETYPE__H__ + +#include + +enum class eAuthMessageType : uint32_t { + LOGIN_REQUEST = 0, + LOGOUT_REQUEST, + CREATE_NEW_ACCOUNT_REQUEST, + LEGOINTERFACE_AUTH_RESPONSE, + SESSIONKEY_RECEIVED_CONFIRM, + RUNTIME_CONFIG +}; + +#endif //!__EAUTHMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eChatInternalMessageType.h b/dCommon/dEnums/eChatInternalMessageType.h new file mode 100644 index 00000000..d3b7020b --- /dev/null +++ b/dCommon/dEnums/eChatInternalMessageType.h @@ -0,0 +1,31 @@ +#ifndef __ECHATINTERNALMESSAGETYPE__H__ +#define __ECHATINTERNALMESSAGETYPE__H__ + +#include + +enum eChatInternalMessageType : uint32_t { + PLAYER_ADDED_NOTIFICATION = 0, + PLAYER_REMOVED_NOTIFICATION, + ADD_FRIEND, + ADD_BEST_FRIEND, + ADD_TO_TEAM, + ADD_BLOCK, + REMOVE_FRIEND, + REMOVE_BLOCK, + REMOVE_FROM_TEAM, + DELETE_TEAM, + REPORT, + PRIVATE_CHAT, + PRIVATE_CHAT_RESPONSE, + ANNOUNCEMENT, + MAIL_COUNT_UPDATE, + MAIL_SEND_NOTIFY, + REQUEST_USER_LIST, + FRIEND_LIST, + ROUTE_TO_PLAYER, + TEAM_UPDATE, + MUTE_UPDATE, + CREATE_TEAM, +}; + +#endif //!__ECHATINTERNALMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eChatMessageType.h b/dCommon/dEnums/eChatMessageType.h new file mode 100644 index 00000000..52895ba3 --- /dev/null +++ b/dCommon/dEnums/eChatMessageType.h @@ -0,0 +1,78 @@ +#ifndef __ECHATMESSAGETYPE__H__ +#define __ECHATMESSAGETYPE__H__ + +#include + +//! The Internal Chat Packet Identifiers +enum class eChatMessageType :uint32_t { + LOGIN_SESSION_NOTIFY = 0, + GENERAL_CHAT_MESSAGE, + PRIVATE_CHAT_MESSAGE, + USER_CHANNEL_CHAT_MESSAGE, + WORLD_DISCONNECT_REQUEST, + WORLD_PROXIMITY_RESPONSE, + WORLD_PARCEL_RESPONSE, + ADD_FRIEND_REQUEST, + ADD_FRIEND_RESPONSE, + REMOVE_FRIEND, + GET_FRIENDS_LIST, + ADD_IGNORE, + REMOVE_IGNORE, + GET_IGNORE_LIST, + TEAM_MISSED_INVITE_CHECK, + TEAM_INVITE, + TEAM_INVITE_RESPONSE, + TEAM_KICK, + TEAM_LEAVE, + TEAM_SET_LOOT, + TEAM_SET_LEADER, + TEAM_GET_STATUS, + GUILD_CREATE, + GUILD_INVITE, + GUILD_INVITE_RESPONSE, + GUILD_LEAVE, + GUILD_KICK, + GUILD_GET_STATUS, + GUILD_GET_ALL, + SHOW_ALL, + BLUEPRINT_MODERATED, + BLUEPRINT_MODEL_READY, + PROPERTY_READY_FOR_APPROVAL, + PROPERTY_MODERATION_CHANGED, + PROPERTY_BUILDMODE_CHANGED, + PROPERTY_BUILDMODE_CHANGED_REPORT, + MAIL, + WORLD_INSTANCE_LOCATION_REQUEST, + REPUTATION_UPDATE, + SEND_CANNED_TEXT, + GMLEVEL_UPDATE, + CHARACTER_NAME_CHANGE_REQUEST, + CSR_REQUEST, + CSR_REPLY, + GM_KICK, + GM_ANNOUNCE, + GM_MUTE, + ACTIVITY_UPDATE, + WORLD_ROUTE_PACKET, + GET_ZONE_POPULATIONS, + REQUEST_MINIMUM_CHAT_MODE, + REQUEST_MINIMUM_CHAT_MODE_PRIVATE, + MATCH_REQUEST, + UGCMANIFEST_REPORT_MISSING_FILE, + UGCMANIFEST_REPORT_DONE_FILE, + UGCMANIFEST_REPORT_DONE_BLUEPRINT, + UGCC_REQUEST, + WHO, + WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE, + ACHIEVEMENT_NOTIFY, + GM_CLOSE_PRIVATE_CHAT_WINDOW, + UNEXPECTED_DISCONNECT, + PLAYER_READY, + GET_DONATION_TOTAL, + UPDATE_DONATION, + PRG_CSR_COMMAND, + HEARTBEAT_REQUEST_FROM_WORLD, + UPDATE_FREE_TRIAL_STATUS +}; + +#endif //!__ECHATMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eClientMessageType.h b/dCommon/dEnums/eClientMessageType.h new file mode 100644 index 00000000..aafccc36 --- /dev/null +++ b/dCommon/dEnums/eClientMessageType.h @@ -0,0 +1,76 @@ +#ifndef __ECLIENTMESSAGETYPE__H__ +#define __ECLIENTMESSAGETYPE__H__ + +#include + +enum class eClientMessageType : uint32_t { + LOGIN_RESPONSE = 0, + LOGOUT_RESPONSE, + LOAD_STATIC_ZONE, + CREATE_OBJECT, + CREATE_CHARACTER, + CREATE_CHARACTER_EXTENDED, + CHARACTER_LIST_RESPONSE, + CHARACTER_CREATE_RESPONSE, + CHARACTER_RENAME_RESPONSE, + CHAT_CONNECT_RESPONSE, + AUTH_ACCOUNT_CREATE_RESPONSE, + DELETE_CHARACTER_RESPONSE, + GAME_MSG, + CONNECT_CHAT, + TRANSFER_TO_WORLD, + IMPENDING_RELOAD_NOTIFY, + MAKE_GM_RESPONSE, + HTTP_MONITOR_INFO_RESPONSE, + SLASH_PUSH_MAP_RESPONSE, + SLASH_PULL_MAP_RESPONSE, + SLASH_LOCK_MAP_RESPONSE, + BLUEPRINT_SAVE_RESPONSE, + BLUEPRINT_LUP_SAVE_RESPONSE, + BLUEPRINT_LOAD_RESPONSE_ITEMID, + BLUEPRINT_GET_ALL_DATA_RESPONSE, + MODEL_INSTANTIATE_RESPONSE, + DEBUG_OUTPUT, + ADD_FRIEND_REQUEST, + ADD_FRIEND_RESPONSE, + REMOVE_FRIEND_RESPONSE, + GET_FRIENDS_LIST_RESPONSE, + UPDATE_FRIEND_NOTIFY, + ADD_IGNORE_RESPONSE, + REMOVE_IGNORE_RESPONSE, + GET_IGNORE_LIST_RESPONSE, + TEAM_INVITE, + TEAM_INVITE_INITIAL_RESPONSE, + GUILD_CREATE_RESPONSE, + GUILD_GET_STATUS_RESPONSE, + GUILD_INVITE, + GUILD_INVITE_INITIAL_RESPONSE, + GUILD_INVITE_FINAL_RESPONSE, + GUILD_INVITE_CONFIRM, + GUILD_ADD_PLAYER, + GUILD_REMOVE_PLAYER, + GUILD_LOGIN_LOGOUT, + GUILD_RANK_CHANGE, + GUILD_DATA, + GUILD_STATUS, + MAIL, + DB_PROXY_RESULT, + SHOW_ALL_RESPONSE, + WHO_RESPONSE, + SEND_CANNED_TEXT, + UPDATE_CHARACTER_NAME, + SET_NETWORK_SIMULATOR, + INVALID_CHAT_MESSAGE, + MINIMUM_CHAT_MODE_RESPONSE, + MINIMUM_CHAT_MODE_RESPONSE_PRIVATE, + CHAT_MODERATION_STRING, + UGC_MANIFEST_RESPONSE, + IN_LOGIN_QUEUE, + SERVER_STATES, + GM_CLOSE_TARGET_CHAT_WINDOW, + GENERAL_TEXT_FOR_LOCALIZATION, + UPDATE_FREE_TRIAL_STATUS, + UGC_DOWNLOAD_FAILED = 120 +}; + +#endif //!__ECLIENTMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eConnectionType.h b/dCommon/dEnums/eConnectionType.h new file mode 100644 index 00000000..ce1ff90c --- /dev/null +++ b/dCommon/dEnums/eConnectionType.h @@ -0,0 +1,14 @@ +#ifndef __ECONNECTIONTYPE__H__ +#define __ECONNECTIONTYPE__H__ + +enum class eConnectionType : uint16_t { + SERVER = 0, + AUTH, + CHAT, + CHAT_INTERNAL, + WORLD, + CLIENT, + MASTER +}; + +#endif //!__ECONNECTIONTYPE__H__ diff --git a/dCommon/dEnums/eGameMessageType.h b/dCommon/dEnums/eGameMessageType.h new file mode 100644 index 00000000..247ee5e2 --- /dev/null +++ b/dCommon/dEnums/eGameMessageType.h @@ -0,0 +1,303 @@ +#ifndef __EGAMEMESSAGETYPE__H__ +#define __EGAMEMESSAGETYPE__H__ + +#include + +enum class eGameMessageType : uint16_t { + TELEPORT = 19, + SET_PLAYER_CONTROL_SCHEME = 26, + DROP_CLIENT_LOOT = 30, + DIE = 37, + REQUEST_DIE = 38, + PLAY_EMOTE = 41, + PLAY_ANIMATION = 43, + CONTROL_BEHAVIOR = 48, + SET_NAME = 72, + ECHO_START_SKILL = 118, + START_SKILL = 119, + VERIFY_ACK = 121, + ADD_SKILL = 127, + REMOVE_SKILL = 128, + SET_CURRENCY = 133, + PICKUP_CURRENCY = 137, + PICKUP_ITEM = 139, + TEAM_PICKUP_ITEM = 140, + PLAY_FX_EFFECT = 154, + STOP_FX_EFFECT = 155, + REQUEST_RESURRECT = 159, + RESURRECT = 160, + PUSH_EQUIPPED_ITEMS_STATE = 191, + POP_EQUIPPED_ITEMS_STATE = 192, + SET_GM_LEVEL = 193, + SET_STUNNED = 198, + SET_STUN_IMMUNITY = 200, + KNOCKBACK = 202, + REBUILD_CANCEL = 209, + ENABLE_REBUILD = 213, + MOVE_ITEM_IN_INVENTORY = 224, + ADD_ITEM_TO_INVENTORY_CLIENT_SYNC = 227, + REMOVE_ITEM_FROM_INVENTORY = 230, + EQUIP_ITEM = 231, + UN_EQUIP_ITEM = 233, + OFFER_MISSION = 248, + RESPOND_TO_MISSION = 249, + NOTIFY_MISSION = 254, + NOTIFY_MISSION_TASK = 255, + REBUILD_NOTIFY_STATE = 336, + TERMINATE_INTERACTION = 357, + SERVER_TERMINATE_INTERACTION = 358, + REQUEST_USE = 364, + VENDOR_OPEN_WINDOW = 369, + BUY_FROM_VENDOR = 373, + SELL_TO_VENDOR = 374, + TEAM_SET_OFF_WORLD_FLAG = 383, + SET_INVENTORY_SIZE = 389, + ACKNOWLEDGE_POSSESSION = 391, + SET_SHOOTING_GALLERY_PARAMS = 400, + REQUEST_ACTIVITY_START_STOP = 402, + REQUEST_ACTIVITY_ENTER = 403, + REQUEST_ACTIVITY_EXIT = 404, + ACTIVITY_ENTER = 405, + ACTIVITY_EXIT = 406, + ACTIVITY_START = 407, + ACTIVITY_STOP = 408, + SHOOTING_GALLERY_CLIENT_AIM_UPDATE = 409, + SHOOTING_GALLERY_FIRE = 411, + REQUEST_VENDOR_STATUS_UPDATE = 416, + VENDOR_STATUS_UPDATE = 417, + NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE = 425, + CONSUME_CLIENT_ITEM = 427, + CLIENT_ITEM_CONSUMED = 428, + UPDATE_SHOOTING_GALLERY_ROTATION = 448, + SET_FLAG = 471, + NOTIFY_CLIENT_FLAG_CHANGE = 472, + VENDOR_TRANSACTION_RESULT = 476, + HAS_BEEN_COLLECTED = 486, + DISPLAY_CHAT_BUBBLE = 495, + SPAWN_PET = 498, + DESPAWN_PET = 499, + PLAYER_LOADED = 505, + PLAYER_READY = 509, + REQUEST_LINKED_MISSION = 515, + INVALID_ZONE_TRANSFER_LIST = 519, + MISSION_DIALOGUE_OK = 520, + DISPLAY_MESSAGE_BOX = 529, + MESSAGE_BOX_RESPOND = 530, + CHOICE_BOX_RESPOND = 531, + SMASH = 537, + UNSMASH = 538, + PLACE_MODEL_RESPONSE = 547, + SET_SHOOTING_GALLERY_RETICULE_EFFECT = 548, + SET_JET_PACK_MODE = 561, + REGISTER_PET_ID = 565, + REGISTER_PET_DBID = 566, + SHOW_ACTIVITY_COUNTDOWN = 568, + START_ACTIVITY_TIME = 576, + ACTIVITY_PAUSE = 602, + USE_NON_EQUIPMENT_ITEM = 603, + USE_ITEM_RESULT = 607, + COMMAND_PET = 640, + PET_RESPONSE = 641, + REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 648, + SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 649, + NOTIFY_OBJECT = 656, + CLIENT_NOTIFY_PET = 659, + NOTIFY_PET = 660, + NOTIFY_PET_TAMING_MINIGAME = 661, + START_SERVER_PET_MINIGAME_TIMER = 662, + CLIENT_EXIT_TAMING_MINIGAME = 663, + PET_NAME_CHANGED = 686, + PET_TAMING_MINIGAME_RESULT = 667, + PET_TAMING_TRY_BUILD_RESULT = 668, + NOTIFY_TAMING_BUILD_SUCCESS = 673, + NOTIFY_TAMING_MODEL_LOADED_ON_SERVER = 674, + ACTIVATE_BUBBLE_BUFF = 678, + DEACTIVATE_BUBBLE_BUFF = 679, + ADD_PET_TO_PLAYER = 681, + REQUEST_SET_PET_NAME = 683, + SET_PET_NAME = 684, + NOTIFY_PET_TAMING_PUZZLE_SELECTED = 675, + SHOW_PET_ACTION_BUTTON = 692, + SET_EMOTE_LOCK_STATE = 693, + USE_ITEM_REQUIREMENTS_RESPONSE = 703, + PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT = 713, + DOWNLOAD_PROPERTY_DATA = 716, + QUERY_PROPERTY_DATA = 717, + PROPERTY_EDITOR_BEGIN = 724, + PROPERTY_EDITOR_END = 725, + IS_MINIFIG_IN_A_BUBBLE = 729, + START_PATHING = 733, + ACTIVATE_BUBBLE_BUFF_FROM_SERVER = 734, + DEACTIVATE_BUBBLE_BUFF_FROM_SERVER = 735, + NOTIFY_CLIENT_ZONE_OBJECT = 737, + UPDATE_REPUTATION = 746, + PROPERTY_RENTAL_RESPONSE = 750, + REQUEST_PLATFORM_RESYNC = 760, + PLATFORM_RESYNC = 761, + PLAY_CINEMATIC = 762, + END_CINEMATIC = 763, + CINEMATIC_UPDATE = 764, + TOGGLE_GHOST_REFERENCE_OVERRIDE = 767, + SET_GHOST_REFERENCE_POSITION = 768, + FIRE_EVENT_SERVER_SIDE = 770, + SET_NETWORK_SCRIPT_VAR = 781, + UPDATE_MODEL_FROM_CLIENT = 793, + DELETE_MODEL_FROM_CLIENT = 794, + PLAY_ND_AUDIO_EMITTER = 821, + PLAY2_DAMBIENT_SOUND = 831, + ENTER_PROPERTY1 = 840, + ENTER_PROPERTY2 = 841, + PROPERTY_ENTRANCE_SYNC = 842, + PROPERTY_SELECT_QUERY = 845, + PARSE_CHAT_MESSAGE = 850, + BROADCAST_TEXT_TO_CHATBOX = 858, + OPEN_PROPERTY_MANAGEMENT = 860, + OPEN_PROPERTY_VENDOR = 861, + UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK = 863, + CLIENT_TRADE_REQUEST = 868, + SERVER_TRADE_REQUEST = 869, + SERVER_TRADE_INVITE = 870, + CLIENT_TRADE_REPLY = 871, + SERVER_TRADE_REPLY = 872, + SERVER_TRADE_INITIAL_REPLY = 873, + SERVER_TRADE_FINAL_REPLY = 874, + CLIENT_TRADE_UPDATE = 875, + SERVER_SIDE_TRADE_UPDATE = 876, + SERVER_TRADE_UPDATE = 877, + CLIENT_TRADE_CANCEL = 878, + CLIENT_SIDE_TRADE_CANCEL = 879, + CLIENT_TRADE_ACCEPT = 880, + SERVER_SIDE_TRADE_ACCEPT = 881, + SERVER_SIDE_TRADE_CANCEL = 882, + SERVER_TRADE_CANCEL = 883, + SERVER_TRADE_ACCEPT = 884, + READY_FOR_UPDATES = 888, + ORIENT_TO_OBJECT = 905, + ORIENT_TO_POSITION = 906, + ORIENT_TO_ANGLE = 907, + BOUNCER_ACTIVE_STATUS = 942, + UN_USE_BBB_MODEL = 999, + BBB_LOAD_ITEM_REQUEST = 1000, + BBB_SAVE_REQUEST = 1001, + BBB_SAVE_RESPONSE = 1006, + NOTIFY_CLIENT_OBJECT = 1042, + DISPLAY_ZONE_SUMMARY = 1043, + ZONE_SUMMARY_DISMISSED = 1044, + ACTIVITY_STATE_CHANGE_REQUEST = 1053, + MODIFY_PLAYER_ZONE_STATISTIC = 1046, + START_BUILDING_WITH_ITEM = 1057, + START_ARRANGING_WITH_ITEM = 1061, + FINISH_ARRANGING_WITH_ITEM = 1062, + DONE_ARRANGING_WITH_ITEM = 1063, + SET_BUILD_MODE = 1068, + BUILD_MODE_SET = 1069, + SET_BUILD_MODE_CONFIRMED = 1073, + NOTIFY_CLIENT_FAILED_PRECONDITION = 1081, + MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1093, + MODULAR_BUILD_BEGIN = 1094, + MODULAR_BUILD_END = 1095, + MODULAR_BUILD_MOVE_AND_EQUIP = 1096, + MODULAR_BUILD_FINISH = 1097, + REPORT_BUG = 1198, + MISSION_DIALOGUE_CANCELLED = 1129, + ECHO_SYNC_SKILL = 1144, + SYNC_SKILL = 1145, + REQUEST_SERVER_PROJECTILE_IMPACT = 1148, + DO_CLIENT_PROJECTILE_IMPACT = 1151, + MODULAR_BUILD_CONVERT_MODEL = 1155, + SET_PLAYER_ALLOWED_RESPAWN = 1165, + UI_MESSAGE_SERVER_TO_SINGLE_CLIENT = 1184, + UI_MESSAGE_SERVER_TO_ALL_CLIENTS = 1185, + PET_TAMING_TRY_BUILD = 1197, + REQUEST_SMASH_PLAYER = 1202, + FIRE_EVENT_CLIENT_SIDE = 1213, + TOGGLE_GM_INVIS = 1218, + CHANGE_OBJECT_WORLD_STATE = 1223, + VEHICLE_LOCK_INPUT = 1230, + VEHICLE_UNLOCK_INPUT = 1231, + RACING_RESET_PLAYER_TO_LAST_RESET = 1252, + RACING_SERVER_SET_PLAYER_LAP_AND_PLANE = 1253, + RACING_SET_PLAYER_RESET_INFO = 1254, + RACING_PLAYER_INFO_RESET_FINISHED = 1255, + LOCK_NODE_ROTATION = 1260, + VEHICLE_SET_WHEEL_LOCK_STATE = 1273, + NOTIFY_VEHICLE_OF_RACING_OBJECT = 1276, + SET_NAME_BILLBOARD_STATE = 1284, + PLAYER_REACHED_RESPAWN_CHECKPOINT = 1296, + HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE = 1300, + HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE = 1301, + PROPERTY_CONTENTS_FROM_CLIENT = 1305, + GET_MODELS_ON_PROPERTY = 1306, + MATCH_REQUEST = 1308, + MATCH_RESPONSE = 1309, + MATCH_UPDATE = 1310, + MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT = 1131, + MODULE_ASSEMBLY_QUERY_DATA = 1132, + SHOW_BILLBOARD_INTERACT_ICON = 1337, + CHANGE_IDLE_FLAGS = 1338, + VEHICLE_ADD_PASSIVE_BOOST_ACTION = 1340, + VEHICLE_REMOVE_PASSIVE_BOOST_ACTION = 1341, + VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION = 1342, + VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION = 1343, + VEHICLE_ADD_SLOWDOWN_ACTION = 1344, + VEHICLE_REMOVE_SLOWDOWN_ACTION = 1345, + VEHICLE_NOTIFY_SERVER_ADD_SLOWDOWN_ACTION = 1346, + VEHICLE_NOTIFY_SERVER_REMOVE_SLOWDOWN_ACTION = 1347, + BUYBACK_FROM_VENDOR = 1350, + SET_PROPERTY_ACCESS = 1366, + ZONE_PROPERTY_MODEL_PLACED = 1369, + ZONE_PROPERTY_MODEL_ROTATED = 1370, + ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED = 1371, + ZONE_PROPERTY_MODEL_EQUIPPED = 1372, + ZONE_PROPERTY_MODEL_PICKED_UP = 1373, + ZONE_PROPERTY_MODEL_REMOVED = 1374, + NOTIFY_RACING_CLIENT = 1390, + RACING_PLAYER_HACK_CAR = 1391, + RACING_PLAYER_LOADED = 1392, + RACING_CLIENT_READY = 1393, + UPDATE_CHAT_MODE = 1395, + VEHICLE_NOTIFY_FINISHED_RACE = 1396, + SET_CONSUMABLE_ITEM = 1409, + SET_STATUS_IMMUNITY = 1435, + SET_PET_NAME_MODERATED = 1448, + MODIFY_LEGO_SCORE = 1459, + RESTORE_TO_POST_LOAD_STATS = 1468, + SET_RAIL_MOVEMENT = 1471, + START_RAIL_MOVEMENT = 1472, + CANCEL_RAIL_MOVEMENT = 1474, + CLIENT_RAIL_MOVEMENT_READY = 1476, + PLAYER_RAIL_ARRIVED_NOTIFICATION = 1477, + UPDATE_PLAYER_STATISTIC = 1481, + MODULAR_ASSEMBLY_NIF_COMPLETED = 1498, + NOTIFY_NOT_ENOUGH_INV_SPACE = 1516, + TEAM_SET_LEADER = 1557, + TEAM_INVITE_CONFIRM = 1558, + TEAM_GET_STATUS_RESPONSE = 1559, + TEAM_ADD_PLAYER = 1526, + TEAM_REMOVE_PLAYER = 1563, + START_CELEBRATION_EFFECT = 1618, + ADD_BUFF = 1647, + SERVER_DONE_LOADING_ALL_OBJECTS = 1642, + PLACE_PROPERTY_MODEL = 1170, + VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER = 1606, + ADD_RUN_SPEED_MODIFIER = 1505, + HANDLE_HOT_PROPERTY_DATA = 1511, + SEND_HOT_PROPERTY_DATA = 1510, + REMOVE_RUN_SPEED_MODIFIER = 1506, + UPDATE_PROPERTY_PERFORMANCE_COST = 1547, + PROPERTY_ENTRANCE_BEGIN = 1553, + SET_RESURRECT_RESTORE_VALUES = 1591, + VEHICLE_STOP_BOOST = 1617, + REMOVE_BUFF = 1648, + REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1666, + RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1667, + PLAYER_SET_CAMERA_CYCLING_MODE = 1676, + SET_MOUNT_INVENTORY_ID = 1726, + NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE = 1734, + NOTIFY_LEVEL_REWARDS = 1735, + DISMOUNT_COMPLETE = 1756, + MARK_INVENTORY_ITEM_AS_ACTIVE = 1767, + END +}; + +#endif //!__EGAMEMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eMasterMessageType.h b/dCommon/dEnums/eMasterMessageType.h new file mode 100644 index 00000000..5c867d70 --- /dev/null +++ b/dCommon/dEnums/eMasterMessageType.h @@ -0,0 +1,36 @@ +#ifndef __EMASTERMESSAGETYPE__H__ +#define __EMASTERMESSAGETYPE__H__ + +#include + +enum class eMasterMessageType : uint32_t { + REQUEST_PERSISTENT_ID = 1, + REQUEST_PERSISTENT_ID_RESPONSE, + REQUEST_ZONE_TRANSFER, + REQUEST_ZONE_TRANSFER_RESPONSE, + SERVER_INFO, + REQUEST_SESSION_KEY, + SET_SESSION_KEY, + SESSION_KEY_RESPONSE, + PLAYER_ADDED, + PLAYER_REMOVED, + + CREATE_PRIVATE_ZONE, + REQUEST_PRIVATE_ZONE, + + WORLD_READY, + PREP_ZONE, + + SHUTDOWN, + SHUTDOWN_RESPONSE, + SHUTDOWN_IMMEDIATE, + + SHUTDOWN_UNIVERSE, + + AFFIRM_TRANSFER_REQUEST, + AFFIRM_TRANSFER_RESPONSE, + + NEW_SESSION_ALERT +}; + +#endif //!__EMASTERMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eServerMessageType.h b/dCommon/dEnums/eServerMessageType.h new file mode 100644 index 00000000..7f211ffb --- /dev/null +++ b/dCommon/dEnums/eServerMessageType.h @@ -0,0 +1,12 @@ +#ifndef __ESERVERMESSAGETYPE__H__ +#define __ESERVERMESSAGETYPE__H__ + +#include +//! The Internal Server Packet Identifiers +enum class eServerMessageType : uint32_t { + VERSION_CONFIRM = 0, + DISCONNECT_NOTIFY, + GENERAL_NOTIFY +}; + +#endif //!__ESERVERMESSAGETYPE__H__ diff --git a/dCommon/dEnums/eWorldMessageType.h b/dCommon/dEnums/eWorldMessageType.h new file mode 100644 index 00000000..2a65fd98 --- /dev/null +++ b/dCommon/dEnums/eWorldMessageType.h @@ -0,0 +1,42 @@ +#ifndef __EWORLDMESSAGETYPE__H__ +#define __EWORLDMESSAGETYPE__H__ + +#include + +enum class eWorldMessageType : uint32_t { + VALIDATION = 1, // Session info + CHARACTER_LIST_REQUEST, + CHARACTER_CREATE_REQUEST, + LOGIN_REQUEST, // Character selected + GAME_MSG, + CHARACTER_DELETE_REQUEST, + CHARACTER_RENAME_REQUEST, + HAPPY_FLOWER_MODE_NOTIFY, + SLASH_RELOAD_MAP, // Reload map cmp + SLASH_PUSH_MAP_REQUEST, // Push map req cmd + SLASH_PUSH_MAP, // Push map cmd + SLASH_PULL_MAP, // Pull map cmd + LOCK_MAP_REQUEST, + GENERAL_CHAT_MESSAGE, // General chat message + HTTP_MONITOR_INFO_REQUEST, + SLASH_DEBUG_SCRIPTS, // Debug scripts cmd + MODELS_CLEAR, + EXHIBIT_INSERT_MODEL, + LEVEL_LOAD_COMPLETE, // Character data request + TMP_GUILD_CREATE, + ROUTE_PACKET, // Social? + POSITION_UPDATE, + MAIL, + WORD_CHECK, // Whitelist word check + STRING_CHECK, // Whitelist string check + GET_PLAYERS_IN_ZONE, + REQUEST_UGC_MANIFEST_INFO, + BLUEPRINT_GET_ALL_DATA_REQUEST, + CANCEL_MAP_QUEUE, + HANDLE_FUNNESS, + FAKE_PRG_CSR_MESSAGE, + REQUEST_FREE_TRIAL_REFRESH, + GM_SET_FREE_TRIAL_STATUS +}; + +#endif //!__EWORLDMESSAGETYPE__H__ diff --git a/dGame/UserManager.cpp b/dGame/UserManager.cpp index d57caa67..0161395c 100644 --- a/dGame/UserManager.cpp +++ b/dGame/UserManager.cpp @@ -22,11 +22,12 @@ #include "SkillComponent.h" #include "AssetManager.h" #include "CDClientDatabase.h" -#include "dMessageIdentifiers.h" #include "eObjectBits.h" #include "eGameMasterLevel.h" #include "eCharacterCreationResponse.h" #include "eRenameResponse.h" +#include "eConnectionType.h" +#include "eChatInternalMessageType.h" UserManager* UserManager::m_Address = nullptr; @@ -422,7 +423,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) stmt->execute(); delete stmt; CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); bitStream.Write(objectID); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); } diff --git a/dGame/dBehaviors/BehaviorContext.cpp b/dGame/dBehaviors/BehaviorContext.cpp index d0cb68e4..c7db4208 100644 --- a/dGame/dBehaviors/BehaviorContext.cpp +++ b/dGame/dBehaviors/BehaviorContext.cpp @@ -10,12 +10,12 @@ #include -#include "dMessageIdentifiers.h" #include "DestroyableComponent.h" #include "EchoSyncSkill.h" #include "PhantomPhysicsComponent.h" #include "RebuildComponent.h" #include "eReplicaComponentType.h" +#include "eConnectionType.h" BehaviorSyncEntry::BehaviorSyncEntry() { } @@ -253,7 +253,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) { // Write message RakNet::BitStream message; - PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG); + PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); message.Write(this->originator); echo.Serialize(&message); diff --git a/dGame/dComponents/ModuleAssemblyComponent.h b/dGame/dComponents/ModuleAssemblyComponent.h index c6e217ed..39670c9a 100644 --- a/dGame/dComponents/ModuleAssemblyComponent.h +++ b/dGame/dComponents/ModuleAssemblyComponent.h @@ -14,7 +14,7 @@ class ModuleAssemblyComponent : public Component { public: static const eReplicaComponentType ComponentType = eReplicaComponentType::MODULE_ASSEMBLY; - ModuleAssemblyComponent(Entity* MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION); + ModuleAssemblyComponent(Entity* parent); ~ModuleAssemblyComponent() override; void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags); diff --git a/dGame/dComponents/RocketLaunchpadControlComponent.cpp b/dGame/dComponents/RocketLaunchpadControlComponent.cpp index 6cc5e2bc..3cac9e42 100644 --- a/dGame/dComponents/RocketLaunchpadControlComponent.cpp +++ b/dGame/dComponents/RocketLaunchpadControlComponent.cpp @@ -15,9 +15,10 @@ #include "PropertyEntranceComponent.h" #include "RocketLaunchLupComponent.h" #include "dServer.h" -#include "dMessageIdentifiers.h" #include "PacketUtils.h" #include "eObjectWorldState.h" +#include "eConnectionType.h" +#include "eMasterMessageType.h" RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) { auto query = CDClientDatabase::CreatePreppedStmt( @@ -136,7 +137,7 @@ LWOCLONEID RocketLaunchpadControlComponent::GetSelectedCloneId(LWOOBJID player) void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PREP_ZONE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE); bitStream.Write(zoneID); Game::server->SendToMaster(&bitStream); } diff --git a/dGame/dComponents/ScriptedActivityComponent.cpp b/dGame/dComponents/ScriptedActivityComponent.cpp index f998d686..eb4ab761 100644 --- a/dGame/dComponents/ScriptedActivityComponent.cpp +++ b/dGame/dComponents/ScriptedActivityComponent.cpp @@ -18,10 +18,11 @@ #include "dConfig.h" #include "InventoryComponent.h" #include "DestroyableComponent.h" -#include "dMessageIdentifiers.h" #include "Loot.h" #include "eMissionTaskType.h" #include "eMatchUpdate.h" +#include "eConnectionType.h" +#include "eChatInternalMessageType.h" #include "CDCurrencyTableTable.h" #include "CDActivityRewardsTable.h" @@ -517,7 +518,7 @@ void ActivityInstance::StartZone() { // only make a team if we have more than one participant if (participants.size() > 1) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_CREATE_TEAM); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::CREATE_TEAM); bitStream.Write(leader->GetObjectID()); bitStream.Write(m_Participants.size()); diff --git a/dGame/dComponents/SkillComponent.cpp b/dGame/dComponents/SkillComponent.cpp index dc7c16bd..c2f07425 100644 --- a/dGame/dComponents/SkillComponent.cpp +++ b/dGame/dComponents/SkillComponent.cpp @@ -20,11 +20,11 @@ #include "ScriptComponent.h" #include "BuffComponent.h" #include "EchoStartSkill.h" -#include "dMessageIdentifiers.h" #include "DoClientProjectileImpact.h" #include "CDClientManager.h" - #include "CDSkillBehaviorTable.h" +#include "eConnectionType.h" +#include "eClientMessageType.h" ProjectileSyncEntry::ProjectileSyncEntry() { } @@ -304,7 +304,7 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c // Write message RakNet::BitStream message; - PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG); + PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); message.Write(this->m_Parent->GetObjectID()); start.Serialize(&message); @@ -437,7 +437,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry) RakNet::BitStream message; - PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG); + PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); message.Write(this->m_Parent->GetObjectID()); projectileImpact.Serialize(&message); diff --git a/dGame/dGameMessages/DoClientProjectileImpact.h b/dGame/dGameMessages/DoClientProjectileImpact.h index 436e3dd2..6b381aa5 100644 --- a/dGame/dGameMessages/DoClientProjectileImpact.h +++ b/dGame/dGameMessages/DoClientProjectileImpact.h @@ -1,13 +1,10 @@ #ifndef __DOCLIENTPROJECTILEIMPACT__H__ #define __DOCLIENTPROJECTILEIMPACT__H__ -#include "dMessageIdentifiers.h" #include "dCommonVars.h" /* Tell a client local projectile to impact */ class DoClientProjectileImpact { - static const GAME_MSG MsgID = GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT; - public: DoClientProjectileImpact() { i64OrgID = LWOOBJID_EMPTY; @@ -30,7 +27,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT); stream->Write(i64OrgID != LWOOBJID_EMPTY); if (i64OrgID != LWOOBJID_EMPTY) stream->Write(i64OrgID); diff --git a/dGame/dGameMessages/EchoStartSkill.h b/dGame/dGameMessages/EchoStartSkill.h index 6d912798..f5dee816 100644 --- a/dGame/dGameMessages/EchoStartSkill.h +++ b/dGame/dGameMessages/EchoStartSkill.h @@ -2,14 +2,12 @@ #define __ECHOSTARTSKILL__H__ #include "dCommonVars.h" -#include "dMessageIdentifiers.h" #include "NiPoint3.h" #include "NiQuaternion.h" +#include "eGameMessageType.h" /* Same as start skill but with different network options. An echo down to other clients that need to play the skill. */ class EchoStartSkill { - static const GAME_MSG MsgID = GAME_MSG_ECHO_START_SKILL; - public: EchoStartSkill() { bUsedMouse = false; @@ -42,7 +40,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::ECHO_START_SKILL); stream->Write(bUsedMouse); diff --git a/dGame/dGameMessages/EchoSyncSkill.h b/dGame/dGameMessages/EchoSyncSkill.h index b56beae8..ab5a3f2b 100644 --- a/dGame/dGameMessages/EchoSyncSkill.h +++ b/dGame/dGameMessages/EchoSyncSkill.h @@ -4,13 +4,11 @@ #include #include "BitStream.h" +#include "eGameMessageType.h" -#include "dMessageIdentifiers.h" /* Message to synchronize a skill cast */ class EchoSyncSkill { - static const GAME_MSG MsgID = GAME_MSG_ECHO_SYNC_SKILL; - public: EchoSyncSkill() { bDone = false; @@ -31,7 +29,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::ECHO_SYNC_SKILL); stream->Write(bDone); uint32_t sBitStreamLength = sBitStream.length(); diff --git a/dGame/dGameMessages/GameMessageHandler.cpp b/dGame/dGameMessages/GameMessageHandler.cpp index c0893a09..50c7876b 100644 --- a/dGame/dGameMessages/GameMessageHandler.cpp +++ b/dGame/dGameMessages/GameMessageHandler.cpp @@ -33,10 +33,11 @@ #include "EchoSyncSkill.h" #include "eMissionTaskType.h" #include "eReplicaComponentType.h" +#include "eConnectionType.h" using namespace std; -void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, GAME_MSG messageID) { +void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID) { CBITSTREAM; @@ -53,54 +54,54 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System switch (messageID) { - case GAME_MSG_UN_USE_BBB_MODEL: { + case eGameMessageType::UN_USE_BBB_MODEL: { GameMessages::HandleUnUseModel(inStream, entity, sysAddr); break; } - case GAME_MSG_PLAY_EMOTE: { + case eGameMessageType::PLAY_EMOTE: { GameMessages::HandlePlayEmote(inStream, entity); break; } - case GAME_MSG_MOVE_ITEM_IN_INVENTORY: { + case eGameMessageType::MOVE_ITEM_IN_INVENTORY: { GameMessages::HandleMoveItemInInventory(inStream, entity); break; } - case GAME_MSG_REMOVE_ITEM_FROM_INVENTORY: { + case eGameMessageType::REMOVE_ITEM_FROM_INVENTORY: { GameMessages::HandleRemoveItemFromInventory(inStream, entity, sysAddr); break; } - case GAME_MSG_EQUIP_ITEM: + case eGameMessageType::EQUIP_ITEM: GameMessages::HandleEquipItem(inStream, entity); break; - case GAME_MSG_UN_EQUIP_ITEM: + case eGameMessageType::UN_EQUIP_ITEM: GameMessages::HandleUnequipItem(inStream, entity); break; - case GAME_MSG_RESPOND_TO_MISSION: { + case eGameMessageType::RESPOND_TO_MISSION: { GameMessages::HandleRespondToMission(inStream, entity); break; } - case GAME_MSG_REQUEST_USE: { + case eGameMessageType::REQUEST_USE: { GameMessages::HandleRequestUse(inStream, entity, sysAddr); break; } - case GAME_MSG_SET_FLAG: { + case eGameMessageType::SET_FLAG: { GameMessages::HandleSetFlag(inStream, entity); break; } - case GAME_MSG_HAS_BEEN_COLLECTED: { + case eGameMessageType::HAS_BEEN_COLLECTED: { GameMessages::HandleHasBeenCollected(inStream, entity); break; } - case GAME_MSG_PLAYER_LOADED: { + case eGameMessageType::PLAYER_LOADED: { GameMessages::SendRestoreToPostLoadStats(entity, sysAddr); entity->SetPlayerReadyForUpdates(); @@ -174,73 +175,73 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System break; } - case GAME_MSG_REQUEST_LINKED_MISSION: { + case eGameMessageType::REQUEST_LINKED_MISSION: { GameMessages::HandleRequestLinkedMission(inStream, entity); break; } - case GAME_MSG_MISSION_DIALOGUE_OK: { + case eGameMessageType::MISSION_DIALOGUE_OK: { GameMessages::HandleMissionDialogOK(inStream, entity); break; } - case GAME_MSG_MISSION_DIALOGUE_CANCELLED: { + case eGameMessageType::MISSION_DIALOGUE_CANCELLED: { //This message is pointless for our implementation, as the client just carries on after //rejecting a mission offer. We dont need to do anything. This is just here to remove a warning in our logs :) break; } - case GAME_MSG_REQUEST_PLATFORM_RESYNC: { + case eGameMessageType::REQUEST_PLATFORM_RESYNC: { GameMessages::HandleRequestPlatformResync(inStream, entity, sysAddr); break; } - case GAME_MSG_FIRE_EVENT_SERVER_SIDE: { + case eGameMessageType::FIRE_EVENT_SERVER_SIDE: { GameMessages::HandleFireEventServerSide(inStream, entity, sysAddr); break; } - case GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: { + case eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: { GameMessages::HandleActivitySummaryLeaderboardData(inStream, entity, sysAddr); break; } - case GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: { + case eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: { GameMessages::HandleRequestActivitySummaryLeaderboardData(inStream, entity, sysAddr); break; } - case GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST: { + case eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST: { GameMessages::HandleActivityStateChangeRequest(inStream, entity); break; } - case GAME_MSG_PARSE_CHAT_MESSAGE: { + case eGameMessageType::PARSE_CHAT_MESSAGE: { GameMessages::HandleParseChatMessage(inStream, entity, sysAddr); break; } - case GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: { + case eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: { GameMessages::HandleNotifyServerLevelProcessingComplete(inStream, entity); break; } - case GAME_MSG_PICKUP_CURRENCY: { + case eGameMessageType::PICKUP_CURRENCY: { GameMessages::HandlePickupCurrency(inStream, entity); break; } - case GAME_MSG_PICKUP_ITEM: { + case eGameMessageType::PICKUP_ITEM: { GameMessages::HandlePickupItem(inStream, entity); break; } - case GAME_MSG_RESURRECT: { + case eGameMessageType::RESURRECT: { GameMessages::HandleResurrect(inStream, entity); break; } - case GAME_MSG_REQUEST_RESURRECT: { + case eGameMessageType::REQUEST_RESURRECT: { GameMessages::SendResurrect(entity); /*auto* dest = static_cast(entity->GetComponent(eReplicaComponentType::DESTROYABLE)); if (dest) { @@ -251,12 +252,12 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System }*/ break; } - case GAME_MSG_HANDLE_HOT_PROPERTY_DATA: { + case eGameMessageType::HANDLE_HOT_PROPERTY_DATA: { GameMessages::HandleGetHotPropertyData(inStream, entity, sysAddr); break; } - case GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT: + case eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT: { auto message = RequestServerProjectileImpact(); @@ -275,7 +276,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System break; } - case GAME_MSG_START_SKILL: { + case eGameMessageType::START_SKILL: { StartSkill startSkill = StartSkill(); startSkill.Deserialize(inStream); // inStream replaces &bitStream @@ -313,7 +314,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System if (success) { //Broadcast our startSkill: RakNet::BitStream bitStreamLocal; - PacketUtils::WriteHeader(bitStreamLocal, CLIENT, MSG_CLIENT_GAME_MSG); + PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); bitStreamLocal.Write(entity->GetObjectID()); EchoStartSkill echoStartSkill; @@ -333,11 +334,11 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System } } break; - case GAME_MSG_SYNC_SKILL: { + case eGameMessageType::SYNC_SKILL: { RakNet::BitStream bitStreamLocal; - PacketUtils::WriteHeader(bitStreamLocal, CLIENT, MSG_CLIENT_GAME_MSG); + PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); bitStreamLocal.Write(entity->GetObjectID()); - //bitStreamLocal.Write((unsigned short)GAME_MSG_ECHO_SYNC_SKILL); + //bitStreamLocal.Write((unsigned short)eGameMessageType::ECHO_SYNC_SKILL); //bitStreamLocal.Write(inStream); SyncSkill sync = SyncSkill(inStream); // inStream replaced &bitStream @@ -374,306 +375,306 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System Game::server->Send(&bitStreamLocal, sysAddr, true); } break; - case GAME_MSG_REQUEST_SMASH_PLAYER: + case eGameMessageType::REQUEST_SMASH_PLAYER: entity->Smash(entity->GetObjectID()); break; - case GAME_MSG_MOVE_ITEM_BETWEEN_INVENTORY_TYPES: + case eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES: GameMessages::HandleMoveItemBetweenInventoryTypes(inStream, entity, sysAddr); break; - case GAME_MSG_MODULAR_BUILD_FINISH: + case eGameMessageType::MODULAR_BUILD_FINISH: GameMessages::HandleModularBuildFinish(inStream, entity, sysAddr); break; - case GAME_MSG_PUSH_EQUIPPED_ITEMS_STATE: + case eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE: GameMessages::HandlePushEquippedItemsState(inStream, entity); break; - case GAME_MSG_POP_EQUIPPED_ITEMS_STATE: + case eGameMessageType::POP_EQUIPPED_ITEMS_STATE: GameMessages::HandlePopEquippedItemsState(inStream, entity); break; - case GAME_MSG_BUY_FROM_VENDOR: + case eGameMessageType::BUY_FROM_VENDOR: GameMessages::HandleBuyFromVendor(inStream, entity, sysAddr); break; - case GAME_MSG_SELL_TO_VENDOR: + case eGameMessageType::SELL_TO_VENDOR: GameMessages::HandleSellToVendor(inStream, entity, sysAddr); break; - case GAME_MSG_BUYBACK_FROM_VENDOR: + case eGameMessageType::BUYBACK_FROM_VENDOR: GameMessages::HandleBuybackFromVendor(inStream, entity, sysAddr); break; - case GAME_MSG_MODULAR_BUILD_MOVE_AND_EQUIP: + case eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP: GameMessages::HandleModularBuildMoveAndEquip(inStream, entity, sysAddr); break; - case GAME_MSG_DONE_ARRANGING_WITH_ITEM: + case eGameMessageType::DONE_ARRANGING_WITH_ITEM: GameMessages::HandleDoneArrangingWithItem(inStream, entity, sysAddr); break; - case GAME_MSG_MODULAR_BUILD_CONVERT_MODEL: + case eGameMessageType::MODULAR_BUILD_CONVERT_MODEL: GameMessages::HandleModularBuildConvertModel(inStream, entity, sysAddr); break; - case GAME_MSG_BUILD_MODE_SET: + case eGameMessageType::BUILD_MODE_SET: GameMessages::HandleBuildModeSet(inStream, entity); break; - case GAME_MSG_REBUILD_CANCEL: + case eGameMessageType::REBUILD_CANCEL: GameMessages::HandleRebuildCancel(inStream, entity); break; - case GAME_MSG_MATCH_REQUEST: + case eGameMessageType::MATCH_REQUEST: GameMessages::HandleMatchRequest(inStream, entity); break; - case GAME_MSG_USE_NON_EQUIPMENT_ITEM: + case eGameMessageType::USE_NON_EQUIPMENT_ITEM: GameMessages::HandleUseNonEquipmentItem(inStream, entity); break; - case GAME_MSG_CLIENT_ITEM_CONSUMED: + case eGameMessageType::CLIENT_ITEM_CONSUMED: GameMessages::HandleClientItemConsumed(inStream, entity); break; - case GAME_MSG_SET_CONSUMABLE_ITEM: + case eGameMessageType::SET_CONSUMABLE_ITEM: GameMessages::HandleSetConsumableItem(inStream, entity, sysAddr); break; - case GAME_MSG_VERIFY_ACK: + case eGameMessageType::VERIFY_ACK: GameMessages::HandleVerifyAck(inStream, entity, sysAddr); break; // Trading - case GAME_MSG_CLIENT_TRADE_REQUEST: + case eGameMessageType::CLIENT_TRADE_REQUEST: GameMessages::HandleClientTradeRequest(inStream, entity, sysAddr); break; - case GAME_MSG_CLIENT_TRADE_CANCEL: + case eGameMessageType::CLIENT_TRADE_CANCEL: GameMessages::HandleClientTradeCancel(inStream, entity, sysAddr); break; - case GAME_MSG_CLIENT_TRADE_ACCEPT: + case eGameMessageType::CLIENT_TRADE_ACCEPT: GameMessages::HandleClientTradeAccept(inStream, entity, sysAddr); break; - case GAME_MSG_CLIENT_TRADE_UPDATE: + case eGameMessageType::CLIENT_TRADE_UPDATE: GameMessages::HandleClientTradeUpdate(inStream, entity, sysAddr); break; // Pets - case GAME_MSG_PET_TAMING_TRY_BUILD: + case eGameMessageType::PET_TAMING_TRY_BUILD: GameMessages::HandlePetTamingTryBuild(inStream, entity, sysAddr); break; - case GAME_MSG_NOTIFY_TAMING_BUILD_SUCCESS: + case eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS: GameMessages::HandleNotifyTamingBuildSuccess(inStream, entity, sysAddr); break; - case GAME_MSG_REQUEST_SET_PET_NAME: + case eGameMessageType::REQUEST_SET_PET_NAME: GameMessages::HandleRequestSetPetName(inStream, entity, sysAddr); break; - case GAME_MSG_START_SERVER_PET_MINIGAME_TIMER: + case eGameMessageType::START_SERVER_PET_MINIGAME_TIMER: GameMessages::HandleStartServerPetMinigameTimer(inStream, entity, sysAddr); break; - case GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME: + case eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME: GameMessages::HandleClientExitTamingMinigame(inStream, entity, sysAddr); break; - case GAME_MSG_COMMAND_PET: + case eGameMessageType::COMMAND_PET: GameMessages::HandleCommandPet(inStream, entity, sysAddr); break; - case GAME_MSG_DESPAWN_PET: + case eGameMessageType::DESPAWN_PET: GameMessages::HandleDespawnPet(inStream, entity, sysAddr); break; - case GAME_MSG_MESSAGE_BOX_RESPOND: + case eGameMessageType::MESSAGE_BOX_RESPOND: GameMessages::HandleMessageBoxResponse(inStream, entity, sysAddr); break; - case GAME_MSG_CHOICE_BOX_RESPOND: + case eGameMessageType::CHOICE_BOX_RESPOND: GameMessages::HandleChoiceBoxRespond(inStream, entity, sysAddr); break; // Property - case GAME_MSG_QUERY_PROPERTY_DATA: + case eGameMessageType::QUERY_PROPERTY_DATA: GameMessages::HandleQueryPropertyData(inStream, entity, sysAddr); break; - case GAME_MSG_START_BUILDING_WITH_ITEM: + case eGameMessageType::START_BUILDING_WITH_ITEM: GameMessages::HandleStartBuildingWithItem(inStream, entity, sysAddr); break; - case GAME_MSG_SET_BUILD_MODE: + case eGameMessageType::SET_BUILD_MODE: GameMessages::HandleSetBuildMode(inStream, entity, sysAddr); break; - case GAME_MSG_PROPERTY_EDITOR_BEGIN: + case eGameMessageType::PROPERTY_EDITOR_BEGIN: GameMessages::HandlePropertyEditorBegin(inStream, entity, sysAddr); break; - case GAME_MSG_PROPERTY_EDITOR_END: + case eGameMessageType::PROPERTY_EDITOR_END: GameMessages::HandlePropertyEditorEnd(inStream, entity, sysAddr); break; - case GAME_MSG_PROPERTY_CONTENTS_FROM_CLIENT: + case eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT: GameMessages::HandlePropertyContentsFromClient(inStream, entity, sysAddr); break; - case GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED: + case eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED: GameMessages::HandlePropertyModelEquipped(inStream, entity, sysAddr); break; - case GAME_MSG_PLACE_PROPERTY_MODEL: + case eGameMessageType::PLACE_PROPERTY_MODEL: GameMessages::HandlePlacePropertyModel(inStream, entity, sysAddr); break; - case GAME_MSG_UPDATE_MODEL_FROM_CLIENT: + case eGameMessageType::UPDATE_MODEL_FROM_CLIENT: GameMessages::HandleUpdatePropertyModel(inStream, entity, sysAddr); break; - case GAME_MSG_DELETE_MODEL_FROM_CLIENT: + case eGameMessageType::DELETE_MODEL_FROM_CLIENT: GameMessages::HandleDeletePropertyModel(inStream, entity, sysAddr); break; - case GAME_MSG_BBB_LOAD_ITEM_REQUEST: + case eGameMessageType::BBB_LOAD_ITEM_REQUEST: GameMessages::HandleBBBLoadItemRequest(inStream, entity, sysAddr); break; - case GAME_MSG_BBB_SAVE_REQUEST: + case eGameMessageType::BBB_SAVE_REQUEST: GameMessages::HandleBBBSaveRequest(inStream, entity, sysAddr); break; - case GAME_MSG_CONTROL_BEHAVIOR: + case eGameMessageType::CONTROL_BEHAVIOR: GameMessages::HandleControlBehaviors(inStream, entity, sysAddr); break; - case GAME_MSG_PROPERTY_ENTRANCE_SYNC: + case eGameMessageType::PROPERTY_ENTRANCE_SYNC: GameMessages::HandlePropertyEntranceSync(inStream, entity, sysAddr); break; - case GAME_MSG_ENTER_PROPERTY1: + case eGameMessageType::ENTER_PROPERTY1: GameMessages::HandleEnterProperty(inStream, entity, sysAddr); break; - case GAME_MSG_ZONE_PROPERTY_MODEL_ROTATED: + case eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED: EntityManager::Instance()->GetZoneControlEntity()->OnZonePropertyModelRotated(usr->GetLastUsedChar()->GetEntity()); break; - case GAME_MSG_UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK: + case eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK: GameMessages::HandleUpdatePropertyOrModelForFilterCheck(inStream, entity, sysAddr); break; - case GAME_MSG_SET_PROPERTY_ACCESS: + case eGameMessageType::SET_PROPERTY_ACCESS: GameMessages::HandleSetPropertyAccess(inStream, entity, sysAddr); break; // Racing - case GAME_MSG_MODULE_ASSEMBLY_QUERY_DATA: + case eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA: GameMessages::HandleModuleAssemblyQueryData(inStream, entity, sysAddr); break; - case GAME_MSG_ACKNOWLEDGE_POSSESSION: + case eGameMessageType::ACKNOWLEDGE_POSSESSION: GameMessages::HandleAcknowledgePossession(inStream, entity, sysAddr); break; - case GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE: + case eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE: GameMessages::HandleVehicleSetWheelLockState(inStream, entity, sysAddr); break; - case GAME_MSG_MODULAR_ASSEMBLY_NIF_COMPLETED: + case eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED: GameMessages::HandleModularAssemblyNIFCompleted(inStream, entity, sysAddr); break; - case GAME_MSG_RACING_CLIENT_READY: + case eGameMessageType::RACING_CLIENT_READY: GameMessages::HandleRacingClientReady(inStream, entity, sysAddr); break; - case GAME_MSG_REQUEST_DIE: + case eGameMessageType::REQUEST_DIE: GameMessages::HandleRequestDie(inStream, entity, sysAddr); break; - case GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION: + case eGameMessageType::VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION: GameMessages::HandleVehicleNotifyServerAddPassiveBoostAction(inStream, entity, sysAddr); break; - case GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION: + case eGameMessageType::VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION: GameMessages::HandleVehicleNotifyServerRemovePassiveBoostAction(inStream, entity, sysAddr); break; - case GAME_MSG_RACING_PLAYER_INFO_RESET_FINISHED: + case eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED: GameMessages::HandleRacingPlayerInfoResetFinished(inStream, entity, sysAddr); break; - case GAME_MSG_VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER: + case eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER: GameMessages::HandleVehicleNotifyHitImaginationServer(inStream, entity, sysAddr); break; - case GAME_MSG_UPDATE_PROPERTY_PERFORMANCE_COST: + case eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST: GameMessages::HandleUpdatePropertyPerformanceCost(inStream, entity, sysAddr); break; // SG - case GAME_MSG_UPDATE_SHOOTING_GALLERY_ROTATION: + case eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION: GameMessages::HandleUpdateShootingGalleryRotation(inStream, entity, sysAddr); break; // NT - case GAME_MSG_REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES: + case eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES: GameMessages::HandleRequestMoveItemBetweenInventoryTypes(inStream, entity, sysAddr); break; - case GAME_MSG_TOGGLE_GHOST_REFERENCE_OVERRIDE: + case eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE: GameMessages::HandleToggleGhostReferenceOverride(inStream, entity, sysAddr); break; - case GAME_MSG_SET_GHOST_REFERENCE_POSITION: + case eGameMessageType::SET_GHOST_REFERENCE_POSITION: GameMessages::HandleSetGhostReferencePosition(inStream, entity, sysAddr); break; - case GAME_MSG_READY_FOR_UPDATES: + case eGameMessageType::READY_FOR_UPDATES: //We don't really care about this message, as it's simply here to inform us that the client is done loading an object. //In the event we _do_ send an update to an object that hasn't finished loading, the client will handle it anyway. break; - case GAME_MSG_REPORT_BUG: + case eGameMessageType::REPORT_BUG: GameMessages::HandleReportBug(inStream, entity); break; - case GAME_MSG_CLIENT_RAIL_MOVEMENT_READY: + case eGameMessageType::CLIENT_RAIL_MOVEMENT_READY: GameMessages::HandleClientRailMovementReady(inStream, entity, sysAddr); break; - case GAME_MSG_CANCEL_RAIL_MOVEMENT: + case eGameMessageType::CANCEL_RAIL_MOVEMENT: GameMessages::HandleCancelRailMovement(inStream, entity, sysAddr); break; - case GAME_MSG_PLAYER_RAIL_ARRIVED_NOTIFICATION: + case eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION: GameMessages::HandlePlayerRailArrivedNotification(inStream, entity, sysAddr); break; - case GAME_MSG_CINEMATIC_UPDATE: + case eGameMessageType::CINEMATIC_UPDATE: GameMessages::HandleCinematicUpdate(inStream, entity, sysAddr); break; - case GAME_MSG_MODIFY_PLAYER_ZONE_STATISTIC: + case eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC: GameMessages::HandleModifyPlayerZoneStatistic(inStream, entity); break; - case GAME_MSG_UPDATE_PLAYER_STATISTIC: + case eGameMessageType::UPDATE_PLAYER_STATISTIC: GameMessages::HandleUpdatePlayerStatistic(inStream, entity); break; - case GAME_MSG_DISMOUNT_COMPLETE: + case eGameMessageType::DISMOUNT_COMPLETE: GameMessages::HandleDismountComplete(inStream, entity, sysAddr); break; - case GAME_MSG_DEACTIVATE_BUBBLE_BUFF: + case eGameMessageType::DEACTIVATE_BUBBLE_BUFF: GameMessages::HandleDeactivateBubbleBuff(inStream, entity); break; - case GAME_MSG_ACTIVATE_BUBBLE_BUFF: + case eGameMessageType::ACTIVATE_BUBBLE_BUFF: GameMessages::HandleActivateBubbleBuff(inStream, entity); break; - case GAME_MSG_ZONE_SUMMARY_DISMISSED: + case eGameMessageType::ZONE_SUMMARY_DISMISSED: GameMessages::HandleZoneSummaryDismissed(inStream, entity); break; default: diff --git a/dGame/dGameMessages/GameMessageHandler.h b/dGame/dGameMessages/GameMessageHandler.h index 063e97f6..8b6685cb 100644 --- a/dGame/dGameMessages/GameMessageHandler.h +++ b/dGame/dGameMessages/GameMessageHandler.h @@ -7,7 +7,6 @@ #define GAMEMESSAGEHANDLER_H #include "RakNetTypes.h" -#include "dMessageIdentifiers.h" #include "dCommonVars.h" #include #include @@ -21,8 +20,10 @@ #include "GameMessages.h" #include "../dDatabase/CDClientDatabase.h" +enum class eGameMessageType : uint16_t; + namespace GameMessageHandler { - void HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, GAME_MSG messageID); + void HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID); }; #endif // GAMEMESSAGEHANDLER_H diff --git a/dGame/dGameMessages/GameMessages.cpp b/dGame/dGameMessages/GameMessages.cpp index 3475c471..caab6459 100644 --- a/dGame/dGameMessages/GameMessages.cpp +++ b/dGame/dGameMessages/GameMessages.cpp @@ -4,7 +4,6 @@ #include "PacketUtils.h" #include "BitStream.h" #include "Game.h" -#include "dMessageIdentifiers.h" #include "SlashCommandHandler.h" #include "NiPoint3.h" #include "NiQuaternion.h" @@ -42,6 +41,7 @@ #include "eQuickBuildFailReason.h" #include "eControlScheme.h" #include "eStateChangeType.h" +#include "eConnectionType.h" #include #include @@ -89,6 +89,8 @@ #include "eAninmationFlags.h" #include "AMFFormat_BitStream.h" #include "eReplicaComponentType.h" +#include "eClientMessageType.h" +#include "eGameMessageType.h" #include "CDComponentsRegistryTable.h" #include "CDObjectsTable.h" @@ -98,7 +100,7 @@ void GameMessages::SendFireEventClientSide(const LWOOBJID& objectID, const Syste CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_FIRE_EVENT_CLIENT_SIDE); + bitStream.Write(eGameMessageType::FIRE_EVENT_CLIENT_SIDE); //bitStream.Write(args); uint32_t argSize = args.size(); @@ -120,7 +122,7 @@ void GameMessages::SendTeleport(const LWOOBJID& objectID, const NiPoint3& pos, c CBITSTREAM; CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_TELEPORT); + bitStream.Write(eGameMessageType::TELEPORT); bool bIgnoreY = (pos.y == 0.0f); bool bUseNavmesh = false; @@ -158,7 +160,6 @@ void GameMessages::SendPlayAnimation(Entity* entity, const std::u16string& anima //Stolen from the old DLU codebase as the new one's autogenerated code doesn't work properly for animationIDs longer than 6 characters. CBITSTREAM; CMSGHEADER; - uint16_t gameMsgID = GAME_MSG_PLAY_ANIMATION; std::string sAnimationID = GeneralUtils::UTF16ToWTF8(animationName); uint32_t animationIDLength = sAnimationID.size(); @@ -167,7 +168,7 @@ void GameMessages::SendPlayAnimation(Entity* entity, const std::u16string& anima bool bTriggerOnCompleteMsg = false; bitStream.Write(entity->GetObjectID()); - bitStream.Write(gameMsgID); + bitStream.Write(eGameMessageType::PLAY_ANIMATION); bitStream.Write(animationIDLength); PacketUtils::WriteWString(bitStream, animationName, animationIDLength); @@ -191,7 +192,7 @@ void GameMessages::SendPlayerReady(Entity* entity, const SystemAddress& sysAddr) CBITSTREAM; CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_PLAYER_READY); + bitStream.Write(eGameMessageType::PLAYER_READY); SEND_PACKET; } @@ -200,7 +201,7 @@ void GameMessages::SendPlayerAllowedRespawn(LWOOBJID entityID, bool doNotPromptR CMSGHEADER; bitStream.Write(entityID); - bitStream.Write(GAME_MSG::GAME_MSG_SET_PLAYER_ALLOWED_RESPAWN); + bitStream.Write(eGameMessageType::SET_PLAYER_ALLOWED_RESPAWN); bitStream.Write(doNotPromptRespawn); SEND_PACKET; @@ -211,7 +212,7 @@ void GameMessages::SendInvalidZoneTransferList(Entity* entity, const SystemAddre CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_INVALID_ZONE_TRANSFER_LIST); + bitStream.Write(eGameMessageType::INVALID_ZONE_TRANSFER_LIST); uint32_t CustomerFeedbackURLLength = feedbackURL.size(); bitStream.Write(CustomerFeedbackURLLength); @@ -236,7 +237,7 @@ void GameMessages::SendKnockback(const LWOOBJID& objectID, const LWOOBJID& caste CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG_KNOCKBACK); + bitStream.Write(eGameMessageType::KNOCKBACK); bool casterFlag = caster != LWOOBJID_EMPTY; bool originatorFlag = originator != LWOOBJID_EMPTY; @@ -272,7 +273,7 @@ void GameMessages::SendStartArrangingWithItem( CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_START_ARRANGING_WITH_ITEM); + bitStream.Write(eGameMessageType::START_ARRANGING_WITH_ITEM); bitStream.Write(bFirstTime); bitStream.Write(buildAreaID != LWOOBJID_EMPTY); @@ -296,7 +297,7 @@ void GameMessages::SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, cons CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG_PLAYER_SET_CAMERA_CYCLING_MODE); + bitStream.Write(eGameMessageType::PLAYER_SET_CAMERA_CYCLING_MODE); bitStream.Write(bAllowCyclingWhileDeadOnly); @@ -313,7 +314,7 @@ void GameMessages::SendPlayNDAudioEmitter(Entity* entity, const SystemAddress& s CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLAY_ND_AUDIO_EMITTER); + bitStream.Write((uint16_t)eGameMessageType::PLAY_ND_AUDIO_EMITTER); bitStream.Write0(); bitStream.Write0(); @@ -342,7 +343,7 @@ void GameMessages::SendStartPathing(Entity* entity) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG_START_PATHING); + bitStream.Write(eGameMessageType::START_PATHING); SEND_PACKET_BROADCAST; } @@ -364,7 +365,7 @@ void GameMessages::SendPlatformResync(Entity* entity, const SystemAddress& sysAd } bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLATFORM_RESYNC); + bitStream.Write((uint16_t)eGameMessageType::PLATFORM_RESYNC); bool bReverse = false; int eCommand = 0; @@ -405,7 +406,7 @@ void GameMessages::SendRestoreToPostLoadStats(Entity* entity, const SystemAddres CBITSTREAM; CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_RESTORE_TO_POST_LOAD_STATS); + bitStream.Write(eGameMessageType::RESTORE_TO_POST_LOAD_STATS); SEND_PACKET; } @@ -413,7 +414,7 @@ void GameMessages::SendServerDoneLoadingAllObjects(Entity* entity, const SystemA CBITSTREAM; CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_DONE_LOADING_ALL_OBJECTS); + bitStream.Write(eGameMessageType::SERVER_DONE_LOADING_ALL_OBJECTS); SEND_PACKET; } @@ -421,7 +422,7 @@ void GameMessages::SendChatModeUpdate(const LWOOBJID& objectID, eGameMasterLevel CBITSTREAM; CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG_UPDATE_CHAT_MODE); + bitStream.Write((uint16_t)eGameMessageType::UPDATE_CHAT_MODE); bitStream.Write(level); SEND_PACKET_BROADCAST; } @@ -430,7 +431,7 @@ void GameMessages::SendGMLevelBroadcast(const LWOOBJID& objectID, eGameMasterLev CBITSTREAM; CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG_SET_GM_LEVEL); + bitStream.Write((uint16_t)eGameMessageType::SET_GM_LEVEL); bitStream.Write1(); bitStream.Write(level); SEND_PACKET_BROADCAST; @@ -441,7 +442,7 @@ void GameMessages::SendAddItemToInventoryClientSync(Entity* entity, const System CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(static_cast(GAME_MSG_ADD_ITEM_TO_INVENTORY_CLIENT_SYNC)); + bitStream.Write(eGameMessageType::ADD_ITEM_TO_INVENTORY_CLIENT_SYNC); bitStream.Write(item->GetBound()); bitStream.Write(item->GetInfo().isBOE); bitStream.Write(item->GetInfo().isBOP); @@ -500,7 +501,7 @@ void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, uint32_t CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG_NOTIFY_CLIENT_FLAG_CHANGE); + bitStream.Write((uint16_t)eGameMessageType::NOTIFY_CLIENT_FLAG_CHANGE); bitStream.Write(bFlag); bitStream.Write(iFlagID); @@ -512,7 +513,7 @@ void GameMessages::SendChangeObjectWorldState(const LWOOBJID& objectID, eObjectW CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG_CHANGE_OBJECT_WORLD_STATE); + bitStream.Write((uint16_t)eGameMessageType::CHANGE_OBJECT_WORLD_STATE); bitStream.Write(state); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST @@ -530,7 +531,7 @@ void GameMessages::SendOfferMission(const LWOOBJID& entity, const SystemAddress& CMSGHEADER; bitStream.Write(offererID); - bitStream.Write(uint16_t(GAME_MSG_OFFER_MISSION)); + bitStream.Write(eGameMessageType::OFFER_MISSION); bitStream.Write(missionID); bitStream.Write(offererID); @@ -541,7 +542,7 @@ void GameMessages::SendOfferMission(const LWOOBJID& entity, const SystemAddress& CMSGHEADER; bitStream.Write(entity); - bitStream.Write(uint16_t(GAME_MSG_OFFER_MISSION)); + bitStream.Write(eGameMessageType::OFFER_MISSION); bitStream.Write(missionID); bitStream.Write(offererID); @@ -554,7 +555,7 @@ void GameMessages::SendNotifyMission(Entity* entity, const SystemAddress& sysAdd CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_NOTIFY_MISSION)); + bitStream.Write(eGameMessageType::NOTIFY_MISSION); bitStream.Write(missionID); bitStream.Write(missionState); bitStream.Write(sendingRewards); @@ -567,7 +568,7 @@ void GameMessages::SendNotifyMissionTask(Entity* entity, const SystemAddress& sy CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_NOTIFY_MISSION_TASK); + bitStream.Write((uint16_t)eGameMessageType::NOTIFY_MISSION_TASK); bitStream.Write(missionID); bitStream.Write(taskMask); @@ -585,7 +586,7 @@ void GameMessages::SendModifyLEGOScore(Entity* entity, const SystemAddress& sysA CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_MODIFY_LEGO_SCORE); + bitStream.Write((uint16_t)eGameMessageType::MODIFY_LEGO_SCORE); bitStream.Write(score); bitStream.Write(sourceType != eLootSourceType::NONE); @@ -599,7 +600,7 @@ void GameMessages::SendUIMessageServerToSingleClient(Entity* entity, const Syste CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_UI_MESSAGE_SERVER_TO_SINGLE_CLIENT); + bitStream.Write((uint16_t)eGameMessageType::UI_MESSAGE_SERVER_TO_SINGLE_CLIENT); bitStream.Write(args); uint32_t strMessageNameLength = message.size(); @@ -618,7 +619,7 @@ void GameMessages::SendUIMessageServerToAllClients(const std::string& message, A LWOOBJID empty = 0; bitStream.Write(empty); - bitStream.Write((uint16_t)GAME_MSG_UI_MESSAGE_SERVER_TO_ALL_CLIENTS); + bitStream.Write((uint16_t)eGameMessageType::UI_MESSAGE_SERVER_TO_ALL_CLIENTS); bitStream.Write(args); uint32_t strMessageNameLength = message.size(); @@ -636,7 +637,7 @@ void GameMessages::SendPlayEmbeddedEffectOnAllClientsNearObject(Entity* entity, CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT); + bitStream.Write((uint16_t)eGameMessageType::PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT); bitStream.Write(static_cast(effectName.length())); for (uint32_t k = 0; k < effectName.length(); k++) { @@ -657,7 +658,7 @@ void GameMessages::SendPlayFXEffect(const LWOOBJID& entity, int32_t effectID, co CMSGHEADER; bitStream.Write(entity); - bitStream.Write((uint16_t)GAME_MSG::GAME_MSG_PLAY_FX_EFFECT); + bitStream.Write((uint16_t)eGameMessageType::PLAY_FX_EFFECT); bitStream.Write(effectID != -1); if (effectID != -1) bitStream.Write(effectID); @@ -691,7 +692,7 @@ void GameMessages::SendStopFXEffect(Entity* entity, bool killImmediate, std::str CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_STOP_FX_EFFECT); + bitStream.Write(eGameMessageType::STOP_FX_EFFECT); bitStream.Write(killImmediate); bitStream.Write(name.size()); @@ -705,7 +706,7 @@ void GameMessages::SendBroadcastTextToChatbox(Entity* entity, const SystemAddres CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG::GAME_MSG_BROADCAST_TEXT_TO_CHATBOX); + bitStream.Write((uint16_t)eGameMessageType::BROADCAST_TEXT_TO_CHATBOX); LWONameValue attribs; attribs.name = attrs; @@ -731,7 +732,7 @@ void GameMessages::SendSetCurrency(Entity* entity, int64_t currency, int lootTyp CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_SET_CURRENCY)); + bitStream.Write(eGameMessageType::SET_CURRENCY); bitStream.Write(currency); @@ -761,7 +762,7 @@ void GameMessages::SendRebuildNotifyState(Entity* entity, eRebuildState prevStat CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_REBUILD_NOTIFY_STATE); + bitStream.Write((uint16_t)eGameMessageType::REBUILD_NOTIFY_STATE); bitStream.Write(prevState); bitStream.Write(state); @@ -775,7 +776,7 @@ void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, boo CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_ENABLE_REBUILD); + bitStream.Write((uint16_t)eGameMessageType::ENABLE_REBUILD); bitStream.Write(enable); bitStream.Write(fail); @@ -795,7 +796,7 @@ void GameMessages::SendTerminateInteraction(const LWOOBJID& objectID, eTerminate CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG_TERMINATE_INTERACTION); + bitStream.Write((uint16_t)eGameMessageType::TERMINATE_INTERACTION); bitStream.Write(terminator); bitStream.Write(type); @@ -808,7 +809,7 @@ void GameMessages::SendDieNoImplCode(Entity* entity, const LWOOBJID& killerID, c CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_DIE)); + bitStream.Write(eGameMessageType::DIE); bitStream.Write(bClientDeath); bitStream.Write(bSpawnLoot); bitStream.Write(deathType); @@ -831,7 +832,7 @@ void GameMessages::SendDie(Entity* entity, const LWOOBJID& killerID, const LWOOB bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_DIE); + bitStream.Write((uint16_t)eGameMessageType::DIE); bitStream.Write(bClientDeath); bitStream.Write(bSpawnLoot); @@ -867,7 +868,7 @@ void GameMessages::SendSetInventorySize(Entity* entity, int invType, int size) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_SET_INVENTORY_SIZE)); + bitStream.Write(eGameMessageType::SET_INVENTORY_SIZE); bitStream.Write(invType); bitStream.Write(size); @@ -880,7 +881,7 @@ void GameMessages::SendSetEmoteLockState(Entity* entity, bool bLock, int emoteID CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_SET_EMOTE_LOCK_STATE)); + bitStream.Write(eGameMessageType::SET_EMOTE_LOCK_STATE); bitStream.Write(bLock); bitStream.Write(emoteID); @@ -901,7 +902,7 @@ void GameMessages::SendSetJetPackMode(Entity* entity, bool use, bool bypassCheck CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_SET_JET_PACK_MODE)); + bitStream.Write(eGameMessageType::SET_JET_PACK_MODE); bitStream.Write(bypassChecks); bitStream.Write(doHover); @@ -961,7 +962,7 @@ void GameMessages::SendResurrect(Entity* entity) { bool bRezImmediately = false; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_RESURRECT)); + bitStream.Write(eGameMessageType::RESURRECT); bitStream.Write(bRezImmediately); SEND_PACKET_BROADCAST; @@ -972,7 +973,7 @@ void GameMessages::SendStop2DAmbientSound(Entity* entity, bool force, std::strin CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLAY2_DAMBIENT_SOUND); + bitStream.Write((uint16_t)eGameMessageType::PLAY2_DAMBIENT_SOUND); uint32_t audioGUIDSize = audioGUID.size(); @@ -995,7 +996,7 @@ void GameMessages::SendPlay2DAmbientSound(Entity* entity, std::string audioGUID, CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLAY2_DAMBIENT_SOUND); + bitStream.Write((uint16_t)eGameMessageType::PLAY2_DAMBIENT_SOUND); uint32_t audioGUIDSize = audioGUID.size(); @@ -1014,7 +1015,7 @@ void GameMessages::SendSetNetworkScriptVar(Entity* entity, const SystemAddress& CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_SET_NETWORK_SCRIPT_VAR); + bitStream.Write((uint16_t)eGameMessageType::SET_NETWORK_SCRIPT_VAR); // FIXME: this is a bad place to need to do a conversion because we have no clue whether data is utf8 or plain ascii // an this has performance implications @@ -1073,7 +1074,7 @@ void GameMessages::SendDropClientLoot(Entity* entity, const LWOOBJID& sourceID, CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_DROP_CLIENT_LOOT)); + bitStream.Write(eGameMessageType::DROP_CLIENT_LOOT); bitStream.Write(bUsePosition); @@ -1123,7 +1124,7 @@ void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlScheme con bool bSwitchCam = true; bitStream.Write(entity->GetObjectID()); - bitStream.Write(uint16_t(GAME_MSG_SET_PLAYER_CONTROL_SCHEME)); + bitStream.Write(eGameMessageType::SET_PLAYER_CONTROL_SCHEME); bitStream.Write(bDelayCamSwitchIfInCinematic); bitStream.Write(bSwitchCam); @@ -1140,7 +1141,7 @@ void GameMessages::SendPlayerReachedRespawnCheckpoint(Entity* entity, const NiPo CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_PLAYER_REACHED_RESPAWN_CHECKPOINT); + bitStream.Write((uint16_t)eGameMessageType::PLAYER_REACHED_RESPAWN_CHECKPOINT); bitStream.Write(position.x); bitStream.Write(position.y); @@ -1174,7 +1175,7 @@ void GameMessages::SendAddSkill(Entity* entity, TSkillID skillID, int slotID) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write((uint16_t)GAME_MSG_ADD_SKILL); + bitStream.Write((uint16_t)eGameMessageType::ADD_SKILL); bitStream.Write(AICombatWeight != 0); if (AICombatWeight != 0) bitStream.Write(AICombatWeight); @@ -1206,7 +1207,7 @@ void GameMessages::SendRemoveSkill(Entity* entity, TSkillID skillID) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG_REMOVE_SKILL); + bitStream.Write(eGameMessageType::REMOVE_SKILL); bitStream.Write(false); bitStream.Write(skillID); @@ -1235,7 +1236,7 @@ void GameMessages::SendFinishArrangingWithItem(Entity* entity, const LWOOBJID& b bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_FINISH_ARRANGING_WITH_ITEM); + bitStream.Write(eGameMessageType::FINISH_ARRANGING_WITH_ITEM); bitStream.Write(buildAreaID != LWOOBJID_EMPTY); if (buildAreaID != LWOOBJID_EMPTY) bitStream.Write(buildAreaID); @@ -1261,7 +1262,7 @@ void GameMessages::SendModularBuildEnd(Entity* entity) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_MODULAR_BUILD_END); + bitStream.Write(eGameMessageType::MODULAR_BUILD_END); SystemAddress sysAddr = entity->GetSystemAddress(); SEND_PACKET; @@ -1272,7 +1273,7 @@ void GameMessages::SendVendorOpenWindow(Entity* entity, const SystemAddress& sys CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_VENDOR_OPEN_WINDOW); + bitStream.Write(eGameMessageType::VENDOR_OPEN_WINDOW); SEND_PACKET; } @@ -1287,7 +1288,7 @@ void GameMessages::SendVendorStatusUpdate(Entity* entity, const SystemAddress& s std::map vendorItems = vendor->GetInventory(); bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_VENDOR_STATUS_UPDATE); + bitStream.Write(eGameMessageType::VENDOR_STATUS_UPDATE); bitStream.Write(bUpdateOnly); bitStream.Write(static_cast(vendorItems.size())); @@ -1308,7 +1309,7 @@ void GameMessages::SendVendorTransactionResult(Entity* entity, const SystemAddre int iResult = 0x02; // success, seems to be the only relevant one bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_VENDOR_TRANSACTION_RESULT); + bitStream.Write(eGameMessageType::VENDOR_TRANSACTION_RESULT); bitStream.Write(iResult); SEND_PACKET; @@ -1334,7 +1335,7 @@ void GameMessages::SendRemoveItemFromInventory(Entity* entity, const SystemAddre LWOOBJID iTradeID = LWOOBJID_EMPTY; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_REMOVE_ITEM_FROM_INVENTORY); + bitStream.Write(eGameMessageType::REMOVE_ITEM_FROM_INVENTORY); bitStream.Write(bConfirmed); bitStream.Write(bDeleteItem); bitStream.Write(bOutSuccess); @@ -1366,7 +1367,7 @@ void GameMessages::SendConsumeClientItem(Entity* entity, bool bSuccess, LWOOBJID CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG_CONSUME_CLIENT_ITEM); + bitStream.Write(eGameMessageType::CONSUME_CLIENT_ITEM); bitStream.Write(bSuccess); bitStream.Write(item); @@ -1379,7 +1380,7 @@ void GameMessages::SendUseItemResult(Entity* entity, LOT templateID, bool useIte CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG_USE_ITEM_RESULT); + bitStream.Write(eGameMessageType::USE_ITEM_RESULT); bitStream.Write(templateID); bitStream.Write(useItemResult); @@ -1392,7 +1393,7 @@ void GameMessages::SendUseItemRequirementsResponse(LWOOBJID objectID, const Syst CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_USE_ITEM_REQUIREMENTS_RESPONSE); + bitStream.Write(eGameMessageType::USE_ITEM_REQUIREMENTS_RESPONSE); bitStream.Write(itemResponse); @@ -1454,7 +1455,7 @@ void GameMessages::SendMatchResponse(Entity* entity, const SystemAddress& sysAdd CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_MATCH_RESPONSE); + bitStream.Write(eGameMessageType::MATCH_RESPONSE); bitStream.Write(response); SEND_PACKET; @@ -1465,7 +1466,7 @@ void GameMessages::SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_MATCH_UPDATE); + bitStream.Write(eGameMessageType::MATCH_UPDATE); bitStream.Write(uint32_t(data.size())); for (char character : data) { bitStream.Write(uint16_t(character)); @@ -1484,7 +1485,7 @@ void GameMessages::SendRequestActivitySummaryLeaderboardData(const LWOOBJID& obj CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA); + bitStream.Write(eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA); bitStream.Write(gameID != 0); if (gameID != 0) { @@ -1517,7 +1518,7 @@ void GameMessages::SendActivityPause(LWOOBJID objectId, bool pause, const System CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVITY_PAUSE); + bitStream.Write(eGameMessageType::ACTIVITY_PAUSE); bitStream.Write(pause); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; @@ -1529,7 +1530,7 @@ void GameMessages::SendStartActivityTime(LWOOBJID objectId, float_t startTime, c CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_START_ACTIVITY_TIME); + bitStream.Write(eGameMessageType::START_ACTIVITY_TIME); bitStream.Write(startTime); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; @@ -1541,7 +1542,7 @@ void GameMessages::SendRequestActivityEnter(LWOOBJID objectId, const SystemAddre CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_REQUEST_ACTIVITY_ENTER); + bitStream.Write(eGameMessageType::REQUEST_ACTIVITY_ENTER); bitStream.Write(bStart); bitStream.Write(userID); @@ -1554,7 +1555,7 @@ void GameMessages::NotifyLevelRewards(LWOOBJID objectID, const SystemAddress& sy CMSGHEADER; bitStream.Write(objectID); - bitStream.Write((uint16_t)GAME_MSG::GAME_MSG_NOTIFY_LEVEL_REWARDS); + bitStream.Write((uint16_t)eGameMessageType::NOTIFY_LEVEL_REWARDS); bitStream.Write(level); bitStream.Write(sending_rewards); @@ -1575,7 +1576,7 @@ void GameMessages::SendSetShootingGalleryParams(LWOOBJID objectId, const SystemA CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_SHOOTING_GALLERY_PARAMS); + bitStream.Write(eGameMessageType::SET_SHOOTING_GALLERY_PARAMS); /* bitStream.Write(cameraFOV); bitStream.Write(cooldown); @@ -1610,7 +1611,7 @@ void GameMessages::SendNotifyClientShootingGalleryScore(LWOOBJID objectId, const CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE); + bitStream.Write(eGameMessageType::NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE); bitStream.Write(addTime); bitStream.Write(score); bitStream.Write(target); @@ -1641,7 +1642,7 @@ void GameMessages::SendActivitySummaryLeaderboardData(const LWOOBJID& objectID, CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA); + bitStream.Write(eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA); bitStream.Write(leaderboard->GetGameID()); bitStream.Write(leaderboard->GetInfoType()); @@ -1720,7 +1721,7 @@ void GameMessages::SendStartCelebrationEffect(Entity* entity, const SystemAddres CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_START_CELEBRATION_EFFECT); + bitStream.Write(eGameMessageType::START_CELEBRATION_EFFECT); bitStream.Write(0); //animation bitStream.Write0(); //No custom bg obj @@ -1751,7 +1752,7 @@ void GameMessages::SendSetRailMovement(const LWOOBJID& objectID, bool pathGoForw CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_SET_RAIL_MOVEMENT); + bitStream.Write(eGameMessageType::SET_RAIL_MOVEMENT); bitStream.Write(pathGoForward); @@ -1785,7 +1786,7 @@ void GameMessages::SendStartRailMovement(const LWOOBJID& objectID, std::u16strin CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_START_RAIL_MOVEMENT); + bitStream.Write(eGameMessageType::START_RAIL_MOVEMENT); bitStream.Write(damageImmune); bitStream.Write(noAggro); @@ -1845,7 +1846,7 @@ void GameMessages::SendNotifyClientObject(const LWOOBJID& objectID, std::u16stri CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_CLIENT_OBJECT); + bitStream.Write(eGameMessageType::NOTIFY_CLIENT_OBJECT); bitStream.Write(uint32_t(name.size())); for (auto character : name) { @@ -1874,7 +1875,7 @@ void GameMessages::SendNotifyClientZoneObject(const LWOOBJID& objectID, const st CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_CLIENT_ZONE_OBJECT); + bitStream.Write(eGameMessageType::NOTIFY_CLIENT_ZONE_OBJECT); bitStream.Write(uint32_t(name.size())); for (const auto& character : name) { @@ -1900,7 +1901,7 @@ void GameMessages::SendNotifyClientFailedPrecondition(LWOOBJID objectId, const S CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_CLIENT_FAILED_PRECONDITION); + bitStream.Write(eGameMessageType::NOTIFY_CLIENT_FAILED_PRECONDITION); bitStream.Write(uint32_t(failedReason.size())); for (uint16_t character : failedReason) { @@ -1918,7 +1919,7 @@ void GameMessages::SendToggleGMInvis(LWOOBJID objectId, bool enabled, const Syst CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_TOGGLE_GM_INVIS); + bitStream.Write(eGameMessageType::TOGGLE_GM_INVIS); bitStream.Write(enabled); // does not matter? if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; @@ -1930,7 +1931,7 @@ void GameMessages::SendSetName(LWOOBJID objectID, std::u16string name, const Sys CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_SET_NAME); + bitStream.Write(eGameMessageType::SET_NAME); bitStream.Write(name.size()); @@ -1946,7 +1947,7 @@ void GameMessages::SendBBBSaveResponse(const LWOOBJID& objectId, const LWOOBJID& CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_BBB_SAVE_RESPONSE); + bitStream.Write(eGameMessageType::BBB_SAVE_RESPONSE); bitStream.Write(localID); @@ -1963,7 +1964,7 @@ void GameMessages::SendBBBSaveResponse(const LWOOBJID& objectId, const LWOOBJID& bitStream.Write(buffer[i]); SEND_PACKET; - PacketUtils::SavePacket("GAME_MSG_BBB_SAVE_RESPONSE.bin", (char*)bitStream.GetData(), bitStream.GetNumberOfBytesUsed()); + PacketUtils::SavePacket("eGameMessageType::BBB_SAVE_RESPONSE.bin", (char*)bitStream.GetData(), bitStream.GetNumberOfBytesUsed()); } // Property @@ -1973,7 +1974,7 @@ void GameMessages::SendOpenPropertyVendor(const LWOOBJID objectId, const SystemA CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_OPEN_PROPERTY_VENDOR); + bitStream.Write(eGameMessageType::OPEN_PROPERTY_VENDOR); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -1984,7 +1985,7 @@ void GameMessages::SendOpenPropertyManagment(const LWOOBJID objectId, const Syst CMSGHEADER; bitStream.Write(PropertyManagementComponent::Instance()->GetParent()->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_OPEN_PROPERTY_MANAGEMENT); + bitStream.Write(eGameMessageType::OPEN_PROPERTY_MANAGEMENT); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -1995,7 +1996,7 @@ void GameMessages::SendDownloadPropertyData(const LWOOBJID objectId, const Prope CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_DOWNLOAD_PROPERTY_DATA); + bitStream.Write(eGameMessageType::DOWNLOAD_PROPERTY_DATA); data.Serialize(bitStream); @@ -2010,7 +2011,7 @@ void GameMessages::SendPropertyRentalResponse(const LWOOBJID objectId, const LWO CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PROPERTY_RENTAL_RESPONSE); + bitStream.Write(eGameMessageType::PROPERTY_RENTAL_RESPONSE); bitStream.Write(cloneId); bitStream.Write(code); @@ -2026,7 +2027,7 @@ void GameMessages::SendLockNodeRotation(Entity* entity, std::string nodeName) { CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_LOCK_NODE_ROTATION); + bitStream.Write(eGameMessageType::LOCK_NODE_ROTATION); bitStream.Write(uint32_t(nodeName.size())); for (char character : nodeName) { @@ -2041,7 +2042,7 @@ void GameMessages::SendSetBuildModeConfirmed(LWOOBJID objectId, const SystemAddr CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_BUILD_MODE_CONFIRMED); + bitStream.Write(eGameMessageType::SET_BUILD_MODE_CONFIRMED); bitStream.Write(start); bitStream.Write(warnVisitors); @@ -2061,7 +2062,7 @@ void GameMessages::SendGetModelsOnProperty(LWOOBJID objectId, std::map(models.size())); @@ -2081,7 +2082,7 @@ void GameMessages::SendZonePropertyModelEquipped(LWOOBJID objectId, LWOOBJID pla CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED); + bitStream.Write(eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED); bitStream.Write(playerId); bitStream.Write(propertyId); @@ -2096,7 +2097,7 @@ void GameMessages::SendPlaceModelResponse(LWOOBJID objectId, const SystemAddress CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PLACE_MODEL_RESPONSE); + bitStream.Write(eGameMessageType::PLACE_MODEL_RESPONSE); bitStream.Write(position != NiPoint3::ZERO); if (position != NiPoint3::ZERO) { @@ -2128,7 +2129,7 @@ void GameMessages::SendUGCEquipPreCreateBasedOnEditMode(LWOOBJID objectId, const CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE); + bitStream.Write(eGameMessageType::HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE); bitStream.Write(modelCount); bitStream.Write(model); @@ -2142,7 +2143,7 @@ void GameMessages::SendUGCEquipPostDeleteBasedOnEditMode(LWOOBJID objectId, cons CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE); + bitStream.Write(eGameMessageType::HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE); bitStream.Write(inventoryItem); @@ -2192,7 +2193,7 @@ void GameMessages::HandleUnUseModel(RakNet::BitStream* inStream, Entity* entity, if (unknown) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); bitStream.Write(LWOOBJID_EMPTY); //always zero so that a check on the client passes bitStream.Write(eBlueprintSaveResponseType::PlacementFailed); // Sending a non-zero error code here prevents the client from deleting its in progress build for some reason? bitStream.Write(0); @@ -2444,7 +2445,7 @@ void GameMessages::HandleBBBLoadItemRequest(RakNet::BitStream* inStream, Entity* void GameMessages::SendBlueprintLoadItemResponse(const SystemAddress& sysAddr, bool success, LWOOBJID oldItemId, LWOOBJID newItemId) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_BLUEPRINT_LOAD_RESPONSE_ITEMID); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_LOAD_RESPONSE_ITEMID); bitStream.Write(static_cast(success)); bitStream.Write(oldItemId); bitStream.Write(newItemId); @@ -2456,7 +2457,7 @@ void GameMessages::SendSmash(Entity* entity, float force, float ghostOpacity, LW CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_SMASH); + bitStream.Write(eGameMessageType::SMASH); bitStream.Write(ignoreObjectVisibility); bitStream.Write(force); @@ -2471,7 +2472,7 @@ void GameMessages::SendUnSmash(Entity* entity, LWOOBJID builderID, float duratio CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_UNSMASH); + bitStream.Write(eGameMessageType::UNSMASH); bitStream.Write(builderID != LWOOBJID_EMPTY); if (builderID != LWOOBJID_EMPTY) bitStream.Write(builderID); @@ -2692,7 +2693,7 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream* inStream, Entity* ent //Tell the client their model is saved: (this causes us to actually pop out of our current state): CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, CLIENT::MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); bitStream.Write(localId); bitStream.Write(eBlueprintSaveResponseType::EverythingWorked); bitStream.Write(1); @@ -2832,7 +2833,7 @@ void GameMessages::SendPlayCinematic(LWOOBJID objectId, std::u16string pathName, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PLAY_CINEMATIC); + bitStream.Write(eGameMessageType::PLAY_CINEMATIC); bitStream.Write(allowGhostUpdates); bitStream.Write(bCloseMultiInteract); @@ -2871,7 +2872,7 @@ void GameMessages::SendEndCinematic(LWOOBJID objectId, std::u16string pathName, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_END_CINEMATIC); + bitStream.Write(eGameMessageType::END_CINEMATIC); bitStream.Write(leadOut != -1); if (leadOut != -1) bitStream.Write(leadOut); @@ -2944,7 +2945,7 @@ void GameMessages::SendSetStunned(LWOOBJID objectId, eStateChangeType stateChang CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_STUNNED); + bitStream.Write(eGameMessageType::SET_STUNNED); bitStream.Write(originator != LWOOBJID_EMPTY); if (originator != LWOOBJID_EMPTY) bitStream.Write(originator); @@ -2993,7 +2994,7 @@ void GameMessages::SendSetStunImmunity(LWOOBJID target, eStateChangeType state, CMSGHEADER; bitStream.Write(target); - bitStream.Write(GAME_MSG::GAME_MSG_SET_STUN_IMMUNITY); + bitStream.Write(eGameMessageType::SET_STUN_IMMUNITY); bitStream.Write(originator != LWOOBJID_EMPTY); if (originator != LWOOBJID_EMPTY) bitStream.Write(originator); @@ -3026,7 +3027,7 @@ void GameMessages::SendSetStatusImmunity(LWOOBJID objectId, eStateChangeType sta CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_STATUS_IMMUNITY); + bitStream.Write(eGameMessageType::SET_STATUS_IMMUNITY); bitStream.Write(state); @@ -3049,7 +3050,7 @@ void GameMessages::SendOrientToAngle(LWOOBJID objectId, bool bRelativeToCurrent, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ORIENT_TO_ANGLE); + bitStream.Write(eGameMessageType::ORIENT_TO_ANGLE); bitStream.Write(bRelativeToCurrent); bitStream.Write(fAngle); @@ -3064,7 +3065,7 @@ void GameMessages::SendAddRunSpeedModifier(LWOOBJID objectId, LWOOBJID caster, u CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ADD_RUN_SPEED_MODIFIER); + bitStream.Write(eGameMessageType::ADD_RUN_SPEED_MODIFIER); bitStream.Write(caster != LWOOBJID_EMPTY); if (caster != LWOOBJID_EMPTY) bitStream.Write(caster); @@ -3081,7 +3082,7 @@ void GameMessages::SendRemoveRunSpeedModifier(LWOOBJID objectId, uint32_t modifi CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_REMOVE_RUN_SPEED_MODIFIER); + bitStream.Write(eGameMessageType::REMOVE_RUN_SPEED_MODIFIER); bitStream.Write(modifier != 500); if (modifier != 500) bitStream.Write(modifier); @@ -3095,7 +3096,7 @@ void GameMessages::SendPropertyEntranceBegin(LWOOBJID objectId, const SystemAddr CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PROPERTY_ENTRANCE_BEGIN); + bitStream.Write(eGameMessageType::PROPERTY_ENTRANCE_BEGIN); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -3106,7 +3107,7 @@ void GameMessages::SendPropertySelectQuery(LWOOBJID objectId, int32_t navOffset, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PROPERTY_SELECT_QUERY); + bitStream.Write(eGameMessageType::PROPERTY_SELECT_QUERY); bitStream.Write(navOffset); bitStream.Write(thereAreMore); @@ -3129,7 +3130,7 @@ void GameMessages::SendNotifyObject(LWOOBJID objectId, LWOOBJID objIDSender, std CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_OBJECT); + bitStream.Write(eGameMessageType::NOTIFY_OBJECT); bitStream.Write(objIDSender); bitStream.Write(static_cast(name.size())); @@ -3169,7 +3170,7 @@ void GameMessages::SendTeamPickupItem(LWOOBJID objectId, LWOOBJID lootID, LWOOBJ CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_TEAM_PICKUP_ITEM); + bitStream.Write(eGameMessageType::TEAM_PICKUP_ITEM); bitStream.Write(lootID); bitStream.Write(lootOwnerID); @@ -3185,7 +3186,7 @@ void GameMessages::SendServerTradeInvite(LWOOBJID objectId, bool bNeedInvitePopU CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_INVITE); + bitStream.Write(eGameMessageType::SERVER_TRADE_INVITE); bitStream.Write(bNeedInvitePopUp); bitStream.Write(i64Requestor); @@ -3203,7 +3204,7 @@ void GameMessages::SendServerTradeInitialReply(LWOOBJID objectId, LWOOBJID i64In CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_INITIAL_REPLY); + bitStream.Write(eGameMessageType::SERVER_TRADE_INITIAL_REPLY); bitStream.Write(i64Invitee); bitStream.Write(resultType); @@ -3221,7 +3222,7 @@ void GameMessages::SendServerTradeFinalReply(LWOOBJID objectId, bool bResult, LW CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_FINAL_REPLY); + bitStream.Write(eGameMessageType::SERVER_TRADE_FINAL_REPLY); bitStream.Write(bResult); bitStream.Write(i64Invitee); @@ -3239,7 +3240,7 @@ void GameMessages::SendServerTradeAccept(LWOOBJID objectId, bool bFirst, const S CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_ACCEPT); + bitStream.Write(eGameMessageType::SERVER_TRADE_ACCEPT); bitStream.Write(bFirst); @@ -3252,7 +3253,7 @@ void GameMessages::SendServerTradeCancel(LWOOBJID objectId, const SystemAddress& CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_CANCEL); + bitStream.Write(eGameMessageType::SERVER_TRADE_CANCEL); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -3263,7 +3264,7 @@ void GameMessages::SendServerTradeUpdate(LWOOBJID objectId, uint64_t coins, cons CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SERVER_TRADE_UPDATE); + bitStream.Write(eGameMessageType::SERVER_TRADE_UPDATE); bitStream.Write(false); bitStream.Write(coins); @@ -3441,7 +3442,7 @@ void GameMessages::SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_PET_TAMING_MINIGAME); + bitStream.Write(eGameMessageType::NOTIFY_PET_TAMING_MINIGAME); bitStream.Write(petId); bitStream.Write(playerTamingId); @@ -3463,7 +3464,7 @@ void GameMessages::SendNotifyTamingModelLoadedOnServer(LWOOBJID objectId, const CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_TAMING_MODEL_LOADED_ON_SERVER); + bitStream.Write(eGameMessageType::NOTIFY_TAMING_MODEL_LOADED_ON_SERVER); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -3474,7 +3475,7 @@ void GameMessages::SendNotifyPetTamingPuzzleSelected(LWOOBJID objectId, std::vec CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_PET_TAMING_PUZZLE_SELECTED); + bitStream.Write(eGameMessageType::NOTIFY_PET_TAMING_PUZZLE_SELECTED); bitStream.Write(static_cast(bricks.size())); for (const auto& brick : bricks) { @@ -3491,7 +3492,7 @@ void GameMessages::SendPetTamingTryBuildResult(LWOOBJID objectId, bool bSuccess, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PET_TAMING_TRY_BUILD_RESULT); + bitStream.Write(eGameMessageType::PET_TAMING_TRY_BUILD_RESULT); bitStream.Write(bSuccess); bitStream.Write(iNumCorrect != 0); @@ -3506,7 +3507,7 @@ void GameMessages::SendPetResponse(LWOOBJID objectId, LWOOBJID objIDPet, int32_t CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PET_RESPONSE); + bitStream.Write(eGameMessageType::PET_RESPONSE); bitStream.Write(objIDPet); bitStream.Write(iPetCommandType); @@ -3522,7 +3523,7 @@ void GameMessages::SendAddPetToPlayer(LWOOBJID objectId, int32_t iElementalType, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ADD_PET_TO_PLAYER); + bitStream.Write(eGameMessageType::ADD_PET_TO_PLAYER); bitStream.Write(iElementalType); bitStream.Write(static_cast(name.size())); @@ -3542,7 +3543,7 @@ void GameMessages::SendRegisterPetID(LWOOBJID objectId, LWOOBJID objID, const Sy CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_REGISTER_PET_ID); + bitStream.Write(eGameMessageType::REGISTER_PET_ID); bitStream.Write(objID); @@ -3555,7 +3556,7 @@ void GameMessages::SendRegisterPetDBID(LWOOBJID objectId, LWOOBJID petDBID, cons CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_REGISTER_PET_DBID); + bitStream.Write(eGameMessageType::REGISTER_PET_DBID); bitStream.Write(petDBID); @@ -3568,7 +3569,7 @@ void GameMessages::SendMarkInventoryItemAsActive(LWOOBJID objectId, bool bActive CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_MARK_INVENTORY_ITEM_AS_ACTIVE); + bitStream.Write(eGameMessageType::MARK_INVENTORY_ITEM_AS_ACTIVE); bitStream.Write(bActive); @@ -3587,7 +3588,7 @@ void GameMessages::SendClientExitTamingMinigame(LWOOBJID objectId, bool bVolunta CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME); + bitStream.Write(eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME); bitStream.Write(bVoluntaryExit); @@ -3600,7 +3601,7 @@ void GameMessages::SendShowPetActionButton(LWOOBJID objectId, int32_t buttonLabe CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SHOW_PET_ACTION_BUTTON); + bitStream.Write(eGameMessageType::SHOW_PET_ACTION_BUTTON); bitStream.Write(buttonLabel); bitStream.Write(bShow); @@ -3614,7 +3615,7 @@ void GameMessages::SendPlayEmote(LWOOBJID objectId, int32_t emoteID, LWOOBJID ta CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PLAY_EMOTE); + bitStream.Write(eGameMessageType::PLAY_EMOTE); bitStream.Write(emoteID); bitStream.Write(target); @@ -3628,7 +3629,7 @@ void GameMessages::SendRemoveBuff(Entity* entity, bool fromUnEquip, bool removeI CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_REMOVE_BUFF); + bitStream.Write(eGameMessageType::REMOVE_BUFF); bitStream.Write(false); // bFromRemoveBehavior but setting this to true makes the GM not do anything on the client? bitStream.Write(fromUnEquip); @@ -3643,7 +3644,7 @@ void GameMessages::SendBouncerActiveStatus(LWOOBJID objectId, bool bActive, cons CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_BOUNCER_ACTIVE_STATUS); + bitStream.Write(eGameMessageType::BOUNCER_ACTIVE_STATUS); bitStream.Write(bActive); @@ -3657,7 +3658,7 @@ void GameMessages::SendSetPetName(LWOOBJID objectId, std::u16string name, LWOOBJ CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_PET_NAME); + bitStream.Write(eGameMessageType::SET_PET_NAME); bitStream.Write(static_cast(name.size())); for (const auto character : name) { @@ -3677,7 +3678,7 @@ void GameMessages::SendSetPetNameModerated(LWOOBJID objectId, LWOOBJID petDBID, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_PET_NAME_MODERATED); + bitStream.Write(eGameMessageType::SET_PET_NAME_MODERATED); bitStream.Write(petDBID != LWOOBJID_EMPTY); if (petDBID != LWOOBJID_EMPTY) bitStream.Write(petDBID); @@ -3694,7 +3695,7 @@ void GameMessages::SendPetNameChanged(LWOOBJID objectId, int32_t moderationStatu CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_PET_NAME_CHANGED); + bitStream.Write(eGameMessageType::PET_NAME_CHANGED); bitStream.Write(moderationStatus); @@ -3943,7 +3944,7 @@ void GameMessages::SendDisplayZoneSummary(LWOOBJID objectId, const SystemAddress CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_DISPLAY_ZONE_SUMMARY); + bitStream.Write(eGameMessageType::DISPLAY_ZONE_SUMMARY); bitStream.Write(isPropertyMap); bitStream.Write(isZoneStart); @@ -3961,7 +3962,7 @@ void GameMessages::SendNotifyNotEnoughInvSpace(LWOOBJID objectId, uint32_t freeS CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_NOTIFY_FINISHED_RACE); + bitStream.Write(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE); bitStream.Write(freeSlotsNeeded); bitStream.Write(inventoryType != 0); @@ -3976,7 +3977,7 @@ void GameMessages::SendDisplayMessageBox(LWOOBJID objectId, bool bShow, LWOOBJID CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_DISPLAY_MESSAGE_BOX); + bitStream.Write(eGameMessageType::DISPLAY_MESSAGE_BOX); bitStream.Write(bShow); bitStream.Write(callbackClient); @@ -4003,12 +4004,12 @@ void GameMessages::SendDisplayMessageBox(LWOOBJID objectId, bool bShow, LWOOBJID } void GameMessages::SendDisplayChatBubble(LWOOBJID objectId, const std::u16string& text, const SystemAddress& sysAddr) { - // GAME_MSG_DISPLAY_CHAT_BUBBLE + // eGameMessageType::DISPLAY_CHAT_BUBBLE CBITSTREAM; CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_DISPLAY_CHAT_BUBBLE); + bitStream.Write(eGameMessageType::DISPLAY_CHAT_BUBBLE); bitStream.Write(static_cast(text.size())); for (const auto character : text) { @@ -4025,7 +4026,7 @@ void GameMessages::SendChangeIdleFlags(LWOOBJID objectId, eAnimationFlags flagsO CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_CHANGE_IDLE_FLAGS); + bitStream.Write(eGameMessageType::CHANGE_IDLE_FLAGS); bitStream.Write(flagsOff != eAnimationFlags::IDLE_NONE); if (flagsOff != eAnimationFlags::IDLE_NONE) bitStream.Write(flagsOff); bitStream.Write(flagsOn != eAnimationFlags::IDLE_NONE); @@ -4039,7 +4040,7 @@ void GameMessages::SendSetMountInventoryID(Entity* entity, const LWOOBJID& objec CBITSTREAM; CMSGHEADER; bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_SET_MOUNT_INVENTORY_ID); + bitStream.Write(eGameMessageType::SET_MOUNT_INVENTORY_ID); bitStream.Write(objectID); SEND_PACKET_BROADCAST; @@ -4242,7 +4243,7 @@ void GameMessages::SendUpdateReputation(const LWOOBJID objectId, const int64_t r CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_UPDATE_REPUTATION); + bitStream.Write(eGameMessageType::UPDATE_REPUTATION); bitStream.Write(reputation); @@ -4316,7 +4317,7 @@ void GameMessages::SendModuleAssemblyDBDataForClient(LWOOBJID objectId, LWOOBJID CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT); + bitStream.Write(eGameMessageType::MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT); bitStream.Write(assemblyID); @@ -4335,7 +4336,7 @@ void GameMessages::SendNotifyVehicleOfRacingObject(LWOOBJID objectId, LWOOBJID r CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_VEHICLE_OF_RACING_OBJECT); + bitStream.Write(eGameMessageType::NOTIFY_VEHICLE_OF_RACING_OBJECT); bitStream.Write(racingObjectID != LWOOBJID_EMPTY); if (racingObjectID != LWOOBJID_EMPTY) bitStream.Write(racingObjectID); @@ -4350,7 +4351,7 @@ void GameMessages::SendRacingPlayerLoaded(LWOOBJID objectId, LWOOBJID playerID, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_RACING_PLAYER_LOADED); + bitStream.Write(eGameMessageType::RACING_PLAYER_LOADED); bitStream.Write(playerID); bitStream.Write(vehicleID); @@ -4365,7 +4366,7 @@ void GameMessages::SendVehicleUnlockInput(LWOOBJID objectId, bool bLockWheels, c CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_UNLOCK_INPUT); + bitStream.Write(eGameMessageType::VEHICLE_UNLOCK_INPUT); bitStream.Write(bLockWheels); @@ -4379,7 +4380,7 @@ void GameMessages::SendVehicleSetWheelLockState(LWOOBJID objectId, bool bExtraFr CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE); + bitStream.Write(eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE); bitStream.Write(bExtraFriction); bitStream.Write(bLocked); @@ -4394,7 +4395,7 @@ void GameMessages::SendRacingSetPlayerResetInfo(LWOOBJID objectId, int32_t curre CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_RACING_SET_PLAYER_RESET_INFO); + bitStream.Write(eGameMessageType::RACING_SET_PLAYER_RESET_INFO); bitStream.Write(currentLap); bitStream.Write(furthestResetPlane); @@ -4412,7 +4413,7 @@ void GameMessages::SendRacingResetPlayerToLastReset(LWOOBJID objectId, LWOOBJID CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_RACING_RESET_PLAYER_TO_LAST_RESET); + bitStream.Write(eGameMessageType::RACING_RESET_PLAYER_TO_LAST_RESET); bitStream.Write(playerID); @@ -4425,7 +4426,7 @@ void GameMessages::SendVehicleStopBoost(Entity* targetEntity, const SystemAddres CMSGHEADER; bitStream.Write(targetEntity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_STOP_BOOST); + bitStream.Write(eGameMessageType::VEHICLE_STOP_BOOST); bitStream.Write(affectPassive); @@ -4437,7 +4438,7 @@ void GameMessages::SendSetResurrectRestoreValues(Entity* targetEntity, int32_t a CMSGHEADER; bitStream.Write(targetEntity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_SET_RESURRECT_RESTORE_VALUES); + bitStream.Write(eGameMessageType::SET_RESURRECT_RESTORE_VALUES); bitStream.Write(armorRestore != -1); if (armorRestore != -1) bitStream.Write(armorRestore); @@ -4456,7 +4457,7 @@ void GameMessages::SendNotifyRacingClient(LWOOBJID objectId, int32_t eventType, CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_NOTIFY_RACING_CLIENT); + bitStream.Write(eGameMessageType::NOTIFY_RACING_CLIENT); bitStream.Write(eventType != 0); if (eventType != 0) bitStream.Write(eventType); @@ -4482,7 +4483,7 @@ void GameMessages::SendActivityEnter(LWOOBJID objectId, const SystemAddress& sys CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVITY_ENTER); + bitStream.Write(eGameMessageType::ACTIVITY_ENTER); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4494,7 +4495,7 @@ void GameMessages::SendActivityStart(LWOOBJID objectId, const SystemAddress& sys CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVITY_START); + bitStream.Write(eGameMessageType::ACTIVITY_START); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4506,7 +4507,7 @@ void GameMessages::SendActivityExit(LWOOBJID objectId, const SystemAddress& sysA CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVITY_EXIT); + bitStream.Write(eGameMessageType::ACTIVITY_EXIT); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4518,7 +4519,7 @@ void GameMessages::SendActivityStop(LWOOBJID objectId, bool bExit, bool bUserCan CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVITY_STOP); + bitStream.Write(eGameMessageType::ACTIVITY_STOP); bitStream.Write(bExit); bitStream.Write(bUserCancel); @@ -4533,7 +4534,7 @@ void GameMessages::SendVehicleAddPassiveBoostAction(LWOOBJID objectId, const Sys CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_ADD_PASSIVE_BOOST_ACTION); + bitStream.Write(eGameMessageType::VEHICLE_ADD_PASSIVE_BOOST_ACTION); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4545,7 +4546,7 @@ void GameMessages::SendVehicleRemovePassiveBoostAction(LWOOBJID objectId, const CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION); + bitStream.Write(eGameMessageType::VEHICLE_REMOVE_PASSIVE_BOOST_ACTION); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4557,7 +4558,7 @@ void GameMessages::SendVehicleNotifyFinishedRace(LWOOBJID objectId, const System CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_NOTIFY_FINISHED_RACE); + bitStream.Write(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -4571,7 +4572,7 @@ void GameMessages::SendAddBuff(LWOOBJID& objectID, const LWOOBJID& casterID, uin CMSGHEADER; bitStream.Write(objectID); - bitStream.Write(GAME_MSG::GAME_MSG_ADD_BUFF); + bitStream.Write(eGameMessageType::ADD_BUFF); bitStream.Write(false); // Added by teammate bitStream.Write(false); // Apply on teammates @@ -4652,7 +4653,7 @@ void GameMessages::SendShowActivityCountdown(LWOOBJID objectId, bool bPlayAdditi CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SHOW_ACTIVITY_COUNTDOWN); + bitStream.Write(eGameMessageType::SHOW_ACTIVITY_COUNTDOWN); bitStream.Write(bPlayAdditionalSound); @@ -5957,7 +5958,7 @@ void GameMessages::SendGetHotPropertyData(RakNet::BitStream* inStream, Entity* e // TODO This needs to be implemented when reputation is implemented for getting hot properties. /** bitStream.Write(entity->GetObjectID()); - bitStream.Write(GAME_MSG::GAME_MSG_SEND_HOT_PROPERTY_DATA); + bitStream.Write(eGameMessageType::SEND_HOT_PROPERTY_DATA); std::vector t = {25166, 25188, 25191, 25194}; bitStream.Write(4); for (uint8_t i = 0; i < 4; i++) { @@ -6151,7 +6152,7 @@ void GameMessages::SendActivateBubbleBuffFromServer(LWOOBJID objectId, const Sys CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_ACTIVATE_BUBBLE_BUFF_FROM_SERVER); + bitStream.Write(eGameMessageType::ACTIVATE_BUBBLE_BUFF_FROM_SERVER); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -6162,7 +6163,7 @@ void GameMessages::SendDeactivateBubbleBuffFromServer(LWOOBJID objectId, const S CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_DEACTIVATE_BUBBLE_BUFF_FROM_SERVER); + bitStream.Write(eGameMessageType::DEACTIVATE_BUBBLE_BUFF_FROM_SERVER); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST; SEND_PACKET; @@ -6180,7 +6181,7 @@ void GameMessages::SendSetNamebillboardState(const SystemAddress& sysAddr, LWOOB CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SET_NAME_BILLBOARD_STATE); + bitStream.Write(eGameMessageType::SET_NAME_BILLBOARD_STATE); // Technically these bits would be written, however the client does not // contain a deserialize method to actually deserialize, so we are leaving it out. @@ -6198,7 +6199,7 @@ void GameMessages::SendShowBillboardInteractIcon(const SystemAddress& sysAddr, L CMSGHEADER; bitStream.Write(objectId); - bitStream.Write(GAME_MSG::GAME_MSG_SHOW_BILLBOARD_INTERACT_ICON); + bitStream.Write(eGameMessageType::SHOW_BILLBOARD_INTERACT_ICON); if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST else SEND_PACKET diff --git a/dGame/dGameMessages/RequestServerProjectileImpact.h b/dGame/dGameMessages/RequestServerProjectileImpact.h index 01426361..090d8274 100644 --- a/dGame/dGameMessages/RequestServerProjectileImpact.h +++ b/dGame/dGameMessages/RequestServerProjectileImpact.h @@ -2,13 +2,11 @@ #define __REQUESTSERVERPROJECTILEIMPACT__H__ #include "dCommonVars.h" -#include "dMessageIdentifiers.h" +#include "eGameMessageType.h" /* Notifying the server that a locally owned projectile impacted. Sent to the caster of the projectile should always be the local char. */ class RequestServerProjectileImpact { - static const GAME_MSG MsgID = GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT; - public: RequestServerProjectileImpact() { i64LocalID = LWOOBJID_EMPTY; @@ -29,7 +27,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT); stream->Write(i64LocalID != LWOOBJID_EMPTY); if (i64LocalID != LWOOBJID_EMPTY) stream->Write(i64LocalID); diff --git a/dGame/dGameMessages/StartSkill.h b/dGame/dGameMessages/StartSkill.h index af82a9b4..40bc210f 100644 --- a/dGame/dGameMessages/StartSkill.h +++ b/dGame/dGameMessages/StartSkill.h @@ -2,16 +2,14 @@ #define __STARTSKILL__H__ #include "dCommonVars.h" -#include "dMessageIdentifiers.h" #include "NiPoint3.h" #include "NiQuaternion.h" +#include "eGameMessageType.h" /** * Same as sync skill but with different network options. An echo down to other clients that need to play the skill. */ class StartSkill { - static const GAME_MSG MsgID = GAME_MSG_START_SKILL; - public: StartSkill() { bUsedMouse = false; @@ -46,7 +44,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::START_SKILL); stream->Write(bUsedMouse); diff --git a/dGame/dGameMessages/SyncSkill.h b/dGame/dGameMessages/SyncSkill.h index 72a88839..6485199e 100644 --- a/dGame/dGameMessages/SyncSkill.h +++ b/dGame/dGameMessages/SyncSkill.h @@ -5,11 +5,10 @@ #include #include "BitStream.h" +#include "eGameMessageType.h" /* Message to synchronize a skill cast */ class SyncSkill { - static const GAME_MSG MsgID = GAME_MSG_SYNC_SKILL; - public: SyncSkill() { bDone = false; @@ -30,7 +29,7 @@ public: } void Serialize(RakNet::BitStream* stream) { - stream->Write(MsgID); + stream->Write(eGameMessageType::SYNC_SKILL); stream->Write(bDone); uint32_t sBitStreamLength = sBitStream.length(); diff --git a/dGame/dUtilities/Mail.cpp b/dGame/dUtilities/Mail.cpp index 1d3e0f60..5dc55765 100644 --- a/dGame/dUtilities/Mail.cpp +++ b/dGame/dUtilities/Mail.cpp @@ -13,7 +13,6 @@ #include "Entity.h" #include "Character.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "dLogger.h" #include "EntityManager.h" #include "InventoryComponent.h" @@ -26,6 +25,7 @@ #include "WorldConfig.h" #include "eMissionTaskType.h" #include "eReplicaComponentType.h" +#include "eConnectionType.h" void Mail::SendMail(const Entity* recipient, const std::string& subject, const std::string& body, const LOT attachment, const uint16_t attachmentCount) { @@ -283,7 +283,7 @@ void Mail::HandleDataRequest(RakNet::BitStream* packet, const SystemAddress& sys sql::ResultSet* res = stmt->executeQuery(); RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); bitStream.Write(int(MailMessageID::MailData)); bitStream.Write(int(0)); @@ -406,7 +406,7 @@ void Mail::HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t obje void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); bitStream.Write(int(MailMessageID::SendResponse)); bitStream.Write(int(response)); Game::server->Send(&bitStream, sysAddr, false); @@ -414,7 +414,7 @@ void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse respo void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); uint64_t messageType = 2; uint64_t s1 = 0; uint64_t s2 = 0; @@ -433,7 +433,7 @@ void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) { void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); bitStream.Write(int(MailMessageID::AttachmentCollectConfirm)); bitStream.Write(int(0)); //unknown bitStream.Write(mailID); @@ -442,7 +442,7 @@ void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t ma void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); bitStream.Write(int(MailMessageID::MailDeleteConfirm)); bitStream.Write(int(0)); //unknown bitStream.Write(mailID); @@ -456,7 +456,7 @@ void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOO void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); bitStream.Write(int(MailMessageID::MailReadConfirm)); bitStream.Write(int(0)); //unknown bitStream.Write(mailID); diff --git a/dGame/dUtilities/SlashCommandHandler.cpp b/dGame/dUtilities/SlashCommandHandler.cpp index 66e9bc9b..07950d7a 100644 --- a/dGame/dUtilities/SlashCommandHandler.cpp +++ b/dGame/dUtilities/SlashCommandHandler.cpp @@ -71,7 +71,6 @@ #include "eBubbleType.h" #include "AMFFormat.h" #include "MovingPlatformComponent.h" -#include "dMessageIdentifiers.h" #include "eMissionState.h" #include "TriggerComponent.h" #include "eServerDisconnectIdentifiers.h" @@ -79,6 +78,9 @@ #include "eGameMasterLevel.h" #include "eReplicaComponentType.h" #include "eControlScheme.h" +#include "eConnectionType.h" +#include "eChatInternalMessageType.h" +#include "eMasterMessageType.h" #include "CDObjectsTable.h" #include "CDZoneTableTable.h" @@ -765,7 +767,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit if (chatCommand == "shutdownuniverse" && entity->GetGMLevel() == eGameMasterLevel::OPERATOR) { //Tell the master server that we're going to be shutting down whole "universe": CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN_UNIVERSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_UNIVERSE); Game::server->SendToMaster(&bitStream); ChatPackets::SendSystemMessage(sysAddr, u"Sent universe shutdown notification to master."); @@ -1096,7 +1098,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit //Notify chat about it CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE); bitStream.Write(characterId); bitStream.Write(expire); @@ -2044,7 +2046,7 @@ void SlashCommandHandler::SendAnnouncement(const std::string& title, const std:: //Notify chat about it CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ANNOUNCEMENT); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ANNOUNCEMENT); bitStream.Write(title.size()); for (auto character : title) { diff --git a/dMasterServer/InstanceManager.cpp b/dMasterServer/InstanceManager.cpp index fe62a5e5..50f55b72 100644 --- a/dMasterServer/InstanceManager.cpp +++ b/dMasterServer/InstanceManager.cpp @@ -7,10 +7,11 @@ #include "CDClientDatabase.h" #include "CDClientManager.h" #include "CDZoneTableTable.h" -#include "dMessageIdentifiers.h" #include "MasterPackets.h" #include "PacketUtils.h" #include "BinaryPathFinder.h" +#include "eConnectionType.h" +#include "eMasterMessageType.h" InstanceManager::InstanceManager(dLogger* logger, const std::string& externalIP) { mLogger = logger; @@ -201,7 +202,7 @@ void InstanceManager::RequestAffirmation(Instance* instance, const PendingInstan CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_AFFIRM_TRANSFER_REQUEST); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_REQUEST); bitStream.Write(request.id); @@ -405,7 +406,7 @@ bool Instance::GetShutdownComplete() const { void Instance::Shutdown() { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN); Game::server->Send(&bitStream, this->m_SysAddr, false); diff --git a/dMasterServer/MasterServer.cpp b/dMasterServer/MasterServer.cpp index cc2bdd90..4b524d8d 100644 --- a/dMasterServer/MasterServer.cpp +++ b/dMasterServer/MasterServer.cpp @@ -27,6 +27,8 @@ #include "dServer.h" #include "AssetManager.h" #include "BinaryPathFinder.h" +#include "eConnectionType.h" +#include "eMasterMessageType.h" //RakNet includes: #include "RakNetDefines.h" @@ -39,7 +41,6 @@ #include "MasterPackets.h" #include "ObjectIDManager.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "FdbToSqlite.h" namespace Game { @@ -494,9 +495,9 @@ void HandlePacket(Packet* packet) { } } - if (packet->data[1] == MASTER) { - switch (packet->data[3]) { - case MSG_MASTER_REQUEST_PERSISTENT_ID: { + if (static_cast(packet->data[1]) == eConnectionType::MASTER) { + switch (static_cast(packet->data[3])) { + case eMasterMessageType::REQUEST_PERSISTENT_ID: { Game::logger->Log("MasterServer", "A persistent ID req"); RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -508,7 +509,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_REQUEST_ZONE_TRANSFER: { + case eMasterMessageType::REQUEST_ZONE_TRANSFER: { Game::logger->Log("MasterServer", "Received zone transfer req"); RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -544,7 +545,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_SERVER_INFO: { + case eMasterMessageType::SERVER_INFO: { //MasterPackets::HandleServerInfo(packet); //This is here because otherwise we'd have to include IM in @@ -603,7 +604,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_SET_SESSION_KEY: { + case eMasterMessageType::SET_SESSION_KEY: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); uint32_t sessionKey = 0; @@ -617,7 +618,7 @@ void HandlePacket(Packet* packet) { activeSessions.erase(it.first); CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_NEW_SESSION_ALERT); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::NEW_SESSION_ALERT); bitStream.Write(sessionKey); bitStream.Write(username.size()); for (auto character : username) { @@ -634,7 +635,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_REQUEST_SESSION_KEY: { + case eMasterMessageType::REQUEST_SESSION_KEY: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); std::string username = PacketUtils::ReadString(8, packet, false); @@ -642,7 +643,7 @@ void HandlePacket(Packet* packet) { for (auto key : activeSessions) { if (key.second == username) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SESSION_KEY_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SESSION_KEY_RESPONSE); bitStream.Write(key.first); PacketUtils::WriteString(bitStream, key.second, 64); Game::server->Send(&bitStream, packet->systemAddress, false); @@ -652,7 +653,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_PLAYER_ADDED: { + case eMasterMessageType::PLAYER_ADDED: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -672,7 +673,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_PLAYER_REMOVED: { + case eMasterMessageType::PLAYER_REMOVED: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -690,7 +691,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_CREATE_PRIVATE_ZONE: { + case eMasterMessageType::CREATE_PRIVATE_ZONE: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -714,7 +715,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_REQUEST_PRIVATE_ZONE: { + case eMasterMessageType::REQUEST_PRIVATE_ZONE: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -749,7 +750,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_WORLD_READY: { + case eMasterMessageType::WORLD_READY: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -773,7 +774,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_PREP_ZONE: { + case eMasterMessageType::PREP_ZONE: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -789,7 +790,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_AFFIRM_TRANSFER_RESPONSE: { + case eMasterMessageType::AFFIRM_TRANSFER_RESPONSE: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -809,7 +810,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_SHUTDOWN_RESPONSE: { + case eMasterMessageType::SHUTDOWN_RESPONSE: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -824,7 +825,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_SHUTDOWN_UNIVERSE: { + case eMasterMessageType::SHUTDOWN_UNIVERSE: { Game::logger->Log("MasterServer", "Received shutdown universe command, shutting down in 10 minutes."); Game::shouldShutdown = true; break; @@ -888,7 +889,7 @@ void ShutdownSequence(int32_t signal) { { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN); Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true); Game::logger->Log("MasterServer", "Triggered master shutdown"); } diff --git a/dNet/AuthPackets.cpp b/dNet/AuthPackets.cpp index eae23394..4bbb0576 100644 --- a/dNet/AuthPackets.cpp +++ b/dNet/AuthPackets.cpp @@ -1,6 +1,5 @@ #include "AuthPackets.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "dNetCommon.h" #include "dServer.h" @@ -23,6 +22,9 @@ #include "dConfig.h" #include "eServerDisconnectIdentifiers.h" #include "eLoginResponse.h" +#include "eConnectionType.h" +#include "eServerMessageType.h" +#include "eMasterMessageType.h" void AuthPackets::HandleHandshake(dServer* server, Packet* packet) { RakNet::BitStream inStream(packet->data, packet->length, false); @@ -36,7 +38,7 @@ void AuthPackets::HandleHandshake(dServer* server, Packet* packet) { void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, SERVER, MSG_SERVER_VERSION_CONFIRM); + PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM); bitStream.Write(NET_VERSION); bitStream.Write(uint32_t(0x93)); @@ -189,7 +191,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) { void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) { RakNet::BitStream packet; - PacketUtils::WriteHeader(packet, CLIENT, MSG_CLIENT_LOGIN_RESPONSE); + PacketUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE); packet.Write(static_cast(responseCode)); @@ -255,7 +257,7 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd //Inform the master server that we've created a session for this user: { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SET_SESSION_KEY); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY); bitStream.Write(sessionKey); PacketUtils::WriteString(bitStream, username, 66); server->SendToMaster(&bitStream); diff --git a/dNet/ChatPackets.cpp b/dNet/ChatPackets.cpp index 2d592c9b..41661523 100644 --- a/dNet/ChatPackets.cpp +++ b/dNet/ChatPackets.cpp @@ -8,12 +8,13 @@ #include "BitStream.h" #include "Game.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "dServer.h" +#include "eConnectionType.h" +#include "eChatMessageType.h" void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_GENERAL_CHAT_MESSAGE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE); bitStream.Write(static_cast(0)); bitStream.Write(chatChannel); @@ -35,7 +36,7 @@ void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_GENERAL_CHAT_MESSAGE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE); bitStream.Write(static_cast(0)); bitStream.Write(static_cast(4)); @@ -67,7 +68,7 @@ void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) { //0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players." CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_SEND_CANNED_TEXT); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SEND_CANNED_TEXT); bitStream.Write(0); //response type, options above ^ //docs say there's a wstring here-- no idea what it's for, or if it's even needed so leaving it as is for now. SEND_PACKET; diff --git a/dNet/ClientPackets.cpp b/dNet/ClientPackets.cpp index a1c08938..4ccbb609 100644 --- a/dNet/ClientPackets.cpp +++ b/dNet/ClientPackets.cpp @@ -31,7 +31,6 @@ #include "dConfig.h" #include "CharacterComponent.h" #include "Database.h" -#include "dMessageIdentifiers.h" #include "eGameMasterLevel.h" #include "eReplicaComponentType.h" diff --git a/dNet/MasterPackets.cpp b/dNet/MasterPackets.cpp index e5b80e05..4233a37d 100644 --- a/dNet/MasterPackets.cpp +++ b/dNet/MasterPackets.cpp @@ -1,22 +1,23 @@ #include "MasterPackets.h" #include "BitStream.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "dCommonVars.h" #include "dServer.h" +#include "eConnectionType.h" +#include "eMasterMessageType.h" #include void MasterPackets::SendPersistentIDRequest(dServer* server, uint64_t requestID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PERSISTENT_ID); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID); bitStream.Write(requestID); server->SendToMaster(&bitStream); } void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, uint32_t objID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE); bitStream.Write(requestID); bitStream.Write(objID); @@ -26,7 +27,7 @@ void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddres void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t cloneID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_ZONE_TRANSFER); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER); bitStream.Write(requestID); bitStream.Write(static_cast(mythranShift)); @@ -38,7 +39,7 @@ void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint32_t cloneID, const std::string& password) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_CREATE_PRIVATE_ZONE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE); bitStream.Write(zoneID); bitStream.Write(cloneID); @@ -53,7 +54,7 @@ void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, bool mythranShift, const std::string& password) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PRIVATE_ZONE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE); bitStream.Write(requestID); bitStream.Write(static_cast(mythranShift)); @@ -68,7 +69,7 @@ void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCEID instanceId) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_WORLD_READY); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY); bitStream.Write(zoneId); bitStream.Write(instanceId); @@ -78,7 +79,7 @@ void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCE void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, const std::string& serverIP, uint32_t serverPort) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE); bitStream.Write(requestID); bitStream.Write(static_cast(mythranShift)); @@ -110,7 +111,7 @@ void MasterPackets::HandleServerInfo(Packet* packet) { void MasterPackets::SendServerInfo(dServer* server, Packet* packet) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SERVER_INFO); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO); bitStream.Write(server->GetPort()); bitStream.Write(server->GetZoneID()); diff --git a/dNet/PacketUtils.cpp b/dNet/PacketUtils.cpp index 307ff633..77b314d6 100644 --- a/dNet/PacketUtils.cpp +++ b/dNet/PacketUtils.cpp @@ -1,17 +1,9 @@ #include "PacketUtils.h" -#include #include #include #include "dLogger.h" #include "Game.h" -void PacketUtils::WriteHeader(RakNet::BitStream& bitStream, uint16_t connectionType, uint32_t internalPacketID) { - bitStream.Write(MessageID(ID_USER_PACKET_ENUM)); - bitStream.Write(connectionType); - bitStream.Write(internalPacketID); - bitStream.Write(uint8_t(0)); -} - uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) { if (startLoc + 2 > packet->length) return 0; diff --git a/dNet/PacketUtils.h b/dNet/PacketUtils.h index fbbd1839..7c917f2e 100644 --- a/dNet/PacketUtils.h +++ b/dNet/PacketUtils.h @@ -1,11 +1,20 @@ #ifndef PACKETUTILS_H #define PACKETUTILS_H +#include #include #include +enum class eConnectionType : uint16_t; + namespace PacketUtils { - void WriteHeader(RakNet::BitStream& bitStream, uint16_t connectionType, uint32_t internalPacketID); + template + void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) { + bitStream.Write(MessageID(ID_USER_PACKET_ENUM)); + bitStream.Write(connectionType); + bitStream.Write(internalPacketID); + bitStream.Write(uint8_t(0)); + } uint16_t ReadPacketU16(uint32_t startLoc, Packet* packet); uint32_t ReadPacketU32(uint32_t startLoc, Packet* packet); diff --git a/dNet/WorldPackets.cpp b/dNet/WorldPackets.cpp index 3be4fb4d..5fce14d3 100644 --- a/dNet/WorldPackets.cpp +++ b/dNet/WorldPackets.cpp @@ -1,7 +1,6 @@ #include "dCommonVars.h" #include "WorldPackets.h" #include "BitStream.h" -#include "dMessageIdentifiers.h" #include "PacketUtils.h" #include "GeneralUtils.h" #include "User.h" @@ -14,10 +13,11 @@ #include "dZoneManager.h" #include "CharacterComponent.h" #include "ZCompression.h" +#include "eConnectionType.h" void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_LOAD_STATIC_ZONE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE); auto zone = dZoneManager::Instance()->GetZone()->GetZoneID(); bitStream.Write(static_cast(zone.GetMapID())); @@ -41,7 +41,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) { if (!user) return; RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_LIST_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE); std::vector characters = user->GetCharacters(); bitStream.Write(static_cast(characters.size())); @@ -90,28 +90,28 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) { void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_CREATE_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE); bitStream.Write(response); SEND_PACKET; } void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_RENAME_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE); bitStream.Write(response); SEND_PACKET; } void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_DELETE_CHARACTER_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE); bitStream.Write(static_cast(response)); SEND_PACKET; } void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TRANSFER_TO_WORLD); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD); PacketUtils::WriteString(bitStream, serverIP, 33); bitStream.Write(static_cast(serverPort)); @@ -122,14 +122,14 @@ void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std:: void WorldPackets::SendServerState(const SystemAddress& sysAddr) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_SERVER_STATES); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES); bitStream.Write(static_cast(1)); //If the server is receiving this request, it probably is ready anyway. SEND_PACKET; } void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* entity, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CREATE_CHARACTER); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER); RakNet::BitStream data; data.Write(7); //LDF key count @@ -198,7 +198,7 @@ void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* ent void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector> unacceptedItems) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHAT_MODERATION_STRING); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING); bitStream.Write(unacceptedItems.empty()); // Is sentence ok? bitStream.Write(0x16); // Source ID, unknown @@ -222,7 +222,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAKE_GM_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE); bitStream.Write(success); bitStream.Write(static_cast(highestLevel)); diff --git a/dNet/dServer.cpp b/dNet/dServer.cpp index c91c7508..610f06a5 100644 --- a/dNet/dServer.cpp +++ b/dNet/dServer.cpp @@ -6,9 +6,11 @@ #include "RakNetworkFactory.h" #include "MessageIdentifiers.h" +#include "eConnectionType.h" +#include "eServerMessageType.h" +#include "eMasterMessageType.h" #include "PacketUtils.h" -#include "dMessageIdentifiers.h" #include "MasterPackets.h" #include "ZoneInstanceManager.h" @@ -118,14 +120,14 @@ Packet* dServer::ReceiveFromMaster() { } if (packet->data[0] == ID_USER_PACKET_ENUM) { - if (packet->data[1] == MASTER) { - switch (packet->data[3]) { - case MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE: { + if (static_cast(packet->data[1]) == eConnectionType::MASTER) { + switch (static_cast(packet->data[3])) { + case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: { uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); break; } - case MSG_MASTER_SHUTDOWN: + case eMasterMessageType::SHUTDOWN: *mShouldShutdown = true; break; @@ -166,7 +168,7 @@ void dServer::SendToMaster(RakNet::BitStream* bitStream) { void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) { RakNet::BitStream bitStream; - PacketUtils::WriteHeader(bitStream, SERVER, MSG_SERVER_DISCONNECT_NOTIFY); + PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY); bitStream.Write(disconNotifyID); mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false); diff --git a/dWorldServer/WorldServer.cpp b/dWorldServer/WorldServer.cpp index 71384207..4eca86f2 100644 --- a/dWorldServer/WorldServer.cpp +++ b/dWorldServer/WorldServer.cpp @@ -31,7 +31,6 @@ #include "PacketUtils.h" #include "WorldPackets.h" #include "UserManager.h" -#include "dMessageIdentifiers.h" #include "CDClientManager.h" #include "CDClientDatabase.h" #include "GeneralUtils.h" @@ -65,7 +64,12 @@ #include "NiPoint3.h" #include "eServerDisconnectIdentifiers.h" #include "eObjectBits.h" - +#include "eConnectionType.h" +#include "eServerMessageType.h" +#include "eChatInternalMessageType.h" +#include "eWorldMessageType.h" +#include "eMasterMessageType.h" +#include "eGameMessageType.h" #include "ZCompression.h" namespace Game { @@ -547,9 +551,9 @@ void HandlePacketChat(Packet* packet) { } if (packet->data[0] == ID_USER_PACKET_ENUM) { - if (packet->data[1] == CHAT_INTERNAL) { - switch (packet->data[3]) { - case MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER: { + if (static_cast(packet->data[1]) == eConnectionType::CHAT_INTERNAL) { + switch (static_cast(packet->data[3])) { + case eChatInternalMessageType::ROUTE_TO_PLAYER: { CINSTREAM; LWOOBJID playerID; inStream.Read(playerID); @@ -571,7 +575,7 @@ void HandlePacketChat(Packet* packet) { break; } - case MSG_CHAT_INTERNAL_ANNOUNCEMENT: { + case eChatInternalMessageType::ANNOUNCEMENT: { CINSTREAM; LWOOBJID header; inStream.Read(header); @@ -610,7 +614,7 @@ void HandlePacketChat(Packet* packet) { break; } - case MSG_CHAT_INTERNAL_MUTE_UPDATE: { + case eChatInternalMessageType::MUTE_UPDATE: { CINSTREAM; LWOOBJID playerId; time_t expire = 0; @@ -629,7 +633,7 @@ void HandlePacketChat(Packet* packet) { break; } - case MSG_CHAT_INTERNAL_TEAM_UPDATE: { + case eChatInternalMessageType::TEAM_UPDATE: { CINSTREAM; LWOOBJID header; inStream.Read(header); @@ -706,7 +710,7 @@ void HandlePacket(Packet* packet) { { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); bitStream.Write(user->GetLoggedInChar()); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); } @@ -718,35 +722,35 @@ void HandlePacket(Packet* packet) { } CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PLAYER_REMOVED); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED); bitStream.Write((LWOMAPID)Game::server->GetZoneID()); bitStream.Write((LWOINSTANCEID)instanceID); Game::server->SendToMaster(&bitStream); } if (packet->data[0] != ID_USER_PACKET_ENUM) return; - if (packet->data[1] == SERVER) { - if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) { + if (static_cast(packet->data[1]) == eConnectionType::SERVER) { + if (static_cast(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) { AuthPackets::HandleHandshake(Game::server, packet); } } - if (packet->data[1] == MASTER) { - switch (packet->data[3]) { - case MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE: { + if (static_cast(packet->data[1]) == eConnectionType::MASTER) { + switch (static_cast(packet->data[3])) { + case eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE: { uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); uint32_t objectID = PacketUtils::ReadPacketU32(16, packet); ObjectIDManager::Instance()->HandleRequestPersistentIDResponse(requestID, objectID); break; } - case MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE: { + case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: { uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); break; } - case MSG_MASTER_SESSION_KEY_RESPONSE: { + case eMasterMessageType::SESSION_KEY_RESPONSE: { //Read our session key and to which user it belongs: RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -803,7 +807,7 @@ void HandlePacket(Packet* packet) { //Notify master: { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PLAYER_ADDED); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED); bitStream.Write((LWOMAPID)Game::server->GetZoneID()); bitStream.Write((LWOINSTANCEID)instanceID); Game::server->SendToMaster(&bitStream); @@ -812,27 +816,27 @@ void HandlePacket(Packet* packet) { break; } - case MSG_MASTER_AFFIRM_TRANSFER_REQUEST: { + case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: { const uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); Game::logger->Log("MasterServer", "Got affirmation request of transfer %llu", requestID); CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_AFFIRM_TRANSFER_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_RESPONSE); bitStream.Write(requestID); Game::server->SendToMaster(&bitStream); break; } - case MSG_MASTER_SHUTDOWN: { + case eMasterMessageType::SHUTDOWN: { Game::shouldShutdown = true; Game::logger->Log("WorldServer", "Got shutdown request from master, zone (%i), instance (%i)", Game::server->GetZoneID(), Game::server->GetInstanceID()); break; } - case MSG_MASTER_NEW_SESSION_ALERT: { + case eMasterMessageType::NEW_SESSION_ALERT: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); uint32_t sessionKey = inStream.Read(sessionKey); @@ -870,10 +874,10 @@ void HandlePacket(Packet* packet) { return; } - if (packet->data[1] != WORLD) return; + if (static_cast(packet->data[1]) != eConnectionType::WORLD) return; - switch (packet->data[3]) { - case MSG_WORLD_CLIENT_VALIDATION: { + switch (static_cast(packet->data[3])) { + case eWorldMessageType::VALIDATION: { std::string username = PacketUtils::ReadString(0x08, packet, true); std::string sessionKey = PacketUtils::ReadString(74, packet, true); std::string clientDatabaseChecksum = PacketUtils::ReadString(packet->length - 33, packet, false); @@ -905,7 +909,7 @@ void HandlePacket(Packet* packet) { //Request the session info from Master: CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_SESSION_KEY); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_SESSION_KEY); PacketUtils::WriteString(bitStream, username, 64); Game::server->SendToMaster(&bitStream); @@ -918,7 +922,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_CHARACTER_LIST_REQUEST: { + case eWorldMessageType::CHARACTER_LIST_REQUEST: { //We need to delete the entity first, otherwise the char list could delete it while it exists in the world! if (Game::server->GetZoneID() != 0) { auto user = UserManager::Instance()->GetUser(packet->systemAddress); @@ -940,12 +944,12 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_GAME_MSG: { + case eWorldMessageType::GAME_MSG: { RakNet::BitStream bitStream(packet->data, packet->length, false); uint64_t header; LWOOBJID objectID; - uint16_t messageID; + eGameMessageType messageID; bitStream.Read(header); bitStream.Read(objectID); @@ -954,16 +958,16 @@ void HandlePacket(Packet* packet) { RakNet::BitStream dataStream; bitStream.Read(dataStream, bitStream.GetNumberOfUnreadBits()); - GameMessageHandler::HandleMessage(&dataStream, packet->systemAddress, objectID, GAME_MSG(messageID)); + GameMessageHandler::HandleMessage(&dataStream, packet->systemAddress, objectID, messageID); break; } - case MSG_WORLD_CLIENT_CHARACTER_CREATE_REQUEST: { + case eWorldMessageType::CHARACTER_CREATE_REQUEST: { UserManager::Instance()->CreateCharacter(packet->systemAddress, packet); break; } - case MSG_WORLD_CLIENT_LOGIN_REQUEST: { + case eWorldMessageType::LOGIN_REQUEST: { RakNet::BitStream inStream(packet->data, packet->length, false); uint64_t header = inStream.Read(header); @@ -979,7 +983,7 @@ void HandlePacket(Packet* packet) { // This means we swapped characters and we need to remove the previous player from the container. if (static_cast(lastCharacter) != playerID) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); bitStream.Write(lastCharacter); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); } @@ -989,18 +993,18 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_CHARACTER_DELETE_REQUEST: { + case eWorldMessageType::CHARACTER_DELETE_REQUEST: { UserManager::Instance()->DeleteCharacter(packet->systemAddress, packet); UserManager::Instance()->RequestCharacterList(packet->systemAddress); break; } - case MSG_WORLD_CLIENT_CHARACTER_RENAME_REQUEST: { + case eWorldMessageType::CHARACTER_RENAME_REQUEST: { UserManager::Instance()->RenameCharacter(packet->systemAddress, packet); break; } - case MSG_WORLD_CLIENT_LEVEL_LOAD_COMPLETE: { + case eWorldMessageType::LEVEL_LOAD_COMPLETE: { Game::logger->Log("WorldServer", "Received level load complete from user."); User* user = UserManager::Instance()->GetUser(packet->systemAddress); if (user) { @@ -1128,7 +1132,7 @@ void HandlePacket(Packet* packet) { GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT); CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); bitStream.Write(LWOOBJID_EMPTY); //always zero so that a check on the client passes bitStream.Write(eBlueprintSaveResponseType::EverythingWorked); bitStream.Write(1); @@ -1169,7 +1173,7 @@ void HandlePacket(Packet* packet) { //RakNet::RakString playerName(player->GetCharacter()->GetName().c_str()); CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION); bitStream.Write(player->GetObjectID()); bitStream.Write(playerName.size()); for (size_t i = 0; i < playerName.size(); i++) { @@ -1194,12 +1198,12 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_POSITION_UPDATE: { + case eWorldMessageType::POSITION_UPDATE: { ClientPackets::HandleClientPositionUpdate(packet->systemAddress, packet); break; } - case MSG_WORLD_CLIENT_MAIL: { + case eWorldMessageType::MAIL: { RakNet::BitStream bitStream(packet->data, packet->length, false); LWOOBJID space; bitStream.Read(space); @@ -1207,7 +1211,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_ROUTE_PACKET: { + case eWorldMessageType::ROUTE_PACKET: { //Yeet to chat CINSTREAM; uint64_t header = 0; @@ -1222,7 +1226,7 @@ void HandlePacket(Packet* packet) { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, CHAT, packet->data[14]); + PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, packet->data[14]); //We need to insert the player's objectID so the chat server can find who originated this request: LWOOBJID objectID = 0; @@ -1243,12 +1247,12 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_STRING_CHECK: { + case eWorldMessageType::STRING_CHECK: { ClientPackets::HandleChatModerationRequest(packet->systemAddress, packet); break; } - case MSG_WORLD_CLIENT_GENERAL_CHAT_MESSAGE: { + case eWorldMessageType::GENERAL_CHAT_MESSAGE: { if (chatDisabled) { ChatPackets::SendMessageFail(packet->systemAddress); } else { @@ -1258,7 +1262,7 @@ void HandlePacket(Packet* packet) { break; } - case MSG_WORLD_CLIENT_HANDLE_FUNNESS: { + case eWorldMessageType::HANDLE_FUNNESS: { //This means the client is running slower or faster than it should. //Could be insane lag, but I'mma just YEET them as it's usually speedhacking. //This is updated to now count the amount of times we've been caught "speedhacking" to kick with a delay @@ -1346,6 +1350,6 @@ void FinalizeShutdown() { void SendShutdownMessageToMaster() { CBITSTREAM; - PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN_RESPONSE); + PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_RESPONSE); Game::server->SendToMaster(&bitStream); }