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

Breakout message identifiers (#1065)

Browse Source 
and make them scope enums
This commit is contained in:
Aaron Kimbrell 2023-05-03 16:38:32 -05:00 committed by GitHub
parent c17b5fa586
commit e297aacc68
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
43 changed files with 1131 additions and 1066 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
dAuthServer/AuthServer.cpp
View File

@ -15,10 +15,13 @@
//RakNet includes:
#include "RakNetDefines.h"
#include <MessageIdentifiers.h>
//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<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
if (static_cast<eServerMessageType>(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<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
AuthPackets::HandleLoginRequest(Game::server, packet);
}
}

66
dChatServer/ChatPacketHandler.cpp
View File

@ -3,7 +3,6 @@
#include "Database.h"
#include <vector>
#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<uint8_t>(0);
bitStream.Write<uint16_t>(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<uint8_t>(8);
bitStream.Write<unsigned int>(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<uint8_t>(7);
bitStream.Write<unsigned int>(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<uint8_t>(7);
bitStream.Write<unsigned int>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(isSuccessful); //isOnline
PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);

62
dChatServer/ChatServer.cpp
View File

@ -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 <MessageIdentifiers.h>
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<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
switch (static_cast<eChatInternalMessageType>(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<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
switch (static_cast<eChatMessageType>(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<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
switch (static_cast<eWorldMessageType>(packet->data[3])) {
case eWorldMessageType::ROUTE_PACKET: {
Game::logger->Log("ChatServer", "Routing packet from world");
break;
}

7
dChatServer/PlayerContainer.cpp
View File

@ -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);

4
dCommon/dEnums/dCommonVars.h
View File

@ -7,6 +7,8 @@
#include <string>
#include <set>
#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);

564
dCommon/dEnums/dMessageIdentifiers.h
View File

@ -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
};

15
dCommon/dEnums/eAuthMessageType.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __EAUTHMESSAGETYPE__H__
#define __EAUTHMESSAGETYPE__H__
#include <cstdint>
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__

31
dCommon/dEnums/eChatInternalMessageType.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef __ECHATINTERNALMESSAGETYPE__H__
#define __ECHATINTERNALMESSAGETYPE__H__
#include <cstdint>
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__

78
dCommon/dEnums/eChatMessageType.h Normal file
View File

@ -0,0 +1,78 @@
#ifndef __ECHATMESSAGETYPE__H__
#define __ECHATMESSAGETYPE__H__
#include <cstdint>
//! 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__

76
dCommon/dEnums/eClientMessageType.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef __ECLIENTMESSAGETYPE__H__
#define __ECLIENTMESSAGETYPE__H__
#include <cstdint>
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__

14
dCommon/dEnums/eConnectionType.h Normal file
View File

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

303
dCommon/dEnums/eGameMessageType.h Normal file
View File

@ -0,0 +1,303 @@
#ifndef __EGAMEMESSAGETYPE__H__
#define __EGAMEMESSAGETYPE__H__
#include <cstdint>
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__

36
dCommon/dEnums/eMasterMessageType.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef __EMASTERMESSAGETYPE__H__
#define __EMASTERMESSAGETYPE__H__
#include <cstdint>
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__

12
dCommon/dEnums/eServerMessageType.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __ESERVERMESSAGETYPE__H__
#define __ESERVERMESSAGETYPE__H__
#include <cstdint>
//! The Internal Server Packet Identifiers
enum class eServerMessageType : uint32_t {
VERSION_CONFIRM = 0,
DISCONNECT_NOTIFY,
GENERAL_NOTIFY
};
#endif //!__ESERVERMESSAGETYPE__H__

42
dCommon/dEnums/eWorldMessageType.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef __EWORLDMESSAGETYPE__H__
#define __EWORLDMESSAGETYPE__H__
#include <cstdint>
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__

5
dGame/UserManager.cpp
View File

@ -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);
}

4
dGame/dBehaviors/BehaviorContext.cpp
View File

@ -10,12 +10,12 @@
#include <sstream>
#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);

2
dGame/dComponents/ModuleAssemblyComponent.h
View File

@ -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);

5
dGame/dComponents/RocketLaunchpadControlComponent.cpp
View File

@ -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);
}

5
dGame/dComponents/ScriptedActivityComponent.cpp
View File

@ -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());

8
dGame/dComponents/SkillComponent.cpp
View File

