Guild Class Reference

#include "Guild.h"

Classes
class	BankEventLogEntry
class	BankMoveItemData
class	BankTab
class	EventLogEntry
class	LogEntry
class	LogHolder
class	Member
class	MoveItemData
class	PlayerMoveItemData
class	RankInfo

Public Member Functions
Member const *	GetMember (ObjectGuid guid) const
Member *	GetMember (ObjectGuid guid)
Member *	GetMember (std::string_view name)
	Guild ()
	~Guild ()
bool	Create (Player *pLeader, std::string_view name)
void	Disband ()
uint32	GetId () const
ObjectGuid	GetLeaderGUID () const
std::string const &	GetName () const
std::string const &	GetMOTD () const
std::string const &	GetInfo () const
bool	SetName (std::string_view const &name)
void	HandleRoster (WorldSession *session)
void	HandleQuery (WorldSession *session)
void	HandleSetMOTD (WorldSession *session, std::string_view motd)
void	HandleSetInfo (WorldSession *session, std::string_view info)
void	HandleSetEmblem (WorldSession *session, EmblemInfo const &emblemInfo)
void	HandleSetEmblem (EmblemInfo const &emblemInfo)
void	HandleSetLeader (WorldSession *session, std::string_view name)
void	HandleSetBankTabInfo (WorldSession *session, uint8 tabId, std::string_view name, std::string_view icon)
void	HandleSetMemberNote (WorldSession *session, std::string_view name, std::string_view note, bool isPublic)
void	HandleSetRankInfo (WorldSession *session, uint8 rankId, std::string_view name, uint32 rights, uint32 moneyPerDay, std::array< GuildBankRightsAndSlots, GUILD_BANK_MAX_TABS > const &rightsAndSlots)
void	HandleSetRankInfo (uint8 rankId, Optional< std::string_view > name, Optional< uint32 > rights={}, Optional< uint32 > moneyPerDay={})
void	HandleBuyBankTab (WorldSession *session, uint8 tabId)
void	HandleInviteMember (WorldSession *session, std::string const &name)
void	HandleAcceptMember (WorldSession *session)
void	HandleLeaveMember (WorldSession *session)
void	HandleRemoveMember (WorldSession *session, std::string_view name)
void	HandleUpdateMemberRank (WorldSession *session, std::string_view name, bool demote)
void	HandleAddNewRank (WorldSession *session, std::string_view name)
void	HandleRemoveRank (WorldSession *session, uint8 rankId)
void	HandleRemoveLowestRank (WorldSession *session)
void	HandleMemberDepositMoney (WorldSession *session, uint32 amount)
bool	HandleMemberWithdrawMoney (WorldSession *session, uint32 amount, bool repair=false)
void	HandleMemberLogout (WorldSession *session)
void	HandleDisband (WorldSession *session)
void	UpdateMemberData (Player *player, uint8 dataid, uint32 value)
void	OnPlayerStatusChange (Player *player, uint32 flag, bool state)
void	SendInfo (WorldSession *session) const
void	SendEventLog (WorldSession *session) const
void	SendBankLog (WorldSession *session, uint8 tabId) const
void	SendBankTabsInfo (WorldSession *session, bool showTabs=false)
void	SendBankTabData (WorldSession *session, uint8 tabId, bool sendAllSlots) const
void	SendBankTabText (WorldSession *session, uint8 tabId) const
void	SendPermissions (WorldSession *session)
void	SendMoneyInfo (WorldSession *session) const
void	SendLoginInfo (WorldSession *session)
bool	LoadFromDB (Field *fields)
void	LoadRankFromDB (Field *fields)
bool	LoadMemberFromDB (Field *fields)
bool	LoadEventLogFromDB (Field *fields)
void	LoadBankRightFromDB (Field *fields)
void	LoadBankTabFromDB (Field *fields)
bool	LoadBankEventLogFromDB (Field *fields)
bool	LoadBankItemFromDB (Field *fields)
bool	Validate ()
void	BroadcastToGuild (WorldSession *session, bool officerOnly, std::string_view msg, uint32 language=LANG_UNIVERSAL) const
void	BroadcastPacketToRank (WorldPacket const *packet, uint8 rankId) const
void	BroadcastPacket (WorldPacket const *packet) const
void	MassInviteToEvent (WorldSession *session, uint32 minLevel, uint32 maxLevel, uint32 minRank)
template<class Do >
void	BroadcastWorker (Do &_do, Player *except=nullptr)
bool	AddMember (ObjectGuid guid, uint8 rankId=GUILD_RANK_NONE)
void	DeleteMember (ObjectGuid guid, bool isDisbanding=false, bool isKicked=false, bool canDeleteGuild=false)
bool	ChangeMemberRank (ObjectGuid guid, uint8 newRank)
void	SwapItems (Player *player, uint8 tabId, uint8 slotId, uint8 destTabId, uint8 destSlotId, uint32 splitedAmount)
void	SwapItemsWithInventory (Player *player, bool toChar, uint8 tabId, uint8 slotId, uint8 playerBag, uint8 playerSlotId, uint32 splitedAmount)
uint64	GetTotalBankMoney () const
uint32	GetMemberCount () const
time_t	GetCreatedDate () const
void	SetBankTabText (uint8 tabId, std::string_view text)
void	ResetTimes ()
bool	ModifyBankMoney (CharacterDatabaseTransaction trans, uint64 const &amount, bool add)
uint32	GetMemberSize () const
bool	HasRankRight (Player *player, uint32 right) const
uint32	GetRankRights (uint8 rankId) const
bool	MemberHasTabRights (ObjectGuid guid, uint8 tabId, uint32 rights) const

Static Public Member Functions
static void	SendCommandResult (WorldSession *session, GuildCommandType type, GuildCommandError errCode, std::string_view param={})
static void	SendSaveEmblemResult (WorldSession *session, GuildEmblemError errCode)

Protected Attributes
uint32	m_id
std::string	m_name
ObjectGuid	m_leaderGuid
std::string	m_motd
std::string	m_info
time_t	m_createdDate
EmblemInfo	m_emblemInfo
uint32	m_accountsNumber
uint64	m_bankMoney
std::vector< RankInfo >	m_ranks
std::unordered_map< uint32, Member >	m_members
std::vector< BankTab >	m_bankTabs
LogHolder< EventLogEntry >	m_eventLog
std::array< LogHolder< BankEventLogEntry >, GUILD_BANK_MAX_TABS+1 >	m_bankEventLog = {}

Private Member Functions
uint8	_GetRanksSize () const
RankInfo const *	GetRankInfo (uint8 rankId) const
RankInfo *	GetRankInfo (uint8 rankId)
bool	_HasRankRight (Player *player, uint32 right) const
uint8	_GetLowestRankId () const
uint8	_GetPurchasedTabsSize () const
BankTab *	GetBankTab (uint8 tabId)
BankTab const *	GetBankTab (uint8 tabId) const
void	_DeleteMemberFromDB (ObjectGuid::LowType lowguid) const
void	_CreateNewBankTab ()
void	_CreateDefaultGuildRanks (LocaleConstant loc)
bool	_CreateRank (std::string_view name, uint32 rights)
void	_UpdateAccountsNumber ()
bool	_IsLeader (Player *player) const
void	_DeleteBankItems (CharacterDatabaseTransaction trans, bool removeItemsFromDB=false)
bool	_ModifyBankMoney (CharacterDatabaseTransaction trans, uint64 amount, bool add)
void	_SetLeaderGUID (Member &pLeader)
void	_SetRankBankMoneyPerDay (uint8 rankId, uint32 moneyPerDay)
void	_SetRankBankTabRightsAndSlots (uint8 rankId, GuildBankRightsAndSlots rightsAndSlots, bool saveToDB=true)
int8	_GetRankBankTabRights (uint8 rankId, uint8 tabId) const
uint32	_GetRankRights (uint8 rankId) const
int32	_GetRankBankMoneyPerDay (uint8 rankId) const
int32	_GetRankBankTabSlotsPerDay (uint8 rankId, uint8 tabId) const
std::string	_GetRankName (uint8 rankId) const
int32	_GetMemberRemainingSlots (Member const &member, uint8 tabId) const
int32	_GetMemberRemainingMoney (Member const &member) const
void	_UpdateMemberWithdrawSlots (CharacterDatabaseTransaction trans, ObjectGuid guid, uint8 tabId)
bool	_MemberHasTabRights (ObjectGuid guid, uint8 tabId, uint32 rights) const
void	_LogEvent (GuildEventLogTypes eventType, ObjectGuid playerGuid1, ObjectGuid playerGuid2=ObjectGuid::Empty, uint8 newRank=0)
void	_LogBankEvent (CharacterDatabaseTransaction trans, GuildBankEventLogTypes eventType, uint8 tabId, ObjectGuid playerGuid, uint32 itemOrMoney, uint16 itemStackCount=0, uint8 destTabId=0)
Item *	_GetItem (uint8 tabId, uint8 slotId) const
void	_RemoveItem (CharacterDatabaseTransaction trans, uint8 tabId, uint8 slotId)
void	_MoveItems (MoveItemData *pSrc, MoveItemData *pDest, uint32 splitedAmount)
bool	_DoItemsMove (MoveItemData *pSrc, MoveItemData *pDest, bool sendError, uint32 splitedAmount=0)
void	_SendBankContent (WorldSession *session, uint8 tabId, bool sendAllSlots) const
void	_SendBankMoneyUpdate (WorldSession *session) const
void	_SendBankContentUpdate (MoveItemData *pSrc, MoveItemData *pDest) const
void	_SendBankContentUpdate (uint8 tabId, SlotIds slots) const
void	_SendBankList (WorldSession *session=nullptr, uint8 tabId=0, bool sendFullSlots=false, SlotIds *slots=nullptr) const
void	_BroadcastEvent (GuildEvents guildEvent, ObjectGuid guid=ObjectGuid::Empty, Optional< std::string_view > param1={}, Optional< std::string_view > param2={}, Optional< std::string_view > param3={}) const

Detailed Description

Constructor & Destructor Documentation

Guild()

Guild::Guild

(

)

            :
    m_id(0),
    m_createdDate(0),
    m_accountsNumber(0),
    m_bankMoney(0)
{
}

~Guild()

Guild::~Guild

(

)

{
    CharacterDatabaseTransaction temp(nullptr);
    _DeleteBankItems(temp);
}

References _DeleteBankItems().

Member Function Documentation

_BroadcastEvent()

void Guild::_BroadcastEvent ( GuildEvents  guildEvent, ObjectGuid  guid = ObjectGuid::Empty, Optional< std::string_view >  param1 = {}, Optional< std::string_view >  param2 = {}, Optional< std::string_view >  param3 = {}  ) const

private

{
    WorldPackets::Guild::GuildEvent event;
    event.Type = guildEvent;
    if (param1)
        event.Params.push_back(*param1);
 
    if (param2)
    {
        event.Params.resize(2);
        event.Params[1] = *param2;
    }
 
    if (param3)
    {
        event.Params.resize(3);
        event.Params[2] = *param3;
    }
    event.Guid = guid;
    BroadcastPacket(event.Write());
    LOG_DEBUG("guild", "SMSG_GUILD_EVENT [Broadcast] Event: {}", guildEvent);
}

References BroadcastPacket(), LOG_DEBUG, WorldPackets::Guild::GuildEvent::Type, and WorldPackets::Guild::GuildEvent::Write().

Referenced by AddMember(), DeleteMember(), Disband(), HandleAddNewRank(), HandleBuyBankTab(), HandleLeaveMember(), HandleMemberDepositMoney(), HandleMemberLogout(), HandleMemberWithdrawMoney(), HandleRemoveMember(), HandleRemoveRank(), HandleSetBankTabInfo(), HandleSetLeader(), HandleSetMOTD(), HandleSetRankInfo(), HandleSetRankInfo(), HandleUpdateMemberRank(), ResetTimes(), and SendLoginInfo().

_CreateDefaultGuildRanks()

void Guild::_CreateDefaultGuildRanks ( LocaleConstant  loc )

private

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_RANKS);
    stmt->SetData(0, m_id);
    CharacterDatabase.Execute(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS);
    stmt->SetData(0, m_id);
    CharacterDatabase.Execute(stmt);
 
    _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_MASTER,   loc), GR_RIGHT_ALL);
    _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_OFFICER,  loc), GR_RIGHT_ALL);
    _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_VETERAN,  loc), GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
    _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_MEMBER,   loc), GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
    _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_INITIATE, loc), GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
}

References _CreateRank(), CHAR_DEL_GUILD_BANK_RIGHTS, CHAR_DEL_GUILD_RANKS, CharacterDatabase, GR_RIGHT_ALL, GR_RIGHT_GCHATLISTEN, GR_RIGHT_GCHATSPEAK, LANG_GUILD_INITIATE, LANG_GUILD_MASTER, LANG_GUILD_MEMBER, LANG_GUILD_OFFICER, LANG_GUILD_VETERAN, m_id, PreparedStatementBase::SetData(), and sObjectMgr.

Referenced by Create(), and Validate().

_CreateNewBankTab()

void Guild::_CreateNewBankTab ( )

private

{
    uint8 tabId = _GetPurchasedTabsSize();                      // Next free id
    m_bankTabs.emplace_back(m_id, tabId);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_TAB);
    stmt->SetData(0, m_id);
    stmt->SetData (1, tabId);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD_BANK_TAB);
    stmt->SetData(0, m_id);
    stmt->SetData (1, tabId);
    trans->Append(stmt);
 
    ++tabId;
    for (auto& m_rank : m_ranks)
        m_rank.CreateMissingTabsIfNeeded(tabId, trans, false);
 
    CharacterDatabase.CommitTransaction(trans);
}

References _GetPurchasedTabsSize(), CHAR_DEL_GUILD_BANK_TAB, CHAR_INS_GUILD_BANK_TAB, CharacterDatabase, m_bankTabs, m_id, m_ranks, and PreparedStatementBase::SetData().

Referenced by Create(), and HandleBuyBankTab().

_CreateRank()

bool Guild::_CreateRank ( std::string_view  name, uint32  rights  )

private

{
    uint8 newRankId = _GetRanksSize();
    if (newRankId >= GUILD_RANKS_MAX_COUNT)
        return false;
 
    // Ranks represent sequence 0, 1, 2, ... where 0 means guildmaster
    RankInfo info(m_id, newRankId, name, rights, 0);
    m_ranks.push_back(info);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    info.CreateMissingTabsIfNeeded(_GetPurchasedTabsSize(), trans);
    info.SaveToDB(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    return true;
}

References _GetPurchasedTabsSize(), _GetRanksSize(), CharacterDatabase, Guild::RankInfo::CreateMissingTabsIfNeeded(), GUILD_RANKS_MAX_COUNT, m_id, m_ranks, and Guild::RankInfo::SaveToDB().

Referenced by _CreateDefaultGuildRanks(), and HandleAddNewRank().

_DeleteBankItems()

void Guild::_DeleteBankItems ( CharacterDatabaseTransaction  trans, bool  removeItemsFromDB = false  )

private

{
    for (uint8 tabId = 0; tabId < _GetPurchasedTabsSize(); ++tabId)
    {
        m_bankTabs[tabId].Delete(trans, removeItemsFromDB);
    }
    m_bankTabs.clear();
}

References _GetPurchasedTabsSize(), and m_bankTabs.

Referenced by Disband(), and ~Guild().

_DeleteMemberFromDB()

void Guild::_DeleteMemberFromDB ( ObjectGuid::LowType  lowguid ) const

inlineprivate

    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_MEMBER);
        stmt->SetData(0, lowguid);
        CharacterDatabase.Execute(stmt);
    }

References CHAR_DEL_GUILD_MEMBER, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by DeleteMember(), and LoadMemberFromDB().

_DoItemsMove()

bool Guild::_DoItemsMove ( MoveItemData *  pSrc, MoveItemData *  pDest, bool  sendError, uint32  splitedAmount = 0  )

private

{
    Item* pDestItem = pDest->GetItem();
    bool swap = (pDestItem != nullptr);
 
    Item* pSrcItem = pSrc->GetItem(splitedAmount);
    // 1. Can store source item in destination
    if (!pDest->CanStore(pSrcItem, swap, sendError))
        return false;
 
    // 2. Can store destination item in source
    if (swap)
        if (!pSrc->CanStore(pDestItem, true, true))
            return false;
 
    // GM LOG (TODO: move to scripts)
    pDest->LogAction(pSrc);
    if (swap)
        pSrc->LogAction(pDest);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    // 3. Log bank events
    pDest->LogBankEvent(trans, pSrc, pSrcItem->GetCount());
    if (swap)
        pSrc->LogBankEvent(trans, pDest, pDestItem->GetCount());
 
    // 4. Remove item from source
    pSrc->RemoveItem(trans, pDest, splitedAmount);
 
    // 5. Remove item from destination
    if (swap)
        pDest->RemoveItem(trans, pSrc);
 
    // 6. Store item in destination
    pDest->StoreItem(trans, pSrcItem);
 
    // 7. Store item in source
    if (swap)
        pSrc->StoreItem(trans, pDestItem);
 
    CharacterDatabase.CommitTransaction(trans);
    return true;
}

