Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2025-08-04 17:54:01 +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
43 changed files with 1131 additions and 1066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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) {