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 (SQLTransaction &trans, MoveItemData *pOther, uint32 splitedAmount) override

Item *	StoreItem (SQLTransaction &trans, Item *pItem) override

void	LogBankEvent (SQLTransaction &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 (SQLTransaction &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

Constructor & Destructor Documentation

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

inline

725 :

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

Guild::MoveItemData::MoveItemData

MoveItemData(Guild *guild, Player *player, uint8 container, uint8 slotId)

Definition: Guild.h:663

Member Function Documentation

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;
 }

Here is the call graph for this function:

Item * Guild::BankMoveItemData::_StoreItem	(	SQLTransaction &	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 NULL;
 }

Here is the call graph for this function:

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

overrideprotectedvirtual

Implements Guild::MoveItemData.

 {
  TC_LOG_DEBUG("guild", "GUILD STORAGE: CanStore() tab = %u, slot = %u, item = %u, count = %u",
  m_container, m_slotId, pItem->GetEntry(), pItem->GetCount());
 
  uint32 count = pItem->GetCount();
  // Soulbound items cannot be moved
  if (pItem->IsSoulBound())
  return EQUIP_ERR_DROP_BOUND_ITEM;
 
  // Make sure destination bank tab exists
  if (m_container >= m_pGuild->_GetPurchasedTabsSize())
  return EQUIP_ERR_WRONG_BAG_TYPE;
 
  // 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 = NULL;
 
  if (!_ReserveSpace(m_slotId, pItem, pItemDest, count))
  return EQUIP_ERR_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;
 }

Here is the call graph for this function:

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 = NULL;
 
  // If merge skip empty, if not merge skip non-empty
  if ((pItemDest != NULL) != merge)
  continue;
 
  _ReserveSpace(slotId, pItem, pItemDest, count);
  }
 }

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);
 }

Here is the call graph for this function:

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;
 }

Here is the call graph for this function:

bool Guild::BankMoveItemData::InitItem ( )

overridevirtual

Implements Guild::MoveItemData.

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

bool Guild::BankMoveItemData::IsBank ( ) const

inlineoverridevirtual

Implements Guild::MoveItemData.

728 { return true; }

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

overridevirtual

Todo:: Move this to scripts

Reimplemented from Guild::MoveItemData.

 {
  MoveItemData::LogAction(pFrom);
  if (!pFrom->IsBank() && m_pPlayer->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE)) 
  {
  sLog->outCommand(m_pPlayer->GetSession()->GetAccountId(),
  "GM %s (%s) (Account: %u) deposit item: %s (Entry: %d Count: %u) to guild bank named: %s (Guild ID: " UI64FMTD ")",
  m_pPlayer->GetName().c_str(), m_pPlayer->GetGUID().ToString().c_str(), m_pPlayer->GetSession()->GetAccountId(),
  pFrom->GetItem()->GetTemplate()->GetDefaultLocaleName(), pFrom->GetItem()->GetEntry(), pFrom->GetItem()->GetCount(),
  m_pGuild->GetName().c_str(), m_pGuild->GetId());
  }
 }

Here is the call graph for this function:

void Guild::BankMoveItemData::LogBankEvent	(	SQLTransaction &	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().GetCounter(),
  pFrom->GetItem()->GetEntry(), count, m_container);
  else
  // Char -> Bank
  m_pGuild->_LogBankEvent(trans, GUILD_BANK_LOG_DEPOSIT_ITEM, m_container, m_pPlayer->GetGUID().GetCounter(),
  pFrom->GetItem()->GetEntry(), count);
 }

Here is the call graph for this function:

void Guild::BankMoveItemData::RemoveItem	(	SQLTransaction &	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 = NULL;
  }
  // 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);
 }

Here is the call graph for this function:

Item * Guild::BankMoveItemData::StoreItem	(	SQLTransaction &	trans,
		Item *	pItem
	)

overridevirtual

Implements Guild::MoveItemData.

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

Here is the call graph for this function:

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

src/server/game/Guilds/Guild.h
src/server/game/Guilds/Guild.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation