Core/PacketIO: Updated instance/item/loot/npc packets

10 files changed, 147 insertions, 162 deletions

diff --git a/src/server/game/Entities/Item/Item.cpp b/src/server/game/Entities/Item/Item.cpp
index e5904ebc476..70fe83b7825 100644
--- a/src/server/game/Entities/Item/Item.cpp
+++ b/src/server/game/Entities/Item/Item.cpp
@@ -1013,11 +1013,6 @@ void Item::SendUpdateSockets()
 {
     WorldPackets::Item::SocketGemsResult socketGems;
     socketGems.Item = GetGUID();
-    for (uint32 i = 0; i < MAX_GEM_SOCKETS; ++i)
-        socketGems.Sockets[i] = int32(GetEnchantmentId(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT + i)));
-
-    socketGems.SocketMatch = int32(GetEnchantmentId(BONUS_ENCHANTMENT_SLOT));
-
     GetOwner()->GetSession()->SendPacket(socketGems.Write());
 }
 
diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index bf85a856d96..302ea0c13bd 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -22397,7 +22397,6 @@ void Player::SendInstanceResetWarning(uint32 mapid, Difficulty difficulty, uint3
     raidInstanceMessage.Type = type;
     raidInstanceMessage.MapID = mapid;
     raidInstanceMessage.DifficultyID = difficulty;
-    raidInstanceMessage.TimeLeft = int32(time);
     if (InstancePlayerBind const* bind = GetBoundInstance(mapid, difficulty))
         raidInstanceMessage.Locked = bind->perm;
     else
diff --git a/src/server/game/Server/Packets/InstancePackets.cpp b/src/server/game/Server/Packets/InstancePackets.cpp
index a6278c315e2..959f39eccbe 100644
--- a/src/server/game/Server/Packets/InstancePackets.cpp
+++ b/src/server/game/Server/Packets/InstancePackets.cpp
@@ -110,7 +110,6 @@ WorldPacket const* WorldPackets::Instance::RaidInstanceMessage::Write()
     _worldPacket << uint8(Type);
     _worldPacket << uint32(MapID);
     _worldPacket << uint32(DifficultyID);
-    _worldPacket << int32(TimeLeft);
     _worldPacket.WriteBit(Locked);
     _worldPacket.WriteBit(Extended);
     _worldPacket.FlushBits();
diff --git a/src/server/game/Server/Packets/InstancePackets.h b/src/server/game/Server/Packets/InstancePackets.h
index 137984d8396..8895a8aaf82 100644
--- a/src/server/game/Server/Packets/InstancePackets.h
+++ b/src/server/game/Server/Packets/InstancePackets.h
@@ -160,7 +160,6 @@ namespace WorldPackets
             uint8 Type = 0;
             uint32 MapID = 0;
             uint32 DifficultyID = 0;
-            int32 TimeLeft = 0;
             bool Locked = false;
             bool Extended = false;
         };
