Using TC structure allowing easier patches importing

1 files changed, 1687 insertions, 0 deletions

diff --git a/src/server/game/Handlers/ItemHandler.cpp b/src/server/game/Handlers/ItemHandler.cpp
new file mode 100644
index 0000000000..b4aa9ef81c
--- /dev/null
+++ b/src/server/game/Handlers/ItemHandler.cpp
@@ -0,0 +1,1687 @@
+/*
+ * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: http://github.com/azerothcore/azerothcore-wotlk/LICENSE-GPL2
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ */
+
+#include "Common.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
+#include "Opcodes.h"
+#include "Log.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "Item.h"
+#include "UpdateData.h"
+#include "ObjectAccessor.h"
+#include "SpellInfo.h"
+
+void WorldSession::HandleSplitItemOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_SPLIT_ITEM");
+    uint8 srcbag, srcslot, dstbag, dstslot;
+    uint32 count;
+
+    recvData >> srcbag >> srcslot >> dstbag >> dstslot >> count;
+    //sLog->outDebug("STORAGE: receive srcbag = %u, srcslot = %u, dstbag = %u, dstslot = %u, count = %u", srcbag, srcslot, dstbag, dstslot, count);
+
+    uint16 src = ((srcbag << 8) | srcslot);
+    uint16 dst = ((dstbag << 8) | dstslot);
+
+    if (src == dst)
+        return;
+
+    if (count == 0)
+        return;                                             //check count - if zero it's fake packet
+
+    if (!_player->IsValidPos(srcbag, srcslot, true))
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+        return;
+    }
+
+    if (!_player->IsValidPos(dstbag, dstslot, false))       // can be autostore pos
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_DOESNT_GO_TO_SLOT, NULL, NULL);
+        return;
+    }
+
+    _player->SplitItem(src, dst, count);
+}
+
+void WorldSession::HandleSwapInvItemOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_SWAP_INV_ITEM");
+    uint8 srcslot, dstslot;
+
+    recvData >> dstslot >> srcslot;
+    //sLog->outDebug("STORAGE: receive srcslot = %u, dstslot = %u", srcslot, dstslot);
+
+    // prevent attempt swap same item to current position generated by client at special checting sequence
+    if (srcslot == dstslot)
+        return;
+
+    if (!_player->IsValidPos(INVENTORY_SLOT_BAG_0, srcslot, true))
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+        return;
+    }
+
+    if (!_player->IsValidPos(INVENTORY_SLOT_BAG_0, dstslot, true))
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_DOESNT_GO_TO_SLOT, NULL, NULL);
+        return;
+    }
+
+    if (_player->IsBankPos(INVENTORY_SLOT_BAG_0, srcslot) && !CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleSwapInvItemOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    if (_player->IsBankPos(INVENTORY_SLOT_BAG_0, dstslot) && !CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleSwapInvItemOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) | srcslot);
+    uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) | dstslot);
+
+    _player->SwapItem(src, dst);
+}
+
+void WorldSession::HandleAutoEquipItemSlotOpcode(WorldPacket & recvData)
+{
+    uint64 itemguid;
+    uint8 dstslot;
+    recvData >> itemguid >> dstslot;
+
+    // cheating attempt, client should never send opcode in that case
+    if (!Player::IsEquipmentPos(INVENTORY_SLOT_BAG_0, dstslot))
+        return;
+
+    Item* item = _player->GetItemByGuid(itemguid);
+    uint16 dstpos = dstslot | (INVENTORY_SLOT_BAG_0 << 8);
+
+    if (!item || item->GetPos() == dstpos)
+        return;
+
+    _player->SwapItem(item->GetPos(), dstpos);
+}
+
+void WorldSession::HandleSwapItem(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_SWAP_ITEM");
+    uint8 dstbag, dstslot, srcbag, srcslot;
+
+    recvData >> dstbag >> dstslot >> srcbag >> srcslot;
+    //sLog->outDebug("STORAGE: receive srcbag = %u, srcslot = %u, dstbag = %u, dstslot = %u", srcbag, srcslot, dstbag, dstslot);
+
+    uint16 src = ((srcbag << 8) | srcslot);
+    uint16 dst = ((dstbag << 8) | dstslot);
+
+    // prevent attempt swap same item to current position generated by client at special checting sequence
+    if (src == dst)
+        return;
+
+    if (!_player->IsValidPos(srcbag, srcslot, true))
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+        return;
+    }
+
+    if (!_player->IsValidPos(dstbag, dstslot, true))
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_DOESNT_GO_TO_SLOT, NULL, NULL);
+        return;
+    }
+
+    if (_player->IsBankPos(srcbag, srcslot) && !CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleSwapItem - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    if (_player->IsBankPos(dstbag, dstslot) && !CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleSwapItem - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    _player->SwapItem(src, dst);
+}
+
+void WorldSession::HandleAutoEquipItemOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_AUTOEQUIP_ITEM");
+    uint8 srcbag, srcslot;
+
+    recvData >> srcbag >> srcslot;
+    //sLog->outDebug("STORAGE: receive srcbag = %u, srcslot = %u", srcbag, srcslot);
+
+    Item* pSrcItem  = _player->GetItemByPos(srcbag, srcslot);
+    if (!pSrcItem)
+        return;                                             // only at cheat
+
+    uint16 dest;
+    InventoryResult msg = _player->CanEquipItem(NULL_SLOT, dest, pSrcItem, !pSrcItem->IsBag());
+    if (msg != EQUIP_ERR_OK)
+    {
+        _player->SendEquipError(msg, pSrcItem, NULL);
+        return;
+    }
+
+    uint16 src = pSrcItem->GetPos();
+    if (dest == src)                                           // prevent equip in same slot, only at cheat
+        return;
+
+    Item* pDstItem = _player->GetItemByPos(dest);
+    if (!pDstItem)                                         // empty slot, simple case
+    {
+        _player->RemoveItem(srcbag, srcslot, true);
+        _player->EquipItem(dest, pSrcItem, true);
+        _player->AutoUnequipOffhandIfNeed();
+    }
+    else                                                    // have currently equipped item, not simple case
+    {
+        uint8 dstbag = pDstItem->GetBagSlot();
+        uint8 dstslot = pDstItem->GetSlot();
+
+        msg = _player->CanUnequipItem(dest, !pSrcItem->IsBag());
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, pDstItem, NULL);
+            return;
+        }
+
+        // check dest->src move possibility
+        ItemPosCountVec sSrc;
+        uint16 eSrc = 0;
+        if (_player->IsInventoryPos(src))
+        {
+            msg = _player->CanStoreItem(srcbag, srcslot, sSrc, pDstItem, true);
+            if (msg != EQUIP_ERR_OK)
+                msg = _player->CanStoreItem(srcbag, NULL_SLOT, sSrc, pDstItem, true);
+            if (msg != EQUIP_ERR_OK)
+                msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, sSrc, pDstItem, true);
+        }
+        else if (_player->IsBankPos(src))
+        {
+            msg = _player->CanBankItem(srcbag, srcslot, sSrc, pDstItem, true);
+            if (msg != EQUIP_ERR_OK)
+                msg = _player->CanBankItem(srcbag, NULL_SLOT, sSrc, pDstItem, true);
+            if (msg != EQUIP_ERR_OK)
+                msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, sSrc, pDstItem, true);
+        }
+        else if (_player->IsEquipmentPos(src))
+        {
+            msg = _player->CanEquipItem(srcslot, eSrc, pDstItem, true);
+            if (msg == EQUIP_ERR_OK)
+                msg = _player->CanUnequipItem(eSrc, true);
+        }
+
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, pDstItem, pSrcItem);
+            return;
+        }
+
+        // now do moves, remove...
+        _player->RemoveItem(dstbag, dstslot, true, true);
+        _player->RemoveItem(srcbag, srcslot, true, true);
+
+        // add to dest
+        _player->EquipItem(dest, pSrcItem, true);
+
+        // add to src
+        if (_player->IsInventoryPos(src))
+            _player->StoreItem(sSrc, pDstItem, true);
+        else if (_player->IsBankPos(src))
+            _player->BankItem(sSrc, pDstItem, true);
+        else if (_player->IsEquipmentPos(src))
+            _player->EquipItem(eSrc, pDstItem, true);
+
+        _player->AutoUnequipOffhandIfNeed();
+
+        // Xinef: Call this here after all needed items are equipped
+        _player->RemoveItemDependentAurasAndCasts((Item*)NULL);
+    }
+}
+
+void WorldSession::HandleDestroyItemOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_DESTROYITEM");
+    uint8 bag, slot, count, data1, data2, data3;
+
+    recvData >> bag >> slot >> count >> data1 >> data2 >> data3;
+    //sLog->outDebug("STORAGE: receive bag = %u, slot = %u, count = %u", bag, slot, count);
+
+    uint16 pos = (bag << 8) | slot;
+
+    // prevent drop unequipable items (in combat, for example) and non-empty bags
+    if (_player->IsEquipmentPos(pos) || _player->IsBagPos(pos))
+    {
+        InventoryResult msg = _player->CanUnequipItem(pos, false);
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, _player->GetItemByPos(pos), NULL);
+            return;
+        }
+    }
+
+    Item* pItem  = _player->GetItemByPos(bag, slot);
+    if (!pItem)
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+        return;
+    }
+
+    if (pItem->GetTemplate()->Flags & ITEM_PROTO_FLAG_INDESTRUCTIBLE)
+    {
+        _player->SendEquipError(EQUIP_ERR_CANT_DROP_SOULBOUND, NULL, NULL);
+        return;
+    }
+
+    if (count)
+    {
+        uint32 i_count = count;
+        _player->DestroyItemCount(pItem, i_count, true);
+    }
+    else
+        _player->DestroyItem(bag, slot, true);
+}
+
+void ItemTemplate::InitializeQueryData()
+{
+    queryData.Initialize(SMSG_ITEM_QUERY_SINGLE_RESPONSE, 1);
+
+    queryData << ItemId;
+    queryData << Class;
+    queryData << SubClass;
+    queryData << SoundOverrideSubclass;
+    queryData << Name1;
+    queryData << uint8(0x00);                                //pProto->Name2; // blizz not send name there, just uint8(0x00); <-- \0 = empty string = empty name...
+    queryData << uint8(0x00);                                //pProto->Name3; // blizz not send name there, just uint8(0x00);
+    queryData << uint8(0x00);                                //pProto->Name4; // blizz not send name there, just uint8(0x00);
+    queryData << DisplayInfoID;
+    queryData << Quality;
+    queryData << Flags;
+    queryData << Flags2;
+    queryData << BuyPrice;
+    queryData << SellPrice;
+    queryData << InventoryType;
+    queryData << AllowableClass;
+    queryData << AllowableRace;
+    queryData << ItemLevel;
+    queryData << RequiredLevel;
+    queryData << RequiredSkill;
+    queryData << RequiredSkillRank;
+    queryData << RequiredSpell;
+    queryData << RequiredHonorRank;
+    queryData << RequiredCityRank;
+    queryData << RequiredReputationFaction;
+    queryData << RequiredReputationRank;
+    queryData << int32(MaxCount);
+    queryData << int32(Stackable);
+    queryData << ContainerSlots;
+    queryData << StatsCount;                         // item stats count
+    for (uint32 i = 0; i < StatsCount; ++i)
+    {
+        queryData << ItemStat[i].ItemStatType;
+        queryData << ItemStat[i].ItemStatValue;
+    }
+    queryData << ScalingStatDistribution;            // scaling stats distribution
+    queryData << ScalingStatValue;                   // some kind of flags used to determine stat values column
+    for (int i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
+    {
+        queryData << Damage[i].DamageMin;
+        queryData << Damage[i].DamageMax;
+        queryData << Damage[i].DamageType;
+    }
+
+    // resistances (7)
+    queryData << Armor;
+    queryData << HolyRes;
+    queryData << FireRes;
+    queryData << NatureRes;
+    queryData << FrostRes;
+    queryData << ShadowRes;
+    queryData << ArcaneRes;
+
+    queryData << Delay;
+    queryData << AmmoType;
+    queryData << RangedModRange;
+
+    for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
+    {
+        // send DBC data for cooldowns in same way as it used in Spell::SendSpellCooldown
+        // use `item_template` or if not set then only use spell cooldowns
+        SpellInfo const* spell = sSpellMgr->GetSpellInfo(Spells[s].SpellId);
+        if (spell)
+        {
+            bool db_data = Spells[s].SpellCooldown >= 0 || Spells[s].SpellCategoryCooldown >= 0;
+
+            queryData << Spells[s].SpellId;
+            queryData << Spells[s].SpellTrigger;
+            queryData << uint32(-abs(Spells[s].SpellCharges));
+
+            if (db_data)
+            {
+                queryData << uint32(Spells[s].SpellCooldown);
+                queryData << uint32(Spells[s].SpellCategory);
+                queryData << uint32(Spells[s].SpellCategoryCooldown);
+            }
+            else
+            {
+                queryData << uint32(spell->RecoveryTime);
+                queryData << uint32(spell->GetCategory());
+                queryData << uint32(spell->CategoryRecoveryTime);
+            }
+        }
+        else
+        {
+            queryData << uint32(0);
+            queryData << uint32(0);
+            queryData << uint32(0);
+            queryData << uint32(-1);
+            queryData << uint32(0);
+            queryData << uint32(-1);
+        }
+    }
+    queryData << Bonding;
+    queryData << Description;
+    queryData << PageText;
+    queryData << LanguageID;
+    queryData << PageMaterial;
+    queryData << StartQuest;
+    queryData << LockID;
+    queryData << int32(Material);
+    queryData << Sheath;
+    queryData << RandomProperty;
+    queryData << RandomSuffix;
+    queryData << Block;
+    queryData << ItemSet;
+    queryData << MaxDurability;
+    queryData << Area;
+    queryData << Map;                                // Added in 1.12.x & 2.0.1 client branch
+    queryData << BagFamily;
+    queryData << TotemCategory;
+    for (int s = 0; s < MAX_ITEM_PROTO_SOCKETS; ++s)
+    {
+        queryData << Socket[s].Color;
+        queryData << Socket[s].Content;
+    }
+    queryData << socketBonus;
+    queryData << GemProperties;
+    queryData << RequiredDisenchantSkill;
+    queryData << ArmorDamageModifier;
+    queryData << Duration;                           // added in 2.4.2.8209, duration (seconds)
+    queryData << ItemLimitCategory;                  // WotLK, ItemLimitCategory
+    queryData << HolidayId;                          // Holiday.dbc?
+}
+
+// Only _static_ data send in this packet !!!
+void WorldSession::HandleItemQuerySingleOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_ITEM_QUERY_SINGLE");
+    uint32 item;
+    recvData >> item;
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDetail("STORAGE: Item Query = %u", item);
+#endif
+
+    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(item);
+    if (pProto)
+    {
+     std::string Name = pProto->Name1;
+     std::string Description = pProto->Description;
+    
+     int loc_idx = GetSessionDbLocaleIndex();
+     if (loc_idx >= 0)
+     {
+         if (ItemLocale const* il = sObjectMgr->GetItemLocale(pProto->ItemId))
+         {
+             ObjectMgr::GetLocaleString(il->Name, loc_idx, Name);
+             ObjectMgr::GetLocaleString(il->Description, loc_idx, Description);
+         }
+     }
+     // guess size
+     WorldPacket queryData(SMSG_ITEM_QUERY_SINGLE_RESPONSE, 600);
+     queryData << pProto->ItemId;
+     queryData << pProto->Class;
+     queryData << pProto->SubClass;
+     queryData << pProto->SoundOverrideSubclass;
+     queryData << Name;
+     queryData << uint8(0x00);                                //pProto->Name2; // blizz not send name there, just uint8(0x00); <-- \0 = empty string = empty name...
+     queryData << uint8(0x00);                                //pProto->Name3; // blizz not send name there, just uint8(0x00);
+     queryData << uint8(0x00);                                //pProto->Name4; // blizz not send name there, just uint8(0x00);
+     queryData << pProto->DisplayInfoID;
+     queryData << pProto->Quality;
+     queryData << pProto->Flags;
+     queryData << pProto->Flags2;
+     queryData << pProto->BuyPrice;
+     queryData << pProto->SellPrice;
+     queryData << pProto->InventoryType;
+     queryData << pProto->AllowableClass;
+     queryData << pProto->AllowableRace;
+     queryData << pProto->ItemLevel;
+     queryData << pProto->RequiredLevel;
+     queryData << pProto->RequiredSkill;
+     queryData << pProto->RequiredSkillRank;
+     queryData << pProto->RequiredSpell;
+     queryData << pProto->RequiredHonorRank;
+     queryData << pProto->RequiredCityRank;
+     queryData << pProto->RequiredReputationFaction;
+     queryData << pProto->RequiredReputationRank;
+     queryData << int32(pProto->MaxCount);
+     queryData << int32(pProto->Stackable);
+     queryData << pProto->ContainerSlots;
+     queryData << pProto->StatsCount;                         // item stats count
+     for (uint32 i = 0; i < pProto->StatsCount; ++i)
+     {
+         queryData << pProto->ItemStat[i].ItemStatType;
+         queryData << pProto->ItemStat[i].ItemStatValue;
+     }
+     queryData << pProto->ScalingStatDistribution;            // scaling stats distribution
+     queryData << pProto->ScalingStatValue;                   // some kind of flags used to determine stat values column
+     for (int i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
+     {
+         queryData << pProto->Damage[i].DamageMin;
+         queryData << pProto->Damage[i].DamageMax;
+         queryData << pProto->Damage[i].DamageType;
+     }
+    
+     // resistances (7)
+     queryData << pProto->Armor;
+     queryData << pProto->HolyRes;
+     queryData << pProto->FireRes;
+     queryData << pProto->NatureRes;
+     queryData << pProto->FrostRes;
+     queryData << pProto->ShadowRes;
+     queryData << pProto->ArcaneRes;
+     
+     queryData << pProto->Delay;
+     queryData << pProto->AmmoType;
+     queryData << pProto->RangedModRange;
+    
+     for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
+     {
+         // send DBC data for cooldowns in same way as it used in Spell::SendSpellCooldown
+         // use `item_template` or if not set then only use spell cooldowns
+         SpellInfo const* spell = sSpellMgr->GetSpellInfo(pProto->Spells[s].SpellId);
+         if (spell)
+         {
+             bool db_data = pProto->Spells[s].SpellCooldown >= 0 || pProto->Spells[s].SpellCategoryCooldown >= 0;
+    
+             queryData << pProto->Spells[s].SpellId;
+             queryData << pProto->Spells[s].SpellTrigger;
+             queryData << uint32(-abs(pProto->Spells[s].SpellCharges));
+    
+             if (db_data)
+             {
+                 queryData << uint32(pProto->Spells[s].SpellCooldown);
+                 queryData << uint32(pProto->Spells[s].SpellCategory);
+                 queryData << uint32(pProto->Spells[s].SpellCategoryCooldown);
+             }
+             else
+             {
+                 queryData << uint32(spell->RecoveryTime);
+                 queryData << uint32(spell->GetCategory());
+                 queryData << uint32(spell->CategoryRecoveryTime);
+             }
+         }
+         else
+         {
+             queryData << uint32(0);
+             queryData << uint32(0);
+             queryData << uint32(0);
+             queryData << uint32(-1);
+             queryData << uint32(0);
+             queryData << uint32(-1);
+         }
+     }
+    queryData << pProto->Bonding;
+    queryData << Description;
+    queryData << pProto->PageText;
+    queryData << pProto->LanguageID;
+    queryData << pProto->PageMaterial;
+    queryData << pProto->StartQuest;
+    queryData << pProto->LockID;
+    queryData << int32(pProto->Material);
+    queryData << pProto->Sheath;
+    queryData << pProto->RandomProperty;
+    queryData << pProto->RandomSuffix;
+    queryData << pProto->Block;
+    queryData << pProto->ItemSet;
+    queryData << pProto->MaxDurability;
+    queryData << pProto->Area;
+    queryData << pProto->Map;                                // Added in 1.12.x & 2.0.1 client branch
+    queryData << pProto->BagFamily;
+    queryData << pProto->TotemCategory;
+    for (int s = 0; s < MAX_ITEM_PROTO_SOCKETS; ++s)
+    {
+        queryData << pProto->Socket[s].Color;
+        queryData << pProto->Socket[s].Content;
+    }
+    queryData << pProto->socketBonus;
+    queryData << pProto->GemProperties;
+    queryData << pProto->RequiredDisenchantSkill;
+    queryData << pProto->ArmorDamageModifier;
+    queryData << pProto->Duration;                           // added in 2.4.2.8209, duration (seconds)
+    queryData << pProto->ItemLimitCategory;                  // WotLK, ItemLimitCategory
+    queryData << pProto->HolidayId;                          // Holiday.dbc?
+    SendPacket(&queryData);
+    }
+    else
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_ITEM_QUERY_SINGLE - NO item INFO! (ENTRY: %u)", item);
+#endif
+        WorldPacket queryData(SMSG_ITEM_QUERY_SINGLE_RESPONSE, 4);
+        queryData << uint32(item | 0x80000000);
+        SendPacket(&queryData);
+    }
+}
+
+void WorldSession::HandleReadItem(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_READ_ITEM");
+
+    uint8 bag, slot;
+    recvData >> bag >> slot;
+
+    //sLog->outDetail("STORAGE: Read bag = %u, slot = %u", bag, slot);
+    Item* pItem = _player->GetItemByPos(bag, slot);
+
+    if (pItem && pItem->GetTemplate()->PageText)
+    {
+        WorldPacket data;
+
+        InventoryResult msg = _player->CanUseItem(pItem);
+        if (msg == EQUIP_ERR_OK)
+        {
+            data.Initialize (SMSG_READ_ITEM_OK, 8);
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+            sLog->outDetail("STORAGE: Item page sent");
+#endif
+        }
+        else
+        {
+            data.Initialize(SMSG_READ_ITEM_FAILED, 8);
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+            sLog->outDetail("STORAGE: Unable to read item");
+#endif
+            _player->SendEquipError(msg, pItem, NULL);
+        }
+        data << pItem->GetGUID();
+        SendPacket(&data);
+    }
+    else
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+}
+
+void WorldSession::HandleSellItemOpcode(WorldPacket & recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_SELL_ITEM");
+#endif
+    uint64 vendorguid, itemguid;
+    uint32 count;
+
+    recvData >> vendorguid >> itemguid >> count;
+
+    if (!itemguid)
+        return;
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(vendorguid, UNIT_NPC_FLAG_VENDOR);
+    if (!creature)
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleSellItemOpcode - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(vendorguid)));
+#endif
+        _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, itemguid, 0);
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    Item* pItem = _player->GetItemByGuid(itemguid);
+    if (pItem)
+    {
+        // prevent sell not owner item
+        if (_player->GetGUID() != pItem->GetOwnerGUID())
+        {
+            _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+            return;
+        }
+
+        // prevent sell non empty bag by drag-and-drop at vendor's item list
+        if (pItem->IsNotEmptyBag())
+        {
+            _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+            return;
+        }
+
+        // prevent sell currently looted item
+        if (_player->GetLootGUID() == pItem->GetGUID())
+        {
+            _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+            return;
+        }
+
+        // prevent selling item for sellprice when the item is still refundable
+        // this probably happens when right clicking a refundable item, the client sends both
+        // CMSG_SELL_ITEM and CMSG_REFUND_ITEM (unverified)
+        if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_REFUNDABLE))
+            return; // Therefore, no feedback to client
+
+        // special case at auto sell (sell all)
+        if (count == 0)
+        {
+            count = pItem->GetCount();
+        }
+        else
+        {
+            // prevent sell more items that exist in stack (possible only not from client)
+            if (count > pItem->GetCount())
+            {
+                _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+                return;
+            }
+        }
+
+        ItemTemplate const* pProto = pItem->GetTemplate();
+        if (pProto)
+        {
+            if (pProto->SellPrice > 0)
+            {
+                if (count < pItem->GetCount())               // need split items
+                {
+                    Item* pNewItem = pItem->CloneItem(count, _player);
+                    if (!pNewItem)
+                    {
+                        sLog->outError("WORLD: HandleSellItemOpcode - could not create clone of item %u; count = %u", pItem->GetEntry(), count);
+                        _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+                        return;
+                    }
+
+                    pItem->SetCount(pItem->GetCount() - count);
+                    _player->ItemRemovedQuestCheck(pItem->GetEntry(), count);
+                    if (_player->IsInWorld())
+                        pItem->SendUpdateToPlayer(_player);
+                    pItem->SetState(ITEM_CHANGED, _player);
+
+                    _player->AddItemToBuyBackSlot(pNewItem);
+                    if (_player->IsInWorld())
+                        pNewItem->SendUpdateToPlayer(_player);
+                }
+                else
+                {
+                    _player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
+                    _player->RemoveItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
+                    pItem->RemoveFromUpdateQueueOf(_player);
+                    _player->AddItemToBuyBackSlot(pItem);
+                    _player->UpdateTitansGrip();
+                }
+
+                uint32 money = pProto->SellPrice * count;
+                _player->ModifyMoney(money);
+                _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS, money);
+            }
+            else
+                _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
+            return;
+        }
+    }
+    _player->SendSellError(SELL_ERR_CANT_FIND_ITEM, creature, itemguid, 0);
+    return;
+}
+
+void WorldSession::HandleBuybackItem(WorldPacket & recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_BUYBACK_ITEM");
+#endif
+    uint64 vendorguid;
+    uint32 slot;
+
+    recvData >> vendorguid >> slot;
+
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(vendorguid, UNIT_NPC_FLAG_VENDOR);
+    if (!creature)
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleBuybackItem - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(vendorguid)));
+#endif
+        _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, 0, 0);
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    Item* pItem = _player->GetItemFromBuyBackSlot(slot);
+    if (pItem)
+    {
+        uint32 price = _player->GetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + slot - BUYBACK_SLOT_START);
+        if (!_player->HasEnoughMoney(price))
+        {
+            _player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, creature, pItem->GetEntry(), 0);
+            return;
+        }
+
+        ItemPosCountVec dest;
+        InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
+        if (msg == EQUIP_ERR_OK)
+        {
+            _player->ModifyMoney(-(int32)price);
+            _player->RemoveItemFromBuyBackSlot(slot, false);
+            _player->ItemAddedQuestCheck(pItem->GetEntry(), pItem->GetCount());
+            _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, pItem->GetEntry(), pItem->GetCount());
+            _player->StoreItem(dest, pItem, true);
+        }
+        else
+            _player->SendEquipError(msg, pItem, NULL);
+        return;
+    }
+    else
+        _player->SendBuyError(BUY_ERR_CANT_FIND_ITEM, creature, 0, 0);
+}
+
+void WorldSession::HandleBuyItemInSlotOpcode(WorldPacket & recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_BUY_ITEM_IN_SLOT");
+#endif
+    uint64 vendorguid, bagguid;
+    uint32 item, slot, count;
+    uint8 bagslot;
+
+    recvData >> vendorguid >> item  >> slot >> bagguid >> bagslot >> count;
+
+    // client expects count starting at 1, and we send vendorslot+1 to client already
+    if (slot > 0)
+        --slot;
+    else
+        return;                                             // cheating
+
+    uint8 bag = NULL_BAG;                                   // init for case invalid bagGUID
+
+    // find bag slot by bag guid
+    if (bagguid == _player->GetGUID())
+        bag = INVENTORY_SLOT_BAG_0;
+    else
+    {
+        for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
+        {
+            if (Bag* pBag = _player->GetBagByPos(i))
+            {
+                if (bagguid == pBag->GetGUID())
+                {
+                    bag = i;
+                    break;
+                }
+            }
+        }
+    }
+
+    // bag not found, cheating?
+    if (bag == NULL_BAG)
+        return;
+
+    GetPlayer()->BuyItemFromVendorSlot(vendorguid, slot, item, count, bag, bagslot);
+}
+
+void WorldSession::HandleBuyItemOpcode(WorldPacket & recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_BUY_ITEM");
+#endif
+    uint64 vendorguid;
+    uint32 item, slot, count;
+    uint8 unk1;
+
+    recvData >> vendorguid >> item >> slot >> count >> unk1;
+
+    // client expects count starting at 1, and we send vendorslot+1 to client already
+    if (slot > 0)
+        --slot;
+    else
+        return; // cheating
+
+    GetPlayer()->BuyItemFromVendorSlot(vendorguid, slot, item, count, NULL_BAG, NULL_SLOT);
+}
+
+void WorldSession::HandleListInventoryOpcode(WorldPacket & recvData)
+{
+    uint64 guid;
+
+    recvData >> guid;
+
+    if (!GetPlayer()->IsAlive())
+        return;
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Recvd CMSG_LIST_INVENTORY");
+#endif
+
+    SendListInventory(guid);
+}
+
+void WorldSession::SendListInventory(uint64 vendorGuid)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_LIST_INVENTORY");
+#endif
+
+    Creature* vendor = GetPlayer()->GetNPCIfCanInteractWith(vendorGuid, UNIT_NPC_FLAG_VENDOR);
+    if (!vendor)
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendListInventory - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(vendorGuid)));
+#endif
+        _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, 0, 0);
+        return;
+    }
+
+    // remove fake death
+    if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
+        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
+
+    // Stop the npc if moving
+    if (vendor->HasUnitState(UNIT_STATE_MOVING))
+        vendor->StopMoving();
+
+    VendorItemData const* items = vendor->GetVendorItems();
+    if (!items)
+    {
+        WorldPacket data(SMSG_LIST_INVENTORY, 8 + 1 + 1);
+        data << uint64(vendorGuid);
+        data << uint8(0);                                   // count == 0, next will be error code
+        data << uint8(0);                                   // "Vendor has no inventory"
+        SendPacket(&data);
+        return;
+    }
+
+    uint8 itemCount = items->GetItemCount();
+    uint8 count = 0;
+
+    WorldPacket data(SMSG_LIST_INVENTORY, 8 + 1 + itemCount * 8 * 4);
+    data << uint64(vendorGuid);
+
+    size_t countPos = data.wpos();
+    data << uint8(count);
+
+    float discountMod = _player->GetReputationPriceDiscount(vendor);
+
+    for (uint8 slot = 0; slot < itemCount; ++slot)
+    {
+        if (VendorItem const* item = items->GetItem(slot))
+        {
+            if (ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(item->item))
+            {
+                if (!(itemTemplate->AllowableClass & _player->getClassMask()) && itemTemplate->Bonding == BIND_WHEN_PICKED_UP && !_player->IsGameMaster())
+                    continue;
+                // Only display items in vendor lists for the team the
+                // player is on. If GM on, display all items.
+                if (!_player->IsGameMaster() && ((itemTemplate->Flags2 & ITEM_FLAGS_EXTRA_HORDE_ONLY && _player->GetTeamId() == TEAM_ALLIANCE) || (itemTemplate->Flags2 == ITEM_FLAGS_EXTRA_ALLIANCE_ONLY && _player->GetTeamId() == TEAM_HORDE)))
+                    continue;
+
+                // Items sold out are not displayed in list
+                uint32 leftInStock = !item->maxcount ? 0xFFFFFFFF : vendor->GetVendorItemCurrentCount(item);
+                if (!_player->IsGameMaster() && !leftInStock)
+                    continue;
+
+                ConditionList conditions = sConditionMgr->GetConditionsForNpcVendorEvent(vendor->GetEntry(), item->item);
+                if (!sConditionMgr->IsObjectMeetToConditions(_player, vendor, conditions))
+                {
+                    sLog->outError("SendListInventory: conditions not met for creature entry %u item %u", vendor->GetEntry(), item->item);
+                    continue;
+                }
+
+                // reputation discount
+                int32 price = item->IsGoldRequired(itemTemplate) ? uint32(floor(itemTemplate->BuyPrice * discountMod)) : 0;
+
+                data << uint32(slot + 1);       // client expects counting to start at 1
+                data << uint32(item->item);
+                data << uint32(itemTemplate->DisplayInfoID);
+                data << int32(leftInStock);
+                data << uint32(price);
+                data << uint32(itemTemplate->MaxDurability);
+                data << uint32(itemTemplate->BuyCount);
+                data << uint32(item->ExtendedCost);
+
+                if (++count >= MAX_VENDOR_ITEMS)
+                    break;
+            }
+        }
+    }
+
+    if (count == 0)
+    {
+        data << uint8(0);
+        SendPacket(&data);
+        return;
+    }
+
+    data.put<uint8>(countPos, count);
+    SendPacket(&data);
+}
+
+void WorldSession::HandleAutoStoreBagItemOpcode(WorldPacket & recvData)
+{
+    //sLog->outDebug(LOG_FILTER_PACKETIO, "WORLD: CMSG_AUTOSTORE_BAG_ITEM");
+    uint8 srcbag, srcslot, dstbag;
+
+    recvData >> srcbag >> srcslot >> dstbag;
+    //sLog->outDebug("STORAGE: receive srcbag = %u, srcslot = %u, dstbag = %u", srcbag, srcslot, dstbag);
+
+    Item* pItem = _player->GetItemByPos(srcbag, srcslot);
+    if (!pItem)
+        return;
+
+    if (!_player->IsValidPos(dstbag, NULL_SLOT, false))      // can be autostore pos
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_DOESNT_GO_TO_SLOT, NULL, NULL);
+        return;
+    }
+
+    uint16 src = pItem->GetPos();
+
+    // check unequip potability for equipped items and bank bags
+    if (_player->IsEquipmentPos (src) || _player->IsBagPos (src))
+    {
+        InventoryResult msg = _player->CanUnequipItem(src, !_player->IsBagPos (src));
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, pItem, NULL);
+            return;
+        }
+    }
+
+    ItemPosCountVec dest;
+    InventoryResult msg = _player->CanStoreItem(dstbag, NULL_SLOT, dest, pItem, false);
+    if (msg != EQUIP_ERR_OK)
+    {
+        _player->SendEquipError(msg, pItem, NULL);
+        return;
+    }
+
+    // no-op: placed in same slot
+    if (dest.size() == 1 && dest[0].pos == src)
+    {
+        // just remove grey item state
+        _player->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
+        return;
+    }
+
+    _player->RemoveItem(srcbag, srcslot, true);
+    _player->StoreItem(dest, pItem, true);
+    _player->UpdateTitansGrip();
+}
+
+void WorldSession::HandleBuyBankSlotOpcode(WorldPacket& recvPacket)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_BUY_BANK_SLOT");
+#endif
+
+    uint64 guid;
+    recvPacket >> guid;
+
+    if (!CanUseBank(guid))
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleBuyBankSlotOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)));
+        return;
+    }
+
+    uint32 slot = _player->GetBankBagSlotCount();
+
+    // next slot
+    ++slot;
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDetail("PLAYER: Buy bank bag slot, slot number = %u", slot);
+#endif
+
+    BankBagSlotPricesEntry const* slotEntry = sBankBagSlotPricesStore.LookupEntry(slot);
+
+    WorldPacket data(SMSG_BUY_BANK_SLOT_RESULT, 4);
+
+    if (!slotEntry)
+    {
+        data << uint32(ERR_BANKSLOT_FAILED_TOO_MANY);
+        SendPacket(&data);
+        return;
+    }
+
+    uint32 price = slotEntry->price;
+
+    if (!_player->HasEnoughMoney(price))
+    {
+        data << uint32(ERR_BANKSLOT_INSUFFICIENT_FUNDS);
+        SendPacket(&data);
+        return;
+    }
+
+    _player->SetBankBagSlotCount(slot);
+    _player->ModifyMoney(-int32(price));
+
+     data << uint32(ERR_BANKSLOT_OK);
+     SendPacket(&data);
+
+    _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT);
+}
+
+void WorldSession::HandleAutoBankItemOpcode(WorldPacket& recvPacket)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_AUTOBANK_ITEM");
+#endif
+    uint8 srcbag, srcslot;
+
+    recvPacket >> srcbag >> srcslot;
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "STORAGE: receive srcbag = %u, srcslot = %u", srcbag, srcslot);
+#endif
+
+    if (!CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleAutoBankItemOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    Item* pItem = _player->GetItemByPos(srcbag, srcslot);
+    if (!pItem)
+        return;
+
+    ItemPosCountVec dest;
+    InventoryResult msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
+    if (msg != EQUIP_ERR_OK)
+    {
+        _player->SendEquipError(msg, pItem, NULL);
+        return;
+    }
+
+    if (dest.size() == 1 && dest[0].pos == pItem->GetPos())
+    {
+        _player->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
+        return;
+    }
+
+    _player->RemoveItem(srcbag, srcslot, true);
+    _player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
+    _player->BankItem(dest, pItem, true);
+    _player->UpdateTitansGrip();
+}
+
+void WorldSession::HandleAutoStoreBankItemOpcode(WorldPacket& recvPacket)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_AUTOSTORE_BANK_ITEM");
+#endif
+    uint8 srcbag, srcslot;
+
+    recvPacket >> srcbag >> srcslot;
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "STORAGE: receive srcbag = %u, srcslot = %u", srcbag, srcslot);
+#endif
+
+    if (!CanUseBank())
+    {
+        //TC_LOG_DEBUG("network", "WORLD: HandleAutoStoreBankItemOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(m_currentBankerGUID)));
+        return;
+    }
+
+    Item* pItem = _player->GetItemByPos(srcbag, srcslot);
+    if (!pItem)
+        return;
+
+    if (_player->IsBankPos(srcbag, srcslot))                 // moving from bank to inventory
+    {
+        ItemPosCountVec dest;
+        InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, pItem, NULL);
+            return;
+        }
+
+        _player->RemoveItem(srcbag, srcslot, true);
+        if (Item const* storedItem = _player->StoreItem(dest, pItem, true))
+            _player->ItemAddedQuestCheck(storedItem->GetEntry(), storedItem->GetCount());
+    }
+    else                                                    // moving from inventory to bank
+    {
+        ItemPosCountVec dest;
+        InventoryResult msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
+        if (msg != EQUIP_ERR_OK)
+        {
+            _player->SendEquipError(msg, pItem, NULL);
+            return;
+        }
+
+        _player->RemoveItem(srcbag, srcslot, true);
+        _player->BankItem(dest, pItem, true);
+        _player->UpdateTitansGrip();
+    }
+}
+
+void WorldSession::HandleSetAmmoOpcode(WorldPacket & recvData)
+{
+    if (!_player->IsAlive())
+    {
+        _player->SendEquipError(EQUIP_ERR_YOU_ARE_DEAD, NULL, NULL);
+        return;
+    }
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_SET_AMMO");
+#endif
+    uint32 item;
+
+    recvData >> item;
+
+    if (item)
+    {
+        if (!_player->GetItemCount(item))
+        {
+            _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
+            return;
+        }
+
+        _player->SetAmmo(item);
+    }
+    else
+        _player->RemoveAmmo();
+}
+
+void WorldSession::SendEnchantmentLog(uint64 target, uint64 caster, uint32 itemId, uint32 enchantId)
+{
+    WorldPacket data(SMSG_ENCHANTMENTLOG, (8+8+4+4));     // last check 2.0.10
+    data.appendPackGUID(target);
+    data.appendPackGUID(caster);
+    data << uint32(itemId);
+    data << uint32(enchantId);
+    GetPlayer()->SendMessageToSet(&data, true);
+}
+
+void WorldSession::SendItemEnchantTimeUpdate(uint64 Playerguid, uint64 Itemguid, uint32 slot, uint32 Duration)
+{
+                                                            // last check 2.0.10
+    WorldPacket data(SMSG_ITEM_ENCHANT_TIME_UPDATE, (8+4+4+8));
+    data << uint64(Itemguid);
+    data << uint32(slot);
+    data << uint32(Duration);
+    data << uint64(Playerguid);
+    SendPacket(&data);
+}
+
+void WorldSession::HandleItemNameQueryOpcode(WorldPacket & recvData)
+{
+    uint32 itemid;
+    recvData >> itemid;
+    recvData.read_skip<uint64>();                          // guid
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_ITEM_NAME_QUERY %u", itemid);
+#endif
+    ItemSetNameEntry const* pName = sObjectMgr->GetItemSetNameEntry(itemid);
+    if (pName)
+    {
+        std::string Name = pName->name;
+        LocaleConstant loc_idx = GetSessionDbLocaleIndex();
+        if (loc_idx >= 0)
+            if (ItemSetNameLocale const* isnl = sObjectMgr->GetItemSetNameLocale(itemid))
+                ObjectMgr::GetLocaleString(isnl->Name, loc_idx, Name);
+        
+        WorldPacket data(SMSG_ITEM_NAME_QUERY_RESPONSE, (4+Name.size()+1+4));
+        data << uint32(itemid);
+        data << Name;
+        data << uint32(pName->InventoryType);
+        SendPacket(&data);
+    }
+}
+
+void WorldSession::HandleWrapItemOpcode(WorldPacket& recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "Received opcode CMSG_WRAP_ITEM");
+#endif
+
+    uint8 gift_bag, gift_slot, item_bag, item_slot;
+
+    recvData >> gift_bag >> gift_slot;                     // paper
+    recvData >> item_bag >> item_slot;                     // item
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WRAP: receive gift_bag = %u, gift_slot = %u, item_bag = %u, item_slot = %u", gift_bag, gift_slot, item_bag, item_slot);
+#endif
+
+    Item* gift = _player->GetItemByPos(gift_bag, gift_slot);
+    if (!gift)
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
+        return;
+    }
+
+    if (!(gift->GetTemplate()->Flags & ITEM_PROTO_FLAG_WRAPPER)) // cheating: non-wrapper wrapper
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
+        return;
+    }
+
+    Item* item = _player->GetItemByPos(item_bag, item_slot);
+
+    if (!item)
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
+        return;
+    }
+
+    // xinef: do not allow to wrap removed items, just in case
+    if (item->GetState() == ITEM_REMOVED)
+    {
+        _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
+        return;
+    }
+
+    if (item == gift)                                          // not possable with pacjket from real client
+    {
+        _player->SendEquipError(EQUIP_ERR_WRAPPED_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    if (item->IsEquipped())
+    {
+        _player->SendEquipError(EQUIP_ERR_EQUIPPED_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    if (item->GetUInt64Value(ITEM_FIELD_GIFTCREATOR))        // HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED);
+    {
+        _player->SendEquipError(EQUIP_ERR_WRAPPED_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    if (item->IsBag())
+    {
+        _player->SendEquipError(EQUIP_ERR_BAGS_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    if (item->IsSoulBound())
+    {
+        _player->SendEquipError(EQUIP_ERR_BOUND_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    if (item->GetMaxStackCount() != 1)
+    {
+        _player->SendEquipError(EQUIP_ERR_STACKABLE_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    // maybe not correct check  (it is better than nothing)
+    if (item->GetTemplate()->MaxCount>0)
+    {
+        _player->SendEquipError(EQUIP_ERR_UNIQUE_CANT_BE_WRAPPED, item, NULL);
+        return;
+    }
+
+    SQLTransaction trans = CharacterDatabase.BeginTransaction();
+
+    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_GIFT);
+    stmt->setUInt32(0, GUID_LOPART(item->GetOwnerGUID()));
+    stmt->setUInt32(1, item->GetGUIDLow());
+    stmt->setUInt32(2, item->GetEntry());
+    stmt->setUInt32(3, item->GetUInt32Value(ITEM_FIELD_FLAGS));
+    trans->Append(stmt);
+
+    item->SetEntry(gift->GetEntry());
+
+    switch (item->GetEntry())
+    {
+        case 5042:  item->SetEntry(5043); break;
+        case 5048:  item->SetEntry(5044); break;
+        case 17303: item->SetEntry(17302); break;
+        case 17304: item->SetEntry(17305); break;
+        case 17307: item->SetEntry(17308); break;
+        case 21830: item->SetEntry(21831); break;
+    }
+    item->SetUInt64Value(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
+    item->SetUInt32Value(ITEM_FIELD_FLAGS, ITEM_FLAG_WRAPPED);
+    item->SetState(ITEM_CHANGED, _player);
+
+    // after save it will be impossible to remove the item from the queue
+    _player->SaveInventoryAndGoldToDB(trans);
+
+    CharacterDatabase.CommitTransaction(trans);
+
+    uint32 count = 1;
+    _player->DestroyItemCount(gift, count, true);
+}
+
+void WorldSession::HandleSocketOpcode(WorldPacket& recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_SOCKET_GEMS");
+#endif
+
+    uint64 item_guid;
+    uint64 gem_guids[MAX_GEM_SOCKETS];
+
+    recvData >> item_guid;
+    if (!item_guid)
+        return;
+
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
+        recvData >> gem_guids[i];
+
+    //cheat -> tried to socket same gem multiple times
+    if ((gem_guids[0] && (gem_guids[0] == gem_guids[1] || gem_guids[0] == gem_guids[2])) ||
+        (gem_guids[1] && (gem_guids[1] == gem_guids[2])))
+        return;
+
+    Item* itemTarget = _player->GetItemByGuid(item_guid);
+    if (!itemTarget)                                         //missing item to socket
+        return;
+
+    ItemTemplate const* itemProto = itemTarget->GetTemplate();
+    if (!itemProto)
+        return;
+
+    //this slot is excepted when applying / removing meta gem bonus
+    uint8 slot = itemTarget->IsEquipped() ? itemTarget->GetSlot() : uint8(NULL_SLOT);
+
+    Item* Gems[MAX_GEM_SOCKETS];
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
+        Gems[i] = gem_guids[i] ? _player->GetItemByGuid(gem_guids[i]) : NULL;
+
+    GemPropertiesEntry const* GemProps[MAX_GEM_SOCKETS];
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //get geminfo from dbc storage
+        GemProps[i] = (Gems[i]) ? sGemPropertiesStore.LookupEntry(Gems[i]->GetTemplate()->GemProperties) : NULL;
+
+    // Find first prismatic socket
+    int32 firstPrismatic = 0;
+    while (firstPrismatic < MAX_GEM_SOCKETS && itemProto->Socket[firstPrismatic].Color)
+        ++firstPrismatic;
+
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //check for hack maybe
+    {
+        if (!GemProps[i])
+            continue;
+
+        // tried to put gem in socket where no socket exists (take care about prismatic sockets)
+        if (!itemProto->Socket[i].Color)
+        {
+            // no prismatic socket
+            if (!itemTarget->GetEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT))
+                return;
+
+            if (i != firstPrismatic)
+                return;
+        }
+
+        // tried to put normal gem in meta socket
+        if (itemProto->Socket[i].Color == SOCKET_COLOR_META && GemProps[i]->color != SOCKET_COLOR_META)
+            return;
+
+        // tried to put meta gem in normal socket
+        if (itemProto->Socket[i].Color != SOCKET_COLOR_META && GemProps[i]->color == SOCKET_COLOR_META)
+            return;
+    }
+
+    uint32 GemEnchants[MAX_GEM_SOCKETS];
+    uint32 OldEnchants[MAX_GEM_SOCKETS];
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //get new and old enchantments
+    {
+        GemEnchants[i] = (GemProps[i]) ? GemProps[i]->spellitemenchantement : 0;
+        OldEnchants[i] = itemTarget->GetEnchantmentId(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT+i));
+    }
+
+    // check unique-equipped conditions
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
+    {
+        if (!Gems[i])
+            continue;
+
+        // continue check for case when attempt add 2 similar unique equipped gems in one item.
+        ItemTemplate const* iGemProto = Gems[i]->GetTemplate();
+
+        // unique item (for new and already placed bit removed enchantments
+        if (iGemProto->Flags & ITEM_PROTO_FLAG_UNIQUE_EQUIPPED)
+        {
+            for (int j = 0; j < MAX_GEM_SOCKETS; ++j)
+            {
+                if (i == j)                                    // skip self
+                    continue;
+
+                if (Gems[j])
+                {
+                    if (iGemProto->ItemId == Gems[j]->GetEntry())
+                    {
+                        _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
+                        return;
+                    }
+                }
+                else if (OldEnchants[j])
+                {
+                    if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
+                    {
+                        if (iGemProto->ItemId == enchantEntry->GemID)
+                        {
+                            _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        // unique limit type item
+        int32 limit_newcount = 0;
+        if (iGemProto->ItemLimitCategory)
+        {
+            if (ItemLimitCategoryEntry const* limitEntry = sItemLimitCategoryStore.LookupEntry(iGemProto->ItemLimitCategory))
+            {
+                // NOTE: limitEntry->mode is not checked because if item has limit then it is applied in equip case
+                for (int j = 0; j < MAX_GEM_SOCKETS; ++j)
+                {
+                    if (Gems[j])
+                    {
+                        // new gem
+                        if (iGemProto->ItemLimitCategory == Gems[j]->GetTemplate()->ItemLimitCategory)
+                            ++limit_newcount;
+                    }
+                    else if (OldEnchants[j])
+                    {
+                        // existing gem
+                        if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
+                            if (ItemTemplate const* jProto = sObjectMgr->GetItemTemplate(enchantEntry->GemID))
+                                if (iGemProto->ItemLimitCategory == jProto->ItemLimitCategory)
+                                    ++limit_newcount;
+                    }
+                }
+
+                if (limit_newcount > 0 && uint32(limit_newcount) > limitEntry->maxCount)
+                {
+                    _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
+                    return;
+                }
+            }
+        }
+
+        // for equipped item check all equipment for duplicate equipped gems
+        if (itemTarget->IsEquipped())
+        {
+            if (InventoryResult res = _player->CanEquipUniqueItem(Gems[i], slot, std::max(limit_newcount, 0)))
+            {
+                _player->SendEquipError(res, itemTarget, NULL);
+                return;
+            }
+        }
+    }
+
+    bool SocketBonusActivated = itemTarget->GemsFitSockets();    //save state of socketbonus
+    _player->ToggleMetaGemsActive(slot, false);             //turn off all metagems (except for the target item)
+
+    //if a meta gem is being equipped, all information has to be written to the item before testing if the conditions for the gem are met
+
+    //remove ALL enchants
+    for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + MAX_GEM_SOCKETS; ++enchant_slot)
+        _player->ApplyEnchantment(itemTarget, EnchantmentSlot(enchant_slot), false);
+
+    for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
+    {
+        if (GemEnchants[i])
+        {
+            itemTarget->SetEnchantment(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT+i), GemEnchants[i], 0, 0, _player->GetGUID());
+            if (Item* guidItem = _player->GetItemByGuid(gem_guids[i]))
+                _player->DestroyItem(guidItem->GetBagSlot(), guidItem->GetSlot(), true);
+        }
+    }
+
+    for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS; ++enchant_slot)
+        _player->ApplyEnchantment(itemTarget, EnchantmentSlot(enchant_slot), true);
+
+    bool SocketBonusToBeActivated = itemTarget->GemsFitSockets();//current socketbonus state
+    if (SocketBonusActivated ^ SocketBonusToBeActivated)     //if there was a change...
+    {
+        _player->ApplyEnchantment(itemTarget, BONUS_ENCHANTMENT_SLOT, false);
+        itemTarget->SetEnchantment(BONUS_ENCHANTMENT_SLOT, (SocketBonusToBeActivated ? itemTarget->GetTemplate()->socketBonus : 0), 0, 0, _player->GetGUID());
+        _player->ApplyEnchantment(itemTarget, BONUS_ENCHANTMENT_SLOT, true);
+        //it is not displayed, client has an inbuilt system to determine if the bonus is activated
+    }
+
+    _player->ToggleMetaGemsActive(slot, true);              //turn on all metagems (except for target item)
+
+    _player->RemoveTradeableItem(itemTarget);
+    itemTarget->ClearSoulboundTradeable(_player);           // clear tradeable flag
+
+    itemTarget->SendUpdateSockets();
+}
+
+void WorldSession::HandleCancelTempEnchantmentOpcode(WorldPacket& recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_CANCEL_TEMP_ENCHANTMENT");
+#endif
+
+    uint32 eslot;
+
+    recvData >> eslot;
+
+    // apply only to equipped item
+    if (!Player::IsEquipmentPos(INVENTORY_SLOT_BAG_0, eslot))
+        return;
+
+    Item* item = GetPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, eslot);
+
+    if (!item)
+        return;
+
+    if (!item->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT))
+        return;
+
+    GetPlayer()->ApplyEnchantment(item, TEMP_ENCHANTMENT_SLOT, false);
+    item->ClearEnchantment(TEMP_ENCHANTMENT_SLOT);
+}
+
+void WorldSession::HandleItemRefundInfoRequest(WorldPacket& recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_ITEM_REFUND_INFO");
+#endif
+
+    uint64 guid;
+    recvData >> guid;                                      // item guid
+
+    Item* item = _player->GetItemByGuid(guid);
+    if (!item)
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "Item refund: item not found!");
+#endif
+        return;
+    }
+
+    GetPlayer()->SendRefundInfo(item);
+}
+
+void WorldSession::HandleItemRefund(WorldPacket &recvData)
+{
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_ITEM_REFUND");
+#endif
+    uint64 guid;
+    recvData >> guid;                                      // item guid
+
+    Item* item = _player->GetItemByGuid(guid);
+    if (!item)
+    {
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+        sLog->outDebug(LOG_FILTER_NETWORKIO, "Item refund: item not found!");
+#endif
+        return;
+    }
+  
+    // Don't try to refund item currently being disenchanted
+    if (_player->GetLootGUID() == guid)
+        return;
+
+    GetPlayer()->RefundItem(item);
+}
+
+/**
+ * Handles the packet sent by the client when requesting information about item text.
+ *
+ * This function is called when player clicks on item which has some flag set
+ */
+void WorldSession::HandleItemTextQuery(WorldPacket & recvData )
+{
+    uint64 itemGuid;
+    recvData >> itemGuid;
+
+#if defined(ENABLE_EXTRAS) && defined(ENABLE_EXTRA_LOGS)
+    sLog->outDebug(LOG_FILTER_NETWORKIO, "CMSG_ITEM_TEXT_QUERY item guid: %u", GUID_LOPART(itemGuid));
+#endif
+
+    WorldPacket data(SMSG_ITEM_TEXT_QUERY_RESPONSE, 50);        // guess size
+
+    if (Item* item = _player->GetItemByGuid(itemGuid))
+    {
+        data << uint8(0);                                       // has text
+        data << uint64(itemGuid);                               // item guid
+        data << item->GetText();
+    }
+    else
+    {
+        data << uint8(1);                                       // no text
+    }
+
+    SendPacket(&data);
+}
+
+bool WorldSession::CanUseBank(uint64 bankerGUID) const
+{
+    // bankerGUID parameter is optional, set to 0 by default.
+    if (!bankerGUID)
+        bankerGUID = m_currentBankerGUID;
+
+    bool isUsingBankCommand = (bankerGUID == GetPlayer()->GetGUID() && bankerGUID == m_currentBankerGUID);
+
+    if (!isUsingBankCommand)
+    {
+        Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(bankerGUID, UNIT_NPC_FLAG_BANKER);
+        if (!creature)
+            return false;
+    }
+
+    return true;
+}