mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-13 13:37:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
server/src/game/WorldHandlers/ItemHandler.cpp
Yaki Khadafi 13316a27d1 Fix socket gems
2020-02-17 12:01:09 +00:00

1565 lines
51 KiB
C++
Raw Blame History

/**
* MaNGOS is a full featured server for World of Warcraft, supporting
* the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
*
* Copyright (C) 2005-2015 MaNGOS project <http://getmangos.eu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* World of Warcraft, and all World of Warcraft or Warcraft art, images,
* and lore are copyrighted by Blizzard Entertainment, Inc.
*/
#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 "Chat.h"
void WorldSession::HandleSplitItemOpcode(WorldPacket& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_SPLIT_ITEM");
uint8 srcbag, srcslot, dstbag, dstslot;
uint32 count;
recv_data >> srcbag >> srcslot >> dstbag >> dstslot >> count;
// DEBUG_LOG("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& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_SWAP_INV_ITEM");
uint8 srcslot, dstslot;
recv_data >> dstslot >> srcslot;
// DEBUG_LOG("STORAGE: receive srcslot = %u, dstslot = %u", srcslot, dstslot);
// prevent attempt swap same item to current position generated by client at special cheating 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;
}
uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) | srcslot);
uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) | dstslot);
_player->SwapItem(src, dst);
}
void WorldSession::HandleAutoEquipItemSlotOpcode(WorldPacket& recv_data)
{
ObjectGuid itemGuid;
uint8 dstslot;
recv_data >> 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& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_SWAP_ITEM");
uint8 dstbag, dstslot, srcbag, srcslot;
recv_data >> dstbag >> dstslot >> srcbag >> srcslot ;
// DEBUG_LOG("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 cheating 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;
}
_player->SwapItem(src, dst);
}
void WorldSession::HandleAutoEquipItemOpcode(WorldPacket& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_AUTOEQUIP_ITEM");
uint8 srcbag, srcslot;
recv_data >> srcbag >> srcslot;
// DEBUG_LOG("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, false);
_player->RemoveItem(srcbag, srcslot, false);
// 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();
}
}
void WorldSession::HandleDestroyItemOpcode(WorldPacket& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_DESTROYITEM");
uint8 bag, slot, count, data1, data2, data3;
recv_data >> bag >> slot >> count >> data1 >> data2 >> data3;
// DEBUG_LOG("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;
}
// checked at client side and not have server side appropriate error output
if (pItem->GetProto()->Flags & ITEM_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 WorldSession::HandleReadItemOpcode(WorldPacket& recv_data)
{
// DEBUG_LOG("WORLD: Received opcode CMSG_READ_ITEM");
uint8 bag, slot;
recv_data >> bag >> slot;
// sLog.outDetail("STORAGE: Read bag = %u, slot = %u", bag, slot);
Item* pItem = _player->GetItemByPos(bag, slot);
if (pItem && pItem->GetProto()->PageText)
{
WorldPacket data;
InventoryResult msg = _player->CanUseItem(pItem);
if (msg == EQUIP_ERR_OK)
{
data.Initialize(SMSG_READ_ITEM_OK, 8);
DETAIL_LOG("STORAGE: Item page sent");
}
else
{
data.Initialize(SMSG_READ_ITEM_FAILED, 8);
DETAIL_LOG("STORAGE: Unable to read item");
_player->SendEquipError(msg, pItem, NULL);
}
data << pItem->GetObjectGuid();
SendPacket(&data);
}
else
_player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
}
void WorldSession::HandlePageQuerySkippedOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: Received opcode CMSG_PAGE_TEXT_QUERY");
uint32 itemid;
ObjectGuid guid;
recv_data >> itemid >> guid;
DETAIL_LOG("Packet Info: itemid: %u guid: %s", itemid, guid.GetString().c_str());
}
void WorldSession::HandleSellItemOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: Received opcode CMSG_SELL_ITEM");
ObjectGuid vendorGuid;
ObjectGuid itemGuid;
uint32 count;
recv_data >> vendorGuid;
recv_data >> itemGuid;
recv_data >> count;
if (!itemGuid)
return;
Creature* pCreature = GetPlayer()->GetNPCIfCanInteractWith(vendorGuid, UNIT_NPC_FLAG_VENDOR);
if (!pCreature)
{
DEBUG_LOG("WORLD: HandleSellItemOpcode - %s not found or you can't interact with him.", vendorGuid.GetString().c_str());
_player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, itemGuid, 0);
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
Item* pItem = _player->GetItemByGuid(itemGuid);
if (pItem)
{
// prevent sell not owner item
if (_player->GetObjectGuid() != pItem->GetOwnerGuid())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, pCreature, itemGuid, 0);
return;
}
// prevent sell non empty bag by drag-and-drop at vendor's item list
if (pItem->IsBag() && !((Bag*)pItem)->IsEmpty())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, pCreature, itemGuid, 0);
return;
}
// prevent sell currently looted item
if (_player->GetLootGuid() == pItem->GetObjectGuid())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, pCreature, itemGuid, 0);
return;
}
// 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, pCreature, itemGuid, 0);
return;
}
}
ItemPrototype const* pProto = pItem->GetProto();
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, pCreature, itemGuid, 0);
return;
}
pItem->SetCount(pItem->GetCount() - count);
_player->ItemRemovedQuestCheck(pItem->GetEntry(), count);
if (_player->IsInWorld())
pItem->SendCreateUpdateToPlayer(_player);
pItem->SetState(ITEM_CHANGED, _player);
_player->AddItemToBuyBackSlot(pNewItem);
if (_player->IsInWorld())
pNewItem->SendCreateUpdateToPlayer(_player);
}
else
{
_player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
_player->RemoveItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
pItem->RemoveFromUpdateQueueOf(_player);
_player->AddItemToBuyBackSlot(pItem);
}
uint64 money = pProto->SellPrice * count;
_player->ModifyMoney(money);
_player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS, money);
}
else
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, pCreature, itemGuid, 0);
return;
}
}
_player->SendSellError(SELL_ERR_CANT_FIND_ITEM, pCreature, itemGuid, 0);
return;
}
void WorldSession::HandleBuybackItem(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: Received opcode CMSG_BUYBACK_ITEM");
ObjectGuid vendorGuid;
uint32 slot;
recv_data >> vendorGuid >> slot;
Creature* pCreature = GetPlayer()->GetNPCIfCanInteractWith(vendorGuid, UNIT_NPC_FLAG_VENDOR);
if (!pCreature)
{
DEBUG_LOG("WORLD: HandleBuybackItem - %s not found or you can't interact with him.", vendorGuid.GetString().c_str());
_player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, ObjectGuid(), 0);
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
Item* pItem = _player->GetItemFromBuyBackSlot(slot);
if (pItem)
{
uint64 price = _player->GetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + slot - BUYBACK_SLOT_START);
if (_player->GetMoney() < price)
{
_player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, pCreature, pItem->GetEntry(), 0);
return;
}
ItemPosCountVec dest;
InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
if (msg == EQUIP_ERR_OK)
{
_player->ModifyMoney(-(int64)price);
_player->RemoveItemFromBuyBackSlot(slot, false);
_player->ItemAddedQuestCheck(pItem->GetEntry(), pItem->GetCount());
_player->GetAchievementMgr().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, pCreature, 0, 0);
}
void WorldSession::HandleBuyItemOpcode(WorldPacket& recv_data)
{
ObjectGuid vendorGuid, bagGuid;
uint32 item, slot, count;
uint8 type, bagSlot;
recv_data >> vendorGuid >> type >> item >> slot >> count >> bagGuid >> bagSlot;
DEBUG_LOG("WORLD: Received opcode CMSG_BUY_ITEM, vendorguid: %s, type: %u, item: %u, slot: %u, count: %u, bagGuid: %s, bagSlog: %u",
vendorGuid.GetString().c_str(), type, item, slot, count, bagGuid.GetString().c_str(), bagSlot);
// client side expected counting from 1, and we send to client vendorslot+1 already
if (slot > 0)
--slot;
else
return; // cheating
switch (type)
{
case VENDOR_ITEM_TYPE_NONE:
break;
case VENDOR_ITEM_TYPE_ITEM:
{
uint8 bag = NULL_BAG; // init for case invalid bagGUID
// find bag slot by bag guid
if (bagGuid == _player->GetObjectGuid())
bag = INVENTORY_SLOT_BAG_0;
else
{
for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
{
if (Bag* pBag = (Bag*)_player->GetItemByPos(INVENTORY_SLOT_BAG_0, i))
{
if (bagGuid == pBag->GetObjectGuid())
{
bag = i;
break;
}
}
}
}
GetPlayer()->BuyItemFromVendorSlot(vendorGuid, slot, item, count, bag, bagSlot);
break;
}
case VENDOR_ITEM_TYPE_CURRENCY:
{
GetPlayer()->BuyCurrencyFromVendorSlot(vendorGuid, slot, item, count);
break;
}
}
}
void WorldSession::HandleListInventoryOpcode(WorldPacket& recv_data)
{
ObjectGuid guid;
recv_data >> guid;
if (!GetPlayer()->isAlive())
return;
DEBUG_LOG("WORLD: Received opcode CMSG_LIST_INVENTORY");
SendListInventory(guid);
}
void WorldSession::SendListInventory(ObjectGuid vendorguid)
{
DEBUG_LOG("WORLD: Sent SMSG_LIST_INVENTORY");
Creature* pCreature = GetPlayer()->GetNPCIfCanInteractWith(vendorguid, UNIT_NPC_FLAG_VENDOR);
if (!pCreature)
{
DEBUG_LOG("WORLD: SendListInventory - %s not found or you can't interact with him.", vendorguid.GetString().c_str());
_player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, ObjectGuid(), 0);
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// Stop the npc if moving
pCreature->StopMoving();
VendorItemData const* vItems = pCreature->GetVendorItems();
VendorItemData const* tItems = pCreature->GetVendorTemplateItems();
uint8 customitems = vItems ? vItems->GetItemCount() : 0;
uint8 numitems = customitems + (tItems ? tItems->GetItemCount() : 0);
std::vector<bool> bitFlags;
float discountMod = _player->GetReputationPriceDiscount(pCreature);
uint8 count = 0;
ByteBuffer buffer;
for (uint8 vendorslot = 0; vendorslot < numitems; ++vendorslot)
{
VendorItem const* crItem = vendorslot < customitems ? vItems->GetItem(vendorslot) : tItems->GetItem(vendorslot - customitems);
if (crItem)
{
uint32 price, displayId, buyCount, maxDurability;
int32 maxCount;
if (crItem->type == VENDOR_ITEM_TYPE_ITEM)
{
ItemPrototype const * pProto = ObjectMgr::GetItemPrototype(crItem->item);
if (!pProto)
continue;
if (!_player->isGameMaster())
{
// class wrong item skip only for bindable case
if ((pProto->AllowableClass & _player->getClassMask()) == 0 && pProto->Bonding == BIND_WHEN_PICKED_UP)
continue;
// race wrong item skip always
if ((pProto->Flags2 & ITEM_FLAG2_HORDE_ONLY) && _player->GetTeam() != HORDE)
continue;
if ((pProto->Flags2 & ITEM_FLAG2_ALLIANCE_ONLY) && _player->GetTeam() != ALLIANCE)
continue;
if ((pProto->AllowableRace & _player->getRaceMask()) == 0)
continue;
if (crItem->conditionId && !sObjectMgr.IsPlayerMeetToCondition(crItem->conditionId, _player, pCreature->GetMap(), pCreature, CONDITION_FROM_VENDOR))
continue;
}
// possible item coverting for BoA case
if (pProto->Flags & ITEM_FLAG_BOA)
{
// convert if can use and then buy
if (pProto->RequiredReputationFaction && uint32(_player->GetReputationRank(pProto->RequiredReputationFaction)) >= pProto->RequiredReputationRank)
{
// checked at convert data loading as existed
if (uint32 newItemId = sObjectMgr.GetItemConvert(crItem->item, _player->getRaceMask()))
pProto = ObjectMgr::GetItemPrototype(newItemId);
}
}
++count;
if (count >= MAX_VENDOR_ITEMS)
break;
// reputation discount
maxDurability = pProto->MaxDurability;
price = (crItem->ExtendedCost == 0 || pProto->Flags2 & ITEM_FLAG2_EXT_COST_REQUIRES_GOLD) ? uint32(floor(pProto->BuyPrice * discountMod)) : 0;
displayId = pProto->DisplayInfoID;
maxCount = crItem->maxcount <= 0 ? -1 : int32(pCreature->GetVendorItemCurrentCount(crItem));
buyCount = pProto->BuyCount;
}
else if (crItem->type == VENDOR_ITEM_TYPE_CURRENCY)
{
CurrencyTypesEntry const * pCurrency = sCurrencyTypesStore.LookupEntry(crItem->item);
if (!pCurrency)
continue;
if (pCurrency->Category == CURRENCY_CATEGORY_META)
continue;
++count;
if (count >= MAX_VENDOR_ITEMS)
break;
maxDurability = 0;
price = 0;
displayId = 0;
maxCount = -1;
buyCount = crItem->maxcount;
}
else
continue;
bitFlags.push_back(crItem->ExtendedCost == 0);
bitFlags.push_back(true); // unk
buffer << uint32(vendorslot + 1); // client size expected counting from 1
buffer << uint32(maxDurability);
if (crItem->ExtendedCost)
buffer << uint32(crItem->ExtendedCost);
buffer << uint32(crItem->item);
buffer << uint32(crItem->type);
buffer << uint32(price);
buffer << uint32(displayId);
buffer << int32(maxCount);
buffer << uint32(buyCount);
}
}
WorldPacket data(SMSG_LIST_INVENTORY, (8 + 3 + 1 + 1 + numitems * 8 * 4));
data.WriteGuidMask<1, 0>(vendorguid);
data.WriteBits(count, 21);
data.WriteGuidMask<3, 6, 5, 2, 7>(vendorguid);
for (uint32 i = 0; i < bitFlags.size(); ++i)
data.WriteBit(bitFlags[i]);
data.WriteGuidMask<4>(vendorguid);
data.FlushBits();
data.append(buffer);
data.WriteGuidBytes<5, 4, 1, 0, 6>(vendorguid);
data << uint8(count == 0);
data.WriteGuidBytes<2, 3, 7>(vendorguid);
SendPacket(&data);
}
void WorldSession::HandleAutoStoreBagItemOpcode(WorldPacket& recv_data)
{
// DEBUG_LOG("WORLD: CMSG_AUTOSTORE_BAG_ITEM");
uint8 srcbag, srcslot, dstbag;
recv_data >> srcbag >> srcslot >> dstbag;
// DEBUG_LOG("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 gray item state
_player->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
return;
}
_player->RemoveItem(srcbag, srcslot, true);
_player->StoreItem(dest, pItem, true);
}
bool WorldSession::CheckBanker(ObjectGuid guid)
{
// GM case
if (guid == GetPlayer()->GetObjectGuid())
{
// command case will return only if player have real access to command
if (!ChatHandler(GetPlayer()).FindCommand("bank"))
{
DEBUG_LOG("%s attempt open bank in cheating way.", guid.GetString().c_str());
return false;
}
}
// banker case
else
{
if (!GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_BANKER))
{
DEBUG_LOG("Banker %s not found or you can't interact with him.", guid.GetString().c_str());
return false;
}
}
return true;
}
void WorldSession::HandleBuyBankSlotOpcode(WorldPacket& recvPacket)
{
DEBUG_LOG("WORLD: CMSG_BUY_BANK_SLOT");
ObjectGuid guid;
recvPacket >> guid;
if (!CheckBanker(guid))
return;
uint32 slot = _player->GetBankBagSlotCount();
// next slot
++slot;
DETAIL_LOG("PLAYER: Buy bank bag slot, slot number = %u", slot);
BankBagSlotPricesEntry const* slotEntry = sBankBagSlotPricesStore.LookupEntry(slot);
if (!slotEntry)
return;
uint64 price = slotEntry->price;
if (_player->GetMoney() < price)
return;
_player->SetBankBagSlotCount(slot);
_player->ModifyMoney(-int64(price));
_player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT);
}
void WorldSession::HandleAutoBankItemOpcode(WorldPacket& recvPacket)
{
DEBUG_LOG("WORLD: CMSG_AUTOBANK_ITEM");
uint8 srcbag, srcslot;
recvPacket >> srcbag >> srcslot;
DEBUG_LOG("STORAGE: receive srcbag = %u, srcslot = %u", srcbag, srcslot);
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;
}
// no-op: placed in same slot
if (dest.size() == 1 && dest[0].pos == pItem->GetPos())
{
// just remove gray item state
_player->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
return;
}
_player->RemoveItem(srcbag, srcslot, true);
_player->BankItem(dest, pItem, true);
}
void WorldSession::HandleAutoStoreBankItemOpcode(WorldPacket& recvPacket)
{
DEBUG_LOG("WORLD: CMSG_AUTOSTORE_BANK_ITEM");
uint8 srcbag, srcslot;
recvPacket >> srcbag >> srcslot;
DEBUG_LOG("STORAGE: receive srcbag = %u, srcslot = %u", srcbag, srcslot);
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);
_player->StoreItem(dest, pItem, true);
}
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);
}
}
void WorldSession::HandleSetAmmoOpcode(WorldPacket& recv_data)
{
if (!GetPlayer()->isAlive())
{
GetPlayer()->SendEquipError(EQUIP_ERR_YOU_ARE_DEAD, NULL, NULL);
return;
}
DEBUG_LOG("WORLD: CMSG_SET_AMMO");
uint32 item;
recv_data >> item;
if (!item)
GetPlayer()->RemoveAmmo();
else
GetPlayer()->SetAmmo(item);
}
void WorldSession::SendEnchantmentLog(ObjectGuid targetGuid, ObjectGuid casterGuid, uint32 itemId, uint32 enchantId)
{
WorldPacket data(SMSG_ENCHANTMENTLOG, (8 + 8 + 4 + 4 + 1)); // last check 2.0.10
data << targetGuid.WriteAsPacked();
data << casterGuid.WriteAsPacked();
data << uint32(itemId);
data << uint32(enchantId);
SendPacket(&data);
}
void WorldSession::SendItemEnchantTimeUpdate(ObjectGuid playerGuid, ObjectGuid itemGuid, uint32 slot, uint32 duration)
{
// last check 2.0.10
WorldPacket data(SMSG_ITEM_ENCHANT_TIME_UPDATE, (8 + 4 + 4 + 8));
data << ObjectGuid(itemGuid);
data << uint32(slot);
data << uint32(duration);
data << ObjectGuid(playerGuid);
SendPacket(&data);
}
void WorldSession::HandleWrapItemOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("Received opcode CMSG_WRAP_ITEM");
uint8 gift_bag, gift_slot, item_bag, item_slot;
// recv_data.hexlike();
recv_data >> gift_bag >> gift_slot; // paper
recv_data >> item_bag >> item_slot; // item
DEBUG_LOG("WRAP: receive gift_bag = %u, gift_slot = %u, item_bag = %u, item_slot = %u", gift_bag, gift_slot, item_bag, item_slot);
Item* gift = _player->GetItemByPos(gift_bag, gift_slot);
if (!gift)
{
_player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
return;
}
// cheating: non-wrapper wrapper (all empty wrappers are stackable)
if (!(gift->GetProto()->Flags & ITEM_FLAG_WRAPPER) || gift->GetMaxStackCount() == 1)
{
_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;
}
if (item == gift) // not possible with packet 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->GetGuidValue(ITEM_FIELD_GIFTCREATOR)) // HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_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->GetProto()->MaxCount > 0)
{
_player->SendEquipError(EQUIP_ERR_UNIQUE_CANT_BE_WRAPPED, item, NULL);
return;
}
CharacterDatabase.BeginTransaction();
CharacterDatabase.PExecute("INSERT INTO character_gifts VALUES ('%u', '%u', '%u', '%u')", item->GetOwnerGuid().GetCounter(), item->GetGUIDLow(), item->GetEntry(), item->GetUInt32Value(ITEM_FIELD_FLAGS));
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->SetGuidValue(ITEM_FIELD_GIFTCREATOR, _player->GetObjectGuid());
item->SetUInt32Value(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_WRAPPED);
item->SetState(ITEM_CHANGED, _player);
if (item->GetState() == ITEM_NEW) // save new item, to have alway for `character_gifts` record in `item_instance`
{
// after save it will be impossible to remove the item from the queue
item->RemoveFromUpdateQueueOf(_player);
item->SaveToDB(); // item gave inventory record unchanged and can be save standalone
}
CharacterDatabase.CommitTransaction();
uint32 count = 1;
_player->DestroyItemCount(gift, count, true);
}
void WorldSession::HandleSocketOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: CMSG_SOCKET_GEMS");
ObjectGuid itemGuid;
ObjectGuid gemGuids[MAX_GEM_SOCKETS];
recv_data >> itemGuid;
if (!itemGuid.IsItem())
return;
for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
recv_data >> gemGuids[i];
// cheat -> tried to socket same gem multiple times
for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
{
ObjectGuid gemGuid = gemGuids[i];
if (!gemGuid)
continue;
if (!gemGuid.IsItem())
return;
for (int j = i + 1; j < MAX_GEM_SOCKETS; ++j)
if (gemGuids[j] == gemGuid)
return;
}
Item* itemTarget = _player->GetItemByGuid(itemGuid);
if (!itemTarget) // missing item to socket
return;
ItemPrototype const* itemProto = itemTarget->GetProto();
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] = gemGuids[i] ? _player->GetItemByGuid(gemGuids[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]->GetProto()->GemProperties) : NULL;
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;
// not first not-colored (not normally used) socket
if (i != 0 && !itemProto->Socket[i - 1].Color && (i + 1 >= MAX_GEM_SOCKETS || itemProto->Socket[i + 1].Color))
return;
// ok, this is first not colored socket for item with prismatic socket
}
// 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.
ItemPrototype const* iGemProto = Gems[i]->GetProto();
// unique item (for new and already placed bit removed enchantments
if (iGemProto->Flags & ITEM_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 not checked because if item have have-limit then it applied and to equip case
for (int j = 0; j < MAX_GEM_SOCKETS; ++j)
{
if (Gems[j])
{
// destroyed gem
if (OldEnchants[j])
{
if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
if (ItemPrototype const* jProto = ObjectMgr::GetItemPrototype(enchantEntry->GemID))
if (iGemProto->ItemLimitCategory == jProto->ItemLimitCategory)
--limit_newcount;
}
// new gem
if (iGemProto->ItemLimitCategory == Gems[j]->GetProto()->ItemLimitCategory)
++limit_newcount;
}
// existing gem
else if (OldEnchants[j])
{
if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
if (ItemPrototype const* jProto = ObjectMgr::GetItemPrototype(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, limit_newcount >= 0 ? 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])
{
uint32 count = 1;
itemTarget->SetEnchantment(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT + i), GemEnchants[i], 0, 0, _player->GetObjectGuid());
if (Item* guidItem = gemGuids[i] ? _player->GetItemByGuid(gemGuids[i]) : NULL)
_player->DestroyItemCount(guidItem, count, 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->GetProto()->socketBonus : 0), 0, 0, _player->GetObjectGuid());
_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)
itemTarget->SendUpdateSockets();
}
void WorldSession::HandleCancelTempEnchantmentOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: CMSG_CANCEL_TEMP_ENCHANTMENT");
uint32 eslot;
recv_data >> 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& recv_data)
{
DEBUG_LOG("WORLD: CMSG_ITEM_REFUND_INFO_REQUEST");
ObjectGuid itemGuid;
recv_data >> itemGuid;
Item* item = _player->GetItemByGuid(itemGuid);
if (!item)
{
DEBUG_LOG("Item refund: item not found!");
return;
}
if (!(item->GetProto()->Flags & ITEM_FLAG_REFUNDABLE))
{
DEBUG_LOG("Item refund: item not refundable!");
return;
}
// item refund system not implemented yet
}
/*
* 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& recv_data)
{
ObjectGuid itemGuid;
recv_data >> itemGuid;
DEBUG_LOG("CMSG_ITEM_TEXT_QUERY item guid: %u", itemGuid.GetCounter());
WorldPacket data(SMSG_ITEM_TEXT_QUERY_RESPONSE, (4 + 10)); // guess size
if (Item* item = _player->GetItemByGuid(itemGuid))
{
data << uint8(0); // has text
data << ObjectGuid(itemGuid); // item guid
data << item->GetText();
}
else
{
data << uint8(1); // no text
}
SendPacket(&data);
}
void WorldSession::SendItemDb2Reply(uint32 entry)
{
WorldPacket data(SMSG_DB_REPLY, 44);
ItemPrototype const* proto = sObjectMgr.GetItemPrototype(entry);
if (!proto)
{
data << uint32(-1); // entry
data << uint32(DB2_REPLY_ITEM);
data << uint32(time(NULL)); // hotfix date
data << uint32(0); // size of next block
SendPacket(&data);
return;
}
data << uint32(entry);
data << uint32(DB2_REPLY_ITEM);
data << uint32(sObjectMgr.GetHotfixDate(entry, DB2_REPLY_ITEM));
ByteBuffer buff;
buff << uint32(entry);
buff << uint32(proto->Class);
buff << uint32(proto->SubClass);
buff << int32(proto->Unk0);
buff << uint32(proto->Material);
buff << uint32(proto->DisplayInfoID);
buff << uint32(proto->InventoryType);
buff << uint32(proto->Sheath);
data << uint32(buff.size());
data.append(buff);
SendPacket(&data);
}
void WorldSession::SendItemSparseDb2Reply(uint32 entry)
{
WorldPacket data(SMSG_DB_REPLY, 526);
ItemPrototype const* proto = sObjectMgr.GetItemPrototype(entry);
if (!proto)
{
data << uint32(-1); // entry
data << uint32(DB2_REPLY_SPARSE);
data << uint32(time(NULL)); // hotfix date
data << uint32(0); // size of next block
SendPacket(&data);
return;
}
data << uint32(entry);
data << uint32(DB2_REPLY_SPARSE);
data << uint32(sObjectMgr.GetHotfixDate(entry, DB2_REPLY_SPARSE));
ByteBuffer buff;
buff << uint32(entry);
buff << uint32(proto->Quality);
buff << uint32(proto->Flags);
buff << uint32(proto->Flags2);
buff << float(proto->Unknown);
buff << float(proto->Unknown1);
buff << uint32(proto->BuyCount);
buff << int32(proto->BuyPrice);
buff << uint32(proto->SellPrice);
buff << uint32(proto->InventoryType);
buff << int32(proto->AllowableClass);
buff << int32(proto->AllowableRace);
buff << uint32(proto->ItemLevel);
buff << uint32(proto->RequiredLevel);
buff << uint32(proto->RequiredSkill);
buff << uint32(proto->RequiredSkillRank);
buff << uint32(proto->RequiredSpell);
buff << uint32(proto->RequiredHonorRank);
buff << uint32(proto->RequiredCityRank);
buff << uint32(proto->RequiredReputationFaction);
buff << uint32(proto->RequiredReputationRank);
buff << int32(proto->MaxCount);
buff << int32(proto->Stackable);
buff << uint32(proto->ContainerSlots);
for (uint32 x = 0; x < MAX_ITEM_PROTO_STATS; ++x)
buff << uint32(proto->ItemStat[x].ItemStatType);
for (uint32 x = 0; x < MAX_ITEM_PROTO_STATS; ++x)
buff << int32(proto->ItemStat[x].ItemStatValue);
for (uint32 x = 0; x < MAX_ITEM_PROTO_STATS; ++x)
buff << int32(proto->ItemStat[x].ItemStatType2);
for (uint32 x = 0; x < MAX_ITEM_PROTO_STATS; ++x)
buff << int32(proto->ItemStat[x].ItemStatValue2);
buff << uint32(proto->ScalingStatDistribution);
buff << uint32(proto->DamageType);
buff << uint32(proto->Delay);
buff << float(proto->RangedModRange);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << int32(proto->Spells[x].SpellId);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << uint32(proto->Spells[x].SpellTrigger);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << int32(proto->Spells[x].SpellCharges);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << int32(proto->Spells[x].SpellCooldown);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << uint32(proto->Spells[x].SpellCategory);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
buff << int32(proto->Spells[x].SpellCategoryCooldown);
buff << uint32(proto->Bonding);
// item name
std::string name = proto->Name1;
buff << uint16(name.length());
if (name.length())
buff << name;
for (uint32 i = 0; i < 3; ++i) // other 3 names
buff << uint16(0);
std::string desc = proto->Description;
buff << uint16(desc.length());
if (desc.length())
buff << desc;
buff << uint32(proto->PageText);
buff << uint32(proto->LanguageID);
buff << uint32(proto->PageMaterial);
buff << uint32(proto->StartQuest);
buff << uint32(proto->LockID);
buff << int32(proto->Material);
buff << uint32(proto->Sheath);
buff << int32(proto->RandomProperty);
buff << int32(proto->RandomSuffix);
buff << uint32(proto->ItemSet);
buff << uint32(proto->Area);
buff << uint32(proto->Map);
buff << uint32(proto->BagFamily);
buff << uint32(proto->TotemCategory);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SOCKETS; ++x)
buff << uint32(proto->Socket[x].Color);
for (uint32 x = 0; x < MAX_ITEM_PROTO_SOCKETS; ++x)
buff << uint32(proto->Socket[x].Content);
buff << uint32(proto->socketBonus);
buff << uint32(proto->GemProperties);
buff << float(proto->ArmorDamageModifier);
buff << int32(proto->Duration);
buff << uint32(proto->ItemLimitCategory);
buff << uint32(proto->HolidayId);
buff << float(proto->StatScalingFactor);
buff << uint32(proto->Unknown400_1);
buff << uint32(proto->Unknown400_2);
data << uint32(buff.size());
data.append(buff);
SendPacket(&data);
}
void WorldSession::SendReforgeResult(bool success)
{
WorldPacket data(SMSG_REFORGE_RESULT, 1);
data.WriteBit(success);
SendPacket(&data);
}
void WorldSession::HandleReforgeItemOpcode(WorldPacket& recvData)
{
uint32 slot, reforgeEntry;
ObjectGuid guid;
uint32 bag;
Player* player = GetPlayer();
recvData >> reforgeEntry >> slot >> bag;
recvData.ReadGuidMask<2, 6, 3, 4, 1, 0, 7, 5>(guid);
recvData.ReadGuidBytes<2, 3, 6, 4, 1, 0, 7, 5>(guid);
if (!player->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_REFORGER))
{
sLog.outDebug("WORLD: HandleReforgeItemOpcode - Unit (GUID: %s) not found or player can't interact with it.", guid.GetString().c_str());
SendReforgeResult(false);
return;
}
Item* item = player->GetItemByPos(bag, slot);
if (!item)
{
sLog.outDebug("WORLD: HandleReforgeItemOpcode - Player (Guid: %s) tried to reforge an invalid/non-existant item.", player->GetGuidStr().c_str());
SendReforgeResult(false);
return;
}
if (!reforgeEntry)
{
// Reset the item
if (item->IsEquipped())
player->ApplyReforgeEnchantment(item, false);
item->ClearEnchantment(REFORGE_ENCHANTMENT_SLOT);
SendReforgeResult(true);
return;
}
ItemReforgeEntry const* stats = sItemReforgeStore.LookupEntry(reforgeEntry);
if (!stats)
{
sLog.outDebug("WORLD: HandleReforgeItemOpcode - Player (Guid: %s) tried to reforge an item with invalid reforge entry (%u).", player->GetGuidStr().c_str(), reforgeEntry);
SendReforgeResult(false);
return;
}
if (!item->GetReforgableStat(ItemModType(stats->SourceStat)) || item->GetReforgableStat(ItemModType(stats->FinalStat))) // Cheating, you cant reforge to a stat that the item already has, nor reforge from a stat that the item does not have
{
SendReforgeResult(false);
return;
}
if (player->GetMoney() < uint64(item->GetSpecialPrice())) // cheating
{
SendReforgeResult(false);
return;
}
player->ModifyMoney(-int64(item->GetSpecialPrice()));
item->SetEnchantment(REFORGE_ENCHANTMENT_SLOT, reforgeEntry, 0, 0);
SendReforgeResult(true);
if (item->IsEquipped())
player->ApplyReforgeEnchantment(item, true);
}
Reference in a new issue View git blame Copy permalink