Guild::BankMoveItemData Class Reference

Inheritance diagram for Guild::BankMoveItemData:

Public Member Functions
	BankMoveItemData (Guild *guild, Player *player, uint8 container, uint8 slotId)
bool	IsBank () const override
bool	InitItem () override
bool	HasStoreRights (MoveItemData *pOther) const override
bool	HasWithdrawRights (MoveItemData *pOther) const override
void	RemoveItem (CharacterDatabaseTransaction trans, MoveItemData *pOther, uint32 splitedAmount) override
Item *	StoreItem (CharacterDatabaseTransaction trans, Item *pItem) override
void	LogBankEvent (CharacterDatabaseTransaction trans, MoveItemData *pFrom, uint32 count) const override
void	LogAction (MoveItemData *pFrom) const override
Public Member Functions inherited from Guild::MoveItemData
	MoveItemData (Guild *guild, Player *player, uint8 container, uint8 slotId)
virtual	~MoveItemData ()
virtual bool	CheckItem (uint32 &splitedAmount)
bool	CanStore (Item *pItem, bool swap, bool sendError)
bool	CloneItem (uint32 count)
void	CopySlots (SlotIds &ids) const
Item *	GetItem (bool isCloned=false) const
uint8	GetContainer () const
uint8	GetSlotId () const

Protected Member Functions
InventoryResult	CanStore (Item *pItem, bool swap) override

Private Member Functions
Item *	_StoreItem (CharacterDatabaseTransaction trans, BankTab *pTab, Item *pItem, ItemPosCount &pos, bool clone) const
bool	_ReserveSpace (uint8 slotId, Item *pItem, Item *pItemDest, uint32 &count)
void	CanStoreItemInTab (Item *pItem, uint8 skipSlotId, bool merge, uint32 &count)

Additional Inherited Members
Protected Attributes inherited from Guild::MoveItemData
Guild *	m_pGuild
Player *	m_pPlayer
uint8	m_container
uint8	m_slotId
Item *	m_pItem
Item *	m_pClonedItem
ItemPosCountVec	m_vec

Detailed Description

Constructor & Destructor Documentation

BankMoveItemData()

Guild::BankMoveItemData::BankMoveItemData ( Guild *  guild, Player *  player, uint8  container, uint8  slotId  )

inline

                                                                                      :
            MoveItemData(guild, player, container, slotId) { }

Member Function Documentation

_ReserveSpace()

bool Guild::BankMoveItemData::_ReserveSpace ( uint8  slotId, Item *  pItem, Item *  pItemDest, uint32 &  count  )

private

{
    uint32 requiredSpace = pItem->GetMaxStackCount();
    if (pItemDest)
    {
        // Make sure source and destination items match and destination item has space for more stacks.
        if (pItemDest->GetEntry() != pItem->GetEntry() || pItemDest->GetCount() >= pItem->GetMaxStackCount())
            return false;
        requiredSpace -= pItemDest->GetCount();
    }
    // Let's not be greedy, reserve only required space
    requiredSpace = std::min(requiredSpace, count);
 
    // Reserve space
    ItemPosCount pos(slotId, requiredSpace);
    if (!pos.isContainedIn(m_vec))
    {
        m_vec.push_back(pos);
        count -= requiredSpace;
    }
    return true;
}

References Item::GetCount(), Object::GetEntry(), Item::GetMaxStackCount(), and ItemPosCount::isContainedIn().

_StoreItem()

Item * Guild::BankMoveItemData::_StoreItem ( CharacterDatabaseTransaction  trans, BankTab *  pTab, Item *  pItem, ItemPosCount &  pos, bool  clone  ) const

private

{
    uint8 slotId = uint8(pos.pos);
    uint32 count = pos.count;
    if (Item* pItemDest = pTab->GetItem(slotId))
    {
        pItemDest->SetCount(pItemDest->GetCount() + count);
        pItemDest->FSetState(ITEM_CHANGED);
        pItemDest->SaveToDB(trans);
        if (!clone)
        {
            pItem->RemoveFromWorld();
            pItem->DeleteFromDB(trans);
            delete pItem;
        }
        return pItemDest;
    }
 
    if (clone)
        pItem = pItem->CloneItem(count);
    else
        pItem->SetCount(count);
 
    if (pItem && pTab->SetItem(trans, slotId, pItem))
        return pItem;
 
    return nullptr;
}

References Item::CloneItem(), ItemPosCount::count, Item::DeleteFromDB(), Guild::BankTab::GetItem(), ITEM_CHANGED, ItemPosCount::pos, Object::RemoveFromWorld(), Item::SetCount(), and Guild::BankTab::SetItem().

CanStore()

InventoryResult Guild::BankMoveItemData::CanStore ( Item *  pItem, bool  swap  )

overrideprotectedvirtual

Implements Guild::MoveItemData.

