Merge remote-tracking branch 'upstream/main' into first-draft-leaderboard-re-write

dGame/dGameMessages/DoClientProjectileImpact.h

@@ -1,13 +1,10 @@
 #ifndef __DOCLIENTPROJECTILEIMPACT__H__
 #define __DOCLIENTPROJECTILEIMPACT__H__
 
-#include "dMessageIdentifiers.h"
 #include "dCommonVars.h"
 
 /*  Tell a client local projectile to impact */
 class DoClientProjectileImpact {
-	static const GAME_MSG MsgID = GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT;
-
 public:
 	DoClientProjectileImpact() {
 		i64OrgID = LWOOBJID_EMPTY;
@@ -30,7 +27,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT);
 
 		stream->Write(i64OrgID != LWOOBJID_EMPTY);
 		if (i64OrgID != LWOOBJID_EMPTY) stream->Write(i64OrgID);

dGame/dGameMessages/EchoStartSkill.h

@@ -2,14 +2,12 @@
 #define __ECHOSTARTSKILL__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
+#include "eGameMessageType.h"
 
 /*  Same as start skill but with different network options. An echo down to other clients that need to play the skill. */
 class EchoStartSkill {
-	static const GAME_MSG MsgID = GAME_MSG_ECHO_START_SKILL;
-
 public:
 	EchoStartSkill() {
 		bUsedMouse = false;
@@ -42,7 +40,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::ECHO_START_SKILL);
 
 		stream->Write(bUsedMouse);
 

dGame/dGameMessages/EchoSyncSkill.h

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

dGame/dGameMessages/GameMessageHandler.cpp

@@ -33,10 +33,11 @@
 #include "EchoSyncSkill.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
+#include "eConnectionType.h"
 
 using namespace std;
 
-void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, GAME_MSG messageID) {
+void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID) {
 
 	CBITSTREAM;
 
@@ -53,54 +54,54 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 
 	switch (messageID) {
 
-	case GAME_MSG_UN_USE_BBB_MODEL: {
+	case eGameMessageType::UN_USE_BBB_MODEL: {
 		GameMessages::HandleUnUseModel(inStream, entity, sysAddr);
 		break;
 	}
-	case GAME_MSG_PLAY_EMOTE: {
+	case eGameMessageType::PLAY_EMOTE: {
 		GameMessages::HandlePlayEmote(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MOVE_ITEM_IN_INVENTORY: {
+	case eGameMessageType::MOVE_ITEM_IN_INVENTORY: {
 		GameMessages::HandleMoveItemInInventory(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REMOVE_ITEM_FROM_INVENTORY: {
+	case eGameMessageType::REMOVE_ITEM_FROM_INVENTORY: {
 		GameMessages::HandleRemoveItemFromInventory(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_EQUIP_ITEM:
+	case eGameMessageType::EQUIP_ITEM:
 		GameMessages::HandleEquipItem(inStream, entity);
 		break;
 
-	case GAME_MSG_UN_EQUIP_ITEM:
+	case eGameMessageType::UN_EQUIP_ITEM:
 		GameMessages::HandleUnequipItem(inStream, entity);
 		break;
 
-	case GAME_MSG_RESPOND_TO_MISSION: {
+	case eGameMessageType::RESPOND_TO_MISSION: {
 		GameMessages::HandleRespondToMission(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_USE: {
+	case eGameMessageType::REQUEST_USE: {
 		GameMessages::HandleRequestUse(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_SET_FLAG: {
+	case eGameMessageType::SET_FLAG: {
 		GameMessages::HandleSetFlag(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_HAS_BEEN_COLLECTED: {
+	case eGameMessageType::HAS_BEEN_COLLECTED: {
 		GameMessages::HandleHasBeenCollected(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PLAYER_LOADED: {
+	case eGameMessageType::PLAYER_LOADED: {
 		GameMessages::SendRestoreToPostLoadStats(entity, sysAddr);
 		entity->SetPlayerReadyForUpdates();
 
@@ -174,73 +175,73 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		break;
 	}
 
-	case GAME_MSG_REQUEST_LINKED_MISSION: {
+	case eGameMessageType::REQUEST_LINKED_MISSION: {
 		GameMessages::HandleRequestLinkedMission(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MISSION_DIALOGUE_OK: {
+	case eGameMessageType::MISSION_DIALOGUE_OK: {
 		GameMessages::HandleMissionDialogOK(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MISSION_DIALOGUE_CANCELLED: {
+	case eGameMessageType::MISSION_DIALOGUE_CANCELLED: {
 		//This message is pointless for our implementation, as the client just carries on after
 		//rejecting a mission offer. We dont need to do anything. This is just here to remove a warning in our logs :)
 		break;
 	}
 
-	case GAME_MSG_REQUEST_PLATFORM_RESYNC: {
+	case eGameMessageType::REQUEST_PLATFORM_RESYNC: {
 		GameMessages::HandleRequestPlatformResync(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_FIRE_EVENT_SERVER_SIDE: {
+	case eGameMessageType::FIRE_EVENT_SERVER_SIDE: {
 		GameMessages::HandleFireEventServerSide(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
+	case eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
 		GameMessages::HandleActivitySummaryLeaderboardData(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
+	case eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
 		GameMessages::HandleRequestActivitySummaryLeaderboardData(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST: {
+	case eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST: {
 		GameMessages::HandleActivityStateChangeRequest(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PARSE_CHAT_MESSAGE: {
+	case eGameMessageType::PARSE_CHAT_MESSAGE: {
 		GameMessages::HandleParseChatMessage(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
+	case eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
 		GameMessages::HandleNotifyServerLevelProcessingComplete(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PICKUP_CURRENCY: {
+	case eGameMessageType::PICKUP_CURRENCY: {
 		GameMessages::HandlePickupCurrency(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PICKUP_ITEM: {
+	case eGameMessageType::PICKUP_ITEM: {
 		GameMessages::HandlePickupItem(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_RESURRECT: {
+	case eGameMessageType::RESURRECT: {
 		GameMessages::HandleResurrect(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_RESURRECT: {
+	case eGameMessageType::REQUEST_RESURRECT: {
 		GameMessages::SendResurrect(entity);
 		/*auto* dest = static_cast<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,308 +375,311 @@ 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;
+	case eGameMessageType::REQUEST_ACTIVITY_EXIT:
+		GameMessages::HandleRequestActivityExit(inStream, entity);
+		break;
 	default:
 		// Game::logger->Log("GameMessageHandler", "Unknown game message ID: %i", messageID);
 		break;

dGame/dGameMessages/GameMessageHandler.h

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

dGame/dGameMessages/GameMessages.h

@@ -12,7 +12,7 @@
 #include "eLootSourceType.h"
 #include "Brick.h"
 
-class AMFValue;
+class AMFBaseValue;
 class Entity;
 class Item;
 class NiQuaternion;
@@ -88,8 +88,8 @@ namespace GameMessages {
 	void NotifyLevelRewards(LWOOBJID objectID, const SystemAddress& sysAddr, int level, bool sending_rewards);
 
 	void SendModifyLEGOScore(Entity* entity, const SystemAddress& sysAddr, int64_t score, eLootSourceType sourceType);
-	void SendUIMessageServerToSingleClient(Entity* entity, const SystemAddress& sysAddr, const std::string& message, AMFValue* args);
-	void SendUIMessageServerToAllClients(const std::string& message, AMFValue* args);
+	void SendUIMessageServerToSingleClient(Entity* entity, const SystemAddress& sysAddr, const std::string& message, AMFBaseValue& args);
+	void SendUIMessageServerToAllClients(const std::string& message, AMFBaseValue& args);
 
 	void SendPlayEmbeddedEffectOnAllClientsNearObject(Entity* entity, std::u16string effectName, const LWOOBJID& fromObjectID, float radius);
 	void SendPlayFXEffect(Entity* entity, int32_t effectID, const std::u16string& effectType, const std::string& name, LWOOBJID secondary, float priority = 1, float scale = 1, bool serialize = true);
@@ -648,6 +648,7 @@ namespace GameMessages {
 	void SendDeactivateBubbleBuffFromServer(LWOOBJID objectId, const SystemAddress& sysAddr);
 
 	void HandleZoneSummaryDismissed(RakNet::BitStream* inStream, Entity* entity);
+	void HandleRequestActivityExit(RakNet::BitStream* inStream, Entity* entity);
 };
 
 #endif // GAMEMESSAGES_H

dGame/dGameMessages/RequestServerProjectileImpact.h

@@ -2,13 +2,11 @@
 #define __REQUESTSERVERPROJECTILEIMPACT__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
+#include "eGameMessageType.h"
 
 /*  Notifying the server that a locally owned projectile impacted. Sent to the caster of the projectile
 		should always be the local char. */
 class RequestServerProjectileImpact {
-	static const GAME_MSG MsgID = GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT;
-
 public:
 	RequestServerProjectileImpact() {
 		i64LocalID = LWOOBJID_EMPTY;
@@ -29,7 +27,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT);
 
 		stream->Write(i64LocalID != LWOOBJID_EMPTY);
 		if (i64LocalID != LWOOBJID_EMPTY) stream->Write(i64LocalID);

dGame/dGameMessages/StartSkill.h

@@ -2,16 +2,14 @@
 #define __STARTSKILL__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
+#include "eGameMessageType.h"
 
 /**
  * Same as sync skill but with different network options. An echo down to other clients that need to play the skill.
  */
 class StartSkill {
-	static const GAME_MSG MsgID = GAME_MSG_START_SKILL;
-
 public:
 	StartSkill() {
 		bUsedMouse = false;
@@ -46,7 +44,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::START_SKILL);
 
 		stream->Write(bUsedMouse);
 

dGame/dGameMessages/SyncSkill.h

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