References Guild::MoveItemData::CanStore(), CharacterDatabase, Item::GetCount(), Guild::MoveItemData::GetItem(), Guild::MoveItemData::LogAction(), Guild::MoveItemData::LogBankEvent(), Guild::MoveItemData::RemoveItem(), and Guild::MoveItemData::StoreItem().

Referenced by _MoveItems().

_GetItem()

Item * Guild::_GetItem ( uint8  tabId, uint8  slotId  ) const

inlineprivate

{
    if (BankTab const* tab = GetBankTab(tabId))
        return tab->GetItem(slotId);
    return nullptr;
}

References GetBankTab().

_GetLowestRankId()

uint8 Guild::_GetLowestRankId ( ) const

inlineprivate

{ return uint8(m_ranks.size() - 1); }

References m_ranks.

Referenced by AddMember(), ChangeMemberRank(), HandleRemoveLowestRank(), HandleUpdateMemberRank(), and Validate().

_GetMemberRemainingMoney()

int32 Guild::_GetMemberRemainingMoney ( Member const &  member ) const

inlineprivate

{
    uint8 rankId = member.GetRankId();
    if (rankId == GR_GUILDMASTER)
        return static_cast<int32>(GUILD_WITHDRAW_MONEY_UNLIMITED);
 
    if ((_GetRankRights(rankId) & (GR_RIGHT_WITHDRAW_REPAIR | GR_RIGHT_WITHDRAW_GOLD)) != 0)
    {
        int32 remaining = _GetRankBankMoneyPerDay(rankId) - member.GetBankWithdrawValue(GUILD_BANK_MAX_TABS);
        if (remaining > 0)
            return remaining;
    }
    return 0;
}

References _GetRankBankMoneyPerDay(), _GetRankRights(), Guild::Member::GetBankWithdrawValue(), Guild::Member::GetRankId(), GR_GUILDMASTER, GR_RIGHT_WITHDRAW_GOLD, GR_RIGHT_WITHDRAW_REPAIR, GUILD_BANK_MAX_TABS, and GUILD_WITHDRAW_MONEY_UNLIMITED.

Referenced by HandleMemberWithdrawMoney(), and SendMoneyInfo().

_GetMemberRemainingSlots()

int32 Guild::_GetMemberRemainingSlots ( Member const &  member, uint8  tabId  ) const

inlineprivate

{
    uint8 rankId = member.GetRankId();
    if (rankId == GR_GUILDMASTER)
        return static_cast<int32>(GUILD_WITHDRAW_SLOT_UNLIMITED);
    if ((_GetRankBankTabRights(rankId, tabId) & GUILD_BANK_RIGHT_VIEW_TAB) != 0)
    {
        int32 remaining = _GetRankBankTabSlotsPerDay(rankId, tabId) - member.GetBankWithdrawValue(tabId);
        if (remaining > 0)
            return remaining;
    }
    return 0;
}

References _GetRankBankTabRights(), _GetRankBankTabSlotsPerDay(), Guild::Member::GetBankWithdrawValue(), Guild::Member::GetRankId(), GR_GUILDMASTER, GUILD_BANK_RIGHT_VIEW_TAB, and GUILD_WITHDRAW_SLOT_UNLIMITED.

Referenced by _SendBankList(), and SendPermissions().

_GetPurchasedTabsSize()

uint8 Guild::_GetPurchasedTabsSize ( ) const

inlineprivate

{ return uint8(m_bankTabs.size()); }

References m_bankTabs.

Referenced by _CreateNewBankTab(), _CreateRank(), _DeleteBankItems(), _GetRankBankTabSlotsPerDay(), _SendBankList(), _SetRankBankTabRightsAndSlots(), HandleBuyBankTab(), LoadBankEventLogFromDB(), LoadBankItemFromDB(), LoadBankTabFromDB(), SendBankLog(), SendBankTabData(), SendPermissions(), SwapItems(), SwapItemsWithInventory(), and Validate().

_GetRankBankMoneyPerDay()

int32 Guild::_GetRankBankMoneyPerDay ( uint8  rankId ) const

inlineprivate

{
    if (RankInfo const* rankInfo = GetRankInfo(rankId))
        return rankInfo->GetBankMoneyPerDay();
    return 0;
}

References GetRankInfo().

Referenced by _GetMemberRemainingMoney(), and SendPermissions().

_GetRankBankTabRights()

int8 Guild::_GetRankBankTabRights ( uint8  rankId, uint8  tabId  ) const

inlineprivate

{
    if (RankInfo const* rankInfo = GetRankInfo(rankId))
        return rankInfo->GetBankTabRights(tabId);
    return 0;
}

References GetRankInfo().

Referenced by _GetMemberRemainingSlots(), _MemberHasTabRights(), and SendPermissions().

_GetRankBankTabSlotsPerDay()

int32 Guild::_GetRankBankTabSlotsPerDay ( uint8  rankId, uint8  tabId  ) const

inlineprivate

{
    if (tabId < _GetPurchasedTabsSize())
        if (RankInfo const* rankInfo = GetRankInfo(rankId))
            return rankInfo->GetBankTabSlotsPerDay(tabId);
    return 0;
}

References _GetPurchasedTabsSize(), and GetRankInfo().

Referenced by _GetMemberRemainingSlots(), and _UpdateMemberWithdrawSlots().

_GetRankName()

std::string Guild::_GetRankName ( uint8  rankId ) const

inlineprivate

{
    if (RankInfo const* rankInfo = GetRankInfo(rankId))
        return rankInfo->GetName();
    return "<unknown>";
}

References GetRankInfo().

Referenced by HandleUpdateMemberRank().

_GetRankRights()

uint32 Guild::_GetRankRights ( uint8  rankId ) const

inlineprivate

{
    if (RankInfo const* rankInfo = GetRankInfo(rankId))
        return rankInfo->GetRights();
    return 0;
}

References GetRankInfo().

Referenced by _GetMemberRemainingMoney(), _HasRankRight(), GetRankRights(), HandleMemberWithdrawMoney(), and SendPermissions().

_GetRanksSize()

uint8 Guild::_GetRanksSize ( ) const

inlineprivate

{ return uint8(m_ranks.size()); }

References m_ranks.

Referenced by _CreateRank(), GetRankInfo(), GetRankInfo(), HandleAddNewRank(), HandleQuery(), HandleRemoveRank(), and Validate().

_HasRankRight()

bool Guild::_HasRankRight ( Player *  player, uint32  right  ) const

inlineprivate

    {
        if (player)
            if (Member const* member = GetMember(player->GetGUID()))
                return (_GetRankRights(member->GetRankId()) & right) != GR_RIGHT_EMPTY;
        return false;
    }

References _GetRankRights(), Object::GetGUID(), GetMember(), and GR_RIGHT_EMPTY.

Referenced by BroadcastToGuild(), HandleInviteMember(), HandleRemoveMember(), HandleRoster(), HandleSetInfo(), HandleSetMemberNote(), HandleSetMOTD(), HandleUpdateMemberRank(), and HasRankRight().

_IsLeader()

bool Guild::_IsLeader ( Player *  player ) const

private

{
    if (player->GetGUID() == m_leaderGuid)
        return true;
    if (Member const* member = GetMember(player->GetGUID()))
        return member->IsRank(GR_GUILDMASTER);
    return false;
}

References Object::GetGUID(), GetMember(), GR_GUILDMASTER, and m_leaderGuid.

Referenced by HandleAddNewRank(), HandleDisband(), HandleLeaveMember(), HandleRemoveRank(), HandleSetEmblem(), HandleSetLeader(), and HandleSetRankInfo().

_LogBankEvent()

void Guild::_LogBankEvent ( CharacterDatabaseTransaction  trans, GuildBankEventLogTypes  eventType, uint8  tabId, ObjectGuid  playerGuid, uint32  itemOrMoney, uint16  itemStackCount = 0, uint8  destTabId = 0  )

private

{
    if (tabId > GUILD_BANK_MAX_TABS)
        return;
 
    // not logging moves within the same tab
    if (eventType == GUILD_BANK_LOG_MOVE_ITEM && tabId == destTabId)
        return;
 
    uint8 dbTabId = tabId;
    if (BankEventLogEntry::IsMoneyEvent(eventType))
    {
        tabId = GUILD_BANK_MAX_TABS;
        dbTabId = GUILD_BANK_MONEY_LOGS_TAB;
    }
    LogHolder<BankEventLogEntry>& pLog = m_bankEventLog[tabId];
    pLog.AddEvent(trans, m_id, pLog.GetNextGUID(), eventType, dbTabId, guid, itemOrMoney, itemStackCount, destTabId);
 
    sScriptMgr->OnGuildBankEvent(this, uint8(eventType), tabId, guid.GetCounter(), itemOrMoney, itemStackCount, destTabId);
}

References Guild::LogHolder< Entry >::AddEvent(), ObjectGuid::GetCounter(), Guild::LogHolder< Entry >::GetNextGUID(), GUILD_BANK_LOG_MOVE_ITEM, GUILD_BANK_MAX_TABS, GUILD_BANK_MONEY_LOGS_TAB, Guild::BankEventLogEntry::IsMoneyEvent(), m_bankEventLog, m_id, and sScriptMgr.

Referenced by HandleMemberDepositMoney(), and HandleMemberWithdrawMoney().

_LogEvent()

void Guild::_LogEvent ( GuildEventLogTypes  eventType, ObjectGuid  playerGuid1, ObjectGuid  playerGuid2 = ObjectGuid::Empty, uint8  newRank = 0  )

inlineprivate

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    m_eventLog.AddEvent(trans, m_id, m_eventLog.GetNextGUID(), eventType, playerGuid1, playerGuid2, newRank);
    CharacterDatabase.CommitTransaction(trans);
 
    sScriptMgr->OnGuildEvent(this, uint8(eventType), playerGuid1.GetCounter(), playerGuid2.GetCounter(), newRank);
}

References CharacterDatabase, ObjectGuid::GetCounter(), m_eventLog, m_id, and sScriptMgr.

Referenced by AddMember(), HandleInviteMember(), HandleLeaveMember(), HandleRemoveMember(), and HandleUpdateMemberRank().

_MemberHasTabRights()

bool Guild::_MemberHasTabRights ( ObjectGuid  guid, uint8  tabId, uint32  rights  ) const

inlineprivate

{
    if (Member const* member = GetMember(guid))
    {
        // Leader always has full rights
        if (member->IsRank(GR_GUILDMASTER) || m_leaderGuid == guid)
            return true;
        return (_GetRankBankTabRights(member->GetRankId(), tabId) & rights) == rights;
    }
    return false;
}

References _GetRankBankTabRights(), GetMember(), GR_GUILDMASTER, and m_leaderGuid.

Referenced by _SendBankContent(), _SendBankList(), and MemberHasTabRights().

_ModifyBankMoney()

bool Guild::_ModifyBankMoney ( CharacterDatabaseTransaction  trans, uint64  amount, bool  add  )

private

{
    if (add)
        m_bankMoney += amount;
    else
    {
        // Check if there is enough money in bank.
        if (m_bankMoney < amount)
            return false;
        m_bankMoney -= amount;
    }
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_BANK_MONEY);
    stmt->SetData(0, m_bankMoney);
    stmt->SetData(1, m_id);
    trans->Append(stmt);
    return true;
}

References CHAR_UPD_GUILD_BANK_MONEY, CharacterDatabase, m_bankMoney, m_id, and PreparedStatementBase::SetData().

Referenced by HandleMemberDepositMoney(), HandleMemberWithdrawMoney(), and ModifyBankMoney().

_MoveItems()

void Guild::_MoveItems ( MoveItemData *  pSrc, MoveItemData *  pDest, uint32  splitedAmount  )

private

{
    // 1. Initialize source item
    if (!pSrc->InitItem())
        return; // No source item
 
    // 2. Check source item
    if (!pSrc->CheckItem(splitedAmount))
        return; // Source item or splited amount is invalid
 
    // 3. Check destination rights
    if (!pDest->HasStoreRights(pSrc))
        return; // Player has no rights to store item in destination
 
    // 4. Check source withdraw rights
    if (!pSrc->HasWithdrawRights(pDest))
        return; // Player has no rights to withdraw items from source
 
    // 5. Check split
    if (splitedAmount)
    {
        // 5.1. Clone source item
        if (!pSrc->CloneItem(splitedAmount))
            return; // Item could not be cloned
 
        // 5.2. Move splited item to destination
        _DoItemsMove(pSrc, pDest, true, splitedAmount);
    }
    else // 6. No split
    {
        // 6.1. Try to merge items in destination (pDest->GetItem() == nullptr)
        if (!_DoItemsMove(pSrc, pDest, false)) // Item could not be merged
        {
            // 6.2. Try to swap items
            // 6.2.1. Initialize destination item
            if (!pDest->InitItem())
                return;
 
            // 6.2.2. Check rights to store item in source (opposite direction)
            if (!pSrc->HasStoreRights(pDest))
                return; // Player has no rights to store item in source (opposite direction)
 
            if (!pDest->HasWithdrawRights(pSrc))
                return; // Player has no rights to withdraw item from destination (opposite direction)
 
            // 6.2.3. Swap items (pDest->GetItem() != nullptr)
            _DoItemsMove(pSrc, pDest, true);
        }
    }
    // 7. Send changes
    _SendBankContentUpdate(pSrc, pDest);
}

References _DoItemsMove(), _SendBankContentUpdate(), Guild::MoveItemData::CheckItem(), Guild::MoveItemData::CloneItem(), Guild::MoveItemData::HasStoreRights(), Guild::MoveItemData::HasWithdrawRights(), and Guild::MoveItemData::InitItem().

Referenced by SwapItems(), and SwapItemsWithInventory().

_RemoveItem()

void Guild::_RemoveItem ( CharacterDatabaseTransaction  trans, uint8  tabId, uint8  slotId  )

inlineprivate

{
    if (BankTab* pTab = GetBankTab(tabId))
        pTab->SetItem(trans, slotId, nullptr);
}

References GetBankTab().

_SendBankContent()

void Guild::_SendBankContent ( WorldSession *  session, uint8  tabId, bool  sendAllSlots  ) const

private

{
    ObjectGuid guid = session->GetPlayer()->GetGUID();
    if (!_MemberHasTabRights(guid, tabId, GUILD_BANK_RIGHT_VIEW_TAB))
        return;
 
    _SendBankList(session, tabId, sendAllSlots);
}

References _MemberHasTabRights(), _SendBankList(), Object::GetGUID(), WorldSession::GetPlayer(), and GUILD_BANK_RIGHT_VIEW_TAB.

Referenced by SendBankTabData().

_SendBankContentUpdate() [1/2]

void Guild::_SendBankContentUpdate ( MoveItemData *  pSrc, MoveItemData *  pDest  ) const

private

{
    ASSERT(pSrc->IsBank() || pDest->IsBank());
 
    uint8 tabId = 0;
    SlotIds slots;
    if (pSrc->IsBank()) // B ->
    {
        tabId = pSrc->GetContainer();
        slots.insert(pSrc->GetSlotId());
        if (pDest->IsBank()) // B -> B
        {
            // Same tab - add destination slots to collection
            if (pDest->GetContainer() == pSrc->GetContainer())
                pDest->CopySlots(slots);
            else // Different tabs - send second message
            {
                SlotIds destSlots;
                pDest->CopySlots(destSlots);
                _SendBankContentUpdate(pDest->GetContainer(), destSlots);
            }
        }
    }
    else if (pDest->IsBank()) // C -> B
    {
        tabId = pDest->GetContainer();
        pDest->CopySlots(slots);
    }
 
    _SendBankContentUpdate(tabId, slots);
}

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

Referenced by _MoveItems(), and _SendBankContentUpdate().

_SendBankContentUpdate() [2/2]

void Guild::_SendBankContentUpdate ( uint8  tabId, SlotIds  slots  ) const

private

{
    _SendBankList(nullptr, tabId, false, &slots);
}

References _SendBankList().

_SendBankList()

void Guild::_SendBankList ( WorldSession *  session = nullptr, uint8  tabId = 0, bool  sendFullSlots = false, SlotIds *  slots = nullptr  ) const

private