{
    LOG_DEBUG("guild", "GUILD STORAGE: CanStore() tab = {}, slot = {}, item = {}, count = {}",
                   m_container, m_slotId, pItem->GetEntry(), pItem->GetCount());
    uint32 count = pItem->GetCount();
    // Soulbound items cannot be moved
    if (pItem->IsSoulBound())
        return EQUIP_ERR_CANT_DROP_SOULBOUND;
 
    // Prevent swapping limited duration items into guild bank
    if (pItem->GetTemplate()->Duration > 0)
        return EQUIP_ERR_ITEMS_CANT_BE_SWAPPED;
 
    // Make sure destination bank tab exists
    if (m_container >= m_pGuild->_GetPurchasedTabsSize())
        return EQUIP_ERR_ITEM_DOESNT_GO_INTO_BAG;
 
    // Slot explicitely specified. Check it.
    if (m_slotId != NULL_SLOT)
    {
        Item* pItemDest = m_pGuild->_GetItem(m_container, m_slotId);
        // Ignore swapped item (this slot will be empty after move)
        if ((pItemDest == pItem) || swap)
            pItemDest = nullptr;
 
        if (!_ReserveSpace(m_slotId, pItem, pItemDest, count))
            return EQUIP_ERR_ITEM_CANT_STACK;
 
        if (count == 0)
            return EQUIP_ERR_OK;
    }
 
    // Slot was not specified or it has not enough space for all the items in stack
    // Search for stacks to merge with
    if (pItem->GetMaxStackCount() > 1)
    {
        CanStoreItemInTab(pItem, m_slotId, true, count);
        if (count == 0)
            return EQUIP_ERR_OK;
    }
 
    // Search free slot for item
    CanStoreItemInTab(pItem, m_slotId, false, count);
    if (count == 0)
        return EQUIP_ERR_OK;
 
    return EQUIP_ERR_BANK_FULL;
}

References ItemTemplate::Duration, EQUIP_ERR_BANK_FULL, EQUIP_ERR_CANT_DROP_SOULBOUND, EQUIP_ERR_ITEM_CANT_STACK, EQUIP_ERR_ITEM_DOESNT_GO_INTO_BAG, EQUIP_ERR_ITEMS_CANT_BE_SWAPPED, EQUIP_ERR_OK, Item::GetCount(), Object::GetEntry(), Item::GetMaxStackCount(), Item::GetTemplate(), Item::IsSoulBound(), LOG_DEBUG, and NULL_SLOT.

CanStoreItemInTab()

void Guild::BankMoveItemData::CanStoreItemInTab ( Item *  pItem, uint8  skipSlotId, bool  merge, uint32 &  count  )

private

{
    for (uint8 slotId = 0; (slotId < GUILD_BANK_MAX_SLOTS) && (count > 0); ++slotId)
    {
        // Skip slot already processed in CanStore (when destination slot was specified)
        if (slotId == skipSlotId)
            continue;
 
        Item* pItemDest = m_pGuild->_GetItem(m_container, slotId);
        if (pItemDest == pItem)
            pItemDest = nullptr;
 
        // If merge skip empty, if not merge skip non-empty
        if ((pItemDest != nullptr) != merge)
            continue;
 
        _ReserveSpace(slotId, pItem, pItemDest, count);
    }
}

References GUILD_BANK_MAX_SLOTS.

HasStoreRights()

bool Guild::BankMoveItemData::HasStoreRights ( MoveItemData *  pOther ) const

overridevirtual

Reimplemented from Guild::MoveItemData.

{
    ASSERT(pOther);
    // Do not check rights if item is being swapped within the same bank tab
    if (pOther->IsBank() && pOther->GetContainer() == m_container)
        return true;
    return m_pGuild->_MemberHasTabRights(m_pPlayer->GetGUID(), m_container, GUILD_BANK_RIGHT_DEPOSIT_ITEM);
}

References ASSERT, Guild::MoveItemData::GetContainer(), GUILD_BANK_RIGHT_DEPOSIT_ITEM, and Guild::MoveItemData::IsBank().

HasWithdrawRights()

bool Guild::BankMoveItemData::HasWithdrawRights ( MoveItemData *  pOther ) const

overridevirtual

Reimplemented from Guild::MoveItemData.

{
    ASSERT(pOther);
    // Do not check rights if item is being swapped within the same bank tab
    if (pOther->IsBank() && pOther->GetContainer() == m_container)
        return true;
 
    int32 slots = 0;
    if (Member const* member = m_pGuild->GetMember(m_pPlayer->GetGUID()))
        slots = m_pGuild->_GetMemberRemainingSlots(*member, m_container);
 
    return slots != 0;
}

References ASSERT, Guild::MoveItemData::GetContainer(), and Guild::MoveItemData::IsBank().

InitItem()

bool Guild::BankMoveItemData::InitItem ( )

