Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-04-12 10:46:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into property_entrance_component

Browse Source
This commit is contained in:
David Markowitz
2024-11-17 19:49:07 -08:00
parent bf61ae8984 83f8646936
commit 77a141ee66
100 changed files with 4371 additions and 3041 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
dGame/Character.cpp
View File

@@ -40,8 +40,8 @@ void Character::UpdateInfoFromDatabase() {
auto charInfo = Database::Get()->GetCharacterInfo(m_ID);
if (charInfo) {
m_Name = charInfo->name;
m_UnapprovedName = charInfo->pendingName;
m_Name = charInfo->name;
m_UnapprovedName = charInfo->pendingName;
m_NameRejected = charInfo->needsRename;
m_PropertyCloneID = charInfo->cloneId;
m_PermissionMap = charInfo->permissionMap;
@@ -76,7 +76,7 @@ void Character::DoQuickXMLDataParse() {
if (m_Doc.Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
LOG("Loaded xmlData for character %s (%i)!", m_Name.c_str(), m_ID);
} else {
LOG("Failed to load xmlData!");
LOG("Failed to load xmlData (%i) (%s) (%s)!", m_Doc.ErrorID(), m_Doc.ErrorIDToName(m_Doc.ErrorID()), m_Doc.ErrorStr());
//Server::rakServer->CloseConnection(m_ParentUser->GetSystemAddress(), true);
return;
}

5
dGame/Character.h
View File

@@ -38,6 +38,7 @@ public:
const std::string& GetXMLData() const { return m_XMLData; }
const tinyxml2::XMLDocument& GetXMLDoc() const { return m_Doc; }
void _setXmlDoc(tinyxml2::XMLDocument& doc) { doc.DeepCopy(&m_Doc); }
/**
* Out of abundance of safety and clarity of what this saves, this is its own function.
@@ -459,6 +460,10 @@ public:
User* GetParentUser() const { return m_ParentUser; }
void _doQuickXMLDataParse() { DoQuickXMLDataParse(); }
void _setXmlData(const std::string& xmlData) { m_XMLData = xmlData; }
private:
void UpdateInfoFromDatabase();
/**

8
dGame/Entity.cpp
View File

@@ -24,7 +24,7 @@
#include "eTriggerEventType.h"
#include "eObjectBits.h"
#include "PositionUpdate.h"
#include "eChatMessageType.h"
#include "MessageType/Chat.h"
#include "PlayerManager.h"
//Component includes:
@@ -96,6 +96,8 @@
#include "CDSkillBehaviorTable.h"
#include "CDZoneTableTable.h"
Observable<Entity*, const PositionUpdate&> Entity::OnPlayerPositionUpdate;
Entity::Entity(const LWOOBJID& objectID, EntityInfo info, User* parentUser, Entity* parentEntity) {
m_ObjectID = objectID;
m_TemplateID = info.lot;
@@ -881,7 +883,7 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
// Update the chat server of our GM Level
{
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GMLEVEL_UPDATE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GMLEVEL_UPDATE);
bitStream.Write(m_ObjectID);
bitStream.Write(m_GMLevel);
@@ -2133,6 +2135,8 @@ void Entity::ProcessPositionUpdate(PositionUpdate& update) {
Game::entityManager->QueueGhostUpdate(GetObjectID());
if (updateChar) Game::entityManager->SerializeEntity(this);
OnPlayerPositionUpdate.Notify(this, update);
}
const SystemAddress& Entity::GetSystemAddress() const {

6
dGame/Entity.h
View File

@@ -11,6 +11,7 @@
#include "NiQuaternion.h"
#include "LDFFormat.h"
#include "eKillType.h"
#include "Observable.h"
namespace Loot {
class Info;
@@ -299,6 +300,11 @@ public:
// Scale will only be communicated to the client when the construction packet is sent
void SetScale(const float scale) { m_Scale = scale; };
/**
* @brief The observable for player entity position updates.
*/
static Observable<Entity*, const PositionUpdate&> OnPlayerPositionUpdate;
protected:
LWOOBJID m_ObjectID;

10
dGame/UserManager.cpp
View File

@@ -26,7 +26,7 @@
#include "eCharacterCreationResponse.h"
#include "eRenameResponse.h"
#include "eConnectionType.h"
#include "eChatMessageType.h"
#include "MessageType/Chat.h"
#include "BitStreamUtils.h"
#include "CheatDetection.h"
@@ -216,7 +216,7 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
}
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHARACTER_LIST_RESPONSE);
std::vector<Character*> characters = u->GetCharacters();
bitStream.Write<uint8_t>(characters.size());
@@ -266,7 +266,7 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet) {
User* u = GetUser(sysAddr);
if (!u) return;
LUWString LUWStringName;
uint32_t firstNameIndex;
uint32_t middleNameIndex;
@@ -422,7 +422,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
Database::Get()->DeleteCharacter(charID);
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::UNEXPECTED_DISCONNECT);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::UNEXPECTED_DISCONNECT);
bitStream.Write(objectID);
Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
@@ -439,7 +439,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
CINSTREAM_SKIP_HEADER;
LWOOBJID objectID;
inStream.Read(objectID);
inStream.Read(objectID);
GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);

4
dGame/dBehaviors/BehaviorContext.cpp
View File