{
    if (!sScriptMgr->CanGuildSendBankList(this, session, tabId, sendAllSlots))
        return;
 
    WorldPackets::Guild::GuildBankQueryResults packet;
 
    packet.Money = m_bankMoney;
    packet.Tab = int32(tabId);
    packet.FullUpdate = sendAllSlots;
 
    if (sendAllSlots && !tabId)
    {
        packet.TabInfo.reserve(_GetPurchasedTabsSize());
        for (uint8 i = 0; i < _GetPurchasedTabsSize(); ++i)
        {
            WorldPackets::Guild::GuildBankTabInfo tabInfo;
            tabInfo.Name = m_bankTabs[i].GetName();
            tabInfo.Icon = m_bankTabs[i].GetIcon();
            packet.TabInfo.push_back(tabInfo);
        }
    }
 
    if (BankTab const* tab = GetBankTab(tabId))
    {
        auto fillItems = [&](auto begin, auto end, bool skipEmpty)
        {
            for (auto itr = begin; itr != end; ++itr)
            {
                if (Item* tabItem = tab->GetItem(*itr))
                {
                    WorldPackets::Guild::GuildBankItemInfo itemInfo;
 
                    itemInfo.Slot = *itr;
                    itemInfo.ItemID = tabItem->GetEntry();
                    itemInfo.Count = int32(tabItem->GetCount());
                    itemInfo.Charges = int32(std::abs(tabItem->GetSpellCharges()));
                    itemInfo.EnchantmentID = int32(tabItem->GetEnchantmentId(PERM_ENCHANTMENT_SLOT));
                    itemInfo.Flags = tabItem->GetInt32Value(ITEM_FIELD_FLAGS);
                    itemInfo.RandomPropertiesID = tabItem->GetItemRandomPropertyId();
                    itemInfo.RandomPropertiesSeed = int32(tabItem->GetItemSuffixFactor());
 
                    for (uint32 socketSlot = 0; socketSlot < MAX_GEM_SOCKETS; ++socketSlot)
                    {
                        if (uint32 enchId = tabItem->GetEnchantmentId(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT + socketSlot)))
                        {
                            WorldPackets::Guild::GuildBankSocketEnchant gem;
                            gem.SocketIndex = socketSlot;
                            gem.SocketEnchantID = int32(enchId);
                            itemInfo.SocketEnchant.push_back(gem);
                        }
                    }
 
                    packet.ItemInfo.push_back(itemInfo);
                }
                else if (!skipEmpty)
                {
                    WorldPackets::Guild::GuildBankItemInfo itemInfo;
 
                    itemInfo.Slot = *itr;
                    itemInfo.ItemID = 0;
 
                    packet.ItemInfo.push_back(itemInfo);
                }
            }
 
        };
 
        if (sendAllSlots)
            fillItems(boost::make_counting_iterator(uint8(0)), boost::make_counting_iterator(uint8(GUILD_BANK_MAX_SLOTS)), true);
        else if (slots && !slots->empty())
            fillItems(slots->begin(), slots->end(), false);
    }
 
    if (session)
    {
        if (Member const* member = GetMember(session->GetPlayer()->GetGUID()))
            packet.WithdrawalsRemaining = _GetMemberRemainingSlots(*member, tabId);
 
        session->SendPacket(packet.Write());
        LOG_DEBUG("guild", "SMSG_GUILD_BANK_LIST [{}]: TabId: {}, FullSlots: {}, slots: {}",
                     session->GetPlayerInfo(), tabId, sendAllSlots, packet.WithdrawalsRemaining);
    }
    else
    {
        packet.Write();
        for (auto const& [guid, member] : m_members)
        {
            if (!member.ShouldReceiveBankPartialUpdatePackets())
                continue;
 
            if (!_MemberHasTabRights(member.GetGUID(), tabId, GUILD_BANK_RIGHT_VIEW_TAB))
                continue;
 
            Player* player = member.FindPlayer();
            if (!player)
                continue;
 
            packet.SetWithdrawalsRemaining(_GetMemberRemainingSlots(member, tabId));
            player->SendDirectMessage(packet.GetRawPacket());
            LOG_DEBUG("guild", "SMSG_GUILD_BANK_LIST [{}]: TabId: {}, FullSlots: {}, slots: {}"
                    , player->GetName(), tabId, sendAllSlots, packet.WithdrawalsRemaining);
        }
    }
}

References _GetMemberRemainingSlots(), _GetPurchasedTabsSize(), _MemberHasTabRights(), WorldPackets::Guild::GuildBankItemInfo::Charges, WorldPackets::Guild::GuildBankItemInfo::Count, WorldPackets::Guild::GuildBankItemInfo::EnchantmentID, WorldPackets::Guild::GuildBankItemInfo::Flags, WorldPackets::Guild::GuildBankQueryResults::FullUpdate, GetBankTab(), Object::GetGUID(), GetMember(), WorldObject::GetName(), WorldSession::GetPlayer(), WorldSession::GetPlayerInfo(), WorldPackets::Packet::GetRawPacket(), GUILD_BANK_MAX_SLOTS, GUILD_BANK_RIGHT_VIEW_TAB, WorldPackets::Guild::GuildBankTabInfo::Icon, ITEM_FIELD_FLAGS, WorldPackets::Guild::GuildBankItemInfo::ItemID, WorldPackets::Guild::GuildBankQueryResults::ItemInfo, LOG_DEBUG, m_bankMoney, m_bankTabs, m_members, MAX_GEM_SOCKETS, WorldPackets::Guild::GuildBankQueryResults::Money, WorldPackets::Guild::GuildBankTabInfo::Name, PERM_ENCHANTMENT_SLOT, WorldPackets::Guild::GuildBankItemInfo::RandomPropertiesID, WorldPackets::Guild::GuildBankItemInfo::RandomPropertiesSeed, Player::SendDirectMessage(), WorldSession::SendPacket(), WorldPackets::Guild::GuildBankQueryResults::SetWithdrawalsRemaining(), WorldPackets::Guild::GuildBankItemInfo::Slot, SOCK_ENCHANTMENT_SLOT, WorldPackets::Guild::GuildBankItemInfo::SocketEnchant, WorldPackets::Guild::GuildBankSocketEnchant::SocketEnchantID, WorldPackets::Guild::GuildBankSocketEnchant::SocketIndex, sScriptMgr, WorldPackets::Guild::GuildBankQueryResults::Tab, WorldPackets::Guild::GuildBankQueryResults::TabInfo, WorldPackets::Guild::GuildBankQueryResults::WithdrawalsRemaining, and WorldPackets::Guild::GuildBankQueryResults::Write().

Referenced by _SendBankContent(), _SendBankContentUpdate(), _SendBankMoneyUpdate(), and SendBankTabsInfo().

_SendBankMoneyUpdate()

void Guild::_SendBankMoneyUpdate ( WorldSession *  session ) const

private

{
    _SendBankList(session);
}

References _SendBankList().

_SetLeaderGUID()

void Guild::_SetLeaderGUID ( Member &  pLeader )

private

{
    m_leaderGuid = pLeader.GetGUID();
    pLeader.ChangeRank(GR_GUILDMASTER);
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_LEADER);
    stmt->SetData(0, m_leaderGuid.GetCounter());
    stmt->SetData(1, m_id);
    CharacterDatabase.Execute(stmt);
}

References Guild::Member::ChangeRank(), CHAR_UPD_GUILD_LEADER, CharacterDatabase, ObjectGuid::GetCounter(), Guild::Member::GetGUID(), GR_GUILDMASTER, m_id, m_leaderGuid, and PreparedStatementBase::SetData().

Referenced by DeleteMember(), HandleSetLeader(), and Validate().

_SetRankBankMoneyPerDay()

void Guild::_SetRankBankMoneyPerDay ( uint8  rankId, uint32  moneyPerDay  )

private

{
    if (RankInfo* rankInfo = GetRankInfo(rankId))
        rankInfo->SetBankMoneyPerDay(moneyPerDay);
}

References GetRankInfo().

Referenced by HandleSetRankInfo(), and HandleSetRankInfo().

_SetRankBankTabRightsAndSlots()

void Guild::_SetRankBankTabRightsAndSlots ( uint8  rankId, GuildBankRightsAndSlots  rightsAndSlots, bool  saveToDB = true  )

private

{
    if (rightsAndSlots.GetTabId() >= _GetPurchasedTabsSize())
        return;
 
    if (RankInfo* rankInfo = GetRankInfo(rankId))
        rankInfo->SetBankTabSlotsAndRights(rightsAndSlots, saveToDB);
}

References _GetPurchasedTabsSize(), GetRankInfo(), and GuildBankRightsAndSlots::GetTabId().

Referenced by HandleSetRankInfo(), and LoadBankRightFromDB().

_UpdateAccountsNumber()

void Guild::_UpdateAccountsNumber ( )

private

{
    // We use a set to be sure each element will be unique
    std::unordered_set<uint32> accountsIdSet;
    for (auto const& [guid, member] : m_members)
        accountsIdSet.insert(member.GetAccountId());
 
    m_accountsNumber = accountsIdSet.size();
}

References m_accountsNumber, and m_members.

Referenced by AddMember(), DeleteMember(), and Validate().

_UpdateMemberWithdrawSlots()

void Guild::_UpdateMemberWithdrawSlots ( CharacterDatabaseTransaction  trans, ObjectGuid  guid, uint8  tabId  )

inlineprivate

{
    if (Member* member = GetMember(guid))
    {
        uint8 rankId = member->GetRankId();
        if (rankId != GR_GUILDMASTER
                && member->GetBankWithdrawValue(tabId) < _GetRankBankTabSlotsPerDay(rankId, tabId))
            member->UpdateBankWithdrawValue(trans, tabId, 1);
    }
}

References _GetRankBankTabSlotsPerDay(), GetMember(), and GR_GUILDMASTER.

AddMember()

bool Guild::AddMember	(	ObjectGuid	guid,
		uint8	rankId = GUILD_RANK_NONE
	)

{
    Player* player = ObjectAccessor::FindConnectedPlayer(guid);
    // Player cannot be in guild
    if (player)
    {
        if (player->GetGuildId() != 0)
            return false;
    }
    else if (sCharacterCache->GetCharacterGuildIdByGuid(guid) != 0)
        return false;
 
    // Remove all player signs from another petitions
    // This will be prevent attempt to join many guilds and corrupt guild data integrity
    Player::RemovePetitionsAndSigns(guid, GUILD_CHARTER_TYPE);
 
    ObjectGuid::LowType lowguid = guid.GetCounter();
 
    // If rank was not passed, assign lowest possible rank
    if (rankId == GUILD_RANK_NONE)
        rankId = _GetLowestRankId();
 
    auto [memberIt, isNew] = m_members.try_emplace(lowguid, m_id, guid, rankId);
    if (!isNew)
    {
        LOG_ERROR("guild", "Tried to add {} to guild '{}'. Member already exists.", guid.ToString(), m_name);
        return false;
    }
 
    Member& member = memberIt->second;
    std::string name;
    if (player)
    {
        player->SetInGuild(m_id);
        player->SetGuildIdInvited(0);
        player->SetRank(rankId);
        member.SetStats(player);
        SendLoginInfo(player->GetSession());
        name = player->GetName();
    }
    else
    {
        member.ResetFlags();
 
        bool ok = false;
        // xinef: sync query
        // Player must exist
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_DATA_FOR_GUILD);
        stmt->SetData(0, guid.GetCounter());
        if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
        {
            Field* fields = result->Fetch();
            name = fields[0].Get<std::string>();
            member.SetStats(
                name,
                fields[1].Get<uint8>(),
                fields[2].Get<uint8>(),
                fields[3].Get<uint8>(),
                fields[4].Get<uint16>(),
                fields[5].Get<uint32>());
 
            ok = member.CheckStats();
        }
        if (!ok)
        {
            m_members.erase(memberIt);
            return false;
        }
        sCharacterCache->UpdateCharacterGuildId(guid, m_id);
    }
 
    CharacterDatabaseTransaction trans(nullptr);
    member.SaveToDB(trans);
 
    _UpdateAccountsNumber();
    _LogEvent(GUILD_EVENT_LOG_JOIN_GUILD, guid);
    _BroadcastEvent(GE_JOINED, guid, name);
 
    // Call scripts if member was succesfully added (and stored to database)
    sScriptMgr->OnGuildAddMember(this, player, rankId);
 
    return true;
}

References _BroadcastEvent(), _GetLowestRankId(), _LogEvent(), _UpdateAccountsNumber(), CHAR_SEL_CHAR_DATA_FOR_GUILD, CharacterDatabase, Guild::Member::CheckStats(), ObjectAccessor::FindConnectedPlayer(), GE_JOINED, Field::Get(), ObjectGuid::GetCounter(), Player::GetGuildId(), WorldObject::GetName(), Player::GetSession(), GUILD_CHARTER_TYPE, GUILD_EVENT_LOG_JOIN_GUILD, GUILD_RANK_NONE, LOG_ERROR, m_id, m_members, m_name, Player::RemovePetitionsAndSigns(), Guild::Member::ResetFlags(), Guild::Member::SaveToDB(), sCharacterCache, SendLoginInfo(), PreparedStatementBase::SetData(), Player::SetGuildIdInvited(), Player::SetInGuild(), Player::SetRank(), Guild::Member::SetStats(), sScriptMgr, and ObjectGuid::ToString().

Referenced by Create(), HandleAcceptMember(), guild_commandscript::HandleGuildInviteCommand(), and WorldSession::HandleTurnInPetitionOpcode().

BroadcastPacket()

void Guild::BroadcastPacket

(

WorldPacket const *

packet

)

const

{
    for (auto const& [guid, member] : m_members)
        if (Player* player = member.FindPlayer())
            player->SendDirectMessage(packet);
}

References m_members.

Referenced by _BroadcastEvent(), and Guild::BankTab::SendText().

BroadcastPacketToRank()

void Guild::BroadcastPacketToRank	(	WorldPacket const *	packet,
		uint8	rankId
	)		const

{
    for (auto const& [guid, member] : m_members)
        if (member.IsRank(rankId))
            if (Player* player = member.FindPlayer())
                player->SendDirectMessage(packet);
}

References m_members.

BroadcastToGuild()

void Guild::BroadcastToGuild	(	WorldSession *	session,
		bool	officerOnly,
		std::string_view	msg,
		uint32	language = LANG_UNIVERSAL
	)		const

{
    if (session && session->GetPlayer() && _HasRankRight(session->GetPlayer(), officerOnly ? GR_RIGHT_OFFCHATSPEAK : GR_RIGHT_GCHATSPEAK))
    {
        WorldPacket data;
        ChatHandler::BuildChatPacket(data, officerOnly ? CHAT_MSG_OFFICER : CHAT_MSG_GUILD, Language(language), session->GetPlayer(), nullptr, msg);
        for (auto const& [guid, member] : m_members)
            if (Player* player = member.FindPlayer())
                if (_HasRankRight(player, officerOnly ? GR_RIGHT_OFFCHATLISTEN : GR_RIGHT_GCHATLISTEN) && !player->GetSocial()->HasIgnore(session->GetPlayer()->GetGUID()))
                    player->SendDirectMessage(&data);
    }
}

References _HasRankRight(), ChatHandler::BuildChatPacket(), CHAT_MSG_GUILD, CHAT_MSG_OFFICER, Object::GetGUID(), WorldSession::GetPlayer(), GR_RIGHT_GCHATLISTEN, GR_RIGHT_GCHATSPEAK, GR_RIGHT_OFFCHATLISTEN, GR_RIGHT_OFFCHATSPEAK, and m_members.

BroadcastWorker()

template<class Do >

void Guild::BroadcastWorker ( Do &  _do, Player *  except = nullptr  )

inline

    {
        for (auto const& m_member : m_members)
            if (Player* player = m_member.second.FindPlayer())
                if (player != except)
                    _do(player);
    }

References m_members.

Referenced by AchievementMgr::SendAchievementEarned().

ChangeMemberRank()

bool Guild::ChangeMemberRank	(	ObjectGuid	guid,
		uint8	newRank
	)

{
    if (newRank <= _GetLowestRankId())                    // Validate rank (allow only existing ranks)
        if (Member* member = GetMember(guid))
        {
            member->ChangeRank(newRank);
 
            if (newRank == GR_GUILDMASTER)
            {
                m_leaderGuid = guid;
 
                CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_LEADER);
                stmt->SetData(0, m_leaderGuid.GetCounter());
                stmt->SetData(1, m_id);
                CharacterDatabase.Execute(stmt);
            }
 
            return true;
        }
    return false;
}

References _GetLowestRankId(), CHAR_UPD_GUILD_LEADER, CharacterDatabase, ObjectGuid::GetCounter(), GetMember(), GR_GUILDMASTER, m_id, m_leaderGuid, and PreparedStatementBase::SetData().

Referenced by guild_commandscript::HandleGuildRankCommand().

Create()

bool Guild::Create	(	Player *	pLeader,
		std::string_view	name
	)