@ -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);

5
dGame/dGameMessages/DoClientProjectileImpact.h
View File

@ -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);

6
dGame/dGameMessages/EchoStartSkill.h
View File

@ -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);

6
dGame/dGameMessages/EchoSyncSkill.h
View File

@ -4,13 +4,11 @@
#include <string>
#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();

219
dGame/dGameMessages/GameMessageHandler.cpp
View File

@ -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<DestroyableComponent*>(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:

5
dGame/dGameMessages/GameMessageHandler.h
View File

@ -7,7 +7,6 @@
#define GAMEMESSAGEHANDLER_H
#include "RakNetTypes.h"
#include "dMessageIdentifiers.h"
#include "dCommonVars.h"
#include <iostream>
#include <sstream>
@ -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

325
dGame/dGameMessages/GameMessages.cpp
View File

File diff suppressed because it is too large Load Diff

6
dGame/dGameMessages/RequestServerProjectileImpact.h
View File

@ -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);

6
dGame/dGameMessages/StartSkill.h
View File

@ -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);

5
dGame/dGameMessages/SyncSkill.h
View File

@ -5,11 +5,10 @@
#include <string>
#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();

14
dGame/dUtilities/Mail.cpp
View File

@ -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);

10
dGame/dUtilities/SlashCommandHandler.cpp
View File

@ -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<uint32_t>(title.size());
for (auto character : title) {

7
dMasterServer/InstanceManager.cpp
View File

@ -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);

41
dMasterServer/MasterServer.cpp
View File

@ -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<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
switch (static_cast<eMasterMessageType>(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<uint32_t>(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");
}

10
dNet/AuthPackets.cpp
View File

@ -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<unsigned int>(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<uint8_t>(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);

9
dNet/ChatPackets.cpp
View File

@ -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<uint64_t>(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<uint64_t>(0));
bitStream.Write(static_cast<char>(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<uint8_t>(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;

1
dNet/ClientPackets.cpp
View File

@ -31,7 +31,6 @@
#include "dConfig.h"
#include "CharacterComponent.h"
#include "Database.h"
#include "dMessageIdentifiers.h"
#include "eGameMasterLevel.h"
#include "eReplicaComponentType.h"

19
dNet/MasterPackets.cpp
View File

@ -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 <string>
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<uint8_t>(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<uint8_t>(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<uint8_t>(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());

8
dNet/PacketUtils.cpp
View File

@ -1,17 +1,9 @@
#include "PacketUtils.h"
#include <MessageIdentifiers.h>
#include <vector>
#include <fstream>
#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;

11
dNet/PacketUtils.h
View File

@ -1,11 +1,20 @@
#ifndef PACKETUTILS_H
#define PACKETUTILS_H
#include <MessageIdentifiers.h>
#include <BitStream.h>
#include <string>
enum class eConnectionType : uint16_t;
namespace PacketUtils {
void WriteHeader(RakNet::BitStream& bitStream, uint16_t connectionType, uint32_t internalPacketID);
template<typename T>
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);

22
dNet/WorldPackets.cpp
View File

@ -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<uint16_t>(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<Character*> characters = user->GetCharacters();
bitStream.Write(static_cast<uint8_t>(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<uint8_t>(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<uint16_t>(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<uint8_t>(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<uint32_t>(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<std::pair<uint8_t, uint8_t>> unacceptedItems) {
CBITSTREAM;
PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHAT_MODERATION_STRING);
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING);
bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
bitStream.Write<uint16_t>(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<uint8_t>(success);
bitStream.Write(static_cast<uint16_t>(highestLevel));

14
dNet/dServer.cpp
View File

@ -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<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
switch (static_cast<eMasterMessageType>(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);

96
dWorldServer/WorldServer.cpp
View File

@ -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<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
switch (static_cast<eChatInternalMessageType>(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<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
if (static_cast<eServerMessageType>(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<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
switch (static_cast<eMasterMessageType>(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<eConnectionType>(packet->data[1]) != eConnectionType::WORLD) return;
switch (packet->data[3]) {
case MSG_WORLD_CLIENT_VALIDATION: {
switch (static_cast<eWorldMessageType>(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<uint32_t>(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>(LWOOBJID_EMPTY); //always zero so that a check on the client passes
bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
bitStream.Write<uint32_t>(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<uint32_t>(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);
}