diff options
Diffstat (limited to 'src/server/game/Server')
| -rw-r--r-- | src/server/game/Server/Packets/ChatPackets.cpp | 2 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/ChatPackets.h | 2 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/InstancePackets.cpp | 26 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/InstancePackets.h | 24 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/MiscPackets.cpp | 69 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/MiscPackets.h | 21 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/PartyPackets.cpp | 716 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/PartyPackets.h | 616 | ||||
| -rw-r--r-- | src/server/game/Server/Protocol/Opcodes.cpp | 85 | ||||
| -rw-r--r-- | src/server/game/Server/WorldSession.h | 96 |
10 files changed, 1591 insertions, 66 deletions
diff --git a/src/server/game/Server/Packets/ChatPackets.cpp b/src/server/game/Server/Packets/ChatPackets.cpp index 260770e65fe..e3df4f5a15d 100644 --- a/src/server/game/Server/Packets/ChatPackets.cpp +++ b/src/server/game/Server/Packets/ChatPackets.cpp @@ -92,7 +92,7 @@ void WorldPackets::Chat::ChatMessageEmote::Read() Text = _worldPacket.ReadString(len); } -void WorldPackets::Chat::Chat::Initalize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, +void WorldPackets::Chat::Chat::Initialize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, uint32 achievementId /*= 0*/, std::string channelName /*= ""*/, LocaleConstant locale /*= DEFAULT_LOCALE*/, std::string addonPrefix /*= ""*/) { // Clear everything because same packet can be used multiple times diff --git a/src/server/game/Server/Packets/ChatPackets.h b/src/server/game/Server/Packets/ChatPackets.h index 5bc55952168..3bfac840ecc 100644 --- a/src/server/game/Server/Packets/ChatPackets.h +++ b/src/server/game/Server/Packets/ChatPackets.h @@ -151,7 +151,7 @@ namespace WorldPackets public: Chat() : ServerPacket(SMSG_CHAT, 100) { } - void Initalize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, uint32 achievementId = 0, std::string channelName = "", LocaleConstant locale = DEFAULT_LOCALE, std::string addonPrefix = ""); + void Initialize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, uint32 achievementId = 0, std::string channelName = "", LocaleConstant locale = DEFAULT_LOCALE, std::string addonPrefix = ""); WorldPacket const* Write() override; uint8 SlashCmd = 0; ///< @see enum ChatMsg diff --git a/src/server/game/Server/Packets/InstancePackets.cpp b/src/server/game/Server/Packets/InstancePackets.cpp index 50b2a66a8b8..db5bdcbd9e8 100644 --- a/src/server/game/Server/Packets/InstancePackets.cpp +++ b/src/server/game/Server/Packets/InstancePackets.cpp @@ -30,3 +30,29 @@ WorldPacket const* WorldPackets::Instance::UpdateInstanceOwnership::Write() return &_worldPacket; } + +WorldPacket const* WorldPackets::Instance::InstanceInfo::Write() +{ + _worldPacket << int32(LockList.size()); + + for (InstanceLockInfos const& lockInfos : LockList) + _worldPacket << lockInfos; + + return &_worldPacket; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos) +{ + data << lockInfos.MapID; + data << lockInfos.DifficultyID; + data << lockInfos.InstanceID; + data << lockInfos.TimeRemaining; + data << lockInfos.CompletedMask; + + data.WriteBit(lockInfos.Locked); + data.WriteBit(lockInfos.Extended); + + data.FlushBits(); + + return data; +} diff --git a/src/server/game/Server/Packets/InstancePackets.h b/src/server/game/Server/Packets/InstancePackets.h index 09f6c1efdcb..e38bcb97462 100644 --- a/src/server/game/Server/Packets/InstancePackets.h +++ b/src/server/game/Server/Packets/InstancePackets.h @@ -46,7 +46,31 @@ namespace WorldPackets int32 IOwnInstance = 0; // Used to control whether "Reset all instances" button appears on the UI - Script_CanShowResetInstances() // but it has been deperecated in favor of simply checking group leader, being inside an instance or using dungeon finder }; + + struct InstanceLockInfos + { + uint64 InstanceID = 0u; + uint32 MapID = 0u; + uint32 DifficultyID = 0u; + int32 TimeRemaining = 0; + uint32 CompletedMask = 0u; + + bool Locked = false; + bool Extended = false; + }; + + class InstanceInfo final : public ServerPacket + { + public: + InstanceInfo() : ServerPacket(SMSG_INSTANCE_INFO, 4) { } + + WorldPacket const* Write() override; + + std::vector<InstanceLockInfos> LockList; + }; } } +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos); + #endif // InstancePackets_h__ diff --git a/src/server/game/Server/Packets/MiscPackets.cpp b/src/server/game/Server/Packets/MiscPackets.cpp index a12ff537050..bbd3fcb2ba7 100644 --- a/src/server/game/Server/Packets/MiscPackets.cpp +++ b/src/server/game/Server/Packets/MiscPackets.cpp @@ -451,3 +451,72 @@ WorldPacket const* WorldPackets::Misc::Dismount::Write() return &_worldPacket; } + +void WorldPackets::Misc::SaveCUFProfiles::Read() +{ + uint32 count; + _worldPacket >> count; + + for (uint8 i = 0; i < count && i < MAX_CUF_PROFILES; i++) + { + std::unique_ptr<CUFProfile> cufProfile = Trinity::make_unique<CUFProfile>(); + + uint8 strLen = _worldPacket.ReadBits(7); + + // Bool Options + for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++) + cufProfile->BoolOptions.set(option, _worldPacket.ReadBit()); + + // Other Options + _worldPacket >> cufProfile->FrameHeight; + _worldPacket >> cufProfile->FrameWidth; + + _worldPacket >> cufProfile->SortBy; + _worldPacket >> cufProfile->HealthText; + + _worldPacket >> cufProfile->TopPoint; + _worldPacket >> cufProfile->BottomPoint; + _worldPacket >> cufProfile->LeftPoint; + + _worldPacket >> cufProfile->TopOffset; + _worldPacket >> cufProfile->BottomOffset; + _worldPacket >> cufProfile->LeftOffset; + + cufProfile->ProfileName = _worldPacket.ReadString(strLen); + + CUFProfiles.push_back(std::move(cufProfile)); + } +} + +WorldPacket const* WorldPackets::Misc::LoadCUFProfiles::Write() +{ + _worldPacket << uint32(CUFProfiles.size()); + + for (CUFProfile const* cufProfile : CUFProfiles) + { + _worldPacket.WriteBits(cufProfile->ProfileName.size(), 7); + + // Bool Options + for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++) + _worldPacket.WriteBit(cufProfile->BoolOptions[option]); + + // Other Options + _worldPacket << cufProfile->FrameHeight; + _worldPacket << cufProfile->FrameWidth; + + _worldPacket << cufProfile->SortBy; + _worldPacket << cufProfile->HealthText; + + _worldPacket << cufProfile->TopPoint; + _worldPacket << cufProfile->BottomPoint; + _worldPacket << cufProfile->LeftPoint; + + _worldPacket << cufProfile->TopOffset; + _worldPacket << cufProfile->BottomOffset; + _worldPacket << cufProfile->LeftOffset; + + _worldPacket.WriteString(cufProfile->ProfileName); + } + + return &_worldPacket; +} diff --git a/src/server/game/Server/Packets/MiscPackets.h b/src/server/game/Server/Packets/MiscPackets.h index fda0e44990e..93bac0d208b 100644 --- a/src/server/game/Server/Packets/MiscPackets.h +++ b/src/server/game/Server/Packets/MiscPackets.h @@ -24,6 +24,7 @@ #include "G3D/Vector3.h" #include "Object.h" #include "Unit.h" +#include "Player.h" #include "Weather.h" namespace WorldPackets @@ -642,6 +643,26 @@ namespace WorldPackets ObjectGuid Guid; }; + + class SaveCUFProfiles final : public ClientPacket + { + public: + SaveCUFProfiles(WorldPacket&& packet) : ClientPacket(CMSG_SAVE_CUF_PROFILES, std::move(packet)) { } + + void Read() override; + + std::vector<std::unique_ptr<CUFProfile>> CUFProfiles; + }; + + class LoadCUFProfiles final : public ServerPacket + { + public: + LoadCUFProfiles() : ServerPacket(SMSG_LOAD_CUF_PROFILES, 20) { } + + WorldPacket const* Write() override; + + std::vector<CUFProfile const*> CUFProfiles; + }; } } diff --git a/src/server/game/Server/Packets/PartyPackets.cpp b/src/server/game/Server/Packets/PartyPackets.cpp new file mode 100644 index 00000000000..9696cb6a3fc --- /dev/null +++ b/src/server/game/Server/Packets/PartyPackets.cpp @@ -0,0 +1,716 @@ +/* + * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "PartyPackets.h" + +#include "Player.h" +#include "Pet.h" +#include "Vehicle.h" +#include "SpellAuras.h" +#include "SpellAuraEffects.h" + +WorldPacket const* WorldPackets::Party::PartyCommandResult::Write() +{ + _worldPacket.WriteBits(Name.size(), 9); + + _worldPacket.WriteBits(Command, 4); + _worldPacket.WriteBits(Result, 6); + + _worldPacket << ResultData; + _worldPacket << ResultGUID; + _worldPacket.WriteString(Name); + + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +void WorldPackets::Party::PartyInviteClient::Read() +{ + uint32 targetNameLen, targetRealmLen; + + _worldPacket >> PartyIndex; + _worldPacket >> ProposedRoles; + _worldPacket >> TargetGUID; + _worldPacket >> TargetCfgRealmID; + + targetNameLen = _worldPacket.ReadBits(9); + targetRealmLen = _worldPacket.ReadBits(9); + + TargetName = _worldPacket.ReadString(targetNameLen); + TargetRealm = _worldPacket.ReadString(targetRealmLen); +} + +WorldPacket const* WorldPackets::Party::PartyInvite::Write() +{ + // Order guessed + _worldPacket.WriteBit(CanAccept); + _worldPacket.WriteBit(MightCRZYou); + _worldPacket.WriteBit(MustBeBNetFriend); + _worldPacket.WriteBit(AllowMultipleRoles); + _worldPacket.WriteBit(IsXRealm); + + _worldPacket.WriteBits(InviterName.size(), 6); + + _worldPacket << InviterGUID; + _worldPacket << InviterBNetAccountId; + + _worldPacket << InviterVirtualRealmAddress; + _worldPacket << Unk1; + + _worldPacket.WriteBit(IsLocal); + _worldPacket.WriteBit(Unk2); + + _worldPacket.FlushBits(); + + _worldPacket.WriteBits(InviterRealmNameActual.size(), 8); + _worldPacket.WriteBits(InviterRealmNameNormalized.size(), 8); + _worldPacket.WriteString(InviterRealmNameActual); + _worldPacket.WriteString(InviterRealmNameNormalized); + + _worldPacket << ProposedRoles; + _worldPacket << int32(LfgSlots.size()); + _worldPacket << LfgCompletedMask; + + _worldPacket.WriteString(InviterName); + + for (int32 LfgSlot : LfgSlots) + _worldPacket << LfgSlot; + + return &_worldPacket; +} + +void WorldPackets::Party::PartyInvite::Initialize(Player* const inviter, int32 proposedRoles, bool canAccept) +{ + CanAccept = canAccept; + + InviterName = inviter->GetName(); + InviterGUID = inviter->GetGUID(); + InviterBNetAccountId = inviter->GetSession()->GetAccountGUID(); + + ProposedRoles = proposedRoles; + + std::string realmName = sObjectMgr->GetRealmName(realmHandle.Index); + + InviterVirtualRealmAddress = GetVirtualRealmAddress(); + InviterRealmNameActual = realmName; + InviterRealmNameNormalized = realmName; +} + +void WorldPackets::Party::PartyInviteResponse::Read() +{ + _worldPacket >> PartyIndex; + + Accept = _worldPacket.ReadBit(); + + bool hasRolesDesired = _worldPacket.ReadBit(); + if (hasRolesDesired) + { + RolesDesired = boost::in_place(); + _worldPacket >> *RolesDesired; + } +} + +void WorldPackets::Party::PartyUninvite::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> TargetGUID; + + uint8 reasonLen = _worldPacket.ReadBits(8); + Reason = _worldPacket.ReadString(reasonLen); +} + +WorldPacket const* WorldPackets::Party::GroupDecline::Write() +{ + _worldPacket.WriteBits(Name.length(), 9); + _worldPacket.FlushBits(); + _worldPacket.WriteString(Name); + + return &_worldPacket; +} + +void WorldPackets::Party::RequestPartyMemberStats::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> TargetGUID; +} + +WorldPacket const* WorldPackets::Party::PartyMemberStats::Write() +{ + _worldPacket.WriteBit(ForEnemy); + + _worldPacket << MemberStats; + + return &_worldPacket; +} + +void WorldPackets::Party::SetPartyLeader::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> TargetGUID; +} + +void WorldPackets::Party::SetRole::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> TargetGUID; + _worldPacket >> Role; +} + +WorldPacket const* WorldPackets::Party::RoleChangedInform::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << From; + _worldPacket << ChangedUnit; + _worldPacket << OldRole; + _worldPacket << NewRole; + + return &_worldPacket; +} + +void WorldPackets::Party::LeaveGroup::Read() +{ + _worldPacket >> PartyIndex; +} + +void WorldPackets::Party::SetLootMethod::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> LootMethod; + _worldPacket >> LootMasterGUID; + _worldPacket >> LootThreshold; +} + +void WorldPackets::Party::MinimapPingClient::Read() +{ + _worldPacket >> PositionX; + _worldPacket >> PositionY; + _worldPacket >> PartyIndex; +} + +WorldPacket const* WorldPackets::Party::MinimapPing::Write() +{ + _worldPacket << Sender; + _worldPacket << PositionX; + _worldPacket << PositionY; + + return &_worldPacket; +} + +void WorldPackets::Party::UpdateRaidTarget::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> Target; + _worldPacket >> Symbol; +} + +WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateSingle::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << Symbol; + _worldPacket << Target; + _worldPacket << ChangedBy; + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateAll::Write() +{ + _worldPacket << PartyIndex; + + _worldPacket << int32(TargetIcons.size()); + + std::map<uint8, ObjectGuid>::const_iterator itr; + for (itr = TargetIcons.begin(); itr != TargetIcons.end(); itr++) + { + _worldPacket << itr->second; + _worldPacket << itr->first; + } + + return &_worldPacket; +} + +void WorldPackets::Party::ConvertRaid::Read() +{ + Raid = _worldPacket.ReadBit(); +} + +void WorldPackets::Party::RequestPartyJoinUpdates::Read() +{ + _worldPacket >> PartyIndex; +} + +void WorldPackets::Party::SetAssistantLeader::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> Target; + Apply = _worldPacket.ReadBit(); +} + +void WorldPackets::Party::DoReadyCheck::Read() +{ + _worldPacket >> PartyIndex; +} + +WorldPacket const* WorldPackets::Party::ReadyCheckStarted::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << PartyGUID; + _worldPacket << InitiatorGUID; + _worldPacket << Duration; + + return &_worldPacket; +} + +void WorldPackets::Party::ReadyCheckResponseClient::Read() +{ + _worldPacket >> PartyIndex; + IsReady = _worldPacket.ReadBit(); +} + +WorldPacket const* WorldPackets::Party::ReadyCheckResponse::Write() +{ + _worldPacket << PartyGUID; + _worldPacket << Player; + + _worldPacket.WriteBit(IsReady); + + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Party::ReadyCheckCompleted::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << PartyGUID; + + return &_worldPacket; +} + +void WorldPackets::Party::OptOutOfLoot::Read() +{ + PassOnLoot = _worldPacket.ReadBit(); +} + +void WorldPackets::Party::InitiateRolePoll::Read() +{ + _worldPacket >> PartyIndex; +} + +WorldPacket const* WorldPackets::Party::RolePollInform::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << From; + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Party::GroupNewLeader::Write() +{ + _worldPacket << PartyIndex; + _worldPacket.WriteBits(Name.size(), 6); + _worldPacket.WriteString(Name); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Party::PartyUpdate::Write() +{ + _worldPacket << PartyType; + _worldPacket << PartyIndex; + _worldPacket << PartyFlags; + + _worldPacket << MyIndex; + _worldPacket << PartyGUID; + _worldPacket << SequenceNum; + _worldPacket << LeaderGUID; + + _worldPacket << PlayerList; + + _worldPacket.WriteBit(LfgInfos.is_initialized()); + _worldPacket.WriteBit(LootSettings.is_initialized()); + _worldPacket.WriteBit(DifficultySettings.is_initialized()); + + _worldPacket.FlushBits(); + + if (LfgInfos.is_initialized()) + _worldPacket << *LfgInfos; + + if (LootSettings.is_initialized()) + _worldPacket << *LootSettings; + + if (DifficultySettings.is_initialized()) + _worldPacket << *DifficultySettings; + + return &_worldPacket; +} + +void WorldPackets::Party::SetEveryoneIsAssistant::Read() +{ + _worldPacket >> PartyIndex; + EveryoneIsAssistant = _worldPacket.ReadBit(); +} + +void WorldPackets::Party::ChangeSubGroup::Read() +{ + _worldPacket >> TargetGUID; + _worldPacket >> PartyIndex; + _worldPacket >> NewSubGroup; +} + +void WorldPackets::Party::SwapSubGroups::Read() +{ + _worldPacket >> PartyIndex; + _worldPacket >> FirstTarget; + _worldPacket >> SecondTarget; +} + +void WorldPackets::Party::ClearRaidMarker::Read() +{ + _worldPacket >> MarkerId; +} + +WorldPacket const* WorldPackets::Party::RaidMarkersChanged::Write() +{ + _worldPacket << PartyIndex; + _worldPacket << ActiveMarkers; + + _worldPacket.WriteBits(RaidMarkers.size(), 4); + _worldPacket.FlushBits(); + + for (RaidMarker* raidMarker : RaidMarkers) + { + _worldPacket << raidMarker->TransportGUID; + _worldPacket << raidMarker->Location.GetMapId(); + _worldPacket << raidMarker->Location.PositionXYZStream(); + } + + return &_worldPacket; +} + +void WorldPackets::Party::PartyMemberStats::Initialize(Player const* player) +{ + ForEnemy = false; + + MemberStats.GUID = player->GetGUID(); + + // Status + MemberStats.Status = MEMBER_STATUS_ONLINE; + + if (player->IsPvP()) + MemberStats.Status |= MEMBER_STATUS_PVP; + + if (!player->IsAlive()) + { + if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST)) + MemberStats.Status |= MEMBER_STATUS_GHOST; + else + MemberStats.Status |= MEMBER_STATUS_DEAD; + } + + if (player->IsFFAPvP()) + MemberStats.Status |= MEMBER_STATUS_PVP_FFA; + + if (player->isAFK()) + MemberStats.Status |= MEMBER_STATUS_AFK; + + if (player->isDND()) + MemberStats.Status |= MEMBER_STATUS_DND; + + // Level + MemberStats.Level = player->getLevel(); + + // Health + MemberStats.CurrentHealth = player->GetHealth(); + MemberStats.MaxHealth = player->GetMaxHealth(); + + // Power + MemberStats.PowerType = player->getPowerType(); + MemberStats.CurrentPower = player->GetPower(player->getPowerType()); + MemberStats.MaxPower = player->GetMaxPower(player->getPowerType()); + + // Position + MemberStats.ZoneID = player->GetZoneId(); + MemberStats.PositionX = int16(player->GetPositionX()); + MemberStats.PositionY = int16(player->GetPositionY()); + MemberStats.PositionZ = int16(player->GetPositionZ()); + + // Unk + MemberStats.Unk322 = 0; // Always 0 + MemberStats.Unk704[0] = 1; // Always 1 + MemberStats.Unk704[1] = 0; // Always 0 + MemberStats.Unk200000 = 0; // Always 0 + + MemberStats.Unk2000000 = 0; + MemberStats.Unk4000000 = 0; + + // Vehicle + if (player->GetVehicle() && player->GetVehicle()->GetVehicleInfo()) + MemberStats.VehicleSeat = player->GetVehicle()->GetVehicleInfo()->SeatID[player->m_movementInfo.transport.seat]; + + // Auras + for (uint8 i = 0; i < MAX_AURAS; ++i) + { + if (AuraApplication const* aurApp = player->GetVisibleAura(i)) + { + WorldPackets::Party::GroupAura aura; + + aura.SpellId = aurApp->GetBase()->GetId(); + aura.EffectMask = aurApp->GetEffectMask(); + aura.Scalings = aurApp->GetFlags(); // ?? + + if (aurApp->GetFlags() & AFLAG_SCALABLE) + { + for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i) + { + float scale = 0.f; + if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i)) + scale = float(eff->GetAmount()); + aura.EffectScales.push_back(scale); + } + } + + MemberStats.AuraList.push_back(aura); + } + } + + // Phases + std::set<uint32> const& phases = player->GetPhases(); + MemberStats.Phases.PhaseShiftFlags = 0x08 | (phases.size() ? 0x10 : 0); + MemberStats.Phases.PersonalGUID = ObjectGuid::Empty; + for (uint32 phaseId : phases) + { + WorldPackets::Party::GroupPhase phase; + phase.Id = phaseId; + phase.Flags = 1; + MemberStats.Phases.List.push_back(phase); + } + + // Pet + if (player->GetPet()) + { + Pet* pet = player->GetPet(); + + MemberStats.PetStats = boost::in_place(); + + MemberStats.PetStats->GUID = pet->GetGUID(); + MemberStats.PetStats->Name = pet->GetName(); + MemberStats.PetStats->ModelId = pet->GetDisplayId(); + + MemberStats.PetStats->CurrentHealth = pet->GetHealth(); + MemberStats.PetStats->MaxHealth = pet->GetMaxHealth(); + + for (uint8 i = 0; i < MAX_AURAS; ++i) + { + if (AuraApplication const* aurApp = pet->GetVisibleAura(i)) + { + WorldPackets::Party::GroupAura aura; + + aura.SpellId = aurApp->GetBase()->GetId(); + aura.EffectMask = aurApp->GetEffectMask(); + aura.Scalings = aurApp->GetFlags(); // ?? + + if (aurApp->GetFlags() & AFLAG_SCALABLE) + { + for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i) + { + float scale = 0.f; + if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i)) + scale = float(eff->GetAmount()); + aura.EffectScales.push_back(scale); + } + } + + MemberStats.PetStats->AuraList.push_back(aura); + } + } + } +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhase const& phase) +{ + data << phase.Flags; + data << phase.Id; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhases const& phases) +{ + data << phases.PhaseShiftFlags; + data << int32(phases.List.size()); + data << phases.PersonalGUID; + + for (WorldPackets::Party::GroupPhase const& phase : phases.List) + data << phase; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupAura const& aura) +{ + data << aura.SpellId; + data << aura.Scalings; + data << aura.EffectMask; + + data << int32(aura.EffectScales.size()); + for (float scale : aura.EffectScales) + data << scale; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupAura> const& auraList) +{ + data << int32(auraList.size()); + for (WorldPackets::Party::GroupAura const& aura : auraList) + data << aura; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPetStats const& petStats) +{ + data << petStats.GUID; + + data << petStats.ModelId; + + data << petStats.CurrentHealth; + data << petStats.MaxHealth; + + data << petStats.AuraList; + + data.WriteBits(petStats.Name.size(), 8); + data.FlushBits(); + data.WriteString(petStats.Name); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupMemberStats const& memberStats) +{ + data << memberStats.GUID; + + for (uint8 i = 0; i < 2; i++) + data << memberStats.Unk704[i]; + + data << memberStats.Status; + + data << memberStats.PowerType; + + data << memberStats.Unk322; + + data << memberStats.CurrentHealth; + data << memberStats.MaxHealth; + + data << memberStats.CurrentPower; + data << memberStats.MaxPower; + + data << memberStats.Level; + + data << memberStats.Unk200000; + + data << memberStats.ZoneID; + + data << memberStats.Unk2000000; + data << memberStats.Unk4000000; + + data << memberStats.PositionX; + data << memberStats.PositionY; + data << memberStats.PositionZ; + + data << memberStats.VehicleSeat; + + data << int32(memberStats.AuraList.size()); + + data << memberStats.Phases; + + for (WorldPackets::Party::GroupAura const& aura : memberStats.AuraList) + data << aura; + + data.WriteBit(memberStats.PetStats.is_initialized()); + data.FlushBits(); + + if (memberStats.PetStats.is_initialized()) + data << *memberStats.PetStats; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupPlayerInfos> const& playerList) +{ + data << int32(playerList.size()); + + for (WorldPackets::Party::GroupPlayerInfos const& playerInfos : playerList) + data << playerInfos; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPlayerInfos const& playerInfos) +{ + data.WriteBits(playerInfos.Name.size(), 6); + data.FlushBits(); + + data << playerInfos.GUID; + data << playerInfos.Status; + data << playerInfos.Subgroup; + data << playerInfos.Flags; + data << playerInfos.RolesAssigned; + data << playerInfos.Class; + + data.WriteString(playerInfos.Name); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLfgInfos const& lfgInfos) +{ + data << lfgInfos.MyFlags; + data << lfgInfos.Slot; + data << lfgInfos.MyRandomSlot; + data << lfgInfos.MyPartialClear; + data << lfgInfos.MyGearDiff; + data << lfgInfos.MyStrangerCount; + data << lfgInfos.MyKickVoteCount; + data << lfgInfos.BootCount; + + data.WriteBit(lfgInfos.Aborted); + data.WriteBit(lfgInfos.MyFirstReward); + data.FlushBits(); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLootSettings const& lootSettings) +{ + data << lootSettings.Method; + data << lootSettings.LootMaster; + data << lootSettings.Threshold; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupDifficultySettings const& difficultySettings) +{ + data << difficultySettings.DungeonDifficultyID; + data << difficultySettings.RaidDifficultyID; + data << difficultySettings.LegacyRaidDifficultyID; + + return data; +} diff --git a/src/server/game/Server/Packets/PartyPackets.h b/src/server/game/Server/Packets/PartyPackets.h new file mode 100644 index 00000000000..ed3eed60ef4 --- /dev/null +++ b/src/server/game/Server/Packets/PartyPackets.h @@ -0,0 +1,616 @@ +/* + * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef PartyPackets_h__ +#define PartyPackets_h__ + +#include "Packet.h" +#include "ObjectGuid.h" +#include "Group.h" + +namespace WorldPackets +{ + namespace Party + { + class PartyCommandResult final : public ServerPacket + { + public: + PartyCommandResult() : ServerPacket(SMSG_PARTY_COMMAND_RESULT, 23) { } + + WorldPacket const* Write() override; + + std::string Name; + uint8 Command = 0u; + uint8 Result = 0u; + uint32 ResultData = 0u; + ObjectGuid ResultGUID; + }; + + class PartyInviteClient final : public ClientPacket + { + public: + PartyInviteClient(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_INVITE, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + int32 ProposedRoles = 0; + int32 TargetCfgRealmID = 0; + std::string TargetName; + std::string TargetRealm; + ObjectGuid TargetGUID; + }; + + class PartyInvite final : public ServerPacket + { + public: + PartyInvite() : ServerPacket(SMSG_PARTY_INVITE, 55) { } + + WorldPacket const* Write() override; + void Initialize(Player* const inviter, int32 proposedRoles, bool canAccept); + + bool MightCRZYou = false; + bool MustBeBNetFriend = false; + bool AllowMultipleRoles = false; + bool Unk2 = false; + int16 Unk1 = 0; + + bool CanAccept = false; + + // Inviter + ObjectGuid InviterGUID; + ObjectGuid InviterBNetAccountId; + std::string InviterName; + + // Realm + bool IsXRealm = false; + bool IsLocal = true; + uint32 InviterVirtualRealmAddress = 0u; + std::string InviterRealmNameActual; + std::string InviterRealmNameNormalized; + + // Lfg + int32 ProposedRoles = 0; + int32 LfgCompletedMask = 0; + std::vector<int32> LfgSlots; + }; + + class PartyInviteResponse final : public ClientPacket + { + public: + PartyInviteResponse(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_INVITE_RESPONSE, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + bool Accept = false; + Optional<int32> RolesDesired; + }; + + class PartyUninvite final : public ClientPacket + { + public: + PartyUninvite(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_UNINVITE, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid TargetGUID; + std::string Reason; + }; + + class GroupDecline final : public ServerPacket + { + public: + GroupDecline(std::string const& name) : ServerPacket(SMSG_GROUP_DECLINE, 2 + name.size()), Name(name) { } + + WorldPacket const* Write() override; + + std::string Name; + }; + + class RequestPartyMemberStats final : public ClientPacket + { + public: + RequestPartyMemberStats(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_PARTY_MEMBER_STATS, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid TargetGUID; + }; + + struct GroupPhase + { + uint16 Flags = 0u; + uint16 Id = 0u; + }; + + struct GroupPhases + { + int32 PhaseShiftFlags = 0; + ObjectGuid PersonalGUID; + std::vector<GroupPhase> List; + }; + + struct GroupAura + { + uint32 SpellId = 0u; + uint8 Scalings = 0; + uint32 EffectMask = 0u; + std::vector<float> EffectScales; + }; + + struct GroupPetStats + { + ObjectGuid GUID; + std::string Name; + int16 ModelId = 0; + + int32 CurrentHealth = 0; + int32 MaxHealth = 0; + + std::vector<GroupAura> AuraList; + }; + + struct GroupMemberStats + { + ObjectGuid GUID; + int16 Level = 0; + int16 Status = 0; + + int32 CurrentHealth = 0; + int32 MaxHealth; + + uint8 PowerType = 0u; + int16 CurrentPower = 0; + int16 MaxPower = 0; + + int16 ZoneID = 0; + int16 PositionX = 0; + int16 PositionY = 0; + int16 PositionZ = 0; + + int32 VehicleSeat = 0; + + GroupPhases Phases; + std::vector<GroupAura> AuraList; + Optional<GroupPetStats> PetStats; + + int16 Unk322 = 0; + int16 Unk200000 = 0; + int16 Unk2000000 = 0; + int32 Unk4000000 = 0; + int8 Unk704[2]; + }; + + class PartyMemberStats final : public ServerPacket + { + public: + PartyMemberStats() : ServerPacket(SMSG_PARTY_MEMBER_STATE, 80) { } + + WorldPacket const* Write() override; + void Initialize(Player const* player); + + GroupMemberStats MemberStats; + bool ForEnemy = false; + }; + + class SetPartyLeader final : public ClientPacket + { + public: + SetPartyLeader(WorldPacket&& packet) : ClientPacket(CMSG_SET_PARTY_LEADER, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid TargetGUID; + }; + + class SetRole final : public ClientPacket + { + public: + SetRole(WorldPacket&& packet) : ClientPacket(CMSG_SET_ROLE, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid TargetGUID; + int32 Role = 0; + }; + + class RoleChangedInform final : public ServerPacket + { + public: + RoleChangedInform() : ServerPacket(SMSG_ROLE_CHANGED_INFORM, 41) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + ObjectGuid From; + ObjectGuid ChangedUnit; + int32 OldRole = 0; + int32 NewRole = 0; + }; + + class LeaveGroup final : public ClientPacket + { + public: + LeaveGroup(WorldPacket&& packet) : ClientPacket(CMSG_LEAVE_GROUP, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + }; + + class SetLootMethod final : public ClientPacket + { + public: + SetLootMethod(WorldPacket&& packet) : ClientPacket(CMSG_SET_LOOT_METHOD, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid LootMasterGUID; + uint8 LootMethod = 0u; + uint32 LootThreshold = 0u; + }; + + class MinimapPingClient final : public ClientPacket + { + public: + MinimapPingClient(WorldPacket&& packet) : ClientPacket(CMSG_MINIMAP_PING, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + float PositionX = 0.f; + float PositionY = 0.f; + }; + + class MinimapPing final : public ServerPacket + { + public: + MinimapPing() : ServerPacket(SMSG_MINIMAP_PING, 24) { } + + WorldPacket const* Write() override; + + ObjectGuid Sender; + float PositionX = 0.f; + float PositionY = 0.f; + }; + + class UpdateRaidTarget final : public ClientPacket + { + public: + UpdateRaidTarget(WorldPacket&& packet) : ClientPacket(CMSG_UPDATE_RAID_TARGET, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + ObjectGuid Target; + int8 Symbol = 0; + }; + + class SendRaidTargetUpdateSingle final : public ServerPacket + { + public: + SendRaidTargetUpdateSingle() : ServerPacket(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE, 34) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + ObjectGuid Target; + ObjectGuid ChangedBy; + int8 Symbol = 0; + }; + + class SendRaidTargetUpdateAll final : public ServerPacket + { + public: + SendRaidTargetUpdateAll() : ServerPacket(SMSG_SEND_RAID_TARGET_UPDATE_ALL, 1 + TARGET_ICONS_COUNT * (1 + 16)) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + std::map<uint8, ObjectGuid> TargetIcons; + }; + + class ConvertRaid final : public ClientPacket + { + public: + ConvertRaid(WorldPacket&& packet) : ClientPacket(CMSG_CONVERT_RAID, std::move(packet)) { } + + void Read() override; + + bool Raid = false; + }; + + class RequestPartyJoinUpdates final : public ClientPacket + { + public: + RequestPartyJoinUpdates(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_PARTY_JOIN_UPDATES, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + }; + + class SetAssistantLeader final : public ClientPacket + { + public: + SetAssistantLeader(WorldPacket&& packet) : ClientPacket(CMSG_SET_ASSISTANT_LEADER, std::move(packet)) { } + + void Read() override; + + ObjectGuid Target; + int8 PartyIndex = 0; + bool Apply = false; + }; + + class DoReadyCheck final : public ClientPacket + { + public: + DoReadyCheck(WorldPacket&& packet) : ClientPacket(CMSG_DO_READY_CHECK, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + }; + + class ReadyCheckStarted final : public ServerPacket + { + public: + ReadyCheckStarted() : ServerPacket(SMSG_READY_CHECK_STARTED, 37) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + ObjectGuid PartyGUID; + ObjectGuid InitiatorGUID; + uint32 Duration = 0u; + }; + + class ReadyCheckResponseClient final : public ClientPacket + { + public: + ReadyCheckResponseClient(WorldPacket&& packet) : ClientPacket(CMSG_READY_CHECK_RESPONSE, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + bool IsReady = false; + }; + + class ReadyCheckResponse final : public ServerPacket + { + public: + ReadyCheckResponse() : ServerPacket(SMSG_READY_CHECK_RESPONSE, 19) { } + + WorldPacket const* Write() override; + + ObjectGuid PartyGUID; + ObjectGuid Player; + bool IsReady = false; + }; + + class ReadyCheckCompleted final : public ServerPacket + { + public: + ReadyCheckCompleted() : ServerPacket(SMSG_READY_CHECK_COMPLETED, 17) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + ObjectGuid PartyGUID; + }; + + class RequestRaidInfo final : public ClientPacket + { + public: + RequestRaidInfo(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_RAID_INFO, std::move(packet)) { } + + void Read() override { } + }; + + class OptOutOfLoot final : public ClientPacket + { + public: + OptOutOfLoot(WorldPacket&& packet) : ClientPacket(CMSG_OPT_OUT_OF_LOOT, std::move(packet)) { } + + void Read() override; + + bool PassOnLoot = false; + }; + + class InitiateRolePoll final : public ClientPacket + { + public: + InitiateRolePoll(WorldPacket&& packet) : ClientPacket(CMSG_INITIATE_ROLE_POLL, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + }; + + class RolePollInform final : public ServerPacket + { + public: + RolePollInform() : ServerPacket(SMSG_ROLE_POLL_INFORM, 17) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + ObjectGuid From; + }; + + class GroupNewLeader final : public ServerPacket + { + public: + GroupNewLeader() : ServerPacket(SMSG_GROUP_NEW_LEADER, 14) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + std::string Name; + }; + + struct GroupPlayerInfos + { + ObjectGuid GUID; + std::string Name; + uint8 Class = 0; + + uint8 Status = 0u; + uint8 Subgroup = 0u; + uint8 Flags = 0u; + uint8 RolesAssigned = 0u; + }; + + struct GroupLfgInfos + { + int32 Slot = 0u; + int8 BootCount = 0; + + bool Aborted = false; + + int32 MyRandomSlot = 0; + uint8 MyFlags = 0u; + uint8 MyPartialClear = 0u; + float MyGearDiff = 0.f; + + int8 MyStrangerCount = 0; + int8 MyKickVoteCount = 0; + + bool MyFirstReward = false; + }; + + struct GroupLootSettings + { + uint8 Method = 0u; + ObjectGuid LootMaster; + uint8 Threshold = 0u; + }; + + struct GroupDifficultySettings + { + uint32 DungeonDifficultyID = 0u; + uint32 RaidDifficultyID = 0u; + uint32 LegacyRaidDifficultyID = 0u; + }; + + class PartyUpdate final : public ServerPacket + { + public: + PartyUpdate() : ServerPacket(SMSG_PARTY_UPDATE, 200) { } + + WorldPacket const* Write() override; + + int8 PartyFlags = 0; + int8 PartyIndex = 0; + int8 PartyType = 0; + + ObjectGuid PartyGUID; + ObjectGuid LeaderGUID; + + int32 MyIndex = 0; + int32 SequenceNum = 0; + + std::vector<GroupPlayerInfos> PlayerList; + + Optional<GroupLfgInfos> LfgInfos; + Optional<GroupLootSettings> LootSettings; + Optional<GroupDifficultySettings> DifficultySettings; + }; + + class SetEveryoneIsAssistant final : public ClientPacket + { + public: + SetEveryoneIsAssistant(WorldPacket&& packet) : ClientPacket(CMSG_SET_EVERYONE_IS_ASSISTANT, std::move(packet)) { } + + void Read() override; + + int8 PartyIndex = 0; + bool EveryoneIsAssistant = false; + }; + + class ChangeSubGroup final : public ClientPacket + { + public: + ChangeSubGroup(WorldPacket&& packet) : ClientPacket(CMSG_CHANGE_SUB_GROUP, std::move(packet)) { } + + void Read() override; + + ObjectGuid TargetGUID; + int8 PartyIndex = 0; + uint8 NewSubGroup = 0u; + }; + + class SwapSubGroups final : public ClientPacket + { + public: + SwapSubGroups(WorldPacket&& packet) : ClientPacket(CMSG_SWAP_SUB_GROUPS, std::move(packet)) { } + + void Read() override; + + ObjectGuid FirstTarget; + ObjectGuid SecondTarget; + int8 PartyIndex = 0; + }; + + class ClearRaidMarker final : public ClientPacket + { + public: + ClearRaidMarker(WorldPacket&& packet) : ClientPacket(CMSG_CLEAR_RAID_MARKER, std::move(packet)) { } + + void Read() override; + + uint8 MarkerId = 0u; + }; + + class RaidMarkersChanged final : public ServerPacket + { + public: + RaidMarkersChanged() : ServerPacket(SMSG_RAID_MARKERS_CHANGED, 6) { } + + WorldPacket const* Write() override; + + int8 PartyIndex = 0; + uint32 ActiveMarkers = 0u; + + std::vector<RaidMarker*> RaidMarkers; + }; + } +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhase const& phase); +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhases const& phases); + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupAura const& aura); +ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupAura> const& auraList); + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPetStats const& petStats); +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupMemberStats const& memberStats); + +ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupPlayerInfos> const& playerList); +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPlayerInfos const& playerInfos); + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLfgInfos const& lfgInfos); +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLootSettings const& lootSettings); +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupDifficultySettings const& difficultySettings); + +#endif // PartyPackets_h__ diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp index 4c87e00fc91..9b30be91ee3 100644 --- a/src/server/game/Server/Protocol/Opcodes.cpp +++ b/src/server/game/Server/Protocol/Opcodes.cpp @@ -33,6 +33,7 @@ #include "Packets/GameObjectPackets.h" #include "Packets/GarrisonPackets.h" #include "Packets/GuildPackets.h" +#include "Packets/PartyPackets.h" #include "Packets/InspectPackets.h" #include "Packets/InstancePackets.h" #include "Packets/ItemPackets.h" @@ -259,7 +260,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_CHANGE_BAG_SLOT_FLAG, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_CHANGE_MONUMENT_APPEARANCE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CHANGE_SUB_GROUP, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupChangeSubGroupOpcode ); + DEFINE_HANDLER(CMSG_CHANGE_SUB_GROUP, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::ChangeSubGroup, &WorldSession::HandleChangeSubGroupOpcode); DEFINE_HANDLER(CMSG_CHARACTER_RENAME_REQUEST, STATUS_AUTHED, PROCESS_THREADUNSAFE, WorldPackets::Character::CharacterRenameRequest, &WorldSession::HandleCharRenameOpcode); DEFINE_HANDLER(CMSG_CHAR_CUSTOMIZE, STATUS_AUTHED, PROCESS_THREADUNSAFE, WorldPackets::Character::CharCustomize, &WorldSession::HandleCharCustomizeOpcode); DEFINE_HANDLER(CMSG_CHAR_DELETE, STATUS_AUTHED, PROCESS_THREADUNSAFE, WorldPackets::Character::CharDelete, &WorldSession::HandleCharDeleteOpcode); @@ -315,7 +316,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_CHECK_RAF_EMAIL_ENABLED, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_CHECK_WOW_TOKEN_VETERAN_ELIGIBILITY, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_CHOICE_RESPONSE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_HANDLER(CMSG_CLEAR_RAID_MARKER, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); + DEFINE_HANDLER(CMSG_CLEAR_RAID_MARKER, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::ClearRaidMarker, &WorldSession::HandleClearRaidMarker); DEFINE_HANDLER(CMSG_CLEAR_TRADE_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Trade::ClearTradeItem, &WorldSession::HandleClearTradeItemOpcode); DEFINE_HANDLER(CMSG_CLIENT_PORT_GRAVEYARD, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::PortGraveyard, &WorldSession::HandlePortGraveyard); DEFINE_HANDLER(CMSG_CLOSE_INTERACTION, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -331,7 +332,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_COMPLETE_MOVIE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_CONFIRM_RESPEC_WIPE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleConfirmRespecWipeOpcode ); DEFINE_HANDLER(CMSG_CONNECT_TO_FAILED, STATUS_NEVER, PROCESS_INPLACE, WorldPacket, &WorldSession::Handle_EarlyProccess); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CONVERT_RAID, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupRaidConvertOpcode ); + DEFINE_HANDLER(CMSG_CONVERT_RAID, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::ConvertRaid, &WorldSession::HandleConvertRaidOpcode); DEFINE_HANDLER(CMSG_CREATE_CHARACTER, STATUS_AUTHED, PROCESS_THREADUNSAFE, WorldPackets::Character::CreateCharacter, &WorldSession::HandleCharCreateOpcode); DEFINE_HANDLER(CMSG_CREATE_SHIPMENT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_DB_QUERY_BULK, STATUS_AUTHED, PROCESS_INPLACE, WorldPackets::Query::DBQueryBulk, &WorldSession::HandleDBQueryBulk); @@ -357,7 +358,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_DISCARDED_TIME_SYNC_ACKS, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_DISMISS_CRITTER, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleDismissCritter ); DEFINE_HANDLER(CMSG_DO_MASTER_LOOT_ROLL, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_DO_READY_CHECK, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRaidReadyCheckOpcode ); + DEFINE_HANDLER(CMSG_DO_READY_CHECK, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::DoReadyCheck, &WorldSession::HandleDoReadyCheckOpcode); DEFINE_HANDLER(CMSG_DUEL_RESPONSE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Duel::DuelResponse, &WorldSession::HandleDuelResponseOpcode); DEFINE_HANDLER(CMSG_EJECT_PASSENGER, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Vehicle::EjectPassenger, &WorldSession::HandleEjectPassenger); DEFINE_HANDLER(CMSG_EMOTE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Chat::EmoteClient, &WorldSession::HandleEmoteOpcode); @@ -458,7 +459,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_HEARTH_AND_RESURRECT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Battleground::HearthAndResurrect, &WorldSession::HandleHearthAndResurrect); DEFINE_HANDLER(CMSG_IGNORE_TRADE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Trade::IgnoreTrade, &WorldSession::HandleIgnoreTradeOpcode); DEFINE_HANDLER(CMSG_INCREASE_CAST_TIME_FOR_SPELL, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_INITIATE_ROLE_POLL, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRolePollBeginOpcode); + DEFINE_HANDLER(CMSG_INITIATE_ROLE_POLL, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::InitiateRolePoll, &WorldSession::HandleInitiateRolePoll); DEFINE_HANDLER(CMSG_INITIATE_TRADE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Trade::InitiateTrade, &WorldSession::HandleInitiateTradeOpcode); DEFINE_HANDLER(CMSG_INSPECT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Inspect::Inspect, &WorldSession::HandleInspectOpcode); DEFINE_HANDLER(CMSG_INSPECT_PVP, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Inspect::InspectPVPRequest, &WorldSession::HandleInspectPVP); @@ -471,7 +472,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_KEYBOUND_OVERRIDE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_LEARN_PET_SPECIALIZATION_GROUP, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_LEARN_TALENTS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Talent::LearnTalents, &WorldSession::HandleLearnTalentsOpcode); - DEFINE_OPCODE_HANDLER_OLD(CMSG_LEAVE_GROUP, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupDisbandOpcode ); + DEFINE_HANDLER(CMSG_LEAVE_GROUP, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::LeaveGroup, &WorldSession::HandleLeaveGroupOpcode); DEFINE_HANDLER(CMSG_LEAVE_PET_BATTLE_QUEUE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_LFG_LIST_APPLY_TO_GROUP, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_LFG_LIST_CANCEL_APPLICATION, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -514,7 +515,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_MAIL_TAKE_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Mail::MailTakeItem, &WorldSession::HandleMailTakeItem); DEFINE_HANDLER(CMSG_MAIL_TAKE_MONEY, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Mail::MailTakeMoney, &WorldSession::HandleMailTakeMoney); DEFINE_OPCODE_HANDLER_OLD(CMSG_MASTER_LOOT_ITEM, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLootMasterGiveOpcode ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_MINIMAP_PING, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleMinimapPingOpcode ); + DEFINE_HANDLER(CMSG_MINIMAP_PING, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::MinimapPingClient, &WorldSession::HandleMinimapPingOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_MISSILE_TRAJECTORY_COLLISION, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleUpdateProjectilePosition ); DEFINE_HANDLER(CMSG_MOUNT_SET_FAVORITE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_MOUNT_SPECIAL_ANIM, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleMountSpecialAnimOpcode ); @@ -590,10 +591,10 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_OPEN_MISSION_NPC, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_OPEN_SHIPMENT_NPC, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_OPEN_TRADESKILL_NPC, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_OPT_OUT_OF_LOOT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleOptOutOfLootOpcode ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_INVITE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupInviteOpcode ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_INVITE_RESPONSE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupInviteResponseOpcode ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_UNINVITE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupUninviteOpcode ); + DEFINE_HANDLER(CMSG_OPT_OUT_OF_LOOT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::OptOutOfLoot, &WorldSession::HandleOptOutOfLootOpcode); + DEFINE_HANDLER(CMSG_PARTY_INVITE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::PartyInviteClient, &WorldSession::HandlePartyInviteOpcode); + DEFINE_HANDLER(CMSG_PARTY_INVITE_RESPONSE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::PartyInviteResponse, &WorldSession::HandlePartyInviteResponseOpcode); + DEFINE_HANDLER(CMSG_PARTY_UNINVITE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::PartyUninvite, &WorldSession::HandlePartyUninviteOpcode); DEFINE_HANDLER(CMSG_PETITION_BUY, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionBuy, &WorldSession::HandlePetitionBuy); DEFINE_HANDLER(CMSG_PETITION_RENAME_GUILD, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionRenameGuild, &WorldSession::HandlePetitionRenameGuild); DEFINE_HANDLER(CMSG_PETITION_SHOW_LIST, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionShowList, &WorldSession::HandlePetitionShowList); @@ -655,7 +656,7 @@ void OpcodeTable::Initialize() DEFINE_OPCODE_HANDLER_OLD(CMSG_QUEST_PUSH_RESULT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleQuestPushResult ); DEFINE_HANDLER(CMSG_QUEUED_MESSAGES_END, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_RANDOM_ROLL, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::RandomRollClient, &WorldSession::HandleRandomRollOpcode); - DEFINE_HANDLER(CMSG_READY_CHECK_RESPONSE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); + DEFINE_HANDLER(CMSG_READY_CHECK_RESPONSE, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::ReadyCheckResponseClient, &WorldSession::HandleReadyCheckResponseOpcode); DEFINE_HANDLER(CMSG_READ_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Item::ReadItem, &WorldSession::HandleReadItem); DEFINE_HANDLER(CMSG_RECLAIM_CORPSE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::ReclaimCorpse, &WorldSession::HandleReclaimCorpse); DEFINE_HANDLER(CMSG_RECRUIT_A_FRIEND, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -676,12 +677,12 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_REQUEST_GUILD_REWARDS_LIST, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Guild::RequestGuildRewardsList, &WorldSession::HandleRequestGuildRewardsList); DEFINE_HANDLER(CMSG_REQUEST_HONOR_STATS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Inspect::RequestHonorStats, &WorldSession::HandleRequestHonorStatsOpcode); DEFINE_HANDLER(CMSG_REQUEST_LFG_LIST_BLACKLIST, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PARTY_JOIN_UPDATES, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupRequestJoinUpdates); - DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PARTY_MEMBER_STATS, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestPartyMemberStatsOpcode); + DEFINE_HANDLER(CMSG_REQUEST_PARTY_JOIN_UPDATES, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::RequestPartyJoinUpdates, &WorldSession::HandleRequestPartyJoinUpdates); + DEFINE_HANDLER(CMSG_REQUEST_PARTY_MEMBER_STATS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::RequestPartyMemberStats, &WorldSession::HandleRequestPartyMemberStatsOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PET_INFO, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestPetInfoOpcode ); DEFINE_HANDLER(CMSG_REQUEST_PLAYED_TIME, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Character::RequestPlayedTime, &WorldSession::HandlePlayedTime); DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PVP_REWARDS, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleRequestPvpReward ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_RAID_INFO, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestRaidInfoOpcode ); + DEFINE_HANDLER(CMSG_REQUEST_RAID_INFO, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::RequestRaidInfo, &WorldSession::HandleRequestRaidInfoOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_RATED_BATTLEFIELD_INFO, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestRatedBattlefieldInfo); DEFINE_HANDLER(CMSG_REQUEST_RESEARCH_HISTORY, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_STABLED_PETS, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleListStabledPetsOpcode ); @@ -695,7 +696,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_RESURRECT_RESPONSE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::ResurrectResponse, &WorldSession::HandleResurrectResponse); DEFINE_HANDLER(CMSG_REVERT_MONUMENT_APPEARANCE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_RIDE_VEHICLE_INTERACT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Vehicle::RideVehicleInteract, &WorldSession::HandleRideVehicleInteract); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SAVE_CUF_PROFILES, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleSaveCUFProfiles ); + DEFINE_HANDLER(CMSG_SAVE_CUF_PROFILES, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Misc::SaveCUFProfiles, &WorldSession::HandleSaveCUFProfiles); DEFINE_HANDLER(CMSG_SAVE_EQUIPMENT_SET, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::EquipmentSet::SaveEquipmentSet, &WorldSession::HandleEquipmentSetSave); DEFINE_HANDLER(CMSG_SAVE_GUILD_EMBLEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Guild::SaveGuildEmblem, &WorldSession::HandleSaveGuildEmblem); DEFINE_HANDLER(CMSG_SCENE_PLAYBACK_CANCELED, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Scenes::ScenePlaybackCanceled, &WorldSession::HandleScenePlaybackCanceled); @@ -716,7 +717,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_SET_ACTIVE_MOVER, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Movement::SetActiveMover, &WorldSession::HandleSetActiveMoverOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ACTIVE_VOICE_CHANNEL, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetActiveVoiceChannel ); DEFINE_HANDLER(CMSG_SET_ADVANCED_COMBAT_LOGGING, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ASSISTANT_LEADER, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupAssistantLeaderOpcode); + DEFINE_HANDLER(CMSG_SET_ASSISTANT_LEADER, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SetAssistantLeader, &WorldSession::HandleSetAssistantLeaderOpcode); DEFINE_HANDLER(CMSG_SET_BACKPACK_AUTOSORT_DISABLED, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_BANK_AUTOSORT_DISABLED, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_BANK_BAG_SLOT_FLAG, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -724,22 +725,22 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_SET_CURRENCY_FLAGS, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_DIFFICULTY_ID, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_DUNGEON_DIFFICULTY, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::SetDungeonDifficulty, &WorldSession::HandleSetDungeonDifficultyOpcode); - DEFINE_HANDLER(CMSG_SET_EVERYONE_IS_ASSISTANT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); + DEFINE_HANDLER(CMSG_SET_EVERYONE_IS_ASSISTANT, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SetEveryoneIsAssistant, &WorldSession::HandleSetEveryoneIsAssistant); DEFINE_HANDLER(CMSG_SET_FACTION_AT_WAR, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionAtWar, &WorldSession::HandleSetFactionAtWar); DEFINE_HANDLER(CMSG_SET_FACTION_INACTIVE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionInactive, &WorldSession::HandleSetFactionInactiveOpcode); DEFINE_HANDLER(CMSG_SET_FACTION_NOT_AT_WAR, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionNotAtWar, &WorldSession::HandleSetFactionNotAtWar); DEFINE_HANDLER(CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_LFG_BONUS_FACTION_ID, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_LOOT_METHOD, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLootMethodOpcode ); + DEFINE_HANDLER(CMSG_SET_LOOT_METHOD, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::SetLootMethod, &WorldSession::HandleSetLootMethodOpcode); DEFINE_HANDLER(CMSG_SET_LOOT_SPECIALIZATION, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PARTY_ASSIGNMENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePartyAssignmentOpcode ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PARTY_LEADER, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupSetLeaderOpcode ); + DEFINE_HANDLER(CMSG_SET_PARTY_LEADER, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SetPartyLeader, &WorldSession::HandleSetPartyLeaderOpcode); DEFINE_HANDLER(CMSG_SET_PET_SLOT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PLAYER_DECLINED_NAMES, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetPlayerDeclinedNames ); DEFINE_HANDLER(CMSG_SET_PREFERRED_CEMETERY, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_PVP, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_RAID_DIFFICULTY, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::SetRaidDifficulty, &WorldSession::HandleSetRaidDifficultyOpcode); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ROLE, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupSetRolesOpcode ); + DEFINE_HANDLER(CMSG_SET_ROLE, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SetRole, &WorldSession::HandleSetRoleOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_SAVED_INSTANCE_EXTEND, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetSavedInstanceExtend ); DEFINE_HANDLER(CMSG_SET_SELECTION, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::SetSelection, &WorldSession::HandleSetSelectionOpcode); DEFINE_HANDLER(CMSG_SET_SHEATHED, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Combat::SetSheathed, &WorldSession::HandleSetSheathedOpcode); @@ -775,7 +776,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_SUSPEND_TOKEN_RESPONSE, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SWAP_INV_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Item::SwapInvItem, &WorldSession::HandleSwapInvItemOpcode); DEFINE_HANDLER(CMSG_SWAP_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Item::SwapItem, &WorldSession::HandleSwapItem); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SWAP_SUB_GROUPS, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::HandleGroupSwapSubGroupOpcode ); + DEFINE_HANDLER(CMSG_SWAP_SUB_GROUPS, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SwapSubGroups, &WorldSession::HandleSwapSubGroupsOpcode); DEFINE_HANDLER(CMSG_SWAP_VOID_ITEM, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::VoidStorage::SwapVoidItem, &WorldSession::HandleVoidSwapItem); DEFINE_HANDLER(CMSG_TABARD_VENDOR_ACTIVATE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleTabardVendorActivateOpcode); DEFINE_HANDLER(CMSG_TALK_TO_GOSSIP, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleGossipHelloOpcode); @@ -809,7 +810,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_UPDATE_ACCOUNT_DATA, STATUS_AUTHED, PROCESS_THREADUNSAFE, WorldPackets::ClientConfig::UserClientUpdateAccountData, &WorldSession::HandleUpdateAccountData); DEFINE_HANDLER(CMSG_UPDATE_CLIENT_SETTINGS, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_OPCODE_HANDLER_OLD(CMSG_UPDATE_MISSILE_TRAJECTORY, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleUpdateMissileTrajectory ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_UPDATE_RAID_TARGET, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRaidTargetUpdateOpcode ); + DEFINE_HANDLER(CMSG_UPDATE_RAID_TARGET, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Party::UpdateRaidTarget, &WorldSession::HandleUpdateRaidTargetOpcode); DEFINE_HANDLER(CMSG_UPDATE_WOW_TOKEN_AUCTIONABLE_LIST, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Token::UpdateListedAuctionableTokens, &WorldSession::HandleUpdateListedAuctionableTokens); DEFINE_HANDLER(CMSG_UPDATE_WOW_TOKEN_COUNT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_UPGRADE_GARRISON, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -1169,10 +1170,10 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_MESSAGE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_POI, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_ACTION_THROTTLED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DECLINE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_NEW_LEADER, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_UNINVITE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DECLINE, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_NEW_LEADER, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_UNINVITE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_DELETED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_EARNED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_MEMBERS, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1248,7 +1249,7 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_START, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_TIMER_START, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_GROUP_SIZE_CHANGED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_INFO, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_INFO, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_RESET, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_RESET_FAILED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_SAVE_CREATED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1298,7 +1299,7 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_CHARACTER_COPY_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_CUF_PROFILES, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_CUF_PROFILES, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_EQUIPMENT_SET, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_SELECTED_TROPHY_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOGIN_SET_TIME_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); @@ -1327,7 +1328,7 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_MAP_OBJ_EVENTS, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_MASTER_LOOT_CANDIDATE_LIST, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_MESSAGE_BOX, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_MINIMAP_PING, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_MINIMAP_PING, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_COMPONENTED_DATA, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_CREATURE_DATA, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_MISSILE_CANCEL, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1431,11 +1432,11 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_OPEN_SHIPMENT_NPC_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_OVERRIDE_LIGHT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_PAGE_TEXT, STATUS_NEVER, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_COMMAND_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_INVITE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_COMMAND_RESULT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_INVITE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_KILL_LOG, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_UPDATE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_UPDATE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_PAUSE_MIRROR_TIMER, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_PENDING_RAID_LOCK, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_ALREADY_SIGNED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1539,12 +1540,12 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_DIFFICULTY_SET, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_GROUP_ONLY, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_INSTANCE_MESSAGE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_MARKERS_CHANGED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_MARKERS_CHANGED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RANDOM_ROLL, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RATED_BATTLEFIELD_INFO, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_COMPLETED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_RESPONSE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_STARTED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_COMPLETED, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_RESPONSE, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_STARTED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_READ_ITEM_RESULT_FAILED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_READ_ITEM_RESULT_OK, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_REALM_QUERY_RESPONSE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1573,9 +1574,9 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESUME_TOKEN, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESURRECT_REQUEST, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESYNC_RUNES, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHANGED_INFORM, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHANGED_INFORM, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHOSEN, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_RUNE_REGEN_DEBUG, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SCENARIO_BOOT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SCENARIO_COMPLETED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); @@ -1594,8 +1595,8 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_SELL_RESPONSE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_ITEM_PASSIVES, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_KNOWN_SPELLS, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_ALL, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_ALL, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_CHARGES, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_HISTORY, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_UNLEARN_SPELLS, STATUS_NEVER, CONNECTION_TYPE_INSTANCE); diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h index bd4fefdd665..d8bad3d4933 100644 --- a/src/server/game/Server/WorldSession.h +++ b/src/server/game/Server/WorldSession.h @@ -171,6 +171,9 @@ namespace WorldPackets class ChannelPlayerCommand; class JoinChannel; class LeaveChannel; + class UserlistAdd; + class UserlistRemove; + class UserlistUpdate; } namespace Chat @@ -275,6 +278,11 @@ namespace WorldPackets class RequestHonorStats; } + namespace Instance + { + class InstanceInfo; + } + namespace Item { class AutoEquipItem; @@ -338,6 +346,8 @@ namespace WorldPackets class CompleteCinematic; class NextCinematicCamera; class FarSight; + class LoadCUFProfiles; + class SaveCUFProfiles; } namespace Movement @@ -360,6 +370,47 @@ namespace WorldPackets class TrainerBuySpell; } + namespace Party + { + class PartyCommandResult; + class PartyInviteClient; + class PartyInvite; + class PartyInviteResponse; + class PartyUninvite; + class GroupDecline; + class RequestPartyMemberStats; + class PartyMemberStats; + class SetPartyLeader; + class SetRole; + class RoleChangedInform; + class SetLootMethod; + class LeaveGroup; + class MinimapPingClient; + class MinimapPing; + class UpdateRaidTarget; + class SendRaidTargetUpdateSingle; + class SendRaidTargetUpdateAll; + class ConvertRaid; + class RequestPartyJoinUpdates; + class SetAssistantLeader; + class DoReadyCheck; + class ReadyCheckStarted; + class ReadyCheckResponseClient; + class ReadyCheckResponse; + class ReadyCheckCompleted; + class RequestRaidInfo; + class OptOutOfLoot; + class InitiateRolePoll; + class RolePollInform; + class GroupNewLeader; + class PartyUpdate; + class SetEveryoneIsAssistant; + class ChangeSubGroup; + class SwapSubGroups; + class RaidMarkersChanged; + class ClearRaidMarker; + } + namespace Petition { class DeclinePetition; @@ -855,8 +906,6 @@ class WorldSession void SendNotInArenaTeamPacket(uint8 type); void SendPetitionShowList(ObjectGuid guid); - void BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data); - void DoLootRelease(ObjectGuid lguid); // Account mute time @@ -1051,28 +1100,31 @@ class WorldSession void HandleMoveTimeSkippedOpcode(WorldPackets::Movement::MoveTimeSkipped& moveTimeSkipped); void HandleMovementAckMessage(WorldPackets::Movement::MovementAckMessage& movementAck); - void HandleRequestRaidInfoOpcode(WorldPacket& recvData); + void HandleRequestRaidInfoOpcode(WorldPackets::Party::RequestRaidInfo& packet); - void HandleGroupInviteOpcode(WorldPacket& recvPacket); + void HandlePartyInviteOpcode(WorldPackets::Party::PartyInviteClient& packet); //void HandleGroupCancelOpcode(WorldPacket& recvPacket); - void HandleGroupInviteResponseOpcode(WorldPacket& recvPacket); - void HandleGroupUninviteOpcode(WorldPacket& recvPacket); - void HandleGroupSetLeaderOpcode(WorldPacket& recvPacket); - void HandleGroupSetRolesOpcode(WorldPacket& recvData); - void HandleGroupDisbandOpcode(WorldPacket& recvPacket); - void HandleOptOutOfLootOpcode(WorldPacket& recvData); - void HandleLootMethodOpcode(WorldPacket& recvPacket); + void HandlePartyInviteResponseOpcode(WorldPackets::Party::PartyInviteResponse& packet); + void HandlePartyUninviteOpcode(WorldPackets::Party::PartyUninvite& packet); + void HandleSetPartyLeaderOpcode(WorldPackets::Party::SetPartyLeader& packet); + void HandleSetRoleOpcode(WorldPackets::Party::SetRole& packet); + void HandleLeaveGroupOpcode(WorldPackets::Party::LeaveGroup& packet); + void HandleOptOutOfLootOpcode(WorldPackets::Party::OptOutOfLoot& packet); + void HandleSetLootMethodOpcode(WorldPackets::Party::SetLootMethod& packet); void HandleLootRoll(WorldPackets::Loot::LootRoll& packet); - void HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData); - void HandleRaidTargetUpdateOpcode(WorldPacket& recvData); - void HandleRaidReadyCheckOpcode(WorldPacket& recvData); - void HandleGroupRaidConvertOpcode(WorldPacket& recvData); - void HandleGroupRequestJoinUpdates(WorldPacket& recvData); - void HandleGroupChangeSubGroupOpcode(WorldPacket& recvData); - void HandleGroupSwapSubGroupOpcode(WorldPacket& recvData); - void HandleGroupAssistantLeaderOpcode(WorldPacket& recvData); + void HandleRequestPartyMemberStatsOpcode(WorldPackets::Party::RequestPartyMemberStats& packet); + void HandleUpdateRaidTargetOpcode(WorldPackets::Party::UpdateRaidTarget& packet); + void HandleDoReadyCheckOpcode(WorldPackets::Party::DoReadyCheck& packet); + void HandleReadyCheckResponseOpcode(WorldPackets::Party::ReadyCheckResponseClient& packet); + void HandleConvertRaidOpcode(WorldPackets::Party::ConvertRaid& packet); + void HandleRequestPartyJoinUpdates(WorldPackets::Party::RequestPartyJoinUpdates& packet); + void HandleChangeSubGroupOpcode(WorldPackets::Party::ChangeSubGroup& packet); + void HandleSwapSubGroupsOpcode(WorldPackets::Party::SwapSubGroups& packet); + void HandleSetAssistantLeaderOpcode(WorldPackets::Party::SetAssistantLeader& packet); void HandlePartyAssignmentOpcode(WorldPacket& recvData); - void HandleRolePollBeginOpcode(WorldPacket& recvData); + void HandleInitiateRolePoll(WorldPackets::Party::InitiateRolePoll& packet); + void HandleSetEveryoneIsAssistant(WorldPackets::Party::SetEveryoneIsAssistant& packet); + void HandleClearRaidMarker(WorldPackets::Party::ClearRaidMarker& packet); void HandleDeclinePetition(WorldPackets::Petition::DeclinePetition& packet); void HandleOfferPetition(WorldPackets::Petition::OfferPetition& packet); @@ -1337,7 +1389,7 @@ class WorldSession void HandleWardenDataOpcode(WorldPacket& recvData); void HandleWorldTeleportOpcode(WorldPacket& recvData); - void HandleMinimapPingOpcode(WorldPacket& recvData); + void HandleMinimapPingOpcode(WorldPackets::Party::MinimapPingClient& packet); void HandleRandomRollOpcode(WorldPackets::Misc::RandomRollClient& packet); void HandleFarSightOpcode(WorldPackets::Misc::FarSight& packet); void HandleSetDungeonDifficultyOpcode(WorldPackets::Misc::SetDungeonDifficulty& setDungeonDifficulty); @@ -1470,7 +1522,7 @@ class WorldSession void HandleRequestWowTokenMarketPrice(WorldPackets::Token::RequestWowTokenMarketPrice& requestWowTokenMarketPrice); // Compact Unit Frames (4.x) - void HandleSaveCUFProfiles(WorldPacket& recvPacket); + void HandleSaveCUFProfiles(WorldPackets::Misc::SaveCUFProfiles& packet); void SendLoadCUFProfiles(); // Garrison |