{
    // Check if guild with such name already exists
    if (sGuildMgr->GetGuildByName(name))
        return false;
 
    WorldSession* pLeaderSession = pLeader->GetSession();
    if (!pLeaderSession)
        return false;
 
    m_id = sGuildMgr->GenerateGuildId();
    m_leaderGuid = pLeader->GetGUID();
    m_name = name;
    m_info = "";
    m_motd = "No message set.";
    m_bankMoney = 0;
    m_createdDate = GameTime::GetGameTime().count();
 
    LOG_DEBUG("guild", "GUILD: creating guild [{}] for leader {} ({})",
              m_name, pLeader->GetName(), m_leaderGuid.ToString());
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_MEMBERS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    uint8 index = 0;
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD);
    stmt->SetData(  index, m_id);
    stmt->SetData(++index, m_name);
    stmt->SetData(++index, m_leaderGuid.GetCounter());
    stmt->SetData(++index, m_info);
    stmt->SetData(++index, m_motd);
    stmt->SetData(++index, uint32(m_createdDate));
    stmt->SetData(++index, m_emblemInfo.GetStyle());
    stmt->SetData(++index, m_emblemInfo.GetColor());
    stmt->SetData(++index, m_emblemInfo.GetBorderStyle());
    stmt->SetData(++index, m_emblemInfo.GetBorderColor());
    stmt->SetData(++index, m_emblemInfo.GetBackgroundColor());
    stmt->SetData(++index, m_bankMoney);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
    _CreateDefaultGuildRanks(pLeaderSession->GetSessionDbLocaleIndex()); // Create default ranks
    bool ret = AddMember(m_leaderGuid, GR_GUILDMASTER);                  // Add guildmaster
 
    for (short i = 0; i < static_cast<short>(sWorld->getIntConfig(CONFIG_GUILD_BANK_INITIAL_TABS)); i++)
    {
        _CreateNewBankTab();
    }
 
    if (ret)
        sScriptMgr->OnGuildCreate(this, pLeader, m_name);
 
    return ret;
}

References _CreateDefaultGuildRanks(), _CreateNewBankTab(), AddMember(), CHAR_DEL_GUILD_MEMBERS, CHAR_INS_GUILD, CharacterDatabase, CONFIG_GUILD_BANK_INITIAL_TABS, EmblemInfo::GetBackgroundColor(), EmblemInfo::GetBorderColor(), EmblemInfo::GetBorderStyle(), EmblemInfo::GetColor(), ObjectGuid::GetCounter(), GameTime::GetGameTime(), Object::GetGUID(), WorldObject::GetName(), Player::GetSession(), WorldSession::GetSessionDbLocaleIndex(), EmblemInfo::GetStyle(), GR_GUILDMASTER, LOG_DEBUG, m_bankMoney, m_createdDate, m_emblemInfo, m_id, m_info, m_leaderGuid, m_motd, m_name, PreparedStatementBase::SetData(), sGuildMgr, sScriptMgr, sWorld, and ObjectGuid::ToString().

Referenced by guild_commandscript::HandleGuildCreateCommand(), and WorldSession::HandleTurnInPetitionOpcode().

DeleteMember()

void Guild::DeleteMember	(	ObjectGuid	guid,
		bool	isDisbanding = false,
		bool	isKicked = false,
		bool	canDeleteGuild = false
	)

{
    ObjectGuid::LowType lowguid = guid.GetCounter();
    Player* player = ObjectAccessor::FindConnectedPlayer(guid);
 
    // Guild master can be deleted when loading guild and guid doesn't exist in characters table
    // or when he is removed from guild by gm command
    if (m_leaderGuid == guid && !isDisbanding)
    {
        Member* oldLeader = nullptr;
        Member* newLeader = nullptr;
        for (auto& [guid, member] : m_members)
        {
            if (guid == lowguid)
                oldLeader = &member;
            else if (!newLeader || newLeader->GetRankId() > member.GetRankId())
                newLeader = &member;
        }
 
        if (!newLeader)
        {
            Disband();
            if (canDeleteGuild)
                delete this;
            return;
        }
 
        _SetLeaderGUID(*newLeader);
 
        // If player not online data in data field will be loaded from guild tabs no need to update it !!
        if (Player* newLeaderPlayer = newLeader->FindPlayer())
            newLeaderPlayer->SetRank(GR_GUILDMASTER);
 
        // If leader does not exist (at guild loading with deleted leader) do not send broadcasts
        if (oldLeader)
        {
            _BroadcastEvent(GE_LEADER_CHANGED, ObjectGuid::Empty, oldLeader->GetName(), newLeader->GetName());
            _BroadcastEvent(GE_LEFT, guid, oldLeader->GetName());
        }
    }
    // Call script on remove before member is actually removed from guild (and database)
    sScriptMgr->OnGuildRemoveMember(this, player, isDisbanding, isKicked);
 
    m_members.erase(lowguid);
 
    // If player not online data in data field will be loaded from guild tabs no need to update it !!
    if (player)
    {
        player->SetInGuild(0);
        player->SetRank(0);
    }
    else
    {
        sCharacterCache->UpdateCharacterGuildId(guid, 0);
    }
 
    _DeleteMemberFromDB(guid.GetCounter());
    if (!isDisbanding)
        _UpdateAccountsNumber();
}

References _BroadcastEvent(), _DeleteMemberFromDB(), _SetLeaderGUID(), _UpdateAccountsNumber(), Disband(), ObjectGuid::Empty, ObjectAccessor::FindConnectedPlayer(), Guild::Member::FindPlayer(), GE_LEADER_CHANGED, GE_LEFT, ObjectGuid::GetCounter(), Guild::Member::GetName(), Guild::Member::GetRankId(), GR_GUILDMASTER, m_leaderGuid, m_members, sCharacterCache, Player::SetInGuild(), Player::SetRank(), and sScriptMgr.

Referenced by Disband(), guild_commandscript::HandleGuildUninviteCommand(), HandleLeaveMember(), HandleRemoveMember(), and Validate().

Disband()

void Guild::Disband

(

)

{
    // Call scripts before guild data removed from database
    sScriptMgr->OnGuildDisband(this);
 
    _BroadcastEvent(GE_DISBANDED);
    // Remove all members
    while (!m_members.empty())
    {
        auto itr = m_members.begin();
        DeleteMember(itr->second.GetGUID(), true);
    }
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_RANKS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_TABS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    // Free bank tab used memory and delete items stored in them
    _DeleteBankItems(trans, true);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_ITEMS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_EVENTLOGS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_EVENTLOGS);
    stmt->SetData(0, m_id);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
    sGuildMgr->RemoveGuild(m_id);
}

References _BroadcastEvent(), _DeleteBankItems(), CHAR_DEL_GUILD, CHAR_DEL_GUILD_BANK_EVENTLOGS, CHAR_DEL_GUILD_BANK_ITEMS, CHAR_DEL_GUILD_BANK_RIGHTS, CHAR_DEL_GUILD_BANK_TABS, CHAR_DEL_GUILD_EVENTLOGS, CHAR_DEL_GUILD_RANKS, CharacterDatabase, DeleteMember(), GE_DISBANDED, m_id, m_members, PreparedStatementBase::SetData(), sGuildMgr, and sScriptMgr.

Referenced by DeleteMember(), HandleDisband(), guild_commandscript::HandleGuildDeleteCommand(), HandleLeaveMember(), and Validate().

GetBankTab() [1/2]

BankTab * Guild::GetBankTab ( uint8  tabId )

inlineprivate

{ return tabId < m_bankTabs.size() ? &m_bankTabs[tabId] : nullptr; }

References m_bankTabs.

Referenced by _GetItem(), _RemoveItem(), _SendBankList(), HandleSetBankTabInfo(), SendBankTabText(), and SetBankTabText().

GetBankTab() [2/2]

BankTab const * Guild::GetBankTab ( uint8  tabId ) const

inlineprivate

{ return tabId < m_bankTabs.size() ? &m_bankTabs[tabId] : nullptr; }

References m_bankTabs.

GetCreatedDate()

time_t Guild::GetCreatedDate ( ) const

inline

{ return m_createdDate; }

References m_createdDate.

Referenced by guild_commandscript::HandleGuildInfoCommand().

GetId()

uint32 Guild::GetId ( ) const

inline

{ return m_id; }

References m_id.

Referenced by GuildMgr::AddGuild(), guild_commandscript::HandleGuildInfoCommand(), HandleLeaveMember(), HandleMemberDepositMoney(), HandleMemberWithdrawMoney(), LoadMemberFromDB(), and SetName().

GetInfo()

std::string const & Guild::GetInfo ( ) const

inline

{ return m_info; }

References m_info.

Referenced by guild_commandscript::HandleGuildInfoCommand().

GetLeaderGUID()

ObjectGuid Guild::GetLeaderGUID ( ) const

inline

{ return m_leaderGuid; }

References m_leaderGuid.

Referenced by HandleAcceptMember(), guild_commandscript::HandleGuildInfoCommand(), HandleMemberDepositMoney(), and HandleMemberWithdrawMoney().

GetMember() [1/3]

Member * Guild::GetMember ( ObjectGuid  guid )

inline

    {
        auto itr = m_members.find(guid.GetCounter());
        return (itr != m_members.end()) ? &itr->second : nullptr;
    }

References ObjectGuid::GetCounter(), and m_members.

GetMember() [2/3]

Member const * Guild::GetMember ( ObjectGuid  guid ) const

inline

    {
        auto itr = m_members.find(guid.GetCounter());
        return (itr != m_members.end()) ? &itr->second : nullptr;
    }

References ObjectGuid::GetCounter(), and m_members.

Referenced by _HasRankRight(), _IsLeader(), _MemberHasTabRights(), _SendBankList(), _UpdateMemberWithdrawSlots(), ChangeMemberRank(), HandleBuyBankTab(), HandleMemberLogout(), HandleMemberWithdrawMoney(), WorldSession::HandlePlayerLoginFromDB(), HandleRemoveMember(), HandleSetLeader(), HandleSetMemberNote(), HandleUpdateMemberRank(), OnPlayerStatusChange(), SendBankTabsInfo(), SendLoginInfo(), SendMoneyInfo(), SendPermissions(), UpdateMemberData(), and Validate().

GetMember() [3/3]

Member * Guild::GetMember ( std::string_view  name )

inline

    {
        for (auto& m_member : m_members)
            if (m_member.second.GetName() == name)
                return &m_member.second;
 
        return nullptr;
    }

References m_members.

GetMemberCount()

uint32 Guild::GetMemberCount ( ) const

inline

{ return m_members.size(); }

References m_members.

Referenced by guild_commandscript::HandleGuildInfoCommand(), HandleInviteMember(), HandleMemberDepositMoney(), and HandleMemberWithdrawMoney().

GetMemberSize()

uint32 Guild::GetMemberSize ( ) const

inline

{ return m_members.size(); }

References m_members.

GetMOTD()

std::string const & Guild::GetMOTD ( ) const

inline

{ return m_motd; }

References m_motd.

Referenced by guild_commandscript::HandleGuildInfoCommand().

GetName()

std::string const & Guild::GetName ( ) const

inline

{ return m_name; }

References m_name.

Referenced by GuildMgr::GetGuildNameById(), guild_commandscript::HandleGuildInfoCommand(), HandleInviteMember(), HandleMemberDepositMoney(), HandleMemberWithdrawMoney(), ChatLogScript::OnPlayerCanUseChat(), and AchievementMgr::SendAchievementEarned().

GetRankInfo() [1/2]

RankInfo * Guild::GetRankInfo ( uint8  rankId )

inlineprivate

{ return rankId < _GetRanksSize() ? &m_ranks[rankId] : nullptr; }

References _GetRanksSize(), and m_ranks.

GetRankInfo() [2/2]

RankInfo const * Guild::GetRankInfo ( uint8  rankId ) const

inlineprivate

{ return rankId < _GetRanksSize() ? &m_ranks[rankId] : nullptr; }

References _GetRanksSize(), and m_ranks.

Referenced by _GetRankBankMoneyPerDay(), _GetRankBankTabRights(), _GetRankBankTabSlotsPerDay(), _GetRankName(), _GetRankRights(), _SetRankBankMoneyPerDay(), _SetRankBankTabRightsAndSlots(), HandleSetRankInfo(), HandleSetRankInfo(), and Validate().

GetRankRights()

uint32 Guild::GetRankRights

(

uint8

rankId

)

const

{
    return _GetRankRights(rankId);
}

References _GetRankRights().

GetTotalBankMoney()

uint64 Guild::GetTotalBankMoney ( ) const

inline

{ return m_bankMoney; }

References m_bankMoney.

Referenced by guild_commandscript::HandleGuildInfoCommand(), HandleMemberDepositMoney(), and HandleMemberWithdrawMoney().

HandleAcceptMember()

void Guild::HandleAcceptMember

(

WorldSession *

session

)

{
    Player* player = session->GetPlayer();
    if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeamId() != sCharacterCache->GetCharacterTeamByGuid(GetLeaderGUID()))
    {
        return;
    }
 
    AddMember(player->GetGUID());
}

References AddMember(), CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD, Object::GetGUID(), GetLeaderGUID(), WorldSession::GetPlayer(), Player::GetTeamId(), sCharacterCache, and sWorld.

HandleAddNewRank()

void Guild::HandleAddNewRank	(	WorldSession *	session,
		std::string_view	name
	)

{
    uint8 size = _GetRanksSize();
    if (size >= GUILD_RANKS_MAX_COUNT)
        return;
 
    // Only leader can add new rank
    if (_IsLeader(session->GetPlayer()))
        if (_CreateRank(name, GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK))
            _BroadcastEvent(GE_RANK_UPDATED, ObjectGuid::Empty, std::to_string(size), name, std::to_string(m_ranks.size()));
}

References _BroadcastEvent(), _CreateRank(), _GetRanksSize(), _IsLeader(), ObjectGuid::Empty, GE_RANK_UPDATED, WorldSession::GetPlayer(), GR_RIGHT_GCHATLISTEN, GR_RIGHT_GCHATSPEAK, GUILD_RANKS_MAX_COUNT, and m_ranks.

HandleBuyBankTab()

void Guild::HandleBuyBankTab	(	WorldSession *	session,
		uint8	tabId
	)

Hack to force client to update permissions

{
    Player* player = session->GetPlayer();
    if (!player)
        return;
 
    Member const* member = GetMember(player->GetGUID());
    if (!member)
        return;
 
    if (_GetPurchasedTabsSize() >= GUILD_BANK_MAX_TABS)
        return;
 
    if (tabId != _GetPurchasedTabsSize())
        return;
 
    uint32 tabCost = _GetGuildBankTabPrice(tabId);
    if (!tabCost)
        return;
 
    if (!player->HasEnoughMoney(tabCost))                   // Should not happen, this is checked by client
        return;
 
    player->ModifyMoney(-int32(tabCost));
 
    _CreateNewBankTab();
    _BroadcastEvent(GE_BANK_TAB_PURCHASED);
    SendPermissions(session); 
}

References _BroadcastEvent(), _CreateNewBankTab(), _GetGuildBankTabPrice(), _GetPurchasedTabsSize(), GE_BANK_TAB_PURCHASED, Object::GetGUID(), GetMember(), WorldSession::GetPlayer(), GUILD_BANK_MAX_TABS, Player::HasEnoughMoney(), Player::ModifyMoney(), and SendPermissions().

HandleDisband()

void Guild::HandleDisband

(

WorldSession *

session

)

{
    // Only leader can disband guild
    if (_IsLeader(session->GetPlayer()))
    {
        Disband();
        LOG_DEBUG("guild", "Guild Successfully Disbanded");
        delete this;
    }
}

References _IsLeader(), Disband(), WorldSession::GetPlayer(), and LOG_DEBUG.

HandleInviteMember()

void Guild::HandleInviteMember	(	WorldSession *	session,
		std::string const &	name
	)