overridevirtual

Implements Guild::MoveItemData.

{
    m_pItem = m_pGuild->_GetItem(m_container, m_slotId);
    return (m_pItem != nullptr);
}

IsBank()

bool Guild::BankMoveItemData::IsBank ( ) const

inlineoverridevirtual

Implements Guild::MoveItemData.

{ return true; }

LogAction()

void Guild::BankMoveItemData::LogAction ( MoveItemData *  pFrom ) const

overridevirtual

Reimplemented from Guild::MoveItemData.

{
    MoveItemData::LogAction(pFrom);
    if (!pFrom->IsBank() && m_pPlayer->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
    {
        LOG_GM(m_pPlayer->GetSession()->GetAccountId(), "GM {} (Account: {}) deposit item: {} (Entry: {} Count: {}) to guild bank named: {} (Guild ID: {})",
            m_pPlayer->GetName(), m_pPlayer->GetSession()->GetAccountId(),
            pFrom->GetItem()->GetTemplate()->Name1, pFrom->GetItem()->GetEntry(), pFrom->GetItem()->GetCount(),
            m_pGuild->GetName(), m_pGuild->GetId());
    }
}

References Item::GetCount(), Object::GetEntry(), Guild::MoveItemData::GetItem(), Item::GetTemplate(), Guild::MoveItemData::IsBank(), LOG_GM, Guild::MoveItemData::LogAction(), ItemTemplate::Name1, and rbac::RBAC_PERM_LOG_GM_TRADE.

LogBankEvent()

void Guild::BankMoveItemData::LogBankEvent ( CharacterDatabaseTransaction  trans, MoveItemData *  pFrom, uint32  count  ) const

overridevirtual

Implements Guild::MoveItemData.

{
    ASSERT(pFrom->GetItem());
    if (pFrom->IsBank())
        // Bank -> Bank
        m_pGuild->_LogBankEvent(trans, GUILD_BANK_LOG_MOVE_ITEM, pFrom->GetContainer(), m_pPlayer->GetGUID(),
                                pFrom->GetItem()->GetEntry(), count, m_container);
    else
        // Char -> Bank
        m_pGuild->_LogBankEvent(trans, GUILD_BANK_LOG_DEPOSIT_ITEM, m_container, m_pPlayer->GetGUID(),
                                pFrom->GetItem()->GetEntry(), count);
}

References ASSERT, Guild::MoveItemData::GetContainer(), Object::GetEntry(), Guild::MoveItemData::GetItem(), GUILD_BANK_LOG_DEPOSIT_ITEM, GUILD_BANK_LOG_MOVE_ITEM, and Guild::MoveItemData::IsBank().

RemoveItem()

void Guild::BankMoveItemData::RemoveItem ( CharacterDatabaseTransaction  trans, MoveItemData *  pOther, uint32  splitedAmount  )

overridevirtual

Implements Guild::MoveItemData.

{
    ASSERT(m_pItem);
    if (splitedAmount)
    {
        m_pItem->SetCount(m_pItem->GetCount() - splitedAmount);
        m_pItem->FSetState(ITEM_CHANGED);
        m_pItem->SaveToDB(trans);
    }
    else
    {
        m_pGuild->_RemoveItem(trans, m_container, m_slotId);
        m_pItem = nullptr;
    }
    // Decrease amount of player's remaining items (if item is moved to different tab or to player)
    if (!pOther->IsBank() || pOther->GetContainer() != m_container)
        m_pGuild->_UpdateMemberWithdrawSlots(trans, m_pPlayer->GetGUID(), m_container);
}

References ASSERT, Guild::MoveItemData::GetContainer(), Guild::MoveItemData::IsBank(), and ITEM_CHANGED.

StoreItem()

Item * Guild::BankMoveItemData::StoreItem ( CharacterDatabaseTransaction  trans, Item *  pItem  )

overridevirtual

Implements Guild::MoveItemData.

{
    if (!pItem)
        return nullptr;
 
    BankTab* pTab = m_pGuild->GetBankTab(m_container);
    if (!pTab)
        return nullptr;
 
    Item* pLastItem = pItem;
    for (ItemPosCountVec::const_iterator itr = m_vec.begin(); itr != m_vec.end(); )
    {
        ItemPosCount pos(*itr);
        ++itr;
 
        LOG_DEBUG("guild", "GUILD STORAGE: StoreItem tab = {}, slot = {}, item = {}, count = {}",
                       m_container, m_slotId, pItem->GetEntry(), pItem->GetCount());
        pLastItem = _StoreItem(trans, pTab, pItem, pos, itr != m_vec.end());
    }
    return pLastItem;
}

References Item::GetCount(), Object::GetEntry(), and LOG_DEBUG.

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Guilds/Guild.h
• azerothcore-wotlk/src/server/game/Guilds/Guild.cpp