void WorldSession::HandleConfirmArtifactRespec(WorldPackets::Artifact::ConfirmArtifactRespec& confirmArtifactRespec)
{
if (!_player->GetNPCIfCanInteractWith(confirmArtifactRespec.NpcGUID, UNIT_NPC_FLAG_ARTIFACT_POWER_RESPEC))
return;
Item* artifact = _player->GetItemByGuid(confirmArtifactRespec.ArtifactGUID);
if (!artifact)
return;
uint64 xpCost = 0;
if (GtArtifactLevelXPEntry const* cost = sArtifactLevelXPGameTable.GetRow(artifact->GetTotalPurchasedArtifactPowers() + 1))
xpCost = uint64(artifact->GetModifier(ITEM_MODIFIER_ARTIFACT_TIER) == 1 ? cost->XP2 : cost->XP);
if (xpCost > artifact->GetUInt64Value(ITEM_FIELD_ARTIFACT_XP))
return;
uint64 newAmount = artifact->GetUInt64Value(ITEM_FIELD_ARTIFACT_XP) - xpCost;
for (uint32 i = 0; i <= artifact->GetTotalPurchasedArtifactPowers(); ++i)
if (GtArtifactLevelXPEntry const* cost = sArtifactLevelXPGameTable.GetRow(i))
newAmount += uint64(artifact->GetModifier(ITEM_MODIFIER_ARTIFACT_TIER) == 1 ? cost->XP2 : cost->XP);
for (ItemDynamicFieldArtifactPowers const& artifactPower : artifact->GetArtifactPowers())
{
uint8 oldPurchasedRank = artifactPower.PurchasedRank;
if (!oldPurchasedRank)
continue;
ItemDynamicFieldArtifactPowers newPower = artifactPower;
newPower.PurchasedRank -= oldPurchasedRank;
newPower.CurrentRankWithBonus -= oldPurchasedRank;
artifact->SetArtifactPower(&newPower);
if (artifact->IsEquipped())
if (ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(artifactPower.ArtifactPowerId, 0))
_player->ApplyArtifactPowerRank(artifact, artifactPowerRank, false);
}
for (ItemDynamicFieldArtifactPowers const& power : artifact->GetArtifactPowers())
{
ArtifactPowerEntry const* scaledArtifactPowerEntry = sArtifactPowerStore.AssertEntry(power.ArtifactPowerId);
if (!(scaledArtifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_SCALES_WITH_NUM_POWERS))
continue;
ArtifactPowerRankEntry const* scaledArtifactPowerRank = sDB2Manager.GetArtifactPowerRank(scaledArtifactPowerEntry->ID, 0);
if (!scaledArtifactPowerRank)
continue;
ItemDynamicFieldArtifactPowers newScaledPower = power;
newScaledPower.CurrentRankWithBonus = 0;
artifact->SetArtifactPower(&newScaledPower);
_player->ApplyArtifactPowerRank(artifact, scaledArtifactPowerRank, false);
}
artifact->SetUInt64Value(ITEM_FIELD_ARTIFACT_XP, newAmount);
artifact->SetState(ITEM_CHANGED, _player);
}
void WorldSession::HandleAuctionListBidderItems( WorldPacket & recv_data )
{
uint64 guid;
float unknownAuction;
recv_data >> guid;
recv_data >> unknownAuction;
WorldPacket data;
data.Initialize( SMSG_AUCTION_BIDDER_LIST_RESULT );
uint32 cnt = 0;
Player *pl = GetPlayer();
std::list<bidentry*>::iterator itr;
for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
{
AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
if ((ae) && (ae->auctioneer = GUID_LOPART(guid)))
{
cnt++;
}
}
if (cnt < 51)
{
data << cnt;
}
else
{
data << uint32(50);
}
uint32 cnter = 1;
for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
{
AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
if ((ae->auctioneer = GUID_LOPART(guid)) && (cnter < 51) && (ae))
{
data << ae->Id;
Item *it = objmgr.GetAItem(ae->item);
data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
data << uint32(1);
data << uint32(0);
data << uint32(0);
data << uint32(1);
data << uint32(0);
data << it->GetUInt64Value(ITEM_FIELD_OWNER);
data << ae->bid;
data << uint32(0);
data << ae->buyout;
data << uint32((ae->time - time(NULL)) * 1000);
data << uint64(0);
data << ae->bid;
cnter++;
}
}
data << cnt;
SendPacket(&data);
}
void WorldSession::HandleAuctionListOwnerItems( WorldPacket & recv_data )
{
WorldPacket data;
uint64 auctioneer;
recv_data >> auctioneer;
ObjectMgr::AuctionEntryMap::iterator itr;
uint32 cnt = 0;
Player *pl = GetPlayer();
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
if ((itr->second->auctioneer == GUID_LOPART(auctioneer)) && (itr->second->owner == pl->GetGUIDLow()))
{
cnt++;
}
}
Log::getSingleton().outString("sending owner list with %u items",cnt);
data.Initialize( SMSG_AUCTION_OWNER_LIST_RESULT );
if (cnt < 51)
{
data << uint32(cnt);
}
else
{
data << uint32(50);
}
uint32 cnter = 1;
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
if ((itr->second->auctioneer == GUID_LOPART(auctioneer)) && (itr->second->owner == pl->GetGUIDLow()) && (cnter < 51))
{
AuctionEntry *Aentry = itr->second;
data << Aentry->Id;
Log::getSingleton().outString("getting item with id %u",Aentry->item);
Item *it = objmgr.GetAItem(Aentry->item);
data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
data << uint32(0);
data << uint32(0);
data << uint32(0);
data << uint32(1);
data << uint32(0);
data << it->GetUInt64Value(ITEM_FIELD_OWNER);
data << Aentry->bid;
data << uint32(0);
data << Aentry->buyout;
data << uint32((Aentry->time - time(NULL)) * 1000);
data << uint32(Aentry->bidder);
data << uint32(0);
data << Aentry->bid;
cnter++;
}
}
data << cnt;
SendPacket(&data);
}
void WorldSession::HandleWrapItemOpcode(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "Received opcode CMSG_WRAP_ITEM");
uint8 gift_bag, gift_slot, item_bag, item_slot;
recvData >> gift_bag >> gift_slot; // paper
recvData >> item_bag >> item_slot; // item
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);
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;
}
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);
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(trans); // item gave inventory record unchanged and can be save standalone
}
CharacterDatabase.CommitTransaction(trans);
uint32 count = 1;
_player->DestroyItemCount(gift, count, true);
}
void WorldSession::HandleVoidStorageTransfer(WorldPacket& recvData)
{
SF_LOG_DEBUG("network", "WORLD: Received CMSG_VOID_STORAGE_TRANSFER");
Player* player = GetPlayer();
ObjectGuid npcGuid;
recvData.ReadGuidMask(npcGuid, 7, 4);
uint32 countDeposit = recvData.ReadBits(24); //40
if (countDeposit > 9)
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) wants to deposit more than 9 items (%u).", player->GetGUIDLow(), player->GetName().c_str(), countDeposit);
return;
}
std::vector<ObjectGuid> itemGuids(countDeposit);
for (uint32 i = 0; i < countDeposit; ++i)
{
recvData.ReadGuidMask(itemGuids[i], 0, 3, 6, 5, 4, 2, 1, 7);
}
uint32 countWithdraw = recvData.ReadBits(24);
if (countWithdraw > 9)
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) wants to withdraw more than 9 items (%u).", player->GetGUIDLow(), player->GetName().c_str(), countWithdraw);
return;
}
std::vector<ObjectGuid> itemIds(countWithdraw);
for (uint32 i = 0; i < countWithdraw; ++i)
{
recvData.ReadGuidMask(itemIds[i], 4, 0, 5, 7, 6, 1, 2, 3);
}
recvData.ReadGuidMask(npcGuid, 6, 0, 3, 1, 2, 5);
for (uint32 i = 0; i < countDeposit; ++i)
{
recvData.ReadGuidBytes(itemGuids[i], 5, 6, 3, 4, 1, 7, 2, 0);
}
recvData.ReadGuidBytes(npcGuid, 5);
for (uint32 i = 0; i < countWithdraw; ++i)
{
recvData.ReadGuidBytes(itemIds[i], 0, 4, 1, 2, 6, 3, 7, 5);
}
recvData.ReadGuidBytes(npcGuid, 1, 7, 4, 3, 2, 0, 6);
Creature* unit = player->GetNPCIfCanInteractWith(npcGuid, UNIT_NPC_FLAG_VAULTKEEPER);
if (!unit)
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Unit (GUID: %u) not found or player can't interact with it.", GUID_LOPART(npcGuid));
return;
}
if (!player->IsVoidStorageUnlocked())
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) queried void storage without unlocking it.", player->GetGUIDLow(), player->GetName().c_str());
return;
}
if (itemGuids.size() > player->GetNumOfVoidStorageFreeSlots())
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_FULL);
return;
}
uint32 freeBagSlots = 0;
if (itemIds.size() != 0)
{
// make this a Player function
for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
if (Bag* bag = player->GetBagByPos(i))
freeBagSlots += bag->GetFreeSlots();
for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
if (!player->GetItemByPos(INVENTORY_SLOT_BAG_0, i))
++freeBagSlots;
}
if (itemIds.size() > freeBagSlots)
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
return;
}
if (!player->HasEnoughMoney(uint64(itemGuids.size() * VOID_STORAGE_STORE_ITEM)))
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NOT_ENOUGH_MONEY);
return;
}
std::pair<VoidStorageItem, uint8> depositItems[VOID_STORAGE_MAX_DEPOSIT];
uint8 depositCount = 0;
for (std::vector<ObjectGuid>::iterator itr = itemGuids.begin(); itr != itemGuids.end(); ++itr)
{
Item* item = player->GetItemByGuid(*itr);
if (!item)
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) wants to deposit an invalid item (item guid: " UI64FMTD ").", player->GetGUIDLow(), player->GetName().c_str(), uint64(*itr));
continue;
}
VoidStorageItem itemVS(sObjectMgr->GenerateVoidStorageItemId(), item->GetEntry(), item->GetUInt64Value(ITEM_FIELD_CREATOR), item->GetItemRandomPropertyId(), item->GetItemSuffixFactor());
uint8 slot = player->AddVoidStorageItem(itemVS);
depositItems[depositCount++] = std::make_pair(itemVS, slot);
player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
}
int64 cost = depositCount * VOID_STORAGE_STORE_ITEM;
player->ModifyMoney(-cost);
VoidStorageItem withdrawItems[VOID_STORAGE_MAX_WITHDRAW];
uint8 withdrawCount = 0;
for (std::vector<ObjectGuid>::iterator itr = itemIds.begin(); itr != itemIds.end(); ++itr)
{
uint8 slot;
VoidStorageItem* itemVS = player->GetVoidStorageItem(*itr, slot);
if (!itemVS)
{
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) tried to withdraw an invalid item (id: " UI64FMTD ")", player->GetGUIDLow(), player->GetName().c_str(), uint64(*itr));
continue;
}
ItemPosCountVec dest;
InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemVS->ItemEntry, 1);
if (msg != EQUIP_ERR_OK)
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
SF_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (GUID: %u, name: %s) couldn't withdraw item id " UI64FMTD " because inventory was full.", player->GetGUIDLow(), player->GetName().c_str(), uint64(*itr));
return;
}
Item* item = player->StoreNewItem(dest, itemVS->ItemEntry, true, itemVS->ItemRandomPropertyId);
item->SetUInt64Value(ITEM_FIELD_CREATOR, uint64(itemVS->CreatorGuid));
item->SetBinding(true);
player->SendNewItem(item, 1, false, false, false);
withdrawItems[withdrawCount++] = *itemVS;
player->DeleteVoidStorageItem(slot);
}
WorldPacket data(SMSG_VOID_STORAGE_TRANSFER_CHANGES, ((5 + 5 + (7 + 7) * depositCount +
7 * withdrawCount) / 8) + 7 * withdrawCount + (7 + 7 + 4 * 4) * depositCount);
data.WriteBits(withdrawCount, 4);
for (uint8 i = 0; i < withdrawCount; ++i)
{
ObjectGuid itemId = withdrawItems[i].ItemId;
data.WriteGuidMask(itemId, 1, 6, 7, 3, 2, 0, 4, 5);
}
data.WriteBits(depositCount, 4);
for (uint8 i = 0; i < depositCount; ++i)
{
ObjectGuid itemId = depositItems[i].first.ItemId;
ObjectGuid creatorGuid = depositItems[i].first.CreatorGuid;
data.WriteGuidMask(itemId, 0);
data.WriteGuidMask(creatorGuid, 6, 4);
data.WriteGuidMask(itemId, 3);
data.WriteGuidMask(creatorGuid, 3);
data.WriteGuidMask(itemId, 5, 7);
data.WriteGuidMask(creatorGuid, 0, 5, 7);
data.WriteGuidMask(itemId, 6, 4);
data.WriteGuidMask(creatorGuid, 1);
data.WriteGuidMask(itemId, 1);
data.WriteGuidMask(creatorGuid, 2);
}
data.FlushBits();
for (uint8 i = 0; i < depositCount; ++i)
{
ObjectGuid itemId = depositItems[i].first.ItemId;
ObjectGuid creatorGuid = depositItems[i].first.CreatorGuid;
data << uint32(depositItems[i].second); // slot
data.WriteGuidBytes(creatorGuid, 5);
data << uint32(depositItems[i].first.ItemEntry);
data.WriteGuidBytes(creatorGuid, 6, 3);
data << uint32(depositItems[i].first.ItemSuffixFactor);
data.WriteGuidBytes(creatorGuid, 2);
data.WriteGuidBytes(itemId, 5);
data << uint32(depositItems[i].first.ItemRandomPropertyId);
data.WriteGuidBytes(itemId, 3);
data.WriteGuidBytes(creatorGuid, 7, 4, 1);
data.WriteGuidBytes(itemId, 0, 4, 6);
data << uint32(0); // unk
data.WriteGuidBytes(itemId, 1, 2);
data.WriteGuidBytes(creatorGuid, 0);
data.WriteGuidBytes(itemId, 7);
}
for (uint8 i = 0; i < withdrawCount; ++i)
{
ObjectGuid itemId = withdrawItems[i].ItemId;
data.WriteGuidBytes(itemId, 7, 3, 1, 5, 4, 0, 6, 2);
}
SendPacket(&data);
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NO_ERROR);
}
void WorldSession::HandleWrapItemOpcode(WorldPacket& recv_data)
{
CHECK_PACKET_SIZE(recv_data,1+1+1+1);
sLog.outDebug("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
sLog.outDebug("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;
}
if(!gift->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_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;
}
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->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')", GUID_LOPART(item->GetOwnerGUID()), 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->SetUInt64Value(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
item->SetUInt32Value(ITEM_FIELD_FLAGS, ITEM_FLAGS_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::SendUpdateTrade(bool trader_data /*= true*/)
{
TradeData* view_trade = trader_data ? _player->GetTradeData()->GetTraderData() : _player->GetTradeData();
ByteBuffer itemData(7*2 + 7*4 + 3*4 + 3*4 + 1);
uint8 count = 0;
for (uint8 i = 0; i < TRADE_SLOT_COUNT; ++i)
if (view_trade->GetItem(TradeSlots(i)))
++count;
WorldPacket data(SMSG_TRADE_STATUS_EXTENDED, 4*6 + 8 + 1 + 3 + count * 70);
data << uint32(0); // this value must be equal to value from TRADE_STATUS_OPEN_WINDOW status packet (different value for different players to block multiple trades?)
data << uint32(0); // unk 2
data << uint64(view_trade->GetMoney()); // trader gold
data << uint32(view_trade->GetSpell()); // spell casted on lowest slot item
data << uint32(TRADE_SLOT_COUNT); // trade slots count/number?, = next field in most cases
data << uint32(0); // unk 5
data << uint8(trader_data); // 1 means traders data, 0 means own
data << uint32(TRADE_SLOT_COUNT); // trade slots count/number?, = prev field in most cases
data.WriteBits(count, 22);
for (uint8 i = 0; i < TRADE_SLOT_COUNT; ++i)
{
Item* item = view_trade->GetItem(TradeSlots(i));
if (!item)
continue;
ObjectGuid giftCreatorGuid = item->GetUInt64Value(ITEM_FIELD_GIFTCREATOR);
ObjectGuid creatorGuid = item->GetUInt64Value(ITEM_FIELD_CREATOR);
data.WriteBit(giftCreatorGuid[7]);
data.WriteBit(giftCreatorGuid[1]);
bool notWrapped = data.WriteBit(!item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_WRAPPED));
data.WriteBit(giftCreatorGuid[3]);
if (notWrapped)
{
data.WriteBit(creatorGuid[7]);
data.WriteBit(creatorGuid[1]);
data.WriteBit(creatorGuid[4]);
data.WriteBit(creatorGuid[6]);
data.WriteBit(creatorGuid[2]);
data.WriteBit(creatorGuid[3]);
data.WriteBit(creatorGuid[5]);
data.WriteBit(item->GetTemplate()->LockID != 0);
data.WriteBit(creatorGuid[0]);
itemData.WriteByteSeq(creatorGuid[1]);
itemData << uint32(item->GetEnchantmentId(PERM_ENCHANTMENT_SLOT));
for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS /*3*/; ++enchant_slot)
itemData << uint32(item->GetEnchantmentId(EnchantmentSlot(enchant_slot)));
itemData << uint32(item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY));
itemData.WriteByteSeq(creatorGuid[6]);
itemData.WriteByteSeq(creatorGuid[2]);
itemData.WriteByteSeq(creatorGuid[7]);
itemData.WriteByteSeq(creatorGuid[4]);
itemData << uint32(item->GetEnchantmentId(REFORGE_ENCHANTMENT_SLOT));
itemData << uint32(item->GetUInt32Value(ITEM_FIELD_DURABILITY));
itemData << uint32(item->GetItemRandomPropertyId());
itemData.WriteByteSeq(creatorGuid[3]);
itemData << uint32(0); // unk7
itemData.WriteByteSeq(creatorGuid[0]);
itemData << uint32(item->GetSpellCharges());
itemData << uint32(item->GetItemSuffixFactor());
itemData.WriteByteSeq(creatorGuid[5]);
}
data.WriteBit(giftCreatorGuid[6]);
data.WriteBit(giftCreatorGuid[4]);
data.WriteBit(giftCreatorGuid[2]);
data.WriteBit(giftCreatorGuid[0]);
data.WriteBit(giftCreatorGuid[5]);
itemData.WriteByteSeq(giftCreatorGuid[6]);
itemData.WriteByteSeq(giftCreatorGuid[1]);
itemData.WriteByteSeq(giftCreatorGuid[7]);
itemData.WriteByteSeq(giftCreatorGuid[4]);
itemData << uint32(item->GetTemplate()->ItemId);
itemData.WriteByteSeq(giftCreatorGuid[0]);
itemData << uint32(item->GetCount());
itemData.WriteByteSeq(giftCreatorGuid[5]);
itemData << uint8(i);
itemData.WriteByteSeq(giftCreatorGuid[2]);
itemData.WriteByteSeq(giftCreatorGuid[3]);
}
data.FlushBits();
data.append(itemData);
SendPacket(&data);
}
void WorldSession::SendUpdateTrade()
{
Item *item = NULL;
if( !_player || !_player->pTrader )
return;
// reset trade status
if (_player->acceptTrade)
{
_player->acceptTrade = false;
SendTradeStatus(TRADE_STATUS_BACK_TO_TRADE);
}
if (_player->pTrader->acceptTrade)
{
_player->pTrader->acceptTrade = false;
_player->pTrader->GetSession()->SendTradeStatus(TRADE_STATUS_BACK_TO_TRADE);
}
WorldPacket data(SMSG_TRADE_STATUS_EXTENDED, (100)); // guess size
data << (uint8 ) 1; // can be different (only seen 0 and 1)
data << (uint32) 0; // added in 2.4.0, this value must be equal to value from TRADE_STATUS_OPEN_WINDOW status packet (different value for different players to block multiple trades?)
data << (uint32) TRADE_SLOT_COUNT; // trade slots count/number?, = next field in most cases
data << (uint32) TRADE_SLOT_COUNT; // trade slots count/number?, = prev field in most cases
data << (uint32) _player->pTrader->tradeGold; // trader gold
data << (uint32) 0; // spell casted on lowest slot item
for (uint8 i = 0; i < TRADE_SLOT_COUNT; ++i)
{
item = (_player->pTrader->tradeItems[i] != NULL_SLOT ? _player->pTrader->GetItemByPos( _player->pTrader->tradeItems[i] ) : NULL);
data << (uint8) i; // trade slot number, if not specified, then end of packet
if(item)
{
data << (uint32) item->GetProto()->ItemId; // entry
// display id
data << (uint32) item->GetProto()->DisplayInfoID;
// stack count
data << (uint32) item->GetUInt32Value(ITEM_FIELD_STACK_COUNT);
data << (uint32) 0; // probably gift=1, created_by=0?
// gift creator
data << (uint64) item->GetUInt64Value(ITEM_FIELD_GIFTCREATOR);
data << (uint32) item->GetEnchantmentId(PERM_ENCHANTMENT_SLOT);
for (uint8 j = 0; j < 3; ++j)
data << (uint32) 0; // enchantment id (permanent/gems?)
// creator
data << (uint64) item->GetUInt64Value(ITEM_FIELD_CREATOR);
data << (uint32) item->GetSpellCharges(); // charges
data << (uint32) item->GetItemSuffixFactor(); // SuffixFactor
// random properties id
data << (uint32) item->GetItemRandomPropertyId();
data << (uint32) item->GetProto()->LockID; // lock id
// max durability
data << (uint32) item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY);
// durability
data << (uint32) item->GetUInt32Value(ITEM_FIELD_DURABILITY);
}
else
{
for (uint8 j = 0; j < 18; j++)
data << uint32(0);
}
}
SendPacket(&data);
}
void WorldSession::HandleAuctionPlaceBid( WorldPacket & recv_data )
{
uint64 auctioneer;
uint32 auction,price;
WorldPacket data;
recv_data >> auctioneer;
recv_data >> auction >> price;
AuctionEntry *ah = objmgr.GetAuction(auction);
Player *pl = GetPlayer();
if ((ah) && (ah->owner != pl->GetGUIDLow()))
{
if ((price < ah->buyout) || (ah->buyout == 0))
{
Mail* n = new Mail;
n->messageID = objmgr.GenerateMailID();
n->sender = ah->owner;
n->reciever = ah->bidder;
n->subject = "You have lost a bid";
n->body = "";
n->item = 0;
n->money = ah->bid;
n->time = time(NULL) + (30 * 3600);
n->COD = 0;
n->checked = 0;
uint64 rc;
GUID_LOPART(rc) = ah->bidder;
GUID_HIPART(rc) = 0;
std::string name;
objmgr.GetPlayerNameByGUID(rc,name);
Player *rpl = objmgr.GetPlayer(name.c_str());
std::stringstream ss;
ss << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
n->messageID << ", " << n->sender << ", " << n->reciever << ",' " << n->subject.c_str() << "' ,' " <<
n->body.c_str() << "', " << n->item << ", " << n->time << ", " << n->money << ", " << n->COD << ", " << n->checked << " )";
sDatabase.Execute( ss.str().c_str( ) );
if (rpl)
{
rpl->AddMail(n);
}
ah->bidder = pl->GetGUIDLow();
ah->bid = price;
objmgr.RemoveAuction(ah->Id);
objmgr.AddAuction(ah);
bidentry *be = new bidentry;
be->AuctionID = auction;
be->amt = price;
pl->SetUInt32Value(PLAYER_FIELD_COINAGE,(pl->GetUInt32Value(PLAYER_FIELD_COINAGE) - price));
bidentry *bo = pl->GetBid(auction);
if (bo)
{
Mail* m = new Mail;
m->messageID = objmgr.GenerateMailID();
m->sender = ah->owner;
m->reciever = pl->GetGUIDLow();
m->subject = "You have lost a bid";
m->body = "";
m->item = 0;
m->money = bo->amt;
m->time = time(NULL) + (30 * 3600);
m->COD = 0;
m->checked = 0;
pl->AddMail(m);
}
pl->AddBid(be);
uint64 guid = auctioneer;
data.Initialize( SMSG_AUCTION_BIDDER_LIST_RESULT );
uint32 cnt = 0;
std::list<bidentry*>::iterator itr;
for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
{
AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
if (ae->auctioneer = GUID_LOPART(guid))
{
cnt++;
}
}
if (cnt < 51)
{
data << cnt;
}
else
{
data << uint32(50);
}
uint32 cnter = 1;
for (itr = pl->GetBidBegin(); itr != pl->GetBidEnd(); itr++)
{
AuctionEntry *ae = objmgr.GetAuction((*itr)->AuctionID);
if ((ae->auctioneer = GUID_LOPART(guid)) && (cnter < 33))
{
data << ae->Id;
Item *it = objmgr.GetAItem(ae->item);
data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
data << uint32(0);
data << uint32(0);
data << uint32(0);
data << uint32(1);
data << uint32(0);
data << it->GetUInt64Value(ITEM_FIELD_OWNER);
data << ae->bid;
data << uint32(0);
data << ae->buyout;
data << uint32((ae->time - time(NULL)) * 1000);
data << uint64(0);
data << ae->bid;
cnter++;
}
}
data << cnt;
SendPacket(&data);
data.clear();
data.Initialize( SMSG_AUCTION_LIST_RESULT );
data << uint32(0);
data << uint32(0);
SendPacket(&data);
}
else
{
pl->SetUInt32Value(PLAYER_FIELD_COINAGE,(pl->GetUInt32Value(PLAYER_FIELD_COINAGE) - ah->buyout));
Mail *m = new Mail;
m->messageID = objmgr.GenerateMailID();
m->sender = ah->owner;
m->reciever = pl->GetGUIDLow();
m->subject = "You won an item!";
m->body = "";
m->checked = 0;
m->COD = 0;
m->money = 0;
m->item = ah->item;
m->time = time(NULL) + (29 * 3600);
Item *it = objmgr.GetAItem(ah->item);
objmgr.AddMItem(it);
std::stringstream ss;
ss << "INSERT INTO mailed_items (guid, data) VALUES ("
<< it->GetGUIDLow() << ", '"; // TODO: use full guids
for(uint16 i = 0; i < it->GetValuesCount(); i++ )
{
ss << it->GetUInt32Value(i) << " ";
}
ss << "' )";
sDatabase.Execute( ss.str().c_str() );
std::stringstream md;
// TODO: use full guids
md << "DELETE FROM mail WHERE mailID = " << m->messageID;
sDatabase.Execute( md.str().c_str( ) );
std::stringstream mi;
mi << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
m->messageID << ", " << pl->GetGUIDLow() << ", " << m->reciever << ",' " << m->subject.c_str() << "' ,' " <<
m->body.c_str() << "', " << m->item << ", " << m->time << ", " << m->money << ", " << 0 << ", " << m->checked << " )";
sDatabase.Execute( mi.str().c_str( ) );
uint64 rcpl;
GUID_LOPART(rcpl) = m->reciever;
GUID_HIPART(rcpl) = 0;
std::string pname;
objmgr.GetPlayerNameByGUID(rcpl,pname);
Player *rpl = objmgr.GetPlayer(pname.c_str());
if (rpl)
{
rpl->AddMail(m);
}
std::stringstream delinvq;
std::stringstream id;
std::stringstream bd;
// TODO: use full guids
delinvq << "DELETE FROM auctionhouse WHERE itemowner = " << ah->owner;
sDatabase.Execute( delinvq.str().c_str( ) );
// TODO: use full guids
id << "DELETE FROM auctioned_items WHERE guid = " << ah->item;
sDatabase.Execute( id.str().c_str( ) );
// TODO: use full guids
bd << "DELETE FROM bids WHERE Id = " << ah->Id;
sDatabase.Execute( bd.str().c_str( ) );
data.Initialize( SMSG_AUCTION_LIST_RESULT );
data << uint32(0);
data << uint32(0);
SendPacket(&data);
Mail *mn = new Mail;
mn->messageID = objmgr.GenerateMailID();
mn->sender = ah->bidder;
mn->reciever = ah->owner;
mn->subject = "Your item sold!";
mn->body = "";
mn->checked = 0;
mn->COD = 0;
mn->money = ah->bid;
mn->item = 0;
mn->time = time(NULL) + (29 * 3600);
std::stringstream mdn;
// TODO: use full guids
mdn << "DELETE FROM mail WHERE mailID = " << mn->messageID;
sDatabase.Execute( mdn.str().c_str( ) );
std::stringstream min;
min << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,time,money,COD,checked) VALUES ( " <<
mn->messageID << ", " << mn->sender << ", " << mn->reciever << ",' " << mn->subject.c_str() << "' ,' " <<
mn->body.c_str() << "', " << mn->item << ", " << mn->time << ", " << mn->money << ", " << 0 << ", " << mn->checked << " )";
sDatabase.Execute( min.str().c_str( ) );
uint64 rcpln;
GUID_LOPART(rcpln) = mn->reciever;
GUID_HIPART(rcpln) = 0;
std::string pnamen;
objmgr.GetPlayerNameByGUID(rcpln,pnamen);
Player *rpln = objmgr.GetPlayer(pnamen.c_str());
if (rpln)
{
rpln->AddMail(mn);
}
objmgr.RemoveAItem(ah->item);
objmgr.RemoveAuction(ah->Id);
}
}
}
void WorldSession::HandleAuctionListItems( WorldPacket & recv_data )
{
std::string auctionString;
uint8 levelRange1, levelRange2, usableCheck;
uint32 cnt, guidhigh, guidlow, unk1, auctionSlotID, auctionMainCatagory, auctionSubCatagory, rarityCheck;
recv_data >> guidhigh >> guidlow;
recv_data >> unk1;
recv_data >> auctionString;
recv_data >> levelRange1 >> levelRange2;
recv_data >> auctionSlotID >> auctionMainCatagory >> auctionSubCatagory;
recv_data >> rarityCheck >> usableCheck;
Log::getSingleton( ).outBasic("%s",auctionString.c_str( ) );
Log::getSingleton( ).outBasic("\n unkAuction = %u\n Level Start = %u\n Level End = %u\n auctionSlotID = %u\n auctionMainCatagory = %u\n auctionSubCatagory = %u\n rarityCheck = %u\n usableCheck = %u\n", unk1, levelRange1, levelRange2, auctionSlotID, auctionMainCatagory, auctionSubCatagory, rarityCheck, usableCheck);
WorldPacket data;
ObjectMgr::AuctionEntryMap::iterator itr;
cnt = 0;
if (levelRange2 == 0)
{
levelRange2 = 100;
}
uint32 tempcat1, tempcat2, temprarity, tempslot;
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
AuctionEntry *Aentry = itr->second;
Item *it = objmgr.GetAItem(Aentry->item);
tempcat1 = auctionMainCatagory;
tempcat2 = auctionSubCatagory;
temprarity = rarityCheck;
tempslot = auctionSlotID;
if (auctionMainCatagory == (0xffffffff))
{
auctionMainCatagory = it->GetProto()->Class;
}
if (auctionSlotID == (0xffffffff))
{
auctionSlotID = it->GetProto()->InventoryType;
}
if (rarityCheck == (0xffffffff))
{
rarityCheck = it->GetProto()->Quality;
}
if (auctionSubCatagory == (0xffffffff))
{
auctionSubCatagory = it->GetProto()->SubClass;
}
if ((it->GetProto()->InventoryType == auctionSlotID) &&(it->GetProto()->Quality == rarityCheck) && (it->GetProto()->ItemLevel >= levelRange1) && (it->GetProto()->ItemLevel <= levelRange2) && (it->GetProto()->Class == auctionMainCatagory) && (it->GetProto()->SubClass == auctionSubCatagory))
{
cnt++;
}
auctionMainCatagory = tempcat1;
auctionSubCatagory = tempcat2;
rarityCheck = temprarity;
auctionSlotID = tempslot;
tempcat1 = NULL;
tempcat2 = NULL;
temprarity = NULL;
tempslot = NULL;
}
data.Initialize( SMSG_AUCTION_LIST_RESULT );
if (cnt < 33)
{
data << uint32(cnt);
}
else
{
data << uint32(32);
}
uint32 cnter = 1;
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
AuctionEntry *Aentry = itr->second;
Item *it = objmgr.GetAItem(Aentry->item);
tempcat1 = auctionMainCatagory;
tempcat2 = auctionSubCatagory;
temprarity = rarityCheck;
tempslot = auctionSlotID;
if (auctionMainCatagory == (0xffffffff))
{
auctionMainCatagory = it->GetProto()->Class;
}
if (auctionSubCatagory == (0xffffffff))
{
auctionSubCatagory = it->GetProto()->SubClass;
}
if (rarityCheck == (0xffffffff))
{
rarityCheck = it->GetProto()->Quality;
}
if (auctionSlotID == (0xffffffff))
{
auctionSlotID = it->GetProto()->InventoryType;
}
if ((cnter < 33) && (it->GetProto()->InventoryType == auctionSlotID) &&(it->GetProto()->Quality == rarityCheck) && (it->GetProto()->ItemLevel >= levelRange1) && (it->GetProto()->ItemLevel <= levelRange2) && (it->GetProto()->Class == auctionMainCatagory) && (it->GetProto()->SubClass == auctionSubCatagory))
{
data << Aentry->Id;
data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
data << uint32(0);
data << uint32(0);
data << uint32(0);
data << uint32(1);
data << uint32(0);
data << it->GetUInt64Value(ITEM_FIELD_OWNER);
data << Aentry->bid;
data << uint32(0);
data << Aentry->buyout;
data << uint32((Aentry->time - time(NULL)) * 1000);
data << uint32(Aentry->bidder);
data << uint32(0);
data << Aentry->bid;
cnter++;
}
auctionMainCatagory = tempcat1;
auctionSubCatagory = tempcat2;
rarityCheck = temprarity;
auctionSlotID = tempslot;
tempcat1 = NULL;
tempcat2 = NULL;
temprarity = NULL;
tempslot = NULL;
}
data << uint32(cnt);
SendPacket(&data);
}
void WorldSession::HandleAuctionSellItem( WorldPacket & recv_data )
{
uint64 auctioneer, item;
uint32 etime, bid, buyout;
recv_data >> auctioneer >> item;
recv_data >> bid >> buyout >> etime;
Player *pl = GetPlayer();
AuctionEntry *AH = new AuctionEntry;
AH->auctioneer = GUID_LOPART(auctioneer);
AH->item = GUID_LOPART(item);
AH->owner = pl->GetGUIDLow();
AH->bid = bid;
AH->bidder = 0;
AH->buyout = buyout;
time_t base = time(NULL);
AH->time = ((time_t)(etime * 60)) + base;
//AH->time = base + 300;
AH->Id = objmgr.GenerateAuctionID();
Log::getSingleton().outString("selling item %u to auctioneer %u with inital bid %u with buyout %u and with time %u (in minutes)",GUID_LOPART(item),GUID_LOPART(auctioneer),bid,buyout,time);
objmgr.AddAuction(AH);
uint32 slot = pl->GetSlotByItemGUID(item);
Item *it = pl->GetItemBySlot((uint8)slot);
objmgr.AddAItem(it);
std::stringstream ss;
ss << "INSERT INTO auctioned_items (guid, data) VALUES ("
<< it->GetGUIDLow() << ", '"; // TODO: use full guids
for(uint16 i = 0; i < it->GetValuesCount(); i++ )
{
ss << it->GetUInt32Value(i) << " ";
}
ss << "' )";
sDatabase.Execute( ss.str().c_str() );
pl->RemoveItemFromSlot((uint8)slot);
WorldPacket data;
ObjectMgr::AuctionEntryMap::iterator itr;
uint32 cnt = 0;
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
if ((itr->second->auctioneer == GUID_LOPART(auctioneer)) && (itr->second->owner == pl->GetGUIDLow()))
{
cnt++;
}
}
Log::getSingleton().outString("sending owner list with %u items",cnt);
data.Initialize( SMSG_AUCTION_OWNER_LIST_RESULT );
if (cnt < 51)
{
data << uint32(cnt);
}
else
{
data << uint32(50);
}
uint32 cnter = 1;
for (itr = objmgr.GetAuctionsBegin();itr != objmgr.GetAuctionsEnd();itr++)
{
if ((itr->second->auctioneer == GUID_LOPART(auctioneer)) && (itr->second->owner == pl->GetGUIDLow()) && (cnter < 51))
{
AuctionEntry *Aentry = itr->second;
data << Aentry->Id;
Item *it = objmgr.GetAItem(Aentry->item);
data << it->GetUInt32Value(OBJECT_FIELD_ENTRY);
data << uint32(0);
data << uint32(0);
data << uint32(0);
data << uint32(1);
data << uint32(0);
data << it->GetUInt64Value(ITEM_FIELD_OWNER);
data << Aentry->bid;
data << uint32(0);
data << Aentry->buyout;
time_t base = time(NULL);
data << uint32((Aentry->time - base) * 1000);
data << uint64(0);
data << Aentry->bid;
cnter++;
}
}
data << cnt;
SendPacket(&data);
}
void WorldSession::HandleVoidStorageTransfer(WorldPacket& recvData)
{
Player* player = GetPlayer();
// Read everything
ObjectGuid npcGuid;
recvData.ReadByteMask(npcGuid[1]);
uint32 countDeposit = recvData.ReadBits(26);
if (countDeposit > 9)
return;
std::vector<ObjectGuid> itemGuids(countDeposit);
for (uint32 i = 0; i < countDeposit; ++i)
{
recvData
.ReadByteMask(itemGuids[i][4])
.ReadByteMask(itemGuids[i][6])
.ReadByteMask(itemGuids[i][7])
.ReadByteMask(itemGuids[i][0])
.ReadByteMask(itemGuids[i][1])
.ReadByteMask(itemGuids[i][5])
.ReadByteMask(itemGuids[i][3])
.ReadByteMask(itemGuids[i][2]);
}
recvData
.ReadByteMask(npcGuid[2])
.ReadByteMask(npcGuid[0])
.ReadByteMask(npcGuid[3])
.ReadByteMask(npcGuid[5])
.ReadByteMask(npcGuid[6])
.ReadByteMask(npcGuid[4]);
uint32 countWithdraw = recvData.ReadBits(26);
if (countWithdraw > 9)
return;
std::vector<ObjectGuid> itemIds(countWithdraw);
for (uint32 i = 0; i < countWithdraw; ++i)
{
recvData
.ReadByteMask(itemIds[i][4])
.ReadByteMask(itemIds[i][7])
.ReadByteMask(itemIds[i][1])
.ReadByteMask(itemIds[i][0])
.ReadByteMask(itemIds[i][2])
.ReadByteMask(itemIds[i][3])
.ReadByteMask(itemIds[i][5])
.ReadByteMask(itemIds[i][6]);
}
recvData.ReadByteMask(npcGuid[7]);
for (uint32 i = 0; i < countDeposit; ++i)
{
recvData
.ReadByteSeq(itemGuids[i][6])
.ReadByteSeq(itemGuids[i][1])
.ReadByteSeq(itemGuids[i][0])
.ReadByteSeq(itemGuids[i][2])
.ReadByteSeq(itemGuids[i][4])
.ReadByteSeq(itemGuids[i][5])
.ReadByteSeq(itemGuids[i][3])
.ReadByteSeq(itemGuids[i][7]);
}
recvData.ReadByteSeq(npcGuid[5]);
recvData.ReadByteSeq(npcGuid[6]);
for (uint32 i = 0; i < countWithdraw; ++i)
{
recvData
.ReadByteSeq(itemIds[i][3])
.ReadByteSeq(itemIds[i][0])
.ReadByteSeq(itemIds[i][1])
.ReadByteSeq(itemIds[i][6])
.ReadByteSeq(itemIds[i][2])
.ReadByteSeq(itemIds[i][7])
.ReadByteSeq(itemIds[i][5])
.ReadByteSeq(itemIds[i][4]);
}
recvData
.ReadByteSeq(npcGuid[1])
.ReadByteSeq(npcGuid[4])
.ReadByteSeq(npcGuid[7])
.ReadByteSeq(npcGuid[3])
.ReadByteSeq(npcGuid[2])
.ReadByteSeq(npcGuid[0]);
Creature* unit = player->GetNPCIfCanInteractWith(npcGuid, UNIT_NPC_FLAG_VAULTKEEPER);
if (!unit)
return;
if (!player->IsVoidStorageUnlocked())
return;
if (itemGuids.size() > player->GetNumOfVoidStorageFreeSlots())
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_FULL);
return;
}
uint32 freeBagSlots = 0;
if (itemIds.size() != 0)
{
// make this a Player function
for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
if (Bag* bag = player->GetBagByPos(i))
freeBagSlots += bag->GetFreeSlots();
for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
if (!player->GetItemByPos(INVENTORY_SLOT_BAG_0, i))
++freeBagSlots;
}
if (itemIds.size() > freeBagSlots)
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
return;
}
if (!player->HasEnoughMoney(uint64(itemGuids.size() * VOID_STORAGE_STORE_ITEM)))
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NOT_ENOUGH_MONEY);
return;
}
std::pair<VoidStorageItem, uint8> depositItems[VOID_STORAGE_MAX_DEPOSIT];
uint8 depositCount = 0;
for (std::vector<ObjectGuid>::iterator itr = itemGuids.begin(); itr != itemGuids.end(); ++itr)
{
Item* item = player->GetItemByGuid(*itr);
if (!item)
continue;
VoidStorageItem itemVS(sObjectMgr->GenerateVoidStorageItemId(), item->GetEntry(), item->GetUInt64Value(ITEM_FIELD_CREATOR), item->GetItemRandomPropertyId(), item->GetItemSuffixFactor());
uint8 slot = player->AddVoidStorageItem(itemVS);
depositItems[depositCount++] = std::make_pair(itemVS, slot);
player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
}
int64 cost = depositCount * VOID_STORAGE_STORE_ITEM;
player->ModifyMoney(-cost);
VoidStorageItem withdrawItems[VOID_STORAGE_MAX_WITHDRAW];
uint8 withdrawCount = 0;
for (std::vector<ObjectGuid>::iterator itr = itemIds.begin(); itr != itemIds.end(); ++itr)
{
uint8 slot;
VoidStorageItem* itemVS = player->GetVoidStorageItem(*itr, slot);
if (!itemVS)
continue;
ItemPosCountVec dest;
InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemVS->ItemEntry, 1);
if (msg != EQUIP_ERR_OK)
{
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
return;
}
Item* item = player->StoreNewItem(dest, itemVS->ItemEntry, true, itemVS->ItemRandomPropertyId);
item->SetUInt64Value(ITEM_FIELD_CREATOR, uint64(itemVS->CreatorGuid));
item->SetBinding(true);
player->SendNewItem(item, 1, false, false, false);
withdrawItems[withdrawCount++] = *itemVS;
player->DeleteVoidStorageItem(slot);
}
WorldPacket data(SMSG_VOID_STORAGE_TRANSFER_CHANGES, ((5 + 5 + (7 + 7) * depositCount +
7 * withdrawCount) / 8) + 7 * withdrawCount + (7 + 7 + 4 * 4) * depositCount);
data.WriteBits(depositCount, 5);
data.WriteBits(withdrawCount, 5);
for (uint8 i = 0; i < depositCount; ++i)
{
ObjectGuid itemId = depositItems[i].first.ItemId;
ObjectGuid creatorGuid = depositItems[i].first.CreatorGuid;
data.WriteByteMask(creatorGuid[7]);
data.WriteByteMask(itemId[7]);
data.WriteByteMask(itemId[4]);
data.WriteByteMask(creatorGuid[6]);
data.WriteByteMask(creatorGuid[5]);
data.WriteByteMask(itemId[3]);
data.WriteByteMask(itemId[5]);
data.WriteByteMask(creatorGuid[4]);
data.WriteByteMask(creatorGuid[2]);
data.WriteByteMask(creatorGuid[0]);
data.WriteByteMask(creatorGuid[3]);
data.WriteByteMask(creatorGuid[1]);
data.WriteByteMask(itemId[2]);
data.WriteByteMask(itemId[0]);
data.WriteByteMask(itemId[1]);
data.WriteByteMask(itemId[6]);
}
for (uint8 i = 0; i < withdrawCount; ++i)
{
ObjectGuid itemId = withdrawItems[i].ItemId;
data.WriteByteMask(itemId[1]);
data.WriteByteMask(itemId[7]);
data.WriteByteMask(itemId[3]);
data.WriteByteMask(itemId[5]);
data.WriteByteMask(itemId[6]);
data.WriteByteMask(itemId[2]);
data.WriteByteMask(itemId[4]);
data.WriteByteMask(itemId[0]);
}
for (uint8 i = 0; i < withdrawCount; ++i)
{
ObjectGuid itemId = withdrawItems[i].ItemId;
data.WriteByteSeq(itemId[3]);
data.WriteByteSeq(itemId[1]);
data.WriteByteSeq(itemId[0]);
data.WriteByteSeq(itemId[2]);
data.WriteByteSeq(itemId[7]);
data.WriteByteSeq(itemId[5]);
data.WriteByteSeq(itemId[6]);
data.WriteByteSeq(itemId[4]);
}
for (uint8 i = 0; i < depositCount; ++i)
{
ObjectGuid itemId = depositItems[i].first.ItemId;
ObjectGuid creatorGuid = depositItems[i].first.CreatorGuid;
data << uint32(depositItems[i].first.ItemSuffixFactor);
data.WriteByteSeq(itemId[6]);
data.WriteByteSeq(itemId[4]);
data.WriteByteSeq(creatorGuid[4]);
data.WriteByteSeq(itemId[2]);
data.WriteByteSeq(creatorGuid[1]);
data.WriteByteSeq(creatorGuid[3]);
data.WriteByteSeq(itemId[3]);
data.WriteByteSeq(creatorGuid[0]);
data.WriteByteSeq(itemId[0]);
data.WriteByteSeq(creatorGuid[6]);
data.WriteByteSeq(itemId[5]);
data.WriteByteSeq(creatorGuid[5]);
data.WriteByteSeq(creatorGuid[7]);
data << uint32(depositItems[i].first.ItemEntry);
data.WriteByteSeq(itemId[1]);
data << uint32(depositItems[i].second); // slot
data.WriteByteSeq(creatorGuid[2]);
data.WriteByteSeq(itemId[7]);
data << uint32(depositItems[i].first.ItemRandomPropertyId);
}
SendPacket(&data);
SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NO_ERROR);
}
void WorldSession::HandleArtifactAddPower(WorldPackets::Artifact::ArtifactAddPower& artifactAddPower)
{
if (!_player->GetGameObjectIfCanInteractWith(artifactAddPower.ForgeGUID, GAMEOBJECT_TYPE_ARTIFACT_FORGE))
return;
Item* artifact = _player->GetItemByGuid(artifactAddPower.ArtifactGUID);
if (!artifact)
return;
uint64 xpCost = 0;
if (GtArtifactLevelXPEntry const* cost = sArtifactLevelXPGameTable.GetRow(artifact->GetTotalPurchasedArtifactPowers() + 1))
xpCost = uint64(artifact->GetModifier(ITEM_MODIFIER_ARTIFACT_TIER) == 1 ? cost->XP2 : cost->XP);
if (xpCost > artifact->GetUInt64Value(ITEM_FIELD_ARTIFACT_XP))
return;
if (artifactAddPower.PowerChoices.empty())
return;
ItemDynamicFieldArtifactPowers const* artifactPower = artifact->GetArtifactPower(artifactAddPower.PowerChoices[0].ArtifactPowerID);
if (!artifactPower)
return;
ArtifactPowerEntry const* artifactPowerEntry = sArtifactPowerStore.LookupEntry(artifactPower->ArtifactPowerId);
if (!artifactPowerEntry)
return;
if (artifactAddPower.PowerChoices[0].Rank != artifactPower->PurchasedRank + 1 ||
artifactAddPower.PowerChoices[0].Rank > artifactPowerEntry->MaxPurchasableRank)
return;
if (std::unordered_set<uint32> const* artifactPowerLinks = sDB2Manager.GetArtifactPowerLinks(artifactPower->ArtifactPowerId))
{
bool hasAnyLink = false;
for (uint32 artifactPowerLinkId : *artifactPowerLinks)
{
ArtifactPowerEntry const* artifactPowerLink = sArtifactPowerStore.LookupEntry(artifactPowerLinkId);
if (!artifactPowerLink)
continue;
ItemDynamicFieldArtifactPowers const* artifactPowerLinkLearned = artifact->GetArtifactPower(artifactPowerLinkId);
if (!artifactPowerLinkLearned)
continue;
if (artifactPowerLinkLearned->PurchasedRank >= artifactPowerLink->MaxPurchasableRank)
{
hasAnyLink = true;
break;
}
}
if (!hasAnyLink)
return;
}
ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(artifactPower->ArtifactPowerId, artifactPower->CurrentRankWithBonus + 1 - 1); // need data for next rank, but -1 because of how db2 data is structured
if (!artifactPowerRank)
return;
ItemDynamicFieldArtifactPowers newPower = *artifactPower;
++newPower.PurchasedRank;
++newPower.CurrentRankWithBonus;
artifact->SetArtifactPower(&newPower);
if (artifact->IsEquipped())
{
_player->ApplyArtifactPowerRank(artifact, artifactPowerRank, true);
for (ItemDynamicFieldArtifactPowers const& power : artifact->GetArtifactPowers())
{
ArtifactPowerEntry const* scaledArtifactPowerEntry = sArtifactPowerStore.AssertEntry(power.ArtifactPowerId);
if (!(scaledArtifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_SCALES_WITH_NUM_POWERS))
continue;
ArtifactPowerRankEntry const* scaledArtifactPowerRank = sDB2Manager.GetArtifactPowerRank(scaledArtifactPowerEntry->ID, 0);
if (!scaledArtifactPowerRank)
continue;
ItemDynamicFieldArtifactPowers newScaledPower = power;
++newScaledPower.CurrentRankWithBonus;
artifact->SetArtifactPower(&newScaledPower);
_player->ApplyArtifactPowerRank(artifact, scaledArtifactPowerRank, false);
_player->ApplyArtifactPowerRank(artifact, scaledArtifactPowerRank, true);
}
}
artifact->SetUInt64Value(ITEM_FIELD_ARTIFACT_XP, artifact->GetUInt64Value(ITEM_FIELD_ARTIFACT_XP) - xpCost);
artifact->SetState(ITEM_CHANGED, _player);
}