{
    Player* pInvitee = ObjectAccessor::FindPlayerByName(name, false);
    if (!pInvitee)
    {
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_GUILD_PLAYER_NOT_FOUND_S, name);
        return;
    }
 
    Player* player = session->GetPlayer();
    // Do not show invitations from ignored players
    if (pInvitee->GetSocial()->HasIgnore(player->GetGUID()))
        return;
 
    uint32 memberLimit = sWorld->getIntConfig(CONFIG_GUILD_MEMBER_LIMIT);
    if (memberLimit > 0 && player->GetGuild()->GetMemberCount() >= memberLimit)
    {
        ChatHandler(player->GetSession()).PSendSysMessage("Your guild has reached the maximum amount of members ({}). You cannot send another invite until the guild member count is lower.", memberLimit);
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_GUILD_INTERNAL, name);
        return;
    }
 
    if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && pInvitee->GetTeamId(true) != player->GetTeamId(true))
    {
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_GUILD_NOT_ALLIED, name);
        return;
    }
    // Invited player cannot be in another guild
    if (pInvitee->GetGuildId())
    {
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_ALREADY_IN_GUILD_S, name);
        return;
    }
    // Invited player cannot be invited
    if (pInvitee->GetGuildIdInvited())
    {
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_ALREADY_INVITED_TO_GUILD_S, name);
        return;
    }
    // Inviting player must have rights to invite
    if (!_HasRankRight(player, GR_RIGHT_INVITE))
    {
        SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_GUILD_PERMISSIONS);
        return;
    }
 
    SendCommandResult(session, GUILD_COMMAND_INVITE, ERR_GUILD_COMMAND_SUCCESS, name);
 
    LOG_DEBUG("guild", "Player {} invited {} to join his Guild", player->GetName(), pInvitee->GetName());
 
    pInvitee->SetGuildIdInvited(m_id);
    _LogEvent(GUILD_EVENT_LOG_INVITE_PLAYER, player->GetGUID(), pInvitee->GetGUID());
 
    WorldPackets::Guild::GuildInvite invite;
 
    invite.InviterName = player->GetName();
    invite.GuildName = GetName();
 
    pInvitee->SendDirectMessage(invite.Write());
    LOG_DEBUG("guild", "SMSG_GUILD_INVITE [{}]", pInvitee->GetName());
}

References _HasRankRight(), _LogEvent(), CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD, CONFIG_GUILD_MEMBER_LIMIT, ERR_ALREADY_IN_GUILD_S, ERR_ALREADY_INVITED_TO_GUILD_S, ERR_GUILD_COMMAND_SUCCESS, ERR_GUILD_INTERNAL, ERR_GUILD_NOT_ALLIED, ERR_GUILD_PERMISSIONS, ERR_GUILD_PLAYER_NOT_FOUND_S, ObjectAccessor::FindPlayerByName(), Object::GetGUID(), Player::GetGuild(), Player::GetGuildId(), Player::GetGuildIdInvited(), GetMemberCount(), WorldObject::GetName(), GetName(), WorldSession::GetPlayer(), Player::GetSession(), Player::GetSocial(), Player::GetTeamId(), GR_RIGHT_INVITE, GUILD_COMMAND_INVITE, GUILD_EVENT_LOG_INVITE_PLAYER, WorldPackets::Guild::GuildInvite::GuildName, PlayerSocial::HasIgnore(), WorldPackets::Guild::GuildInvite::InviterName, LOG_DEBUG, m_id, ChatHandler::PSendSysMessage(), SendCommandResult(), Player::SendDirectMessage(), Player::SetGuildIdInvited(), sWorld, and WorldPackets::Guild::GuildInvite::Write().

HandleLeaveMember()

void Guild::HandleLeaveMember

(

WorldSession *

session

)

{
    Player* player = session->GetPlayer();
    bool disband = false;
 
    // If leader is leaving
    if (_IsLeader(player))
    {
        if (m_members.size() > 1)
            // Leader cannot leave if he is not the last member
            SendCommandResult(session, GUILD_COMMAND_QUIT, ERR_GUILD_LEADER_LEAVE);
        else
        {
            // Guild is disbanded if leader leaves.
            Disband();
            disband = true;
        }
    }
    else
    {
        DeleteMember(player->GetGUID(), false, false);
 
        _LogEvent(GUILD_EVENT_LOG_LEAVE_GUILD, player->GetGUID());
        _BroadcastEvent(GE_LEFT, player->GetGUID(), player->GetName());
 
        SendCommandResult(session, GUILD_COMMAND_QUIT, ERR_GUILD_COMMAND_SUCCESS, m_name);
    }
 
    sCalendarMgr->RemovePlayerGuildEventsAndSignups(player->GetGUID(), GetId());
 
    if (disband)
        delete this;
}

References _BroadcastEvent(), _IsLeader(), _LogEvent(), DeleteMember(), Disband(), ERR_GUILD_COMMAND_SUCCESS, ERR_GUILD_LEADER_LEAVE, GE_LEFT, Object::GetGUID(), GetId(), WorldObject::GetName(), WorldSession::GetPlayer(), GUILD_COMMAND_QUIT, GUILD_EVENT_LOG_LEAVE_GUILD, m_members, m_name, sCalendarMgr, and SendCommandResult().

HandleMemberDepositMoney()

void Guild::HandleMemberDepositMoney	(	WorldSession *	session,
		uint32	amount
	)

{
    Player* player = session->GetPlayer();
 
    // Call script after validation and before money transfer.
    sScriptMgr->OnGuildMemberDepositMoney(this, player, amount);
 
    if (m_bankMoney > GUILD_BANK_MONEY_LIMIT - amount)
    {
        SendCommandResult(session, GUILD_COMMAND_MOVE_ITEM, ERR_GUILD_BANK_FULL);
        return;
    }
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    _ModifyBankMoney(trans, amount, true);
 
    player->ModifyMoney(-int32(amount));
    player->SaveGoldToDB(trans);
    _LogBankEvent(trans, GUILD_BANK_LOG_DEPOSIT_MONEY, uint8(0), player->GetGUID(), amount);
 
    CharacterDatabase.CommitTransaction(trans);
 
    if (session->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
    {
        LOG_GM(session->GetAccountId(), "GM {} (Account: {}) deposited {} to guild bank (Guild: {} GuildId: {})",
            player->GetName(), session->GetAccountId(), amount, GetName(), GetId());
    }
 
    std::string aux = Acore::Impl::ByteArrayToHexStr(reinterpret_cast<uint8*>(&m_bankMoney), 8, true);
    _BroadcastEvent(GE_BANK_MONEY_SET, ObjectGuid::Empty, aux.c_str());
 
    if (amount > 10 * GOLD)     // receiver_acc = Guild id, receiver_name = Guild name
        CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"(guild members: {}, new amount: {}, leader guid low: {}, sender level: {})\", NOW(), {})",
            session->GetAccountId(), player->GetGUID().GetCounter(), player->GetName(), session->GetRemoteAddress(), GetId(), GetName(), amount, GetMemberCount(), GetTotalBankMoney(), GetLeaderGUID().GetCounter(), player->GetLevel(), 3);
}

References _BroadcastEvent(), _LogBankEvent(), _ModifyBankMoney(), Acore::Impl::ByteArrayToHexStr(), CharacterDatabase, ObjectGuid::Empty, ERR_GUILD_BANK_FULL, GE_BANK_MONEY_SET, WorldSession::GetAccountId(), ObjectGuid::GetCounter(), Object::GetGUID(), GetId(), GetLeaderGUID(), Unit::GetLevel(), GetMemberCount(), WorldObject::GetName(), GetName(), WorldSession::GetPlayer(), WorldSession::GetRemoteAddress(), GetTotalBankMoney(), GOLD, GUILD_BANK_LOG_DEPOSIT_MONEY, GUILD_BANK_MONEY_LIMIT, GUILD_COMMAND_MOVE_ITEM, WorldSession::HasPermission(), LOG_GM, m_bankMoney, Player::ModifyMoney(), rbac::RBAC_PERM_LOG_GM_TRADE, Player::SaveGoldToDB(), SendCommandResult(), and sScriptMgr.

HandleMemberLogout()

void Guild::HandleMemberLogout

(

WorldSession *

session

)

{
    Player* player = session->GetPlayer();
    if (Member* member = GetMember(player->GetGUID()))
    {
        member->SetStats(player);
        member->UpdateLogoutTime();
        member->ResetFlags();
    }
    _BroadcastEvent(GE_SIGNED_OFF, player->GetGUID(), player->GetName());
}

References _BroadcastEvent(), GE_SIGNED_OFF, Object::GetGUID(), GetMember(), WorldObject::GetName(), and WorldSession::GetPlayer().

HandleMemberWithdrawMoney()

bool Guild::HandleMemberWithdrawMoney	(	WorldSession *	session,
		uint32	amount,
		bool	repair = false
	)

{
    //clamp amount to MAX_MONEY_AMOUNT, Players can't hold more than that anyway
    amount = std::min(amount, uint32(MAX_MONEY_AMOUNT));
 
    if (m_bankMoney < amount)                               // Not enough money in bank
        return false;
 
    Player* player = session->GetPlayer();
 
    Member* member = GetMember(player->GetGUID());
    if (!member)
        return false;
 
    if (uint32(_GetMemberRemainingMoney(*member)) < amount)   // Check if we have enough slot/money today
        return false;
 
    if (!(_GetRankRights(member->GetRankId()) & GR_RIGHT_WITHDRAW_REPAIR) && repair)
        return false;
 
    // Call script after validation and before money transfer.
    sScriptMgr->OnGuildMemberWitdrawMoney(this, player, amount, repair);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    if (!_ModifyBankMoney(trans, amount, false))
        return false;
 
    if (!repair)
    {
        if (!player->ModifyMoney(amount))
        {
            _ModifyBankMoney(trans, amount, true);
            return false;
        }
 
        player->SaveGoldToDB(trans);
    }
 
    // Update remaining money amount
    member->UpdateBankWithdrawValue(trans, GUILD_BANK_MAX_TABS, amount);
 
    // Log guild bank event
    _LogBankEvent(trans, repair ? GUILD_BANK_LOG_REPAIR_MONEY : GUILD_BANK_LOG_WITHDRAW_MONEY, uint8(0), player->GetGUID(), amount);
    CharacterDatabase.CommitTransaction(trans);
 
    if (session->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
    {
        LOG_GM(session->GetAccountId(), "GM {} (Account: {}) withdrew {} from guild bank (Guild: {} GuildId: {})",
            player->GetName(), session->GetAccountId(), amount, GetName(), GetId());
    }
 
    if (amount > 10 * GOLD)     // sender_acc = 0 (guild has no account), sender_guid = Guild id, sender_name = Guild name
        CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"(guild, members: {}, new amount: {}, leader guid low: {}, withdrawer level: {})\", NOW(), {})",
            0, GetId(), GetName(), session->GetRemoteAddress(), session->GetAccountId(), player->GetName(), amount, GetMemberCount(), GetTotalBankMoney(), GetLeaderGUID().GetCounter(), player->GetLevel(), 4);
 
    std::string aux = Acore::Impl::ByteArrayToHexStr(reinterpret_cast<uint8*>(&m_bankMoney), 8, true);
    _BroadcastEvent(GE_BANK_MONEY_SET, ObjectGuid::Empty, aux.c_str());
    return true;
}

References _BroadcastEvent(), _GetMemberRemainingMoney(), _GetRankRights(), _LogBankEvent(), _ModifyBankMoney(), Acore::Impl::ByteArrayToHexStr(), CharacterDatabase, ObjectGuid::Empty, GE_BANK_MONEY_SET, WorldSession::GetAccountId(), Object::GetGUID(), GetId(), GetLeaderGUID(), Unit::GetLevel(), GetMember(), GetMemberCount(), WorldObject::GetName(), GetName(), WorldSession::GetPlayer(), Guild::Member::GetRankId(), WorldSession::GetRemoteAddress(), GetTotalBankMoney(), GOLD, GR_RIGHT_WITHDRAW_REPAIR, GUILD_BANK_LOG_REPAIR_MONEY, GUILD_BANK_LOG_WITHDRAW_MONEY, GUILD_BANK_MAX_TABS, WorldSession::HasPermission(), LOG_GM, m_bankMoney, MAX_MONEY_AMOUNT, Player::ModifyMoney(), rbac::RBAC_PERM_LOG_GM_TRADE, Player::SaveGoldToDB(), sScriptMgr, and Guild::Member::UpdateBankWithdrawValue().

Referenced by Player::DurabilityRepair().

HandleQuery()

void Guild::HandleQuery

(

WorldSession *

session

)

{
    WorldPackets::Guild::QueryGuildInfoResponse response;
    response.GuildId = m_id;
 
    response.Info.EmblemStyle = m_emblemInfo.GetStyle();
    response.Info.EmblemColor = m_emblemInfo.GetColor();
    response.Info.BorderStyle = m_emblemInfo.GetBorderStyle();
    response.Info.BorderColor = m_emblemInfo.GetBorderColor();
    response.Info.BackgroundColor = m_emblemInfo.GetBackgroundColor();
 
    for (uint8 i = 0; i < _GetRanksSize(); ++i)
        response.Info.Ranks[i] = m_ranks[i].GetName();
 
    response.Info.RankCount = _GetRanksSize();
 
    response.Info.GuildName = m_name;
 
    session->SendPacket(response.Write());
    LOG_DEBUG("guild", "SMSG_GUILD_QUERY_RESPONSE [{}]", session->GetPlayerInfo());
}

References _GetRanksSize(), WorldPackets::Guild::GuildInfo::BackgroundColor, WorldPackets::Guild::GuildInfo::BorderColor, WorldPackets::Guild::GuildInfo::BorderStyle, WorldPackets::Guild::GuildInfo::EmblemColor, WorldPackets::Guild::GuildInfo::EmblemStyle, EmblemInfo::GetBackgroundColor(), EmblemInfo::GetBorderColor(), EmblemInfo::GetBorderStyle(), EmblemInfo::GetColor(), WorldSession::GetPlayerInfo(), EmblemInfo::GetStyle(), WorldPackets::Guild::QueryGuildInfoResponse::GuildId, WorldPackets::Guild::GuildInfo::GuildName, WorldPackets::Guild::QueryGuildInfoResponse::Info, LOG_DEBUG, m_emblemInfo, m_id, m_name, m_ranks, WorldPackets::Guild::GuildInfo::RankCount, WorldPackets::Guild::GuildInfo::Ranks, WorldSession::SendPacket(), and WorldPackets::Guild::QueryGuildInfoResponse::Write().

Referenced by HandleSetEmblem().

HandleRemoveLowestRank()

void Guild::HandleRemoveLowestRank

(

WorldSession *

session

)

{
    HandleRemoveRank(session, _GetLowestRankId());
}

References _GetLowestRankId(), and HandleRemoveRank().

HandleRemoveMember()

void Guild::HandleRemoveMember	(	WorldSession *	session,
		std::string_view	name
	)

{
    Player* player = session->GetPlayer();
    // Player must have rights to remove members
    if (!_HasRankRight(player, GR_RIGHT_REMOVE))
        SendCommandResult(session, GUILD_COMMAND_REMOVE, ERR_GUILD_PERMISSIONS);
    else if (Member* member = GetMember(name))
    {
        // Guild masters cannot be removed
        if (member->IsRank(GR_GUILDMASTER))
            SendCommandResult(session, GUILD_COMMAND_REMOVE, ERR_GUILD_LEADER_LEAVE);
        // Do not allow to remove player with the same rank or higher
        else
        {
            Member const* memberMe = GetMember(player->GetGUID());
            if (!memberMe || member->IsRankNotLower(memberMe->GetRankId()))
                SendCommandResult(session, GUILD_COMMAND_REMOVE, ERR_GUILD_RANK_TOO_HIGH_S, name);
            else
            {
                // Copy values since everything will be deleted in DeleteMember().
                ObjectGuid guid = member->GetGUID();
                std::string memberName = member->GetName();
 
                // After call to DeleteMember pointer to member becomes invalid
                DeleteMember(guid, false, true);
                _LogEvent(GUILD_EVENT_LOG_UNINVITE_PLAYER, player->GetGUID(), guid);
                _BroadcastEvent(GE_REMOVED, ObjectGuid::Empty, memberName, player->GetName());
            }
        }
    }
}

References _BroadcastEvent(), _HasRankRight(), _LogEvent(), DeleteMember(), ObjectGuid::Empty, ERR_GUILD_LEADER_LEAVE, ERR_GUILD_PERMISSIONS, ERR_GUILD_RANK_TOO_HIGH_S, GE_REMOVED, Object::GetGUID(), GetMember(), WorldObject::GetName(), WorldSession::GetPlayer(), Guild::Member::GetRankId(), GR_GUILDMASTER, GR_RIGHT_REMOVE, GUILD_COMMAND_REMOVE, GUILD_EVENT_LOG_UNINVITE_PLAYER, Guild::Member::IsRankNotLower(), and SendCommandResult().

HandleRemoveRank()

void Guild::HandleRemoveRank	(	WorldSession *	session,
		uint8	rankId
	)

{
    // Cannot remove rank if total count is minimum allowed by the client or is not leader
    if (_GetRanksSize() <= GUILD_RANKS_MIN_COUNT || rankId >= _GetRanksSize() || !_IsLeader(session->GetPlayer()))
        return;
 
    // Delete bank rights for rank
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS_FOR_RANK);
    stmt->SetData(0, m_id);
    stmt->SetData(1, rankId);
    CharacterDatabase.Execute(stmt);
    // Delete rank
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_LOWEST_RANK);
    stmt->SetData(0, m_id);
    stmt->SetData(1, rankId);
    CharacterDatabase.Execute(stmt);
 
    // match what the sql statement does
    m_ranks.erase(m_ranks.begin() + rankId, m_ranks.end());
 
    _BroadcastEvent(GE_RANK_DELETED, ObjectGuid::Empty, std::to_string(m_ranks.size()));
}

