ItemRecovery Namespace Reference

Functions
bool	Save (Item const *item, uint32 count, RecoveryItemSource source, uint32 money=0, RecoveryItemLoot const &loot={ })
std::optional< RecoveryItem >	Load (uint32 recoveryId)
bool	Restore (RecoveryItem const &recovery, Player *owner)
void	DeleteFromDB (CharacterDatabaseTransaction trans, uint32 recoveryId)
bool	IsInBuyback (Player *player, RecoveryItem const &recovery)

Function Documentation

DeleteFromDB()

void ItemRecovery::DeleteFromDB	(	CharacterDatabaseTransaction	trans,
		uint32	recoveryId
	)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RECOVERY_ITEM_LOOT_BY_RECOVERY_ID);
    stmt->SetData(0, recoveryId);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RECOVERY_ITEM_BY_RECOVERY_ID);
    stmt->SetData(0, recoveryId);
    trans->Append(stmt);
}

References CHAR_DEL_RECOVERY_ITEM_BY_RECOVERY_ID, CHAR_DEL_RECOVERY_ITEM_LOOT_BY_RECOVERY_ID, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by Player::DeleteOldRecoveryItems(), and Restore().

IsInBuyback()

bool ItemRecovery::IsInBuyback	(	Player *	player,
		RecoveryItem const &	recovery
	)

{
    for (uint32 slot = BUYBACK_SLOT_START; slot < BUYBACK_SLOT_END; ++slot)
        if (Item* item = player->GetItemFromBuyBackSlot(slot))
            if (item->GetGUID().GetCounter() == recovery.ItemGuid && item->GetEntry() == recovery.ItemEntry)
                return true;
 
    return false;
}

References BUYBACK_SLOT_END, BUYBACK_SLOT_START, Player::GetItemFromBuyBackSlot(), RecoveryItem::ItemEntry, and RecoveryItem::ItemGuid.

Referenced by item_commandscript::HandleItemRestoreCommand().

Load()

std::optional< RecoveryItem > ItemRecovery::Load

(

uint32

recoveryId

)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_RECOVERY_ITEM);
    stmt->SetData(0, recoveryId);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
    if (!result)
        return std::nullopt;
 
    Field* fields = result->Fetch();
 
    RecoveryItem recovery;
    recovery.Id               = fields[0].Get<uint32>();
    recovery.OwnerGuid        = fields[1].Get<uint32>();
    recovery.ItemEntry        = fields[2].Get<uint32>();
    recovery.ItemGuid         = fields[3].Get<uint32>();
    recovery.Count            = fields[4].Get<uint32>();
    recovery.Source           = RecoveryItemSource(fields[5].Get<uint8>());
    recovery.Money            = fields[6].Get<uint32>();
    recovery.RandomPropertyId = fields[7].Get<int32>();
    recovery.Enchantments     = fields[8].Get<std::string>();
    recovery.CreatorGuid      = fields[9].Get<uint32>();
    recovery.Bound            = fields[10].Get<uint8>() != 0;
    recovery.Loot             = LoadLoot(recovery.Id);
 
    return recovery;
}

References RecoveryItem::Bound, CHAR_SEL_RECOVERY_ITEM, CharacterDatabase, RecoveryItem::Count, RecoveryItem::CreatorGuid, RecoveryItem::Enchantments, Field::Get(), RecoveryItem::Id, RecoveryItem::ItemEntry, RecoveryItem::ItemGuid, RecoveryItem::Loot, RecoveryItem::Money, RecoveryItem::OwnerGuid, RecoveryItem::RandomPropertyId, PreparedStatementBase::SetData(), and RecoveryItem::Source.

Referenced by item_commandscript::HandleItemRestoreCommand().

Restore()

bool ItemRecovery::Restore	(	RecoveryItem const &	recovery,
		Player *	owner
	)

{
    if (!sObjectMgr->GetItemTemplate(recovery.ItemEntry))
        return false;
 
    {
        std::lock_guard<std::mutex> lock(RestoredIdsLock);
        if (!RestoredIds.insert(recovery.Id).second)
            return false;
    }
 
    // A zero id rolls a new random property, which only matters for legacy rows recorded without one
    Item* item = Item::CreateItem(recovery.ItemEntry, recovery.Count, nullptr, false, uint32(recovery.RandomPropertyId));
    if (!item)
    {
        std::lock_guard<std::mutex> lock(RestoredIdsLock);
        RestoredIds.erase(recovery.Id);
        return false;
    }
 
    // An online receiver takes this very object from the mail, and a soulbound item must already be theirs
    item->SetOwnerGUID(ObjectGuid::Create<HighGuid::Player>(recovery.OwnerGuid));
 
    // Item::SetEnchantment logs to and queues the item for its owner, who may be offline and does not hold it yet
    std::vector<std::string_view> enchantments = Acore::Tokenize(recovery.Enchantments, ' ', false);
    if (enchantments.size() == MAX_ENCHANTMENT_SLOT * MAX_ENCHANTMENT_OFFSET)
    {
        for (EnchantmentSlot slot : RecoveryEnchantmentSlots)
        {
            uint32 const field = slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_ID_OFFSET;
            if (Optional<uint32> enchantId = Acore::StringTo<uint32>(enchantments[field]); enchantId && *enchantId)
                item->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + field, *enchantId);
        }
    }
 
    if (recovery.CreatorGuid)
        item->SetGuidValue(ITEM_FIELD_CREATOR, ObjectGuid::Create<HighGuid::Player>(recovery.CreatorGuid));
 
    // A bind-on-equip item would otherwise come back tradeable
    if (recovery.Bound)
        item->SetBinding(true);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    item->SaveToDB(trans);
    MailDraft("Recovered Item", "We recovered a lost item in the twisting nether and noted that it was yours.$B$BPlease find said object enclosed.")
        .AddItem(item)
        .SendMailTo(trans, MailReceiver(owner, recovery.OwnerGuid), MailSender(MAIL_CREATURE, 34337 /* The Postmaster */));
 
    DeleteFromDB(trans, recovery.Id);
    CharacterDatabase.CommitTransaction(trans);
    return true;
}