diff --git a/src/server/game/Server/Packets/ItemPackets.cpp b/src/server/game/Server/Packets/ItemPackets.cpp
index 08648353635..ffaa7f0a88b 100644
--- a/src/server/game/Server/Packets/ItemPackets.cpp
+++ b/src/server/game/Server/Packets/ItemPackets.cpp
@@ -31,37 +31,36 @@ bool WorldPackets::Item::ItemBonusInstanceData::operator==(ItemBonusInstanceData
 
 void WorldPackets::Item::BuyBackItem::Read()
 {
-    _worldPacket >> VendorGUID
-                 >> Slot;
+    _worldPacket >> VendorGUID;
+    _worldPacket >> Slot;
 }
 
 void WorldPackets::Item::BuyItem::Read()
 {
-    _worldPacket >> VendorGUID
-                 >> ContainerGUID
-                 >> Item
-                 >> Quantity
-                 >> Muid
-                 >> Slot;
-
+    _worldPacket >> VendorGUID;
+    _worldPacket >> ContainerGUID;
+    _worldPacket >> Item;
+    _worldPacket >> Quantity;
+    _worldPacket >> Muid;
+    _worldPacket >> Slot;
     ItemType = static_cast<ItemVendorType>(_worldPacket.ReadBits(2));
 }
 
 WorldPacket const* WorldPackets::Item::BuySucceeded::Write()
 {
-    _worldPacket << VendorGUID
-                 << uint32(Muid)
-                 << int32(NewQuantity)
-                 << uint32(QuantityBought);
+    _worldPacket << VendorGUID;
+    _worldPacket << uint32(Muid);
+    _worldPacket << int32(NewQuantity);
+    _worldPacket << uint32(QuantityBought);
 
     return &_worldPacket;
 }
 
 WorldPacket const* WorldPackets::Item::BuyFailed::Write()
 {
-    _worldPacket << VendorGUID
-                 << uint32(Muid)
-                 << uint8(Reason);
+    _worldPacket << VendorGUID;
+    _worldPacket << uint32(Muid);
+    _worldPacket << uint8(Reason);
 
     return &_worldPacket;
 }
@@ -73,23 +72,23 @@ void WorldPackets::Item::GetItemPurchaseData::Read()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Item::ItemPurchaseRefundItem& refundItem)
 {
-    data << refundItem.ItemID;
-    data << refundItem.ItemCount;
+    data << int32(refundItem.ItemID);
+    data << int32(refundItem.ItemCount);
 
     return data;
 }
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Item::ItemPurchaseRefundCurrency& refundCurrency)
 {
-    data << refundCurrency.CurrencyID;
-    data << refundCurrency.CurrencyCount;
+    data << int32(refundCurrency.CurrencyID);
+    data << int32(refundCurrency.CurrencyCount);
 
     return data;
 }
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Item::ItemPurchaseContents& purchaseContents)
 {
-    data << purchaseContents.Money;
+    data << uint64(purchaseContents.Money);
     for (uint32 i = 0; i < 5; ++i)
         data << purchaseContents.Items[i];
 
@@ -103,8 +102,8 @@ WorldPacket const* WorldPackets::Item::SetItemPurchaseData::Write()
 {
     _worldPacket << ItemGUID;
     _worldPacket << Contents;
-    _worldPacket << Flags;
-    _worldPacket << PurchaseTime;
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint32(PurchaseTime);
 
     return &_worldPacket;
 }
@@ -150,15 +149,15 @@ void WorldPackets::Item::SellItem::Read()
 WorldPacket const* WorldPackets::Item::ItemTimeUpdate::Write()
 {
     _worldPacket << ItemGuid;
-    _worldPacket << DurationLeft;
+    _worldPacket << uint32(DurationLeft);
 
     return &_worldPacket;
 }
 
 WorldPacket const* WorldPackets::Item::SetProficiency::Write()
 {
-    _worldPacket << ProficiencyMask;
-    _worldPacket << ProficiencyClass;
+    _worldPacket << uint32(ProficiencyMask);
+    _worldPacket << uint8(ProficiencyClass);
 
     return &_worldPacket;
 }
@@ -168,7 +167,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Item::ItemBonusInstanceDa
     data << uint8(itemBonusInstanceData.Context);
     data << uint32(itemBonusInstanceData.BonusListIDs.size());
     for (uint32 bonusID : itemBonusInstanceData.BonusListIDs)
-        data << bonusID;
+        data << uint32(bonusID);
 
     return data;
 }
@@ -215,8 +214,8 @@ ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Item::ItemInstance& itemI
     data >> itemInstance.RandomPropertiesSeed;
     data >> itemInstance.RandomPropertiesID;
 