References _BroadcastEvent(), _GetRanksSize(), _IsLeader(), CHAR_DEL_GUILD_BANK_RIGHTS_FOR_RANK, CHAR_DEL_GUILD_LOWEST_RANK, CharacterDatabase, ObjectGuid::Empty, GE_RANK_DELETED, WorldSession::GetPlayer(), GUILD_RANKS_MIN_COUNT, m_id, m_ranks, and PreparedStatementBase::SetData().

Referenced by HandleRemoveLowestRank().

HandleRoster()

void Guild::HandleRoster

(

WorldSession *

session

)

{
    WorldPackets::Guild::GuildRoster roster;
 
    roster.RankData.reserve(m_ranks.size());
    for (RankInfo const& rank : m_ranks)
    {
        WorldPackets::Guild::GuildRankData& rankData =  roster.RankData.emplace_back();
 
        rankData.Flags = rank.GetRights();
        rankData.WithdrawGoldLimit = rank.GetBankMoneyPerDay();
        for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; ++i)
        {
            rankData.TabFlags[i] = rank.GetBankTabRights(i);
            rankData.TabWithdrawItemLimit[i] = rank.GetBankTabSlotsPerDay(i);
        }
    }
 
    bool sendOfficerNote = _HasRankRight(session->GetPlayer(), GR_RIGHT_VIEWOFFNOTE);
    roster.MemberData.reserve(m_members.size());
    for (auto const& [guid, member] : m_members)
    {
        WorldPackets::Guild::GuildRosterMemberData& memberData = roster.MemberData.emplace_back();
 
        memberData.Guid = member.GetGUID();
        memberData.RankID = int32(member.GetRankId());
        memberData.AreaID = int32(member.GetZoneId());
        memberData.LastSave = float(float(GameTime::GetGameTime().count() - member.GetLogoutTime()) / DAY);
 
        memberData.Status = member.GetFlags();
        memberData.Level = member.GetLevel();
        memberData.ClassID = member.GetClass();
        memberData.Gender = member.GetGender();
 
        memberData.Name = member.GetName();
        memberData.Note = member.GetPublicNote();
        if (sendOfficerNote)
            memberData.OfficerNote = member.GetOfficerNote();
    }
 
    roster.WelcomeText = m_motd;
    roster.InfoText = m_info;
 
    LOG_DEBUG("guild", "SMSG_GUILD_ROSTER [{}]", session->GetPlayerInfo());
    session->SendPacket(roster.Write());
}

References _HasRankRight(), WorldPackets::Guild::GuildRosterMemberData::AreaID, WorldPackets::Guild::GuildRosterMemberData::ClassID, DAY, WorldPackets::Guild::GuildRankData::Flags, WorldPackets::Guild::GuildRosterMemberData::Gender, GameTime::GetGameTime(), WorldSession::GetPlayer(), WorldSession::GetPlayerInfo(), GR_RIGHT_VIEWOFFNOTE, WorldPackets::Guild::GuildRosterMemberData::Guid, GUILD_BANK_MAX_TABS, WorldPackets::Guild::GuildRoster::InfoText, WorldPackets::Guild::GuildRosterMemberData::LastSave, WorldPackets::Guild::GuildRosterMemberData::Level, LOG_DEBUG, m_info, m_members, m_motd, m_ranks, WorldPackets::Guild::GuildRoster::MemberData, WorldPackets::Guild::GuildRosterMemberData::Name, WorldPackets::Guild::GuildRosterMemberData::Note, WorldPackets::Guild::GuildRosterMemberData::OfficerNote, WorldPackets::Guild::GuildRoster::RankData, WorldPackets::Guild::GuildRosterMemberData::RankID, WorldSession::SendPacket(), WorldPackets::Guild::GuildRosterMemberData::Status, WorldPackets::Guild::GuildRankData::TabFlags, WorldPackets::Guild::GuildRankData::TabWithdrawItemLimit, WorldPackets::Guild::GuildRoster::WelcomeText, WorldPackets::Guild::GuildRankData::WithdrawGoldLimit, and WorldPackets::Guild::GuildRoster::Write().

Referenced by HandleSetMemberNote(), and SendLoginInfo().

HandleSetBankTabInfo()

void Guild::HandleSetBankTabInfo	(	WorldSession *	session,
		uint8	tabId,
		std::string_view	name,
		std::string_view	icon
	)

{
    BankTab* tab = GetBankTab(tabId);
    if (!tab)
    {
        LOG_ERROR("guild", "Guild::HandleSetBankTabInfo: Player {} trying to change bank tab info from unexisting tab {}.",
                       session->GetPlayerInfo(), tabId);
        return;
    }
 
    tab->SetInfo(name, icon);
    _BroadcastEvent(GE_BANK_TAB_UPDATED, ObjectGuid::Empty, std::to_string(tabId), tab->GetName(), tab->GetIcon());
}

References _BroadcastEvent(), ObjectGuid::Empty, GE_BANK_TAB_UPDATED, GetBankTab(), Guild::BankTab::GetIcon(), Guild::BankTab::GetName(), WorldSession::GetPlayerInfo(), LOG_ERROR, and Guild::BankTab::SetInfo().

HandleSetEmblem() [1/2]

void Guild::HandleSetEmblem

(

EmblemInfo const &

emblemInfo

)

{
    m_emblemInfo = emblemInfo;
    m_emblemInfo.SaveToDB(m_id);
}

References m_emblemInfo, m_id, and EmblemInfo::SaveToDB().

HandleSetEmblem() [2/2]

void Guild::HandleSetEmblem	(	WorldSession *	session,
		EmblemInfo const &	emblemInfo
	)

{
    Player* player = session->GetPlayer();
    if (!_IsLeader(player))
        SendSaveEmblemResult(session, ERR_GUILDEMBLEM_NOTGUILDMASTER); // "Only guild leaders can create emblems."
    else if (!player->HasEnoughMoney(EMBLEM_PRICE))
        SendSaveEmblemResult(session, ERR_GUILDEMBLEM_NOTENOUGHMONEY); // "You can't afford to do that."
    else
    {
        player->ModifyMoney(-int32(EMBLEM_PRICE));
 
        HandleSetEmblem(emblemInfo);
 
        SendSaveEmblemResult(session, ERR_GUILDEMBLEM_SUCCESS); // "Guild Emblem saved."
 
        HandleQuery(session);
    }
}

References _IsLeader(), EMBLEM_PRICE, ERR_GUILDEMBLEM_NOTENOUGHMONEY, ERR_GUILDEMBLEM_NOTGUILDMASTER, ERR_GUILDEMBLEM_SUCCESS, WorldSession::GetPlayer(), HandleQuery(), HandleSetEmblem(), Player::HasEnoughMoney(), Player::ModifyMoney(), and SendSaveEmblemResult().

Referenced by HandleSetEmblem().

HandleSetInfo()

void Guild::HandleSetInfo	(	WorldSession *	session,
		std::string_view	info
	)

{
    if (m_info == info)
        return;
 
    // Player must have rights to set guild's info
    if (_HasRankRight(session->GetPlayer(), GR_RIGHT_MODIFY_GUILD_INFO))
    {
        m_info = info;
 
        sScriptMgr->OnGuildInfoChanged(this, m_info);
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_INFO);
        stmt->SetData(0, m_info);
        stmt->SetData(1, m_id);
        CharacterDatabase.Execute(stmt);
    }
}

References _HasRankRight(), CHAR_UPD_GUILD_INFO, CharacterDatabase, WorldSession::GetPlayer(), GR_RIGHT_MODIFY_GUILD_INFO, m_id, m_info, PreparedStatementBase::SetData(), and sScriptMgr.

HandleSetLeader()

void Guild::HandleSetLeader	(	WorldSession *	session,
		std::string_view	name
	)

{
    Player* player = session->GetPlayer();
    // Only leader can assign new leader
    if (!_IsLeader(player))
        SendCommandResult(session, GUILD_COMMAND_CHANGE_LEADER, ERR_GUILD_PERMISSIONS);
    // Old leader must be a member of guild
    else if (Member* pOldLeader = GetMember(player->GetGUID()))
    {
        // New leader must be a member of guild
        if (Member* pNewLeader = GetMember(name))
        {
            _SetLeaderGUID(*pNewLeader);
            pOldLeader->ChangeRank(GR_OFFICER);
            _BroadcastEvent(GE_LEADER_CHANGED, ObjectGuid::Empty, player->GetName(), pNewLeader->GetName());
        }
    }
}

References _BroadcastEvent(), _IsLeader(), _SetLeaderGUID(), ObjectGuid::Empty, ERR_GUILD_PERMISSIONS, GE_LEADER_CHANGED, Object::GetGUID(), GetMember(), WorldObject::GetName(), WorldSession::GetPlayer(), GR_OFFICER, GUILD_COMMAND_CHANGE_LEADER, and SendCommandResult().

HandleSetMemberNote()

void Guild::HandleSetMemberNote	(	WorldSession *	session,
		std::string_view	name,
		std::string_view	note,
		bool	isPublic
	)

{
    // Player must have rights to set public/officer note
    if (!_HasRankRight(session->GetPlayer(), isPublic ? GR_RIGHT_EPNOTE : GR_RIGHT_EOFFNOTE))
        SendCommandResult(session, GUILD_COMMAND_PUBLIC_NOTE, ERR_GUILD_PERMISSIONS);
    else if (Member* member = GetMember(name))
    {
        if (isPublic)
            member->SetPublicNote(note);
        else
            member->SetOfficerNote(note);
 
        HandleRoster(session);
    }
}

References _HasRankRight(), ERR_GUILD_PERMISSIONS, GetMember(), WorldSession::GetPlayer(), GR_RIGHT_EOFFNOTE, GR_RIGHT_EPNOTE, GUILD_COMMAND_PUBLIC_NOTE, HandleRoster(), and SendCommandResult().

HandleSetMOTD()

void Guild::HandleSetMOTD	(	WorldSession *	session,
		std::string_view	motd
	)

{
    if (m_motd == motd)
        return;
 
    // Player must have rights to set MOTD
    if (!_HasRankRight(session->GetPlayer(), GR_RIGHT_SETMOTD))
        SendCommandResult(session, GUILD_COMMAND_EDIT_MOTD, ERR_GUILD_PERMISSIONS);
    else
    {
        m_motd = motd;
 
        sScriptMgr->OnGuildMOTDChanged(this, m_motd);
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_MOTD);
        stmt->SetData(0, m_motd);
        stmt->SetData(1, m_id);
        CharacterDatabase.Execute(stmt);
 
        _BroadcastEvent(GE_MOTD, ObjectGuid::Empty, m_motd);
    }
}

References _BroadcastEvent(), _HasRankRight(), CHAR_UPD_GUILD_MOTD, CharacterDatabase, ObjectGuid::Empty, ERR_GUILD_PERMISSIONS, GE_MOTD, WorldSession::GetPlayer(), GR_RIGHT_SETMOTD, GUILD_COMMAND_EDIT_MOTD, m_id, m_motd, SendCommandResult(), PreparedStatementBase::SetData(), and sScriptMgr.

HandleSetRankInfo() [1/2]

void Guild::HandleSetRankInfo	(	uint8	rankId,
		Optional< std::string_view >	name,
		Optional< uint32 >	rights = {},
		Optional< uint32 >	moneyPerDay = {}
	)

{
    RankInfo* rankInfo = GetRankInfo(rankId);
    if (!rankInfo)
        return;
 
    if (!name && !rights && !moneyPerDay)
        return;
 
    if (name)
        rankInfo->SetName(*name);
 
    if (rights)
        rankInfo->SetRights(*rights);
 
    if (moneyPerDay)
        _SetRankBankMoneyPerDay(rankId, *moneyPerDay);
 
    _BroadcastEvent(GE_RANK_UPDATED, ObjectGuid::Empty, std::to_string(rankId), rankInfo->GetName(),
        std::to_string(m_ranks.size()));
}

References _BroadcastEvent(), _SetRankBankMoneyPerDay(), ObjectGuid::Empty, GE_RANK_UPDATED, Guild::RankInfo::GetName(), GetRankInfo(), m_ranks, Guild::RankInfo::SetName(), and Guild::RankInfo::SetRights().

HandleSetRankInfo() [2/2]

void Guild::HandleSetRankInfo	(	WorldSession *	session,
		uint8	rankId,
		std::string_view	name,
		uint32	rights,
		uint32	moneyPerDay,
		std::array< GuildBankRightsAndSlots, GUILD_BANK_MAX_TABS > const &	rightsAndSlots
	)

{
    // Only leader can modify ranks
    if (!_IsLeader(session->GetPlayer()))
        SendCommandResult(session, GUILD_COMMAND_CHANGE_RANK, ERR_GUILD_PERMISSIONS);
    else if (RankInfo* rankInfo = GetRankInfo(rankId))
    {
        rankInfo->SetName(name);
        rankInfo->SetRights(rights);
        _SetRankBankMoneyPerDay(rankId, moneyPerDay);
 
        for (auto& rightsAndSlot : rightsAndSlots)
            _SetRankBankTabRightsAndSlots(rankId, rightsAndSlot);
 
        _BroadcastEvent(GE_RANK_UPDATED, ObjectGuid::Empty, std::to_string(rankId), rankInfo->GetName(), std::to_string(m_ranks.size()));
 
        LOG_DEBUG("guild", "Changed RankName to '{}', rights to 0x{:08X}", rankInfo->GetName(), rights);
    }
}

References _BroadcastEvent(), _IsLeader(), _SetRankBankMoneyPerDay(), _SetRankBankTabRightsAndSlots(), ObjectGuid::Empty, ERR_GUILD_PERMISSIONS, GE_RANK_UPDATED, WorldSession::GetPlayer(), GetRankInfo(), GUILD_COMMAND_CHANGE_RANK, LOG_DEBUG, m_ranks, and SendCommandResult().

Referenced by WorldSession::HandleGuildRankOpcode().

HandleUpdateMemberRank()

void Guild::HandleUpdateMemberRank	(	WorldSession *	session,
		std::string_view	name,
		bool	demote
	)

{
    Player* player = session->GetPlayer();
    GuildCommandType type = demote ? GUILD_COMMAND_DEMOTE : GUILD_COMMAND_PROMOTE;
    // Player must have rights to promote
    if (!_HasRankRight(player, demote ? GR_RIGHT_DEMOTE : GR_RIGHT_PROMOTE))
        SendCommandResult(session, type, ERR_GUILD_PERMISSIONS);
    // Promoted player must be a member of guild
    else if (Member* member = GetMember(name))
    {
        // Player cannot promote himself
        if (member->IsSamePlayer(player->GetGUID()))
        {
            SendCommandResult(session, type, ERR_GUILD_NAME_INVALID);
            return;
        }
 
        Member const* memberMe = GetMember(player->GetGUID());
        uint8 rankId = memberMe->GetRankId();
        if (demote)
        {
            // Player can demote only lower rank members
            if (member->IsRankNotLower(rankId))
            {
                SendCommandResult(session, type, ERR_GUILD_RANK_TOO_HIGH_S, name);
                return;
            }
            // Lowest rank cannot be demoted
            if (member->GetRankId() >= _GetLowestRankId())
            {
                SendCommandResult(session, type, ERR_GUILD_RANK_TOO_LOW_S, name);
                return;
            }
        }
        else
        {
            // Allow to promote only to lower rank than member's rank
            // member->GetRankId() + 1 is the highest rank that current player can promote to
            if (member->IsRankNotLower(rankId + 1))
            {
                SendCommandResult(session, type, ERR_GUILD_RANK_TOO_HIGH_S, name);
                return;
            }
        }
 
        uint32 newRankId = member->GetRankId() + (demote ? 1 : -1);
        member->ChangeRank(newRankId);
        _LogEvent(demote ? GUILD_EVENT_LOG_DEMOTE_PLAYER : GUILD_EVENT_LOG_PROMOTE_PLAYER, player->GetGUID(), member->GetGUID(), newRankId);
        _BroadcastEvent(demote ? GE_DEMOTION : GE_PROMOTION, ObjectGuid::Empty, player->GetName(), member->GetName(), _GetRankName(newRankId));
    }
}