References MailDraft::AddItem(), RecoveryItem::Bound, CharacterDatabase, RecoveryItem::Count, Item::CreateItem(), RecoveryItem::CreatorGuid, DeleteFromDB(), ENCHANTMENT_ID_OFFSET, RecoveryItem::Enchantments, RecoveryItem::Id, ITEM_FIELD_CREATOR, ITEM_FIELD_ENCHANTMENT_1_1, RecoveryItem::ItemEntry, MAIL_CREATURE, MAX_ENCHANTMENT_OFFSET, MAX_ENCHANTMENT_SLOT, RecoveryItem::OwnerGuid, RecoveryItem::RandomPropertyId, Item::SaveToDB(), MailDraft::SendMailTo(), Item::SetBinding(), Object::SetGuidValue(), Item::SetOwnerGUID(), Object::SetUInt32Value(), sObjectMgr, and Acore::Tokenize().

Referenced by item_commandscript::HandleItemRestoreCommand().

Save()

bool ItemRecovery::Save	(	Item const *	item,
		uint32	count,
		RecoveryItemSource	source,
		uint32	money = 0,
		RecoveryItemLoot const &	loot = { }
	)

{
    ItemTemplate const* proto = item->GetTemplate();
    if (!sWorld->getBoolConfig(CONFIG_ITEMDELETE_METHOD)
        || proto->Quality < sWorld->getIntConfig(CONFIG_ITEMDELETE_QUALITY)
        || proto->ItemLevel < sWorld->getIntConfig(CONFIG_ITEMDELETE_ITEM_LEVEL))
        return false;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    uint8 index = 0;
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_RECOVERY_ITEM);
    stmt->SetData(index++, item->GetOwnerGUID().GetCounter());
    stmt->SetData(index++, item->GetEntry());
    stmt->SetData(index++, item->GetGUID().GetCounter());
    stmt->SetData(index++, count);
    stmt->SetData(index++, uint8(source));
    stmt->SetData(index++, money);
    stmt->SetData(index++, item->GetItemRandomPropertyId());
    stmt->SetData(index++, item->GetEnchantmentsString());
    stmt->SetData(index++, item->GetGuidValue(ITEM_FIELD_CREATOR).GetCounter());
    stmt->SetData(index++, uint8(item->IsSoulBound()));
    trans->Append(stmt);
 
    std::map<uint32, uint32> lootCounts;
    for (auto const& [itemEntry, itemCount] : loot)
        lootCounts[itemEntry] += itemCount;
 
    // recovery_item_loot has no auto-increment column, so LAST_INSERT_ID() keeps pointing at the row above
    for (auto const& [itemEntry, itemCount] : lootCounts)
    {
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_RECOVERY_ITEM_LOOT);
        stmt->SetData(0, itemEntry);
        stmt->SetData(1, itemCount);
        trans->Append(stmt);
    }
 
    // Synchronous, so the row exists before a buyback of the same item tries to delete it
    CharacterDatabase.DirectCommitTransaction(trans);
    return true;
}

References CHAR_INS_RECOVERY_ITEM, CHAR_INS_RECOVERY_ITEM_LOOT, CharacterDatabase, CONFIG_ITEMDELETE_ITEM_LEVEL, CONFIG_ITEMDELETE_METHOD, CONFIG_ITEMDELETE_QUALITY, ObjectGuid::GetCounter(), Item::GetEnchantmentsString(), Object::GetEntry(), Object::GetGUID(), Object::GetGuidValue(), Item::GetItemRandomPropertyId(), Item::GetOwnerGUID(), Item::GetTemplate(), Item::IsSoulBound(), ITEM_FIELD_CREATOR, ItemTemplate::ItemLevel, ItemTemplate::Quality, PreparedStatementBase::SetData(), and sWorld.

Referenced by WorldSession::DoLootRelease(), WorldSession::HandleDestroyItemOpcode(), and WorldSession::HandleSellItemOpcode().