@@ -212,7 +212,7 @@ void BehaviorContext::UpdatePlayerSyncs(float deltaTime) {
echo.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
message.Write(this->originator);
echo.Serialize(message);
@@ -285,7 +285,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
// Write message
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
message.Write(this->originator);
echo.Serialize(message);

2
dGame/dBehaviors/ChangeIdleFlagsBehavior.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "Behavior.h"
#include "eAninmationFlags.h"
#include "eAnimationFlags.h"
class ChangeIdleFlagsBehavior final : public Behavior {
public:

4
dGame/dComponents/ActivityComponent.cpp
View File

@@ -21,7 +21,7 @@
#include "eMissionTaskType.h"
#include "eMatchUpdate.h"
#include "eConnectionType.h"
#include "eChatMessageType.h"
#include "MessageType/Chat.h"
#include "CDCurrencyTableTable.h"
#include "CDActivityRewardsTable.h"
@@ -501,7 +501,7 @@ void ActivityInstance::StartZone() {
// only make a team if we have more than one participant
if (participants.size() > 1) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::CREATE_TEAM);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::CREATE_TEAM);
bitStream.Write(leader->GetObjectID());
bitStream.Write(m_Participants.size());

14
dGame/dComponents/CharacterComponent.h
View File

@@ -25,6 +25,8 @@ struct ZoneStatistics {
uint64_t m_CoinsCollected;
uint64_t m_EnemiesSmashed;
uint64_t m_QuickBuildsCompleted;
bool operator==(const ZoneStatistics& rhs) const = default;
};
/**
@@ -279,9 +281,9 @@ public:
*/
void UpdateClientMinimap(bool showFaction, std::string ventureVisionType) const;
void SetCurrentInteracting(LWOOBJID objectID) {m_CurrentInteracting = objectID;};
void SetCurrentInteracting(LWOOBJID objectID) { m_CurrentInteracting = objectID; };
LWOOBJID GetCurrentInteracting() {return m_CurrentInteracting;};
LWOOBJID GetCurrentInteracting() { return m_CurrentInteracting; };
/**
* Sends a player to another zone with an optional clone ID
@@ -307,6 +309,14 @@ public:
void SetDroppedCoins(const uint64_t value) { m_DroppedCoins = value; };
const std::array<uint64_t, 4>& GetClaimCodes() const { return m_ClaimCodes; };
const std::map<LWOMAPID, ZoneStatistics>& GetZoneStatistics() const { return m_ZoneStatistics; };
const std::u16string& GetLastRocketConfig() const { return m_LastRocketConfig; };
uint64_t GetTotalTimePlayed() const { return m_TotalTimePlayed; };
/**
* Character info regarding this character, including clothing styles, etc.
*/

5
dGame/dComponents/DestroyableComponent.cpp
View File

@@ -38,6 +38,9 @@
#include "CDComponentsRegistryTable.h"
Implementation<bool, const Entity*> DestroyableComponent::IsEnemyImplentation;
Implementation<bool, const Entity*> DestroyableComponent::IsFriendImplentation;
DestroyableComponent::DestroyableComponent(Entity* parent) : Component(parent) {
m_iArmor = 0;
m_fMaxArmor = 0.0f;
@@ -418,6 +421,7 @@ void DestroyableComponent::AddFaction(const int32_t factionID, const bool ignore
}
bool DestroyableComponent::IsEnemy(const Entity* other) const {
if (IsEnemyImplentation.ExecuteWithDefault(other, false)) return true;
if (m_Parent->IsPlayer() && other->IsPlayer()) {
auto* thisCharacterComponent = m_Parent->GetComponent<CharacterComponent>();
if (!thisCharacterComponent) return false;
@@ -440,6 +444,7 @@ bool DestroyableComponent::IsEnemy(const Entity* other) const {
}
bool DestroyableComponent::IsFriend(const Entity* other) const {
if (IsFriendImplentation.ExecuteWithDefault(other, false)) return true;
const auto* otherDestroyableComponent = other->GetComponent<DestroyableComponent>();
if (otherDestroyableComponent != nullptr) {
for (const auto enemyFaction : m_EnemyFactionIDs) {

4
dGame/dComponents/DestroyableComponent.h
View File

@@ -7,6 +7,7 @@
#include "Entity.h"
#include "Component.h"
#include "eReplicaComponentType.h"
#include "Implementation.h"
namespace CppScripts {
class Script;
@@ -463,6 +464,9 @@ public:
// handle hardcode mode drops
void DoHardcoreModeDrops(const LWOOBJID source);
static Implementation<bool, const Entity*> IsEnemyImplentation;
static Implementation<bool, const Entity*> IsFriendImplentation;
private:
/**
* Whether or not the health should be serialized

13
dGame/dComponents/ModelComponent.cpp
View File

@@ -7,6 +7,7 @@
#include "BehaviorStates.h"
#include "ControlBehaviorMsgs.h"
#include "tinyxml2.h"
#include "SimplePhysicsComponent.h"
#include "Database.h"
@@ -95,12 +96,24 @@ void ModelComponent::AddBehavior(AddMessage& msg) {
for (auto& behavior : m_Behaviors) if (behavior.GetBehaviorId() == msg.GetBehaviorId()) return;
m_Behaviors.insert(m_Behaviors.begin() + msg.GetBehaviorIndex(), PropertyBehavior());
m_Behaviors.at(msg.GetBehaviorIndex()).HandleMsg(msg);
auto* const simplePhysComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
if (simplePhysComponent) {
simplePhysComponent->SetPhysicsMotionState(1);
Game::entityManager->SerializeEntity(m_Parent);
}
}
void ModelComponent::MoveToInventory(MoveToInventoryMessage& msg) {
if (msg.GetBehaviorIndex() >= m_Behaviors.size() || m_Behaviors.at(msg.GetBehaviorIndex()).GetBehaviorId() != msg.GetBehaviorId()) return;
m_Behaviors.erase(m_Behaviors.begin() + msg.GetBehaviorIndex());
// TODO move to the inventory
if (m_Behaviors.empty()) {
auto* const simplePhysComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
if (simplePhysComponent) {
simplePhysComponent->SetPhysicsMotionState(4);
Game::entityManager->SerializeEntity(m_Parent);
}
}
}
std::array<std::pair<int32_t, std::string>, 5> ModelComponent::GetBehaviorsForSave() const {

38
dGame/dComponents/PetComponent.cpp
View File

@@ -88,7 +88,7 @@ PetComponent::PetComponent(Entity* parentEntity, uint32_t componentId) : Compone
m_Ability = ePetAbilityType::Invalid;
m_StartPosition = NiPoint3Constant::ZERO;
m_MovementAI = nullptr;
m_TresureTime = 0;
m_TreasureTime = 0;
std::string checkPreconditions = GeneralUtils::UTF16ToWTF8(parentEntity->GetVar<std::u16string>(u"CheckPrecondition"));
@@ -319,27 +319,27 @@ void PetComponent::Update(float deltaTime) {
return;
}
if (m_TresureTime > 0) {
auto* tresure = Game::entityManager->GetEntity(m_Interaction);
if (m_TreasureTime > 0) {
auto* treasure = Game::entityManager->GetEntity(m_Interaction);
if (tresure == nullptr) {
m_TresureTime = 0;
if (treasure == nullptr) {
m_TreasureTime = 0;
return;
}
m_TresureTime -= deltaTime;
m_TreasureTime -= deltaTime;
m_MovementAI->Stop();
if (m_TresureTime <= 0) {
if (m_TreasureTime <= 0) {
m_Parent->SetOwnerOverride(m_Owner);
tresure->Smash(m_Parent->GetObjectID());
treasure->Smash(m_Parent->GetObjectID());
m_Interaction = LWOOBJID_EMPTY;
m_TresureTime = 0;
m_TreasureTime = 0;
}
return;
@@ -396,30 +396,30 @@ void PetComponent::Update(float deltaTime) {
// Determine if the "Lost Tags" mission has been completed and digging has been unlocked
const bool digUnlocked = missionComponent->GetMissionState(842) == eMissionState::COMPLETE;
Entity* closestTresure = PetDigServer::GetClosestTresure(position);
Entity* closestTreasure = PetDigServer::GetClosestTreasure(position);
if (closestTresure != nullptr && digUnlocked) {
if (closestTreasure != nullptr && digUnlocked) {
// Skeleton Dragon Pat special case for bone digging
if (closestTresure->GetLOT() == 12192 && m_Parent->GetLOT() != 13067) {
goto skipTresure;
if (closestTreasure->GetLOT() == 12192 && m_Parent->GetLOT() != 13067) {
goto skipTreasure;
}
NiPoint3 tresurePosition = closestTresure->GetPosition();
float distance = Vector3::DistanceSquared(position, tresurePosition);
NiPoint3 treasurePosition = closestTreasure->GetPosition();
float distance = Vector3::DistanceSquared(position, treasurePosition);
if (distance < 5 * 5) {
m_Interaction = closestTresure->GetObjectID();
m_Interaction = closestTreasure->GetObjectID();
Command(NiPoint3Constant::ZERO, LWOOBJID_EMPTY, 1, 202, true);
m_TresureTime = 2;
m_TreasureTime = 2;
} else if (distance < 10 * 10) {
haltDistance = 1;
destination = tresurePosition;
destination = treasurePosition;
}
}
skipTresure:
skipTreasure:
m_MovementAI->SetHaltDistance(haltDistance);

2
dGame/dComponents/PetComponent.h
View File

@@ -329,7 +329,7 @@ private:
* Timer that tracks how long a pet has been digging up some treasure, required to spawn the treasure contents
* on time
*/
float m_TresureTime;
float m_TreasureTime;
/**
* The position that this pet was spawned at

2
dGame/dComponents/PossessableComponent.h
View File

@@ -5,7 +5,7 @@
#include "Component.h"
#include "Item.h"
#include "PossessorComponent.h"
#include "eAninmationFlags.h"
#include "eAnimationFlags.h"
#include "eReplicaComponentType.h"
/**

4
dGame/dComponents/RocketLaunchpadControlComponent.cpp
View File

@@ -18,7 +18,7 @@
#include "BitStreamUtils.h"
#include "eObjectWorldState.h"
#include "eConnectionType.h"
#include "eMasterMessageType.h"
#include "MessageType/Master.h"
RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) {
auto query = CDClientDatabase::CreatePreppedStmt(
@@ -137,7 +137,7 @@ LWOCLONEID RocketLaunchpadControlComponent::GetSelectedCloneId(LWOOBJID player)
void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, MessageType::Master::PREP_ZONE);
bitStream.Write(zoneID);
Game::server->SendToMaster(bitStream);
}

9
dGame/dComponents/SimplePhysicsComponent.cpp
View File

@@ -27,6 +27,7 @@ SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, uint32_t componen
} else {
SetClimbableType(eClimbableType::CLIMBABLE_TYPE_NOT);
}
m_PhysicsMotionState = m_Parent->GetVarAs<uint32_t>(u"motionType");
}
SimplePhysicsComponent::~SimplePhysicsComponent() {
@@ -47,11 +48,10 @@ void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIs
}
// Physics motion state
if (m_PhysicsMotionState != 0) {
outBitStream.Write1();
outBitStream.Write(m_DirtyPhysicsMotionState || bIsInitialUpdate);
if (m_DirtyPhysicsMotionState || bIsInitialUpdate) {
outBitStream.Write<uint32_t>(m_PhysicsMotionState);
} else {
outBitStream.Write0();
m_DirtyPhysicsMotionState = false;
}
PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
}
@@ -61,5 +61,6 @@ uint32_t SimplePhysicsComponent::GetPhysicsMotionState() const {
}
void SimplePhysicsComponent::SetPhysicsMotionState(uint32_t value) {
m_DirtyPhysicsMotionState = m_PhysicsMotionState != value;
m_PhysicsMotionState = value;
}

4
dGame/dComponents/SimplePhysicsComponent.h
View File

@@ -102,7 +102,9 @@ private:
/**
* The current physics motion state
*/
uint32_t m_PhysicsMotionState = 0;
uint32_t m_PhysicsMotionState = 5;
bool m_DirtyPhysicsMotionState = true;
/**
* Whether or not the entity is climbable

6
dGame/dComponents/SkillComponent.cpp
View File

@@ -24,7 +24,7 @@
#include "CDClientManager.h"
#include "CDSkillBehaviorTable.h"
#include "eConnectionType.h"
#include "eClientMessageType.h"
#include "MessageType/Client.h"
ProjectileSyncEntry::ProjectileSyncEntry() {
}
@@ -320,7 +320,7 @@ SkillExecutionResult SkillComponent::CalculateBehavior(
// Write message
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
message.Write(this->m_Parent->GetObjectID());
start.Serialize(message);
@@ -451,7 +451,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
RakNet::BitStream message;
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
message.Write(this->m_Parent->GetObjectID());
projectileImpact.Serialize(message);

2
dGame/dGameMessages/DoClientProjectileImpact.h
View File

@@ -27,7 +27,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT);
stream.Write(MessageType::Game::DO_CLIENT_PROJECTILE_IMPACT);
stream.Write(i64OrgID != LWOOBJID_EMPTY);
if (i64OrgID != LWOOBJID_EMPTY) stream.Write(i64OrgID);

4
dGame/dGameMessages/EchoStartSkill.h
View File

@@ -4,7 +4,7 @@
#include "dCommonVars.h"
#include "NiPoint3.h"
#include "NiQuaternion.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
/* Same as start skill but with different network options. An echo down to other clients that need to play the skill. */
class EchoStartSkill {
@@ -40,7 +40,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::ECHO_START_SKILL);
stream.Write(MessageType::Game::ECHO_START_SKILL);
stream.Write(bUsedMouse);

4
dGame/dGameMessages/EchoSyncSkill.h
View File

@@ -4,7 +4,7 @@
#include <string>
#include "BitStream.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
/* Message to synchronize a skill cast */
@@ -29,7 +29,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::ECHO_SYNC_SKILL);
stream.Write(MessageType::Game::ECHO_SYNC_SKILL);
stream.Write(bDone);
uint32_t sBitStreamLength = sBitStream.length();

236
dGame/dGameMessages/GameMessageHandler.cpp
View File

@@ -33,13 +33,13 @@
#include "eMissionTaskType.h"
#include "eReplicaComponentType.h"
#include "eConnectionType.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
#include "ePlayerFlag.h"
#include "dConfig.h"
#include "GhostComponent.h"
#include "StringifiedEnum.h"
void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID) {
void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const SystemAddress& sysAddr, LWOOBJID objectID, MessageType::Game messageID) {
CBITSTREAM;
@@ -53,58 +53,58 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
return;
}
if (messageID != eGameMessageType::READY_FOR_UPDATES) LOG_DEBUG("Received GM with ID and name: %4i, %s", messageID, StringifiedEnum::ToString(messageID).data());
if (messageID != MessageType::Game::READY_FOR_UPDATES) LOG_DEBUG("Received GM with ID and name: %4i, %s", messageID, StringifiedEnum::ToString(messageID).data());
switch (messageID) {
case eGameMessageType::UN_USE_BBB_MODEL: {
case MessageType::Game::UN_USE_BBB_MODEL: {
GameMessages::HandleUnUseModel(inStream, entity, sysAddr);
break;
}
case eGameMessageType::PLAY_EMOTE: {
case MessageType::Game::PLAY_EMOTE: {
GameMessages::HandlePlayEmote(inStream, entity);
break;
}
case eGameMessageType::MOVE_ITEM_IN_INVENTORY: {
case MessageType::Game::MOVE_ITEM_IN_INVENTORY: {
GameMessages::HandleMoveItemInInventory(inStream, entity);
break;
}
case eGameMessageType::REMOVE_ITEM_FROM_INVENTORY: {
case MessageType::Game::REMOVE_ITEM_FROM_INVENTORY: {
GameMessages::HandleRemoveItemFromInventory(inStream, entity, sysAddr);
break;
}
case eGameMessageType::EQUIP_INVENTORY:
case MessageType::Game::EQUIP_INVENTORY:
GameMessages::HandleEquipItem(inStream, entity);
break;
case eGameMessageType::UN_EQUIP_INVENTORY:
case MessageType::Game::UN_EQUIP_INVENTORY:
GameMessages::HandleUnequipItem(inStream, entity);
break;
case eGameMessageType::RESPOND_TO_MISSION: {
case MessageType::Game::RESPOND_TO_MISSION: {
GameMessages::HandleRespondToMission(inStream, entity);
break;
}
case eGameMessageType::REQUEST_USE: {
case MessageType::Game::REQUEST_USE: {
GameMessages::HandleRequestUse(inStream, entity, sysAddr);
break;
}
case eGameMessageType::SET_FLAG: {
case MessageType::Game::SET_FLAG: {
GameMessages::HandleSetFlag(inStream, entity);
break;
}
case eGameMessageType::HAS_BEEN_COLLECTED: {
case MessageType::Game::HAS_BEEN_COLLECTED: {
GameMessages::HandleHasBeenCollected(inStream, entity);
break;
}
case eGameMessageType::PLAYER_LOADED: {
case MessageType::Game::PLAYER_LOADED: {
GameMessages::SendRestoreToPostLoadStats(entity, sysAddr);
entity->SetPlayerReadyForUpdates();
@@ -183,82 +183,82 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
break;
}
case eGameMessageType::REQUEST_LINKED_MISSION: {
case MessageType::Game::REQUEST_LINKED_MISSION: {
GameMessages::HandleRequestLinkedMission(inStream, entity);
break;
}
case eGameMessageType::MISSION_DIALOGUE_OK: {
case MessageType::Game::MISSION_DIALOGUE_OK: {
GameMessages::HandleMissionDialogOK(inStream, entity);
break;
}
case eGameMessageType::MISSION_DIALOGUE_CANCELLED: {
case MessageType::Game::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 eGameMessageType::REQUEST_PLATFORM_RESYNC: {
case MessageType::Game::REQUEST_PLATFORM_RESYNC: {
GameMessages::HandleRequestPlatformResync(inStream, entity, sysAddr);
break;
}
case eGameMessageType::FIRE_EVENT_SERVER_SIDE: {
case MessageType::Game::FIRE_EVENT_SERVER_SIDE: {
GameMessages::HandleFireEventServerSide(inStream, entity, sysAddr);
break;
}
case eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
case MessageType::Game::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
GameMessages::HandleActivitySummaryLeaderboardData(inStream, entity, sysAddr);
break;
}
case eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
case MessageType::Game::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
GameMessages::HandleRequestActivitySummaryLeaderboardData(inStream, entity, sysAddr);
break;
}
case eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST: {
case MessageType::Game::ACTIVITY_STATE_CHANGE_REQUEST: {
GameMessages::HandleActivityStateChangeRequest(inStream, entity);
break;
}
case eGameMessageType::PARSE_CHAT_MESSAGE: {
case MessageType::Game::PARSE_CHAT_MESSAGE: {
GameMessages::HandleParseChatMessage(inStream, entity, sysAddr);
break;
}
case eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
case MessageType::Game::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
GameMessages::HandleNotifyServerLevelProcessingComplete(inStream, entity);
break;
}
case eGameMessageType::PICKUP_CURRENCY: {
case MessageType::Game::PICKUP_CURRENCY: {
GameMessages::HandlePickupCurrency(inStream, entity);
break;
}
case eGameMessageType::PICKUP_ITEM: {
case MessageType::Game::PICKUP_ITEM: {
GameMessages::HandlePickupItem(inStream, entity);
break;
}
case eGameMessageType::RESURRECT: {
case MessageType::Game::RESURRECT: {
GameMessages::HandleResurrect(inStream, entity);
break;
}
case eGameMessageType::REQUEST_RESURRECT: {
case MessageType::Game::REQUEST_RESURRECT: {
GameMessages::SendResurrect(entity);
break;
}
case eGameMessageType::GET_HOT_PROPERTY_DATA: {
case MessageType::Game::GET_HOT_PROPERTY_DATA: {
GameMessages::HandleGetHotPropertyData(inStream, entity, sysAddr);
break;
}
case eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT:
case MessageType::Game::REQUEST_SERVER_PROJECTILE_IMPACT:
{
auto message = RequestServerProjectileImpact();
@@ -275,7 +275,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
break;
}
case eGameMessageType::START_SKILL: {
case MessageType::Game::START_SKILL: {
StartSkill startSkill = StartSkill();
startSkill.Deserialize(inStream); // inStream replaces &bitStream
@@ -311,7 +311,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
if (success) {
//Broadcast our startSkill:
RakNet::BitStream bitStreamLocal;
BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
bitStreamLocal.Write(entity->GetObjectID());
EchoStartSkill echoStartSkill;
@@ -331,9 +331,9 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
}
} break;
case eGameMessageType::SYNC_SKILL: {
case MessageType::Game::SYNC_SKILL: {
RakNet::BitStream bitStreamLocal;
BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
bitStreamLocal.Write(entity->GetObjectID());
SyncSkill sync = SyncSkill(inStream); // inStream replaced &bitStream
@@ -365,330 +365,330 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
Game::server->Send(bitStreamLocal, sysAddr, true);
} break;
case eGameMessageType::REQUEST_SMASH_PLAYER:
case MessageType::Game::REQUEST_SMASH_PLAYER:
entity->Smash(entity->GetObjectID());
break;
case eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
case MessageType::Game::MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
GameMessages::HandleMoveItemBetweenInventoryTypes(inStream, entity, sysAddr);
break;
case eGameMessageType::MODULAR_BUILD_FINISH:
case MessageType::Game::MODULAR_BUILD_FINISH:
GameMessages::HandleModularBuildFinish(inStream, entity, sysAddr);
break;
case eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE:
case MessageType::Game::PUSH_EQUIPPED_ITEMS_STATE:
GameMessages::HandlePushEquippedItemsState(inStream, entity);
break;
case eGameMessageType::POP_EQUIPPED_ITEMS_STATE:
case MessageType::Game::POP_EQUIPPED_ITEMS_STATE:
GameMessages::HandlePopEquippedItemsState(inStream, entity);
break;
case eGameMessageType::BUY_FROM_VENDOR:
case MessageType::Game::BUY_FROM_VENDOR:
GameMessages::HandleBuyFromVendor(inStream, entity, sysAddr);
break;
case eGameMessageType::SELL_TO_VENDOR:
case MessageType::Game::SELL_TO_VENDOR:
GameMessages::HandleSellToVendor(inStream, entity, sysAddr);
break;
case eGameMessageType::BUYBACK_FROM_VENDOR:
case MessageType::Game::BUYBACK_FROM_VENDOR:
GameMessages::HandleBuybackFromVendor(inStream, entity, sysAddr);
break;
case eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP:
case MessageType::Game::MODULAR_BUILD_MOVE_AND_EQUIP:
GameMessages::HandleModularBuildMoveAndEquip(inStream, entity, sysAddr);
break;
case eGameMessageType::DONE_ARRANGING_WITH_ITEM:
case MessageType::Game::DONE_ARRANGING_WITH_ITEM:
GameMessages::HandleDoneArrangingWithItem(inStream, entity, sysAddr);
break;
case eGameMessageType::MODULAR_BUILD_CONVERT_MODEL:
case MessageType::Game::MODULAR_BUILD_CONVERT_MODEL:
GameMessages::HandleModularBuildConvertModel(inStream, entity, sysAddr);
break;
case eGameMessageType::BUILD_MODE_SET:
case MessageType::Game::BUILD_MODE_SET:
GameMessages::HandleBuildModeSet(inStream, entity);
break;
case eGameMessageType::REBUILD_CANCEL:
case MessageType::Game::REBUILD_CANCEL:
GameMessages::HandleQuickBuildCancel(inStream, entity);
break;
case eGameMessageType::MATCH_REQUEST:
case MessageType::Game::MATCH_REQUEST:
GameMessages::HandleMatchRequest(inStream, entity);
break;
case eGameMessageType::USE_NON_EQUIPMENT_ITEM:
case MessageType::Game::USE_NON_EQUIPMENT_ITEM:
GameMessages::HandleUseNonEquipmentItem(inStream, entity);
break;
case eGameMessageType::CLIENT_ITEM_CONSUMED:
case MessageType::Game::CLIENT_ITEM_CONSUMED:
GameMessages::HandleClientItemConsumed(inStream, entity);
break;
case eGameMessageType::SET_CONSUMABLE_ITEM:
case MessageType::Game::SET_CONSUMABLE_ITEM:
GameMessages::HandleSetConsumableItem(inStream, entity, sysAddr);
break;
case eGameMessageType::VERIFY_ACK:
case MessageType::Game::VERIFY_ACK:
GameMessages::HandleVerifyAck(inStream, entity, sysAddr);
break;
// Trading
case eGameMessageType::CLIENT_TRADE_REQUEST:
case MessageType::Game::CLIENT_TRADE_REQUEST:
GameMessages::HandleClientTradeRequest(inStream, entity, sysAddr);
break;
case eGameMessageType::CLIENT_TRADE_CANCEL:
case MessageType::Game::CLIENT_TRADE_CANCEL:
GameMessages::HandleClientTradeCancel(inStream, entity, sysAddr);
break;
case eGameMessageType::CLIENT_TRADE_ACCEPT:
case MessageType::Game::CLIENT_TRADE_ACCEPT:
GameMessages::HandleClientTradeAccept(inStream, entity, sysAddr);
break;
case eGameMessageType::CLIENT_TRADE_UPDATE:
case MessageType::Game::CLIENT_TRADE_UPDATE:
GameMessages::HandleClientTradeUpdate(inStream, entity, sysAddr);
break;
// Pets
case eGameMessageType::PET_TAMING_TRY_BUILD:
case MessageType::Game::PET_TAMING_TRY_BUILD:
GameMessages::HandlePetTamingTryBuild(inStream, entity, sysAddr);
break;
case eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS:
case MessageType::Game::NOTIFY_TAMING_BUILD_SUCCESS:
GameMessages::HandleNotifyTamingBuildSuccess(inStream, entity, sysAddr);
break;
case eGameMessageType::REQUEST_SET_PET_NAME:
case MessageType::Game::REQUEST_SET_PET_NAME:
GameMessages::HandleRequestSetPetName(inStream, entity, sysAddr);
break;
case eGameMessageType::START_SERVER_PET_MINIGAME_TIMER:
case MessageType::Game::START_SERVER_PET_MINIGAME_TIMER:
GameMessages::HandleStartServerPetMinigameTimer(inStream, entity, sysAddr);
break;
case eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME:
case MessageType::Game::CLIENT_EXIT_TAMING_MINIGAME:
GameMessages::HandleClientExitTamingMinigame(inStream, entity, sysAddr);
break;
case eGameMessageType::COMMAND_PET:
case MessageType::Game::COMMAND_PET:
GameMessages::HandleCommandPet(inStream, entity, sysAddr);
break;
case eGameMessageType::DESPAWN_PET:
case MessageType::Game::DESPAWN_PET:
GameMessages::HandleDespawnPet(inStream, entity, sysAddr);
break;
case eGameMessageType::MESSAGE_BOX_RESPOND:
case MessageType::Game::MESSAGE_BOX_RESPOND:
GameMessages::HandleMessageBoxResponse(inStream, entity, sysAddr);
break;
case eGameMessageType::CHOICE_BOX_RESPOND:
case MessageType::Game::CHOICE_BOX_RESPOND:
GameMessages::HandleChoiceBoxRespond(inStream, entity, sysAddr);
break;
// Property
case eGameMessageType::QUERY_PROPERTY_DATA:
case MessageType::Game::QUERY_PROPERTY_DATA:
GameMessages::HandleQueryPropertyData(inStream, entity, sysAddr);
break;
case eGameMessageType::START_BUILDING_WITH_ITEM:
case MessageType::Game::START_BUILDING_WITH_ITEM:
GameMessages::HandleStartBuildingWithItem(inStream, entity, sysAddr);
break;
case eGameMessageType::SET_BUILD_MODE:
case MessageType::Game::SET_BUILD_MODE:
GameMessages::HandleSetBuildMode(inStream, entity, sysAddr);
break;
case eGameMessageType::PROPERTY_EDITOR_BEGIN:
case MessageType::Game::PROPERTY_EDITOR_BEGIN:
GameMessages::HandlePropertyEditorBegin(inStream, entity, sysAddr);
break;
case eGameMessageType::PROPERTY_EDITOR_END:
case MessageType::Game::PROPERTY_EDITOR_END:
GameMessages::HandlePropertyEditorEnd(inStream, entity, sysAddr);
break;
case eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT:
case MessageType::Game::PROPERTY_CONTENTS_FROM_CLIENT:
GameMessages::HandlePropertyContentsFromClient(inStream, entity, sysAddr);
break;
case eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED:
case MessageType::Game::ZONE_PROPERTY_MODEL_EQUIPPED:
GameMessages::HandlePropertyModelEquipped(inStream, entity, sysAddr);
break;
case eGameMessageType::PLACE_PROPERTY_MODEL:
case MessageType::Game::PLACE_PROPERTY_MODEL:
GameMessages::HandlePlacePropertyModel(inStream, entity, sysAddr);
break;
case eGameMessageType::UPDATE_MODEL_FROM_CLIENT:
case MessageType::Game::UPDATE_MODEL_FROM_CLIENT:
GameMessages::HandleUpdatePropertyModel(inStream, entity, sysAddr);
break;
case eGameMessageType::DELETE_MODEL_FROM_CLIENT:
case MessageType::Game::DELETE_MODEL_FROM_CLIENT:
GameMessages::HandleDeletePropertyModel(inStream, entity, sysAddr);
break;
case eGameMessageType::BBB_LOAD_ITEM_REQUEST:
case MessageType::Game::BBB_LOAD_ITEM_REQUEST:
GameMessages::HandleBBBLoadItemRequest(inStream, entity, sysAddr);
break;
case eGameMessageType::BBB_SAVE_REQUEST:
case MessageType::Game::BBB_SAVE_REQUEST:
GameMessages::HandleBBBSaveRequest(inStream, entity, sysAddr);
break;
case eGameMessageType::CONTROL_BEHAVIORS:
case MessageType::Game::CONTROL_BEHAVIORS:
GameMessages::HandleControlBehaviors(inStream, entity, sysAddr);
break;
case eGameMessageType::PROPERTY_ENTRANCE_SYNC:
case MessageType::Game::PROPERTY_ENTRANCE_SYNC:
GameMessages::HandlePropertyEntranceSync(inStream, entity, sysAddr);
break;
case eGameMessageType::ENTER_PROPERTY1:
case MessageType::Game::ENTER_PROPERTY1:
GameMessages::HandleEnterProperty(inStream, entity, sysAddr);
break;
case eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED:
case MessageType::Game::ZONE_PROPERTY_MODEL_ROTATED:
Game::entityManager->GetZoneControlEntity()->OnZonePropertyModelRotated(usr->GetLastUsedChar()->GetEntity());
break;
case eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK:
case MessageType::Game::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK:
GameMessages::HandleUpdatePropertyOrModelForFilterCheck(inStream, entity, sysAddr);
break;
case eGameMessageType::SET_PROPERTY_ACCESS:
case MessageType::Game::SET_PROPERTY_ACCESS:
GameMessages::HandleSetPropertyAccess(inStream, entity, sysAddr);
break;
// Racing
case eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA:
case MessageType::Game::MODULE_ASSEMBLY_QUERY_DATA:
GameMessages::HandleModuleAssemblyQueryData(inStream, entity, sysAddr);
break;
case eGameMessageType::ACKNOWLEDGE_POSSESSION:
case MessageType::Game::ACKNOWLEDGE_POSSESSION:
GameMessages::HandleAcknowledgePossession(inStream, entity, sysAddr);
break;
case eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE:
case MessageType::Game::VEHICLE_SET_WHEEL_LOCK_STATE:
GameMessages::HandleVehicleSetWheelLockState(inStream, entity, sysAddr);
break;
case eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED:
case MessageType::Game::MODULAR_ASSEMBLY_NIF_COMPLETED:
GameMessages::HandleModularAssemblyNIFCompleted(inStream, entity, sysAddr);
break;
case eGameMessageType::RACING_CLIENT_READY:
case MessageType::Game::RACING_CLIENT_READY:
GameMessages::HandleRacingClientReady(inStream, entity, sysAddr);
break;
case eGameMessageType::REQUEST_DIE:
case MessageType::Game::REQUEST_DIE:
GameMessages::HandleRequestDie(inStream, entity, sysAddr);
break;
case eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION:
case MessageType::Game::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION:
GameMessages::HandleVehicleNotifyServerAddPassiveBoostAction(inStream, entity, sysAddr);
break;
case eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION:
case MessageType::Game::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION:
GameMessages::HandleVehicleNotifyServerRemovePassiveBoostAction(inStream, entity, sysAddr);
break;
case eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED:
case MessageType::Game::RACING_PLAYER_INFO_RESET_FINISHED:
GameMessages::HandleRacingPlayerInfoResetFinished(inStream, entity, sysAddr);
break;
case eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER:
case MessageType::Game::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER:
GameMessages::HandleVehicleNotifyHitImaginationServer(inStream, entity, sysAddr);
break;
case eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST:
case MessageType::Game::UPDATE_PROPERTY_PERFORMANCE_COST:
GameMessages::HandleUpdatePropertyPerformanceCost(inStream, entity, sysAddr);
break;
// SG
case eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION:
case MessageType::Game::UPDATE_SHOOTING_GALLERY_ROTATION:
GameMessages::HandleUpdateShootingGalleryRotation(inStream, entity, sysAddr);
break;
// NT
case eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
case MessageType::Game::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
GameMessages::HandleRequestMoveItemBetweenInventoryTypes(inStream, entity, sysAddr);
break;
case eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE:
case MessageType::Game::TOGGLE_GHOST_REFERENCE_OVERRIDE:
GameMessages::HandleToggleGhostReferenceOverride(inStream, entity, sysAddr);
break;
case eGameMessageType::SET_GHOST_REFERENCE_POSITION:
case MessageType::Game::SET_GHOST_REFERENCE_POSITION:
GameMessages::HandleSetGhostReferencePosition(inStream, entity, sysAddr);
break;
case eGameMessageType::READY_FOR_UPDATES:
case MessageType::Game::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 eGameMessageType::REPORT_BUG:
case MessageType::Game::REPORT_BUG:
GameMessages::HandleReportBug(inStream, entity);
break;
case eGameMessageType::CLIENT_RAIL_MOVEMENT_READY:
case MessageType::Game::CLIENT_RAIL_MOVEMENT_READY:
GameMessages::HandleClientRailMovementReady(inStream, entity, sysAddr);
break;
case eGameMessageType::CANCEL_RAIL_MOVEMENT:
case MessageType::Game::CANCEL_RAIL_MOVEMENT:
GameMessages::HandleCancelRailMovement(inStream, entity, sysAddr);
break;
case eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION:
case MessageType::Game::PLAYER_RAIL_ARRIVED_NOTIFICATION:
GameMessages::HandlePlayerRailArrivedNotification(inStream, entity, sysAddr);
break;
case eGameMessageType::CINEMATIC_UPDATE:
case MessageType::Game::CINEMATIC_UPDATE:
GameMessages::HandleCinematicUpdate(inStream, entity, sysAddr);
break;
case eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC:
case MessageType::Game::MODIFY_PLAYER_ZONE_STATISTIC:
GameMessages::HandleModifyPlayerZoneStatistic(inStream, entity);
break;
case eGameMessageType::UPDATE_PLAYER_STATISTIC:
case MessageType::Game::UPDATE_PLAYER_STATISTIC:
GameMessages::HandleUpdatePlayerStatistic(inStream, entity);
break;
case eGameMessageType::DISMOUNT_COMPLETE:
case MessageType::Game::DISMOUNT_COMPLETE:
GameMessages::HandleDismountComplete(inStream, entity, sysAddr);
break;
case eGameMessageType::DECTIVATE_BUBBLE_BUFF:
case MessageType::Game::DECTIVATE_BUBBLE_BUFF:
GameMessages::HandleDeactivateBubbleBuff(inStream, entity);
break;
case eGameMessageType::ACTIVATE_BUBBLE_BUFF:
case MessageType::Game::ACTIVATE_BUBBLE_BUFF:
GameMessages::HandleActivateBubbleBuff(inStream, entity);
break;
case eGameMessageType::ZONE_SUMMARY_DISMISSED:
case MessageType::Game::ZONE_SUMMARY_DISMISSED:
GameMessages::HandleZoneSummaryDismissed(inStream, entity);
break;
case eGameMessageType::REQUEST_ACTIVITY_EXIT:
case MessageType::Game::REQUEST_ACTIVITY_EXIT:
GameMessages::HandleRequestActivityExit(inStream, entity);
break;
case eGameMessageType::ADD_DONATION_ITEM:
case MessageType::Game::ADD_DONATION_ITEM:
GameMessages::HandleAddDonationItem(inStream, entity, sysAddr);
break;
case eGameMessageType::REMOVE_DONATION_ITEM:
case MessageType::Game::REMOVE_DONATION_ITEM:
GameMessages::HandleRemoveDonationItem(inStream, entity, sysAddr);
break;
case eGameMessageType::CONFIRM_DONATION_ON_PLAYER:
case MessageType::Game::CONFIRM_DONATION_ON_PLAYER:
GameMessages::HandleConfirmDonationOnPlayer(inStream, entity);
break;
case eGameMessageType::CANCEL_DONATION_ON_PLAYER:
case MessageType::Game::CANCEL_DONATION_ON_PLAYER:
GameMessages::HandleCancelDonationOnPlayer(inStream, entity);
break;
case eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE:
case MessageType::Game::REQUEST_VENDOR_STATUS_UPDATE:
GameMessages::SendVendorStatusUpdate(entity, sysAddr, true);
break;
case eGameMessageType::UPDATE_INVENTORY_GROUP:
case MessageType::Game::UPDATE_INVENTORY_GROUP:
GameMessages::HandleUpdateInventoryGroup(inStream, entity, sysAddr);
break;
case eGameMessageType::UPDATE_INVENTORY_GROUP_CONTENTS:
case MessageType::Game::UPDATE_INVENTORY_GROUP_CONTENTS:
GameMessages::HandleUpdateInventoryGroupContents(inStream, entity, sysAddr);
break;

4
dGame/dGameMessages/GameMessageHandler.h
View File

@@ -19,10 +19,10 @@
#include "Logger.h"
#include "GameMessages.h"
#include "CDClientDatabase.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
namespace GameMessageHandler {
void HandleMessage(RakNet::BitStream& inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID);
void HandleMessage(RakNet::BitStream& inStream, const SystemAddress& sysAddr, LWOOBJID objectID, MessageType::Game messageID);
};
#endif // GAMEMESSAGEHANDLER_H

340
dGame/dGameMessages/GameMessages.cpp
View File

File diff suppressed because it is too large Load Diff

4
dGame/dGameMessages/RequestServerProjectileImpact.h
View File

@@ -2,7 +2,7 @@
#define __REQUESTSERVERPROJECTILEIMPACT__H__
#include "dCommonVars.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
/* Notifying the server that a locally owned projectile impacted. Sent to the caster of the projectile
should always be the local char. */
@@ -27,7 +27,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT);
stream.Write(MessageType::Game::REQUEST_SERVER_PROJECTILE_IMPACT);
stream.Write(i64LocalID != LWOOBJID_EMPTY);
if (i64LocalID != LWOOBJID_EMPTY) stream.Write(i64LocalID);

4
dGame/dGameMessages/StartSkill.h
View File

@@ -4,7 +4,7 @@
#include "dCommonVars.h"
#include "NiPoint3.h"
#include "NiQuaternion.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
/**
* Same as sync skill but with different network options. An echo down to other clients that need to play the skill.
@@ -44,7 +44,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::START_SKILL);
stream.Write(MessageType::Game::START_SKILL);
stream.Write(bUsedMouse);

4
dGame/dGameMessages/SyncSkill.h
View File

@@ -5,7 +5,7 @@
#include <string>
#include "BitStream.h"
#include "eGameMessageType.h"
#include "MessageType/Game.h"
/* Message to synchronize a skill cast */
class SyncSkill {
@@ -29,7 +29,7 @@ public:
}
void Serialize(RakNet::BitStream& stream) {
stream.Write(eGameMessageType::SYNC_SKILL);
stream.Write(MessageType::Game::SYNC_SKILL);
stream.Write(bDone);
uint32_t sBitStreamLength = sBitStream.length();

14
dGame/dUtilities/Mail.cpp
View File

@@ -152,7 +152,7 @@ void Mail::HandleSendMail(RakNet::BitStream& packet, const SystemAddress& sysAdd
LUWString bodyRead(400);
packet.Read(bodyRead);
LUWString recipientRead(32);
packet.Read(recipientRead);
@@ -245,7 +245,7 @@ void Mail::HandleDataRequest(RakNet::BitStream& packet, const SystemAddress& sys
auto playerMail = Database::Get()->GetMailForPlayer(player->GetCharacter()->GetID(), 20);
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
bitStream.Write(int(MailMessageID::MailData));
bitStream.Write(int(0)); // throttled
@@ -348,7 +348,7 @@ void Mail::HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t obje
void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
bitStream.Write(int(MailMessageID::SendResponse));
bitStream.Write(int(response));
Game::server->Send(bitStream, sysAddr, false);
@@ -356,7 +356,7 @@ void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse respo
void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
uint64_t messageType = 2;
uint64_t s1 = 0;
uint64_t s2 = 0;
@@ -375,7 +375,7 @@ void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
bitStream.Write(int(MailMessageID::AttachmentCollectConfirm));
bitStream.Write(int(0)); //unknown
bitStream.Write(mailID);
@@ -384,7 +384,7 @@ void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t ma
void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
bitStream.Write(int(MailMessageID::MailDeleteConfirm));
bitStream.Write(int(0)); //unknown
bitStream.Write(mailID);
@@ -395,7 +395,7 @@ void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOO
void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
bitStream.Write(int(MailMessageID::MailReadConfirm));
bitStream.Write(int(0)); //unknown
bitStream.Write(mailID);

4
dGame/dUtilities/SlashCommandHandler.cpp
View File

@@ -16,7 +16,7 @@
#include "Amf3.h"
#include "Database.h"
#include "eChatMessageType.h"
#include "MessageType/Chat.h"
#include "dServer.h"
namespace {
@@ -153,7 +153,7 @@ void SlashCommandHandler::SendAnnouncement(const std::string& title, const std::
//Notify chat about it
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_ANNOUNCE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_ANNOUNCE);
bitStream.Write<uint32_t>(title.size());
for (auto character : title) {

4
dGame/dUtilities/SlashCommands/DEVGMCommands.cpp
View File

@@ -45,7 +45,7 @@
// Enums
#include "eGameMasterLevel.h"
#include "eMasterMessageType.h"
#include "MessageType/Master.h"
#include "eInventoryType.h"
#include "ePlayerFlag.h"
@@ -503,7 +503,7 @@ namespace DEVGMCommands {
void ShutdownUniverse(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
//Tell the master server that we're going to be shutting down whole "universe":
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_UNIVERSE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, MessageType::Master::SHUTDOWN_UNIVERSE);
Game::server->SendToMaster(bitStream);
ChatPackets::SendSystemMessage(sysAddr, u"Sent universe shutdown notification to master.");

6
dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp
View File

@@ -15,7 +15,7 @@
#include "PropertyManagementComponent.h"
// Enums
#include "eChatMessageType.h"
#include "MessageType/Chat.h"
#include "eServerDisconnectIdentifiers.h"
#include "eObjectBits.h"
@@ -197,7 +197,7 @@ namespace GMGreaterThanZeroCommands {
//Notify chat about it
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_MUTE);
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_MUTE);
bitStream.Write(characterId);
bitStream.Write(expire);
@@ -292,7 +292,7 @@ namespace GMGreaterThanZeroCommands {
bool displayZoneData = true;
bool displayIndividualPlayers = true;
const auto splitArgs = GeneralUtils::SplitString(args, ' ');
if (!splitArgs.empty() && !splitArgs.at(0).empty()) displayZoneData = splitArgs.at(0) == "1";
if (splitArgs.size() > 1) displayIndividualPlayers = splitArgs.at(1) == "1";

4
dGame/dUtilities/VanityUtilities.cpp
View File

@@ -102,7 +102,7 @@ void VanityUtilities::SpawnVanity() {
}
LWOOBJID SpawnSpawner(const VanityObject& object, const VanityObjectLocation& location) {
SceneObject obj;
SceneObject obj{};
obj.lot = object.m_LOT;
// guratantee we have no collisions
do {
@@ -268,7 +268,7 @@ void ParseXml(const std::string& file) {
for (auto* location = locations->FirstChildElement("location"); location != nullptr;
location = location->NextSiblingElement("location")) {
// Get the location data
auto zoneID = GeneralUtils::TryParse<uint32_t>(location->Attribute("zone"));
auto x = GeneralUtils::TryParse<float>(location->Attribute("x"));