References _BroadcastEvent(), _GetLowestRankId(), _GetRankName(), _HasRankRight(), _LogEvent(), ObjectGuid::Empty, ERR_GUILD_NAME_INVALID, ERR_GUILD_PERMISSIONS, ERR_GUILD_RANK_TOO_HIGH_S, ERR_GUILD_RANK_TOO_LOW_S, GE_DEMOTION, GE_PROMOTION, Object::GetGUID(), GetMember(), WorldObject::GetName(), WorldSession::GetPlayer(), Guild::Member::GetRankId(), GR_RIGHT_DEMOTE, GR_RIGHT_PROMOTE, GUILD_COMMAND_DEMOTE, GUILD_COMMAND_PROMOTE, GUILD_EVENT_LOG_DEMOTE_PLAYER, GUILD_EVENT_LOG_PROMOTE_PLAYER, and SendCommandResult().

HasRankRight()

bool Guild::HasRankRight	(	Player *	player,
		uint32	right
	)		const

{
    return _HasRankRight(player, right);
}

References _HasRankRight().

LoadBankEventLogFromDB()

bool Guild::LoadBankEventLogFromDB

(

Field *

fields

)

{
    uint8 dbTabId = fields[1].Get<uint8>();
    bool isMoneyTab = (dbTabId == GUILD_BANK_MONEY_LOGS_TAB);
    if (dbTabId < _GetPurchasedTabsSize() || isMoneyTab)
    {
        uint8 tabId = isMoneyTab ? uint8(GUILD_BANK_MAX_TABS) : dbTabId;
        LogHolder<BankEventLogEntry>& bankLog = m_bankEventLog[tabId];
        if (bankLog.CanInsert())
        {
            ObjectGuid::LowType guid = fields[2].Get<uint32>();
            GuildBankEventLogTypes eventType = GuildBankEventLogTypes(fields[3].Get<uint8>());
            if (BankEventLogEntry::IsMoneyEvent(eventType))
            {
                if (!isMoneyTab)
                {
                    LOG_ERROR("guild", "GuildBankEventLog ERROR: MoneyEvent(LogGuid: {}, Guild: {}) does not belong to money tab ({}), ignoring...", guid, m_id, dbTabId);
                    return false;
                }
            }
            else if (isMoneyTab)
            {
                LOG_ERROR("guild", "GuildBankEventLog ERROR: non-money event (LogGuid: {}, Guild: {}) belongs to money tab, ignoring...", guid, m_id);
                return false;
            }
            bankLog.LoadEvent(
                                m_id,                                                       // guild id
                                guid,                                                       // guid
                                time_t(fields[8].Get<uint32>()),                              // timestamp
                                dbTabId,                                                    // tab id
                                eventType,                                                  // event type
                                ObjectGuid::Create<HighGuid::Player>(fields[4].Get<uint32>()), // player guid
                                fields[5].Get<uint32>(),                                      // item or money
                                fields[6].Get<uint16>(),                                      // itam stack count
                                fields[7].Get<uint8>());                                     // dest tab id
        }
    }
    return true;
}

References _GetPurchasedTabsSize(), Guild::LogHolder< Entry >::CanInsert(), Field::Get(), GUILD_BANK_MAX_TABS, GUILD_BANK_MONEY_LOGS_TAB, Guild::BankEventLogEntry::IsMoneyEvent(), Guild::LogHolder< Entry >::LoadEvent(), LOG_ERROR, m_bankEventLog, and m_id.

LoadBankItemFromDB()

bool Guild::LoadBankItemFromDB

(

Field *

fields

)

{
    uint8 tabId = fields[12].Get<uint8>();
    if (tabId >= _GetPurchasedTabsSize())
    {
        LOG_ERROR("guild", "Invalid tab for item (GUID: {}, id: #{}) in guild bank, skipped.",
                       fields[14].Get<uint32>(), fields[15].Get<uint32>());
        return false;
    }
    return m_bankTabs[tabId].LoadItemFromDB(fields);
}

References _GetPurchasedTabsSize(), Field::Get(), LOG_ERROR, and m_bankTabs.

LoadBankRightFromDB()

void Guild::LoadBankRightFromDB

(

Field *

fields

)

{
    // tabId              rights                slots
    GuildBankRightsAndSlots rightsAndSlots(fields[1].Get<uint8>(), fields[3].Get<uint8>(), fields[4].Get<uint32>());
    // rankId
    _SetRankBankTabRightsAndSlots(fields[2].Get<uint8>(), rightsAndSlots, false);
}

References _SetRankBankTabRightsAndSlots().

LoadBankTabFromDB()

void Guild::LoadBankTabFromDB

(

Field *

fields

)

{
    uint8 tabId = fields[1].Get<uint8>();
    if (tabId >= _GetPurchasedTabsSize())
        LOG_ERROR("guild", "Invalid tab (tabId: {}) in guild bank, skipped.", tabId);
    else
        m_bankTabs[tabId].LoadFromDB(fields);
}

References _GetPurchasedTabsSize(), Field::Get(), LOG_ERROR, and m_bankTabs.

LoadEventLogFromDB()

bool Guild::LoadEventLogFromDB

(

Field *

fields

)

{
    if (m_eventLog.CanInsert())
    {
        m_eventLog.LoadEvent(
                                  m_id,                                                         // guild id
                                  fields[1].Get<uint32>(),                                        // guid
                                  time_t(fields[6].Get<uint32>()),                                // timestamp
                                  GuildEventLogTypes(fields[2].Get<uint8>()),                     // event type
                                  ObjectGuid::Create<HighGuid::Player>(fields[3].Get<uint32>()),  // player guid 1
                                  ObjectGuid::Create<HighGuid::Player>(fields[4].Get<uint32>()),  // player guid 2
                                  fields[5].Get<uint8>());                                       // rank
        return true;
    }
    return false;
}

References m_eventLog, and m_id.

LoadFromDB()

bool Guild::LoadFromDB

(

Field *

fields

)

{
    m_id            = fields[0].Get<uint32>();
    m_name          = fields[1].Get<std::string>();
    m_leaderGuid    = ObjectGuid::Create<HighGuid::Player>(fields[2].Get<uint32>());
    m_emblemInfo.LoadFromDB(fields);
    m_info          = fields[8].Get<std::string>();
    m_motd          = fields[9].Get<std::string>();
    m_createdDate   = time_t(fields[10].Get<uint32>());
    m_bankMoney     = fields[11].Get<uint64>();
 
    uint8 purchasedTabs = uint8(fields[12].Get<uint64>());
    if (purchasedTabs > GUILD_BANK_MAX_TABS)
        purchasedTabs = GUILD_BANK_MAX_TABS;
 
    m_bankTabs.clear();
    m_bankTabs.reserve(purchasedTabs);
    for (uint8 i = 0; i < purchasedTabs; ++i)
        m_bankTabs.emplace_back(m_id, i);
    return true;
}

References Field::Get(), GUILD_BANK_MAX_TABS, EmblemInfo::LoadFromDB(), m_bankMoney, m_bankTabs, m_createdDate, m_emblemInfo, m_id, m_info, m_leaderGuid, m_motd, and m_name.

Referenced by GuildMgr::LoadGuilds().

LoadMemberFromDB()

bool Guild::LoadMemberFromDB

(

Field *

fields

)

{
    ObjectGuid::LowType lowguid = fields[1].Get<uint32>();
    ObjectGuid playerGuid(HighGuid::Player, lowguid);
 
    auto [memberIt, isNew] = m_members.try_emplace(lowguid, m_id, playerGuid, fields[2].Get<uint8>());
    if (!isNew)
    {
        LOG_ERROR("guild", "Tried to add {} to guild '{}'. Member already exists.", playerGuid.ToString(), m_name);
        return false;
    }
 
    Member& member = memberIt->second;
    if (!member.LoadFromDB(fields))
    {
        _DeleteMemberFromDB(lowguid);
        m_members.erase(memberIt);
        return false;
    }
 
    sCharacterCache->UpdateCharacterGuildId(playerGuid, GetId());
    return true;
}

References _DeleteMemberFromDB(), Field::Get(), GetId(), Guild::Member::LoadFromDB(), LOG_ERROR, m_id, m_members, m_name, Player, and sCharacterCache.

LoadRankFromDB()

void Guild::LoadRankFromDB

(

Field *

fields

)

{
    RankInfo rankInfo(m_id);
 
    rankInfo.LoadFromDB(fields);
 
    m_ranks.push_back(rankInfo);
}

References Guild::RankInfo::LoadFromDB(), m_id, and m_ranks.

MassInviteToEvent()

void Guild::MassInviteToEvent	(	WorldSession *	session,
		uint32	minLevel,
		uint32	maxLevel,
		uint32	minRank
	)

{
    uint32 count = 0;
 
    WorldPacket data(SMSG_CALENDAR_FILTER_GUILD);
    data << uint32(count); // count placeholder
 
    for (auto const& [guid, member] : m_members)
    {
        // not sure if needed, maybe client checks it as well
        if (count >= CALENDAR_MAX_INVITES)
        {
            if (Player* player = session->GetPlayer())
                sCalendarMgr->SendCalendarCommandResult(player->GetGUID(), CALENDAR_ERROR_INVITES_EXCEEDED);
            return;
        }
 
        uint32 level = sCharacterCache->GetCharacterLevelByGuid(member.GetGUID());
 
        if (member.GetGUID() != session->GetPlayer()->GetGUID() && level >= minLevel && level <= maxLevel && member.IsRankNotLower(minRank))
        {
            data.appendPackGUID(member.GetGUID().GetRawValue());
            data << uint8(0); // unk
            ++count;
        }
    }
 
    data.put<uint32>(0, count);
 
    session->SendPacket(&data);
}

References ByteBuffer::appendPackGUID(), CALENDAR_ERROR_INVITES_EXCEEDED, CALENDAR_MAX_INVITES, Object::GetGUID(), WorldSession::GetPlayer(), m_members, ByteBuffer::put(), sCalendarMgr, sCharacterCache, WorldSession::SendPacket(), and SMSG_CALENDAR_FILTER_GUILD.

MemberHasTabRights()

bool Guild::MemberHasTabRights	(	ObjectGuid	guid,
		uint8	tabId,
		uint32	rights
	)		const

{
    return _MemberHasTabRights(guid, tabId, rights);
}

References _MemberHasTabRights().

ModifyBankMoney()

bool Guild::ModifyBankMoney ( CharacterDatabaseTransaction  trans, uint64 const &  amount, bool  add  )

inline

{ return _ModifyBankMoney(trans, amount, add); }

References _ModifyBankMoney().

OnPlayerStatusChange()

void Guild::OnPlayerStatusChange	(	Player *	player,
		uint32	flag,
		bool	state
	)

{
    if (Member* member = GetMember(player->GetGUID()))
    {
        if (state)
            member->AddFlag(flag);
        else member->RemFlag(flag);
    }
}

References Object::GetGUID(), and GetMember().

ResetTimes()

void Guild::ResetTimes

(

)

{
    for (auto& [guid, member] : m_members)
        member.ResetValues();
 
    _BroadcastEvent(GE_BANK_TAB_AND_MONEY_UPDATED, ObjectGuid::Empty);
}

References _BroadcastEvent(), ObjectGuid::Empty, GE_BANK_TAB_AND_MONEY_UPDATED, and m_members.

SendBankLog()

void Guild::SendBankLog	(	WorldSession *	session,
		uint8	tabId
	)		const

{
    // GUILD_BANK_MAX_TABS send by client for money log
    if (tabId < _GetPurchasedTabsSize() || tabId == GUILD_BANK_MAX_TABS)
    {
        std::list<BankEventLogEntry> const& bankEventLog = m_bankEventLog[tabId].GetGuildLog();
 
        WorldPackets::Guild::GuildBankLogQueryResults packet;
        packet.Tab = tabId;
 
        packet.Entry.reserve(bankEventLog.size());
        for (BankEventLogEntry const& entry : bankEventLog)
            entry.WritePacket(packet);
 
        session->SendPacket(packet.Write());
        LOG_DEBUG("guild", "MSG_GUILD_BANK_LOG_QUERY [{}]", session->GetPlayerInfo());
    }
}

References _GetPurchasedTabsSize(), WorldPackets::Guild::GuildBankLogQueryResults::Entry, WorldSession::GetPlayerInfo(), GUILD_BANK_MAX_TABS, LOG_DEBUG, m_bankEventLog, WorldSession::SendPacket(), WorldPackets::Guild::GuildBankLogQueryResults::Tab, and WorldPackets::Guild::GuildBankLogQueryResults::Write().

SendBankTabData()

void Guild::SendBankTabData	(	WorldSession *	session,
		uint8	tabId,
		bool	sendAllSlots
	)		const

{
    if (tabId < _GetPurchasedTabsSize())
        _SendBankContent(session, tabId, sendAllSlots);
}

References _GetPurchasedTabsSize(), and _SendBankContent().

SendBankTabsInfo()

void Guild::SendBankTabsInfo	(	WorldSession *	session,
		bool	showTabs = false
	)

{
    Member* member = GetMember(session->GetPlayer()->GetGUID());
    if (!member)
        return;
 
    member->SubscribeToGuildBankUpdatePackets();
 
    _SendBankList(session, 0, sendAllSlots);
}

References _SendBankList(), Object::GetGUID(), GetMember(), WorldSession::GetPlayer(), and Guild::Member::SubscribeToGuildBankUpdatePackets().

Referenced by WorldSession::HandleGuildBankerActivate().

SendBankTabText()

void Guild::SendBankTabText	(	WorldSession *	session,
		uint8	tabId
	)		const

{
    if (BankTab const* tab = GetBankTab(tabId))
        tab->SendText(this, session);
}

References GetBankTab().

SendCommandResult()

void Guild::SendCommandResult ( WorldSession *  session, GuildCommandType  type, GuildCommandError  errCode, std::string_view  param = {}  )

static

{
    WorldPackets::Guild::GuildCommandResult resultPacket;
    resultPacket.Command = type;
    resultPacket.Result = errCode;
    resultPacket.Name = param;
    session->SendPacket(resultPacket.Write());
 
    LOG_DEBUG("guild", "SMSG_GUILD_COMMAND_RESULT [{}]: Type: {}, code: {}, param: {}", session->GetPlayerInfo(), type, errCode, resultPacket.Name);
}

References WorldPackets::Guild::GuildCommandResult::Command, WorldSession::GetPlayerInfo(), LOG_DEBUG, WorldPackets::Guild::GuildCommandResult::Name, WorldPackets::Guild::GuildCommandResult::Result, WorldSession::SendPacket(), and WorldPackets::Guild::GuildCommandResult::Write().

Referenced by WorldSession::HandleGuildAcceptOpcode(), WorldSession::HandleGuildBankerActivate(), WorldSession::HandleGuildRosterOpcode(), HandleInviteMember(), HandleLeaveMember(), HandleMemberDepositMoney(), WorldSession::HandleOfferPetitionOpcode(), WorldSession::HandlePetitionBuyOpcode(), WorldSession::HandlePetitionRenameOpcode(), WorldSession::HandlePetitionSignOpcode(), HandleRemoveMember(), HandleSetLeader(), HandleSetMemberNote(), HandleSetMOTD(), HandleSetRankInfo(), WorldSession::HandleTurnInPetitionOpcode(), and HandleUpdateMemberRank().

SendEventLog()

void Guild::SendEventLog

(

WorldSession *

session

)

const

{
    std::list<EventLogEntry> const& eventLog = m_eventLog.GetGuildLog();
 
    WorldPackets::Guild::GuildEventLogQueryResults packet;
    packet.Entry.reserve(eventLog.size());
 
    for (EventLogEntry const& entry : eventLog)
        entry.WritePacket(packet);
 
    session->SendPacket(packet.Write());
    LOG_DEBUG("guild", "MSG_GUILD_EVENT_LOG_QUERY [{}]", session->GetPlayerInfo());
}

References WorldPackets::Guild::GuildEventLogQueryResults::Entry, WorldSession::GetPlayerInfo(), LOG_DEBUG, m_eventLog, WorldSession::SendPacket(), and WorldPackets::Guild::GuildEventLogQueryResults::Write().

SendInfo()

void Guild::SendInfo

(

WorldSession *

session

)

const

{
    WorldPackets::Guild::GuildInfoResponse guildInfo;
    guildInfo.GuildName = m_name;
    guildInfo.CreateDate = m_createdDate;
    guildInfo.NumMembers = int32(m_members.size());
    guildInfo.NumAccounts = m_accountsNumber;
 
    session->SendPacket(guildInfo.Write());
    LOG_DEBUG("guild", "SMSG_GUILD_INFO [{}]", session->GetPlayerInfo());
}

References WorldPackets::Guild::GuildInfoResponse::CreateDate, WorldSession::GetPlayerInfo(), WorldPackets::Guild::GuildInfoResponse::GuildName, LOG_DEBUG, m_accountsNumber, m_createdDate, m_members, m_name, WorldPackets::Guild::GuildInfoResponse::NumAccounts, WorldPackets::Guild::GuildInfoResponse::NumMembers, WorldSession::SendPacket(), and WorldPackets::Guild::GuildInfoResponse::Write().