-    bool const hasItemBonus = data.ReadBit();
-    bool const hasModifications = data.ReadBit();
+    bool hasItemBonus = data.ReadBit();
+    bool hasModifications = data.ReadBit();
 
     if (hasItemBonus)
     {
@@ -364,64 +363,64 @@ WorldPacket const* WorldPackets::Item::InventoryChangeFailure::Write()
 
 void WorldPackets::Item::SplitItem::Read()
 {
-    _worldPacket >> Inv
-                 >> FromPackSlot
-                 >> FromSlot
-                 >> ToPackSlot
-                 >> ToSlot
-                 >> Quantity;
+    _worldPacket >> Inv;
+    _worldPacket >> FromPackSlot;
+    _worldPacket >> FromSlot;
+    _worldPacket >> ToPackSlot;
+    _worldPacket >> ToSlot;
+    _worldPacket >> Quantity;
 }
 
 void WorldPackets::Item::SwapInvItem::Read()
 {
-    _worldPacket >> Inv
-                 >> Slot2
-                 >> Slot1;
+    _worldPacket >> Inv;
+    _worldPacket >> Slot2;
+    _worldPacket >> Slot1;
 }
 
 void WorldPackets::Item::SwapItem::Read()
 {
-    _worldPacket >> Inv
-                 >> ContainerSlotB
-                 >> ContainerSlotA
-                 >> SlotB
-                 >> SlotA;
+    _worldPacket >> Inv;
+    _worldPacket >> ContainerSlotB;
+    _worldPacket >> ContainerSlotA;
+    _worldPacket >> SlotB;
+    _worldPacket >> SlotA;
 }
 
 void WorldPackets::Item::AutoEquipItem::Read()
 {
-    _worldPacket >> Inv
-                 >> PackSlot
-                 >> Slot;
+    _worldPacket >> Inv;
+    _worldPacket >> PackSlot;
+    _worldPacket >> Slot;
 }
 
 void WorldPackets::Item::AutoEquipItemSlot::Read()
 {
-    _worldPacket >> Inv
-                 >> Item
-                 >> ItemDstSlot;
+    _worldPacket >> Inv;
+    _worldPacket >> Item;
+    _worldPacket >> ItemDstSlot;
 }
 
 void WorldPackets::Item::AutoStoreBagItem::Read()
 {
-    _worldPacket >> Inv
-                 >> ContainerSlotB
-                 >> ContainerSlotA
-                 >> SlotA;
+    _worldPacket >> Inv;
+    _worldPacket >> ContainerSlotB;
+    _worldPacket >> ContainerSlotA;
+    _worldPacket >> SlotA;
 }
 
 void WorldPackets::Item::DestroyItem::Read()
 {
-    _worldPacket >> Count
-                 >> ContainerId
-                 >> SlotNum;
+    _worldPacket >> Count;
+    _worldPacket >> ContainerId;
+    _worldPacket >> SlotNum;
 }
 
 WorldPacket const* WorldPackets::Item::SellResponse::Write()
 {
-    _worldPacket << VendorGUID
-                 << ItemGUID
-                 << uint8(Reason);
+    _worldPacket << VendorGUID;
+    _worldPacket << ItemGUID;
+    _worldPacket << uint8(Reason);
 
     return &_worldPacket;
 }
@@ -429,30 +428,24 @@ WorldPacket const* WorldPackets::Item::SellResponse::Write()
 WorldPacket const* WorldPackets::Item::ItemPushResult::Write()
 {
     _worldPacket << PlayerGUID;
-
     _worldPacket << uint8(Slot);
     _worldPacket << int32(SlotInBag);
-
-    _worldPacket << Item;
-
-    _worldPacket << uint32(QuestLogItemID);
+    _worldPacket << int32(QuestLogItemID);
     _worldPacket << int32(Quantity);
     _worldPacket << int32(QuantityInInventory);
-    _worldPacket << uint32(DungeonEncounterID);
+    _worldPacket << int32(DungeonEncounterID);
     _worldPacket << int32(BattlePetBreedID);
-    _worldPacket << int32(BattlePetBreedQuality);
     _worldPacket << int32(BattlePetSpeciesID);
+    _worldPacket << uint32(BattlePetBreedQuality);
     _worldPacket << int32(BattlePetLevel);
-
     _worldPacket << ItemGUID;
-
     _worldPacket.WriteBit(Pushed);
     _worldPacket.WriteBit(Created);
-    _worldPacket.WriteBits(DisplayText, 2);
+    _worldPacket.WriteBits(DisplayText, 3);
     _worldPacket.WriteBit(IsBonusRoll);
     _worldPacket.WriteBit(IsEncounterLoot);
-
     _worldPacket.FlushBits();
+    _worldPacket << Item;
 
     return &_worldPacket;
 }
@@ -466,7 +459,7 @@ void WorldPackets::Item::ReadItem::Read()
 WorldPacket const* WorldPackets::Item::ReadItemResultFailed::Write()
 {
     _worldPacket << Item;
-    _worldPacket << Delay;
+    _worldPacket << uint32(Delay);
     _worldPacket.WriteBits(Subcode, 3);
 
     _worldPacket.FlushBits();
@@ -536,6 +529,8 @@ void WorldPackets::Item::TransmogrifyItems::Read()
     _worldPacket >> Npc;
     for (TransmogrifyItem& item : Items)
         _worldPacket >> item;
+
+    CurrentSpecOnly = _worldPacket.ReadBit();
 }
 
 void WorldPackets::Item::UseCritterItem::Read()
@@ -553,8 +548,6 @@ void WorldPackets::Item::SocketGems::Read()
 WorldPacket const* WorldPackets::Item::SocketGemsResult::Write()
 {
     _worldPacket << Item;
-    _worldPacket.append(Sockets, MAX_GEM_SOCKETS);
-    _worldPacket << int32(SocketMatch);
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/ItemPackets.h b/src/server/game/Server/Packets/ItemPackets.h
index 7228efc5676..df2e5c9e1d0 100644
--- a/src/server/game/Server/Packets/ItemPackets.h
+++ b/src/server/game/Server/Packets/ItemPackets.h
@@ -135,7 +135,7 @@ namespace WorldPackets
 
         struct ItemPurchaseContents
         {
-            uint32 Money = 0;
+            uint64 Money = 0;
             ItemPurchaseRefundItem Items[5] = { };
             ItemPurchaseRefundCurrency Currencies[5] = { };
         };
@@ -366,9 +366,9 @@ namespace WorldPackets
         public:
             enum DisplayType
             {
-                DISPLAY_TYPE_ENCOUNTER_LOOT = 1,
-                DISPLAY_TYPE_NORMAL = 2,
-                DISPLAY_TYPE_HIDDEN = 3
+                DISPLAY_TYPE_HIDDEN = 0,
+                DISPLAY_TYPE_NORMAL = 1,
+                DISPLAY_TYPE_ENCOUNTER_LOOT = 2
             };
 
             ItemPushResult() : ServerPacket(SMSG_ITEM_PUSH_RESULT, 16 + 1 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 16 + 1 + 1 + 1 + 1) { }
@@ -379,11 +379,11 @@ namespace WorldPackets
             uint8 Slot                      = 0;
             int32 SlotInBag                 = 0;
             ItemInstance Item;
-            uint32 QuestLogItemID           = 0; // Item ID used for updating quest progress
+            int32 QuestLogItemID            = 0; // Item ID used for updating quest progress
                                                  // only set if different than real ID (similar to CreatureTemplate.KillCredit)
             int32 Quantity                  = 0;
             int32 QuantityInInventory       = 0;
-            uint32 DungeonEncounterID       = 0;
+            int32 DungeonEncounterID       = 0;
             int32 BattlePetBreedID          = 0;
             uint32 BattlePetBreedQuality    = 0;
             int32 BattlePetSpeciesID        = 0;
@@ -527,8 +527,6 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             ObjectGuid Item;
-            int32 Sockets[MAX_GEM_SOCKETS] = {};
-            int32 SocketMatch = 0;
         };
 
         ByteBuffer& operator>>(ByteBuffer& data, InvUpdate& invUpdate);
diff --git a/src/server/game/Server/Packets/LootPackets.cpp b/src/server/game/Server/Packets/LootPackets.cpp
index 68a709b15f6..8d85f27b6b0 100644
--- a/src/server/game/Server/Packets/LootPackets.cpp
+++ b/src/server/game/Server/Packets/LootPackets.cpp
@@ -26,13 +26,17 @@ WorldPacket const* WorldPackets::Loot::LootResponse::Write()
 {
     _worldPacket << LootObj;
     _worldPacket << Owner;
-    _worldPacket << FailureReason;
-    _worldPacket << AcquireReason;
-    _worldPacket << LootMethod;
-    _worldPacket << Threshold;
-    _worldPacket << Coins;
+    _worldPacket << uint8(FailureReason);
+    _worldPacket << uint8(AcquireReason);
+    _worldPacket << uint8(LootMethod);
+    _worldPacket << uint8(Threshold);
+    _worldPacket << uint32(Coins);
     _worldPacket << uint32(Items.size());
     _worldPacket << uint32(Currencies.size());
+    _worldPacket.WriteBit(Acquired);
+    _worldPacket.WriteBit(AELooting);
+    _worldPacket.WriteBit(PersonalLooting);
+    _worldPacket.FlushBits();
 
     for (LootItemData const& item : Items)
     {
@@ -40,27 +44,21 @@ WorldPacket const* WorldPackets::Loot::LootResponse::Write()
         _worldPacket.WriteBits(item.UIType, 3);
         _worldPacket.WriteBit(item.CanTradeToTapList);
         _worldPacket.FlushBits();
-
-        _worldPacket << item.Quantity;
-        _worldPacket << item.LootItemType;
-        _worldPacket << item.LootListID;
         _worldPacket << item.Loot; // WorldPackets::Item::ItemInstance
+        _worldPacket << uint32(item.Quantity);
+        _worldPacket << uint8(item.LootItemType);
+        _worldPacket << uint8(item.LootListID);
     }
 
     for (LootCurrency const& currency : Currencies)
     {
-        _worldPacket << currency.CurrencyID;
-        _worldPacket << currency.Quantity;
-        _worldPacket << currency.LootListID;
+        _worldPacket << uint32(currency.CurrencyID);
+        _worldPacket << uint32(currency.Quantity);
+        _worldPacket << uint8(currency.LootListID);
         _worldPacket.WriteBits(currency.UIType, 3);
         _worldPacket.FlushBits();
     }
 
-    _worldPacket.WriteBit(Acquired);
-    _worldPacket.WriteBit(AELooting);
-    _worldPacket.WriteBit(PersonalLooting);
-    _worldPacket.FlushBits();
-
     return &_worldPacket;
 }
 
diff --git a/src/server/game/Server/Packets/NPCPackets.cpp b/src/server/game/Server/Packets/NPCPackets.cpp
index 33721e23d5b..66039eff650 100644
--- a/src/server/game/Server/Packets/NPCPackets.cpp
+++ b/src/server/game/Server/Packets/NPCPackets.cpp
@@ -25,20 +25,18 @@ void WorldPackets::NPC::Hello::Read()
 WorldPacket const* WorldPackets::NPC::GossipMessage::Write()
 {
     _worldPacket << GossipGUID;
-    _worldPacket << GossipID;
-    _worldPacket << FriendshipFactionID;
-    _worldPacket << TextID;
-
-    _worldPacket << int32(GossipOptions.size());
-    _worldPacket << int32(GossipText.size());
+    _worldPacket << int32(GossipID);
+    _worldPacket << int32(FriendshipFactionID);
+    _worldPacket << int32(TextID);
+    _worldPacket << uint32(GossipOptions.size());
+    _worldPacket << uint32(GossipText.size());
 
     for (ClientGossipOptions const& options : GossipOptions)
     {
-        _worldPacket << options.ClientOption;
-        _worldPacket << options.OptionNPC;
-        _worldPacket << options.OptionFlags;
-        _worldPacket << options.OptionCost;
-
+        _worldPacket << int32(options.ClientOption);
+        _worldPacket << uint8(options.OptionNPC);
+        _worldPacket << int8(options.OptionFlags);
+        _worldPacket << int32(options.OptionCost);
         _worldPacket.WriteBits(options.Text.size(), 12);
         _worldPacket.WriteBits(options.Confirm.size(), 12);
         _worldPacket.FlushBits();
@@ -49,13 +47,14 @@ WorldPacket const* WorldPackets::NPC::GossipMessage::Write()
 
     for (ClientGossipText const& text : GossipText)
     {
-        _worldPacket << text.QuestID;
-        _worldPacket << text.QuestType;
-        _worldPacket << text.QuestLevel;
-        _worldPacket << text.QuestFlags[0];
-        _worldPacket << text.QuestFlags[1];
+        _worldPacket << int32(text.QuestID);
+        _worldPacket << int32(text.QuestType);
+        _worldPacket << int32(text.QuestLevel);
+        _worldPacket << int32(text.QuestFlags[0]);
+        _worldPacket << int32(text.QuestFlags[1]);
 
         _worldPacket.WriteBit(text.Repeatable);
+        _worldPacket.WriteBit(text.Ignored);
         _worldPacket.WriteBits(text.QuestTitle.size(), 9);
         _worldPacket.FlushBits();
 
@@ -65,27 +64,31 @@ WorldPacket const* WorldPackets::NPC::GossipMessage::Write()
     return &_worldPacket;
 }
 
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::NPC::VendorItem const &item)
+{
+    data << uint32(item.MuID);
+    data << int32(item.Type);
+    data << int32(item.Quantity);
+    data << uint64(item.Price);
+    data << int32(item.Durability);
+    data << int32(item.StackCount);
+    data << int32(item.ExtendedCostID);
+    data << int32(item.PlayerConditionFailed);
+    data << item.Item;
+    data.WriteBit(item.DoNotFilterOnVendor);
+    data.FlushBits();
+
+    return data;
+}
+
 WorldPacket const* WorldPackets::NPC::VendorInventory::Write()
 {
     _worldPacket << Vendor;
-    _worldPacket << Reason;
-
-    _worldPacket << int32(Items.size());
+    _worldPacket << uint8(Reason);
+    _worldPacket << uint32(Items.size());
     for (VendorItem const& item : Items)
-    {
-        _worldPacket << item.MuID;
-        _worldPacket << item.Type;
-        _worldPacket << item.Item;
-        _worldPacket << item.Quantity;
-        _worldPacket << item.Price;
-        _worldPacket << item.Durability;
-        _worldPacket << item.StackCount;
-        _worldPacket << item.ExtendedCostID;
-        _worldPacket << item.PlayerConditionFailed;
-
-        _worldPacket.WriteBit(item.DoNotFilterOnVendor);
-        _worldPacket.FlushBits();
-    }
+        _worldPacket << item;
 
     return &_worldPacket;
 }
@@ -146,10 +149,10 @@ WorldPacket const* WorldPackets::NPC::GossipPOI::Write()
 {
     _worldPacket.WriteBits(Flags, 14);
     _worldPacket.WriteBits(Name.length(), 6);
-    _worldPacket << Pos.x;
-    _worldPacket << Pos.y;
-    _worldPacket << Icon;
-    _worldPacket << Importance;
+    _worldPacket << float(Pos.x);
+    _worldPacket << float(Pos.y);
+    _worldPacket << int32(Icon);
+    _worldPacket << int32(Importance);
     _worldPacket.WriteString(Name);
 
     return &_worldPacket;
diff --git a/src/server/game/Server/Packets/NPCPackets.h b/src/server/game/Server/Packets/NPCPackets.h
index b18ce340ae0..034ef1fb909 100644
--- a/src/server/game/Server/Packets/NPCPackets.h
+++ b/src/server/game/Server/Packets/NPCPackets.h
@@ -61,6 +61,7 @@ namespace WorldPackets
             int32 QuestType     = 0;
             int32 QuestLevel    = 0;
             bool Repeatable     = false;
+            bool Ignored        = false;
             std::string QuestTitle;
             int32 QuestFlags[2] = { };
         };
@@ -107,7 +108,7 @@ namespace WorldPackets
             int32 Type                      = 0;
             WorldPackets::Item::ItemInstance Item;
             int32 Quantity                  = -1;
-            int32 Price                     = 0;
+            uint64 Price                    = 0;
             int32 Durability                = 0;
             int32 StackCount                = 0;
             int32 ExtendedCostID            = 0;
@@ -175,7 +176,7 @@ namespace WorldPackets
         class GossipPOI final : public ServerPacket
         {
         public:
-            GossipPOI() : ServerPacket(SMSG_GOSSIP_POI, 2 + 2 * 4 + 4 + 4 + 1) { }
+            GossipPOI() : ServerPacket(SMSG_GOSSIP_POI, 2 + 4 + 4 + 4 + 4) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 6885423d5dc..1a2d3f2ae0c 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -196,7 +196,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BUSY_TRADE,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Trade::BusyTrade, &WorldSession::HandleBusyTradeOpcode);
     DEFINE_HANDLER(CMSG_BUY_BACK_ITEM,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::BuyBackItem, &WorldSession::HandleBuybackItem);
     DEFINE_HANDLER(CMSG_BUY_BANK_SLOT,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Bank::BuyBankSlot, &WorldSession::HandleBuyBankSlotOpcode);
-    DEFINE_HANDLER(CMSG_BUY_ITEM,                                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Item::BuyItem, &WorldSession::HandleBuyItemOpcode);
+    DEFINE_HANDLER(CMSG_BUY_ITEM,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::BuyItem, &WorldSession::HandleBuyItemOpcode);
     DEFINE_HANDLER(CMSG_BUY_REAGENT_BANK,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_CONFIRM,                              STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_START,                                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -475,7 +475,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_LOOT_ITEM,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::LootItem, &WorldSession::HandleAutostoreLootItemOpcode);
     DEFINE_HANDLER(CMSG_LOOT_MONEY,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::LootMoney, &WorldSession::HandleLootMoneyOpcode);
     DEFINE_HANDLER(CMSG_LOOT_RELEASE,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::LootRelease, &WorldSession::HandleLootReleaseOpcode);
-    DEFINE_HANDLER(CMSG_LOOT_ROLL,                                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Loot::LootRoll, &WorldSession::HandleLootRoll);
+    DEFINE_HANDLER(CMSG_LOOT_ROLL,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::LootRoll, &WorldSession::HandleLootRoll);
     DEFINE_HANDLER(CMSG_LOOT_UNIT,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::LootUnit, &WorldSession::HandleLootOpcode);
     DEFINE_HANDLER(CMSG_LOW_LEVEL_RAID1,                                    STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_LOW_LEVEL_RAID2,                                    STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -671,7 +671,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_REQUEST_VEHICLE_SWITCH_SEAT,                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Vehicle::RequestVehicleSwitchSeat, &WorldSession::HandleRequestVehicleSwitchSeat);
     DEFINE_HANDLER(CMSG_REQUEST_WOW_TOKEN_MARKET_PRICE,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Token::RequestWowTokenMarketPrice, &WorldSession::HandleRequestWowTokenMarketPrice);
     DEFINE_HANDLER(CMSG_RESET_CHALLENGE_MODE,                               STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_RESET_INSTANCES,                                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Instance::ResetInstances, &WorldSession::HandleResetInstancesOpcode);
+    DEFINE_HANDLER(CMSG_RESET_INSTANCES,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Instance::ResetInstances, &WorldSession::HandleResetInstancesOpcode);
     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);
@@ -733,7 +733,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SHOW_TRADE_SKILL,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SIGN_PETITION,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::SignPetition, &WorldSession::HandleSignPetition);
     DEFINE_HANDLER(CMSG_SILENCE_PARTY_TALKER,                               STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_SOCKET_GEMS,                                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Item::SocketGems, &WorldSession::HandleSocketGems);