SendLoginInfo()

void Guild::SendLoginInfo

(

WorldSession *

session

)

{
    WorldPackets::Guild::GuildEvent motd;
    motd.Type = GE_MOTD;
    motd.Params.emplace_back(m_motd);
    session->SendPacket(motd.Write());
 
    LOG_DEBUG("guild", "SMSG_GUILD_EVENT [{}] MOTD", session->GetPlayerInfo());
 
    Player* player = session->GetPlayer();
 
    HandleRoster(session);
    _BroadcastEvent(GE_SIGNED_ON, player->GetGUID(), player->GetName());
 
    if (Member* member = GetMember(player->GetGUID()))
    {
        member->SetStats(player);
        member->AddFlag(GUILDMEMBER_STATUS_ONLINE);
    }
}

References _BroadcastEvent(), GE_MOTD, GE_SIGNED_ON, Object::GetGUID(), GetMember(), WorldObject::GetName(), WorldSession::GetPlayer(), WorldSession::GetPlayerInfo(), GUILDMEMBER_STATUS_ONLINE, HandleRoster(), LOG_DEBUG, m_motd, WorldPackets::Guild::GuildEvent::Params, WorldSession::SendPacket(), WorldPackets::Guild::GuildEvent::Type, and WorldPackets::Guild::GuildEvent::Write().

Referenced by AddMember(), and WorldSession::HandlePlayerLoginFromDB().

SendMoneyInfo()

void Guild::SendMoneyInfo

(

WorldSession *

session

)

const

{
    Member const* member = GetMember(session->GetPlayer()->GetGUID());
    if (!member)
        return;
 
    int32 amount = _GetMemberRemainingMoney(*member);
 
    WorldPackets::Guild::GuildBankRemainingWithdrawMoney packet;
    packet.RemainingWithdrawMoney = amount;
    session->SendPacket(packet.Write());
 
    LOG_DEBUG("guild", "MSG_GUILD_BANK_MONEY_WITHDRAWN [{}] Money: {}", session->GetPlayerInfo(), amount);
}

References _GetMemberRemainingMoney(), Object::GetGUID(), GetMember(), WorldSession::GetPlayer(), WorldSession::GetPlayerInfo(), LOG_DEBUG, WorldPackets::Guild::GuildBankRemainingWithdrawMoney::RemainingWithdrawMoney, WorldSession::SendPacket(), and WorldPackets::Guild::GuildBankRemainingWithdrawMoney::Write().

SendPermissions()

void Guild::SendPermissions

(

WorldSession *

session

)

{
    Member* member = GetMember(session->GetPlayer()->GetGUID());
    if (!member)
        return;
 
    // We are unsubscribing here since it is the only reliable way to handle /reload from player as
    // GuildPermissionsQuery is sent on each reload, and we don't want to send partial changes while client
    // doesn't know the full state
    member->UnsubscribeFromGuildBankUpdatePackets();
 
    uint8 rankId = member->GetRankId();
 
    WorldPackets::Guild::GuildPermissionsQueryResults queryResult;
    queryResult.RankID = rankId;
    queryResult.WithdrawGoldLimit = _GetRankBankMoneyPerDay(rankId);
    queryResult.Flags = _GetRankRights(rankId);
    queryResult.NumTabs = _GetPurchasedTabsSize();
 
    for (uint8 tabId = 0; tabId < GUILD_BANK_MAX_TABS; ++tabId)
    {
        queryResult.Tab[tabId].Flags = _GetRankBankTabRights(rankId, tabId);
        queryResult.Tab[tabId].WithdrawItemLimit = _GetMemberRemainingSlots(*member, tabId);
    }
 
    session->SendPacket(queryResult.Write());
    LOG_DEBUG("guild", "MSG_GUILD_PERMISSIONS [{}] Rank: {}", session->GetPlayerInfo(), rankId);
}

References _GetMemberRemainingSlots(), _GetPurchasedTabsSize(), _GetRankBankMoneyPerDay(), _GetRankBankTabRights(), _GetRankRights(), WorldPackets::Guild::GuildPermissionsQueryResults::Flags, Object::GetGUID(), GetMember(), WorldSession::GetPlayer(), WorldSession::GetPlayerInfo(), Guild::Member::GetRankId(), GUILD_BANK_MAX_TABS, LOG_DEBUG, WorldPackets::Guild::GuildPermissionsQueryResults::NumTabs, WorldPackets::Guild::GuildPermissionsQueryResults::RankID, WorldSession::SendPacket(), WorldPackets::Guild::GuildPermissionsQueryResults::Tab, Guild::Member::UnsubscribeFromGuildBankUpdatePackets(), WorldPackets::Guild::GuildPermissionsQueryResults::WithdrawGoldLimit, and WorldPackets::Guild::GuildPermissionsQueryResults::Write().

Referenced by HandleBuyBankTab().

SendSaveEmblemResult()

void Guild::SendSaveEmblemResult ( WorldSession *  session, GuildEmblemError  errCode  )

static

{
    WorldPackets::Guild::PlayerSaveGuildEmblem saveResponse;
    saveResponse.Error = int32(errCode);
    session->SendPacket(saveResponse.Write());
 
    LOG_DEBUG("guild", "MSG_SAVE_GUILD_EMBLEM [{}] Code: {}", session->GetPlayerInfo(), errCode);
}

References WorldPackets::Guild::PlayerSaveGuildEmblem::Error, WorldSession::GetPlayerInfo(), LOG_DEBUG, WorldSession::SendPacket(), and WorldPackets::Guild::PlayerSaveGuildEmblem::Write().

Referenced by WorldSession::HandleSaveGuildEmblemOpcode(), and HandleSetEmblem().

SetBankTabText()

void Guild::SetBankTabText	(	uint8	tabId,
		std::string_view	text
	)

{
    if (BankTab* pTab = GetBankTab(tabId))
    {
        pTab->SetText(text);
        pTab->SendText(this, nullptr);
    }
}

References GetBankTab().

SetName()

bool Guild::SetName

(

std::string_view const &

name

)

{
    if (m_name == name || name.empty() || name.length() > 24 || !ObjectMgr::IsValidCharterName(name))
    {
        return false;
    }
 
    m_name = name;
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_NAME);
    stmt->SetData(0, m_name);
    stmt->SetData(1, GetId());
    CharacterDatabase.Execute(stmt);
    return true;
}

References CHAR_UPD_GUILD_NAME, CharacterDatabase, GetId(), ObjectMgr::IsValidCharterName(), m_name, and PreparedStatementBase::SetData().

Referenced by guild_commandscript::HandleGuildRenameCommand().

SwapItems()

void Guild::SwapItems	(	Player *	player,
		uint8	tabId,
		uint8	slotId,
		uint8	destTabId,
		uint8	destSlotId,
		uint32	splitedAmount
	)

{
    if (tabId >= _GetPurchasedTabsSize() || slotId >= GUILD_BANK_MAX_SLOTS ||
            destTabId >= _GetPurchasedTabsSize() || destSlotId >= GUILD_BANK_MAX_SLOTS)
        return;
 
    if (tabId == destTabId && slotId == destSlotId)
        return;
 
    BankMoveItemData from(this, player, tabId, slotId);
    BankMoveItemData to(this, player, destTabId, destSlotId);
    _MoveItems(&from, &to, splitedAmount);
}

References _GetPurchasedTabsSize(), _MoveItems(), and GUILD_BANK_MAX_SLOTS.

Referenced by WorldSession::HandleGuildBankSwapItems().

SwapItemsWithInventory()

void Guild::SwapItemsWithInventory	(	Player *	player,
		bool	toChar,
		uint8	tabId,
		uint8	slotId,
		uint8	playerBag,
		uint8	playerSlotId,
		uint32	splitedAmount
	)

{
    if ((slotId >= GUILD_BANK_MAX_SLOTS && slotId != NULL_SLOT) || tabId >= _GetPurchasedTabsSize())
        return;
 
    BankMoveItemData bankData(this, player, tabId, slotId);
    PlayerMoveItemData charData(this, player, playerBag, playerSlotId);
    if (toChar)
        _MoveItems(&bankData, &charData, splitedAmount);
    else
        _MoveItems(&charData, &bankData, splitedAmount);
}

References _GetPurchasedTabsSize(), _MoveItems(), GUILD_BANK_MAX_SLOTS, and NULL_SLOT.

Referenced by WorldSession::HandleGuildBankSwapItems().

UpdateMemberData()

void Guild::UpdateMemberData	(	Player *	player,
		uint8	dataid,
		uint32	value
	)

{
    if (Member* member = GetMember(player->GetGUID()))
    {
        switch (dataid)
        {
            case GUILD_MEMBER_DATA_ZONEID:
                member->SetZoneID(value);
                break;
            case GUILD_MEMBER_DATA_LEVEL:
                member->SetLevel(value);
                break;
            default:
                LOG_ERROR("guild", "Guild::UpdateMemberData: Called with incorrect DATAID {} (value {})", dataid, value);
                return;
        }
        //HandleRoster();
    }
}

References Object::GetGUID(), GetMember(), GUILD_MEMBER_DATA_LEVEL, GUILD_MEMBER_DATA_ZONEID, and LOG_ERROR.

Validate()

bool Guild::Validate

(

)

{
    // Validate ranks data
    // GUILD RANKS represent a sequence starting from 0 = GUILD_MASTER (ALL PRIVILEGES) to max 9 (lowest privileges).
    // The lower rank id is considered higher rank - so promotion does rank-- and demotion does rank++
    // Between ranks in sequence cannot be gaps - so 0, 1, 2, 4 is impossible
    // Min ranks count is 5 and max is 10.
    bool broken_ranks = false;
    uint8 ranks = _GetRanksSize();
    if (ranks < GUILD_RANKS_MIN_COUNT || ranks > GUILD_RANKS_MAX_COUNT)
    {
        LOG_ERROR("guild", "Guild {} has invalid number of ranks, creating new...", m_id);
        broken_ranks = true;
    }
    else
    {
        for (uint8 rankId = 0; rankId < ranks; ++rankId)
        {
            RankInfo* rankInfo = GetRankInfo(rankId);
            if (rankInfo->GetId() != rankId)
            {
                LOG_ERROR("guild", "Guild {} has broken rank id {}, creating default set of ranks...", m_id, rankId);
                broken_ranks = true;
            }
            else
            {
                CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
                rankInfo->CreateMissingTabsIfNeeded(_GetPurchasedTabsSize(), trans, true);
                CharacterDatabase.CommitTransaction(trans);
            }
        }
    }
 
    if (broken_ranks)
    {
        m_ranks.clear();
        _CreateDefaultGuildRanks(DEFAULT_LOCALE);
    }
 
    // Validate members' data
    for (auto& [guid, member] : m_members)
        if (member.GetRankId() > _GetRanksSize())
            member.ChangeRank(_GetLowestRankId());
 
    // Repair the structure of the guild.
    // If the guildmaster doesn't exist or isn't member of the guild
    // attempt to promote another member.
    Member* pLeader = GetMember(m_leaderGuid);
    if (!pLeader)
    {
        DeleteMember(m_leaderGuid);
        // If no more members left, disband guild
        if (m_members.empty())
        {
            Disband();
            return false;
        }
    }
    else if (!pLeader->IsRank(GR_GUILDMASTER))
        _SetLeaderGUID(*pLeader);
 
    // Check config if multiple guildmasters are allowed
    if (!sConfigMgr->GetOption<bool>("Guild.AllowMultipleGuildMaster", 0))
        for (auto& [guid, member] : m_members)
            if ((member.GetRankId() == GR_GUILDMASTER) && !member.IsSamePlayer(m_leaderGuid))
                member.ChangeRank(GR_OFFICER);
 
    _UpdateAccountsNumber();
    return true;
}

References _CreateDefaultGuildRanks(), _GetLowestRankId(), _GetPurchasedTabsSize(), _GetRanksSize(), _SetLeaderGUID(), _UpdateAccountsNumber(), CharacterDatabase, Guild::RankInfo::CreateMissingTabsIfNeeded(), DEFAULT_LOCALE, DeleteMember(), Disband(), Guild::RankInfo::GetId(), GetMember(), GetRankInfo(), GR_GUILDMASTER, GR_OFFICER, GUILD_RANKS_MAX_COUNT, Guild::Member::IsRank(), LOG_ERROR, m_id, m_leaderGuid, m_members, m_ranks, and sConfigMgr.

Referenced by GuildMgr::LoadGuilds().

Member Data Documentation

m_accountsNumber

uint32 Guild::m_accountsNumber

protected

Referenced by _UpdateAccountsNumber(), and SendInfo().

m_bankEventLog

std::array<LogHolder<BankEventLogEntry>, GUILD_BANK_MAX_TABS + 1> Guild::m_bankEventLog = {}

protected

{};

Referenced by _LogBankEvent(), LoadBankEventLogFromDB(), and SendBankLog().

m_bankMoney

uint64 Guild::m_bankMoney

protected

Referenced by _ModifyBankMoney(), _SendBankList(), Create(), GetTotalBankMoney(), HandleMemberDepositMoney(), HandleMemberWithdrawMoney(), and LoadFromDB().

m_bankTabs

std::vector<BankTab> Guild::m_bankTabs

protected

Referenced by _CreateNewBankTab(), _DeleteBankItems(), _GetPurchasedTabsSize(), _SendBankList(), GetBankTab(), GetBankTab(), LoadBankItemFromDB(), LoadBankTabFromDB(), and LoadFromDB().

m_createdDate

time_t Guild::m_createdDate

protected

Referenced by Create(), GetCreatedDate(), LoadFromDB(), and SendInfo().

m_emblemInfo

EmblemInfo Guild::m_emblemInfo

protected

Referenced by Create(), HandleQuery(), HandleSetEmblem(), and LoadFromDB().

m_eventLog

LogHolder<EventLogEntry> Guild::m_eventLog

protected

Referenced by _LogEvent(), LoadEventLogFromDB(), and SendEventLog().

m_id

uint32 Guild::m_id

protected

Referenced by _CreateDefaultGuildRanks(), _CreateNewBankTab(), _CreateRank(), _LogBankEvent(), _LogEvent(), _ModifyBankMoney(), _SetLeaderGUID(), AddMember(), ChangeMemberRank(), Create(), Disband(), GetId(), HandleInviteMember(), HandleQuery(), HandleRemoveRank(), HandleSetEmblem(), HandleSetInfo(), HandleSetMOTD(), LoadBankEventLogFromDB(), LoadEventLogFromDB(), LoadFromDB(), LoadMemberFromDB(), LoadRankFromDB(), and Validate().

m_info

std::string Guild::m_info

protected

Referenced by Create(), GetInfo(), HandleRoster(), HandleSetInfo(), and LoadFromDB().

m_leaderGuid

ObjectGuid Guild::m_leaderGuid

protected

Referenced by _IsLeader(), _MemberHasTabRights(), _SetLeaderGUID(), ChangeMemberRank(), Create(), DeleteMember(), GetLeaderGUID(), LoadFromDB(), and Validate().

m_members

std::unordered_map<uint32, Member> Guild::m_members

protected

Referenced by _SendBankList(), _UpdateAccountsNumber(), AddMember(), BroadcastPacket(), BroadcastPacketToRank(), BroadcastToGuild(), BroadcastWorker(), DeleteMember(), Disband(), GetMember(), GetMember(), GetMember(), GetMemberCount(), GetMemberSize(), HandleLeaveMember(), HandleRoster(), LoadMemberFromDB(), MassInviteToEvent(), ResetTimes(), SendInfo(), and Validate().

m_motd

std::string Guild::m_motd

protected

Referenced by Create(), GetMOTD(), HandleRoster(), HandleSetMOTD(), LoadFromDB(), and SendLoginInfo().

m_name

std::string Guild::m_name

protected

Referenced by AddMember(), Create(), GetName(), HandleLeaveMember(), HandleQuery(), Guild::RankInfo::LoadFromDB(), Guild::BankTab::LoadFromDB(), LoadFromDB(), LoadMemberFromDB(), Guild::RankInfo::SaveToDB(), SendInfo(), Guild::BankTab::SetInfo(), SetName(), Guild::RankInfo::SetName(), Guild::Member::SetStats(), and Guild::Member::SetStats().

m_ranks

std::vector<RankInfo> Guild::m_ranks

protected

Referenced by _CreateNewBankTab(), _CreateRank(), _GetLowestRankId(), _GetRanksSize(), GetRankInfo(), GetRankInfo(), HandleAddNewRank(), HandleQuery(), HandleRemoveRank(), HandleRoster(), HandleSetRankInfo(), HandleSetRankInfo(), LoadRankFromDB(), and Validate().

---

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