+    DEFINE_HANDLER(CMSG_SOCKET_GEMS,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::SocketGems, &WorldSession::HandleSocketGems);
     DEFINE_HANDLER(CMSG_SORT_BAGS,                                          STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SORT_BANK_BAGS,                                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SORT_REAGENT_BANK_BAGS,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -810,7 +810,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_WHO_IS,                                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Who::WhoIsRequest, &WorldSession::HandleWhoIsOpcode);
     DEFINE_HANDLER(CMSG_WORLD_PORT_RESPONSE,                                STATUS_TRANSFER,  PROCESS_THREADUNSAFE, WorldPackets::Movement::WorldPortResponse, &WorldSession::HandleMoveWorldportAckOpcode);
     DEFINE_HANDLER(CMSG_WORLD_TELEPORT,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::WorldTeleport, &WorldSession::HandleWorldTeleportOpcode);
-    DEFINE_HANDLER(CMSG_WRAP_ITEM,                                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Item::WrapItem, &WorldSession::HandleWrapItem);
+    DEFINE_HANDLER(CMSG_WRAP_ITEM,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::WrapItem, &WorldSession::HandleWrapItem);
 
 #undef DEFINE_OPCODE_HANDLER_OLD
 #undef DEFINE_HANDLER
@@ -1160,8 +1160,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GM_TICKET_SYSTEM_STATUS,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOD_MODE,                                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_COMPLETE,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_MESSAGE,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_POI,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    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_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1233,7 +1233,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_DISENGAGE_UNIT,       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_END,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_ENGAGE_UNIT,          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_GAIN_COMBAT_RESURRECTION_CHARGE, STATUS_UNHANDLED, CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_GAIN_COMBAT_RESURRECTION_CHARGE, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_IN_COMBAT_RESURRECTION, STATUS_NEVER,      CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_COMPLETE,   STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_START,      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
@@ -1255,8 +1255,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_COOLDOWN,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_ENCHANT_TIME_UPDATE,                STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_EXPIRE_PURCHASE_REFUND,             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_PURCHASE_REFUND_RESULT,             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_PUSH_RESULT,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_PURCHASE_REFUND_RESULT,             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_PUSH_RESULT,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_TIME_UPDATE,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_KICK_REASON,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARNED_SPELLS,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1312,7 +1312,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_RELEASE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_RELEASE_ALL,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_REMOVED,                            STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_RESPONSE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_RESPONSE,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_ROLL,                               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_ROLLS_COMPLETE,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_ROLL_WON,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1544,7 +1544,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAF_EMAIL_ENABLED_RESPONSE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_DIFFICULTY_SET,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_GROUP_ONLY,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_INSTANCE_MESSAGE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_INSTANCE_MESSAGE,                   STATUS_NEVER,        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);
@@ -1569,7 +1569,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESEARCH_COMPLETE,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_AREA_TRIGGER,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_COMPRESSION_CONTEXT,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_FAILED_NOTIFY,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_FAILED_NOTIFY,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_RANGED_COMBAT_TIMER,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_WEEKLY_CURRENCY,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESPEC_WIPE_CONFIRM,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1622,7 +1622,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FACTION_VISIBLE,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FLAT_SPELL_MODIFIER,                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FORCED_REACTIONS,                    STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_ITEM_PURCHASE_DATA,                  STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_ITEM_PURCHASE_DATA,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_LOOT_METHOD_FAILED,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_MAX_WEEKLY_QUANTITY,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_MELEE_ANIM_KIT,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1642,7 +1642,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SHOW_NEUTRAL_PLAYER_FACTION_SELECT_UI,   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SHOW_TAXI_NODES,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SHOW_TRADE_SKILL_RESPONSE,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SOCKET_GEMS,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SOCKET_GEMS,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SOCKET_GEMS_FAILURE,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SOR_START_EXPERIENCE_INCOMPLETE,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPECIALIZATION_CHANGED,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1723,7 +1723,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_CHARACTER_FLAGS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_DUNGEON_ENCOUNTER_FOR_LOOT,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_EXPANSION_LEVEL,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_INSTANCE_OWNERSHIP,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_INSTANCE_OWNERSHIP,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_LAST_INSTANCE,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_OBJECT,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UPDATE_TALENT_DATA,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1734,7 +1734,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_USERLIST_REMOVE,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_USERLIST_UPDATE,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_USE_EQUIPMENT_SET_RESULT,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_VENDOR_INVENTORY,                        STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_VENDOR_INVENTORY,                        STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_VIGNETTE_UPDATE,                         STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_VOICE_CHAT_STATUS,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_VOICE_PARENTAL_CONTROLS,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);