AzerothCore 3.3.5a
OpenSource WoW Emulator
Loading...
Searching...
No Matches
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

const MemberGetMember (ObjectGuid guid) const
 
MemberGetMember (ObjectGuid guid)
 
MemberGetMember (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, const EmblemInfo &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 officer)
 
void HandleSetRankInfo (WorldSession *session, uint8 rankId, std::string_view name, uint32 rights, uint32 moneyPerDay, std::array< GuildBankRightsAndSlots, GUILD_BANK_MAX_TABS > const &rightsAndSlots)
 
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, const uint64 &amount, bool add)
 
uint32 GetMemberSize () 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< RankInfom_ranks
 
std::unordered_map< uint32, Memberm_members
 
std::vector< BankTabm_bankTabs
 
LogHolder< EventLogEntrym_eventLog
 
std::array< LogHolder< BankEventLogEntry >, GUILD_BANK_MAX_TABS+1 > m_bankEventLog = {}
 

Private Member Functions

uint8 _GetRanksSize () const
 
const RankInfoGetRankInfo (uint8 rankId) const
 
RankInfoGetRankInfo (uint8 rankId)
 
bool _HasRankRight (Player *player, uint32 right) const
 
uint8 _GetLowestRankId () const
 
uint8 _GetPurchasedTabsSize () const
 
BankTabGetBankTab (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 ( )
1031 :
1032 m_id(0),
1033 m_createdDate(0),
1035 m_bankMoney(0)
1036{
1037}
uint64 m_bankMoney
Definition: Guild.h:795
uint32 m_id
Definition: Guild.h:786
uint32 m_accountsNumber
Definition: Guild.h:794
time_t m_createdDate
Definition: Guild.h:791

◆ ~Guild()

Guild::~Guild ( )
1040{
1041 CharacterDatabaseTransaction temp(nullptr);
1042 _DeleteBankItems(temp);
1043}
SQLTransaction< CharacterDatabaseConnection > CharacterDatabaseTransaction
Definition: DatabaseEnvFwd.h:70
void _DeleteBankItems(CharacterDatabaseTransaction trans, bool removeItemsFromDB=false)
Definition: Guild.cpp:2448

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
2785{
2787 event.Type = guildEvent;
2788 if (param1)
2789 event.Params.push_back(*param1);
2790
2791 if (param2)
2792 {
2793 event.Params.resize(2);
2794 event.Params[1] = *param2;
2795 }
2796
2797 if (param3)
2798 {
2799 event.Params.resize(3);
2800 event.Params[2] = *param3;
2801 }
2802 event.Guid = guid;
2803 BroadcastPacket(event.Write());
2804 LOG_DEBUG("guild", "SMSG_GUILD_EVENT [Broadcast] Event: {}", guildEvent);
2805}
#define LOG_DEBUG(filterType__,...)
Definition: Log.h:171
void BroadcastPacket(WorldPacket const *packet) const
Definition: Guild.cpp:2119
Definition: GuildPackets.h:203
WorldPacket const * Write() override
Definition: GuildPackets.cpp:122
uint8 Type
Definition: GuildPackets.h:209

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(), HandleUpdateMemberRank(), ResetTimes(), and SendLoginInfo().

◆ _CreateDefaultGuildRanks()

void Guild::_CreateDefaultGuildRanks ( LocaleConstant  loc)
private
2390{
2392 stmt->SetData(0, m_id);
2393 CharacterDatabase.Execute(stmt);
2394
2395 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS);
2396 stmt->SetData(0, m_id);
2397 CharacterDatabase.Execute(stmt);
2398
2399 _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_MASTER, loc), GR_RIGHT_ALL);
2400 _CreateRank(sObjectMgr->GetAcoreString(LANG_GUILD_OFFICER, loc), GR_RIGHT_ALL);
2404}
DatabaseWorkerPool< CharacterDatabaseConnection > CharacterDatabase
Accessor to the character database.
Definition: DatabaseEnv.cpp:21
@ CHAR_DEL_GUILD_BANK_RIGHTS
Definition: CharacterDatabase.h:157
@ CHAR_DEL_GUILD_RANKS
Definition: CharacterDatabase.h:148
#define sObjectMgr
Definition: ObjectMgr.h:1640
@ GR_RIGHT_GCHATSPEAK
Definition: Guild.h:81
@ GR_RIGHT_ALL
Definition: Guild.h:97
@ GR_RIGHT_GCHATLISTEN
Definition: Guild.h:80
@ LANG_GUILD_MASTER
Definition: Language.h:722
@ LANG_GUILD_VETERAN
Definition: Language.h:724
@ LANG_GUILD_OFFICER
Definition: Language.h:723
@ LANG_GUILD_INITIATE
Definition: Language.h:726
@ LANG_GUILD_MEMBER
Definition: Language.h:725
Definition: PreparedStatement.h:158
Acore::Types::is_default< T > SetData(const uint8 index, T value)
Definition: PreparedStatement.h:78
bool _CreateRank(std::string_view name, uint32 rights)
Definition: Guild.cpp:2406

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
2366{
2367 uint8 tabId = _GetPurchasedTabsSize(); // Next free id
2368 m_bankTabs.emplace_back(m_id, tabId);
2369
2370 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
2371
2373 stmt->SetData(0, m_id);
2374 stmt->SetData (1, tabId);
2375 trans->Append(stmt);
2376
2377 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD_BANK_TAB);
2378 stmt->SetData(0, m_id);
2379 stmt->SetData (1, tabId);
2380 trans->Append(stmt);
2381
2382 ++tabId;
2383 for (auto & m_rank : m_ranks)
2384 m_rank.CreateMissingTabsIfNeeded(tabId, trans, false);
2385
2386 CharacterDatabase.CommitTransaction(trans);
2387}
std::uint8_t uint8
Definition: Define.h:110
@ CHAR_INS_GUILD_BANK_TAB
Definition: CharacterDatabase.h:150
@ CHAR_DEL_GUILD_BANK_TAB
Definition: CharacterDatabase.h:151
std::vector< BankTab > m_bankTabs
Definition: Guild.h:799
uint8 _GetPurchasedTabsSize() const
Definition: Guild.h:819
std::vector< RankInfo > m_ranks
Definition: Guild.h:797

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
2407{
2408 uint8 newRankId = _GetRanksSize();
2409 if (newRankId >= GUILD_RANKS_MAX_COUNT)
2410 return false;
2411
2412 // Ranks represent sequence 0, 1, 2, ... where 0 means guildmaster
2413 RankInfo info(m_id, newRankId, name, rights, 0);
2414 m_ranks.push_back(info);
2415
2416 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
2417 info.CreateMissingTabsIfNeeded(_GetPurchasedTabsSize(), trans);
2418 info.SaveToDB(trans);
2419 CharacterDatabase.CommitTransaction(trans);
2420
2421 return true;
2422}
@ GUILD_RANKS_MAX_COUNT
Definition: Guild.h:49
uint8 _GetRanksSize() const
Definition: Guild.h:806

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
2449{
2450 for (uint8 tabId = 0; tabId < _GetPurchasedTabsSize(); ++tabId)
2451 {
2452 m_bankTabs[tabId].Delete(trans, removeItemsFromDB);
2453 }
2454 m_bankTabs.clear();
2455}

References _GetPurchasedTabsSize(), and m_bankTabs.

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

◆ _DeleteMemberFromDB()

void Guild::_DeleteMemberFromDB ( ObjectGuid::LowType  lowguid) const
inlineprivate
824 {
826 stmt->SetData(0, lowguid);
827 CharacterDatabase.Execute(stmt);
828 }
@ CHAR_DEL_GUILD_MEMBER
Definition: CharacterDatabase.h:144

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
2689{
2690 Item* pDestItem = pDest->GetItem();
2691 bool swap = (pDestItem != nullptr);
2692
2693 Item* pSrcItem = pSrc->GetItem(splitedAmount);
2694 // 1. Can store source item in destination
2695 if (!pDest->CanStore(pSrcItem, swap, sendError))
2696 return false;
2697
2698 // 2. Can store destination item in source
2699 if (swap)
2700 if (!pSrc->CanStore(pDestItem, true, true))
2701 return false;
2702
2703 // GM LOG (TODO: move to scripts)
2704 pDest->LogAction(pSrc);
2705 if (swap)
2706 pSrc->LogAction(pDest);
2707
2708 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
2709 // 3. Log bank events
2710 pDest->LogBankEvent(trans, pSrc, pSrcItem->GetCount());
2711 if (swap)
2712 pSrc->LogBankEvent(trans, pDest, pDestItem->GetCount());
2713
2714 // 4. Remove item from source
2715 pSrc->RemoveItem(trans, pDest, splitedAmount);
2716
2717 // 5. Remove item from destination
2718 if (swap)
2719 pDest->RemoveItem(trans, pSrc);
2720
2721 // 6. Store item in destination
2722 pDest->StoreItem(trans, pSrcItem);
2723
2724 // 7. Store item in source
2725 if (swap)
2726 pSrc->StoreItem(trans, pDestItem);
2727
2728 CharacterDatabase.CommitTransaction(trans);
2729 return true;
2730}
Definition: Item.h:214
uint32 GetCount() const
Definition: Item.h:263

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
2623{
2624 if (const BankTab* tab = GetBankTab(tabId))
2625 return tab->GetItem(slotId);
2626 return nullptr;
2627}
BankTab * GetBankTab(uint8 tabId)
Definition: Guild.h:820

References GetBankTab().

◆ _GetLowestRankId()

uint8 Guild::_GetLowestRankId ( ) const
inlineprivate
817{ 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
2553{
2554 uint8 rankId = member.GetRankId();
2555 if (rankId == GR_GUILDMASTER)
2556 return static_cast<int32>(GUILD_WITHDRAW_MONEY_UNLIMITED);
2557
2559 {
2560 int32 remaining = _GetRankBankMoneyPerDay(rankId) - member.GetBankWithdrawValue(GUILD_BANK_MAX_TABS);
2561 if (remaining > 0)
2562 return remaining;
2563 }
2564 return 0;
2565}
std::int32_t int32
Definition: Define.h:104
@ GUILD_WITHDRAW_MONEY_UNLIMITED
Definition: Guild.h:51
@ GUILD_BANK_MAX_TABS
Definition: Guild.h:45
@ GR_GUILDMASTER
Definition: Guild.h:68
@ GR_RIGHT_WITHDRAW_REPAIR
Definition: Guild.h:94
@ GR_RIGHT_WITHDRAW_GOLD
Definition: Guild.h:95
uint32 _GetRankRights(uint8 rankId) const
Definition: Guild.cpp:2509
int32 _GetRankBankMoneyPerDay(uint8 rankId) const
Definition: Guild.cpp:2516

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
2539{
2540 uint8 rankId = member.GetRankId();
2541 if (rankId == GR_GUILDMASTER)
2542 return static_cast<int32>(GUILD_WITHDRAW_SLOT_UNLIMITED);
2543 if ((_GetRankBankTabRights(rankId, tabId) & GUILD_BANK_RIGHT_VIEW_TAB) != 0)
2544 {
2545 int32 remaining = _GetRankBankTabSlotsPerDay(rankId, tabId) - member.GetBankWithdrawValue(tabId);
2546 if (remaining > 0)
2547 return remaining;
2548 }
2549 return 0;
2550}
@ GUILD_WITHDRAW_SLOT_UNLIMITED
Definition: Guild.h:52
@ GUILD_BANK_RIGHT_VIEW_TAB
Definition: Guild.h:190
int8 _GetRankBankTabRights(uint8 rankId, uint8 tabId) const
Definition: Guild.cpp:2531
int32 _GetRankBankTabSlotsPerDay(uint8 rankId, uint8 tabId) const
Definition: Guild.cpp:2523

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()

◆ _GetRankBankMoneyPerDay()

int32 Guild::_GetRankBankMoneyPerDay ( uint8  rankId) const
inlineprivate
2517{
2518 if (const RankInfo* rankInfo = GetRankInfo(rankId))
2519 return rankInfo->GetBankMoneyPerDay();
2520 return 0;
2521}
const RankInfo * GetRankInfo(uint8 rankId) const
Definition: Guild.h:807

References GetRankInfo().

Referenced by _GetMemberRemainingMoney(), and SendPermissions().

◆ _GetRankBankTabRights()

int8 Guild::_GetRankBankTabRights ( uint8  rankId,
uint8  tabId 
) const
inlineprivate
2532{
2533 if (const RankInfo* rankInfo = GetRankInfo(rankId))
2534 return rankInfo->GetBankTabRights(tabId);
2535 return 0;
2536}

References GetRankInfo().

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

◆ _GetRankBankTabSlotsPerDay()

int32 Guild::_GetRankBankTabSlotsPerDay ( uint8  rankId,
uint8  tabId 
) const
inlineprivate
2524{
2525 if (tabId < _GetPurchasedTabsSize())
2526 if (const RankInfo* rankInfo = GetRankInfo(rankId))
2527 return rankInfo->GetBankTabSlotsPerDay(tabId);
2528 return 0;
2529}

References _GetPurchasedTabsSize(), and GetRankInfo().

Referenced by _GetMemberRemainingSlots(), and _UpdateMemberWithdrawSlots().

◆ _GetRankName()

std::string Guild::_GetRankName ( uint8  rankId) const
inlineprivate
2503{
2504 if (const RankInfo* rankInfo = GetRankInfo(rankId))
2505 return rankInfo->GetName();
2506 return "<unknown>";
2507}

References GetRankInfo().

Referenced by HandleUpdateMemberRank().

◆ _GetRankRights()

uint32 Guild::_GetRankRights ( uint8  rankId) const
inlineprivate
2510{
2511 if (const RankInfo* rankInfo = GetRankInfo(rankId))
2512 return rankInfo->GetRights();
2513 return 0;
2514}

References GetRankInfo().

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

◆ _GetRanksSize()

uint8 Guild::_GetRanksSize ( ) const
inlineprivate

◆ _HasRankRight()

bool Guild::_HasRankRight ( Player player,
uint32  right 
) const
inlineprivate
810 {
811 if (player)
812 if (Member const* member = GetMember(player->GetGUID()))
813 return (_GetRankRights(member->GetRankId()) & right) != GR_RIGHT_EMPTY;
814 return false;
815 }
@ GR_RIGHT_EMPTY
Definition: Guild.h:79
static ObjectGuid GetGUID(Object const *o)
Definition: Object.h:106
const Member * GetMember(ObjectGuid guid) const
Definition: Guild.h:384

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

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

◆ _IsLeader()

bool Guild::_IsLeader ( Player player) const
private
2440{
2441 if (player->GetGUID() == m_leaderGuid)
2442 return true;
2443 if (const Member* member = GetMember(player->GetGUID()))
2444 return member->IsRank(GR_GUILDMASTER);
2445 return false;
2446}
ObjectGuid m_leaderGuid
Definition: Guild.h:788

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
2602{
2603 if (tabId > GUILD_BANK_MAX_TABS)
2604 return;
2605
2606 // not logging moves within the same tab
2607 if (eventType == GUILD_BANK_LOG_MOVE_ITEM && tabId == destTabId)
2608 return;
2609
2610 uint8 dbTabId = tabId;
2611 if (BankEventLogEntry::IsMoneyEvent(eventType))
2612 {
2613 tabId = GUILD_BANK_MAX_TABS;
2614 dbTabId = GUILD_BANK_MONEY_LOGS_TAB;
2615 }
2616 LogHolder<BankEventLogEntry>& pLog = m_bankEventLog[tabId];
2617 pLog.AddEvent(trans, m_id, pLog.GetNextGUID(), eventType, dbTabId, guid, itemOrMoney, itemStackCount, destTabId);
2618
2619 sScriptMgr->OnGuildBankEvent(this, uint8(eventType), tabId, guid.GetCounter(), itemOrMoney, itemStackCount, destTabId);
2620}
@ GUILD_BANK_MONEY_LOGS_TAB
Definition: Guild.h:47
@ GUILD_BANK_LOG_MOVE_ITEM
Definition: Guild.h:202
#define sScriptMgr
Definition: ScriptMgr.h:2702
std::array< LogHolder< BankEventLogEntry >, GUILD_BANK_MAX_TABS+1 > m_bankEventLog
Definition: Guild.h:803
bool IsMoneyEvent() const
Definition: Guild.h:457

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
2592{
2593 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
2594 m_eventLog.AddEvent(trans, m_id, m_eventLog.GetNextGUID(), eventType, playerGuid1, playerGuid2, newRank);
2595 CharacterDatabase.CommitTransaction(trans);
2596
2597 sScriptMgr->OnGuildEvent(this, uint8(eventType), playerGuid1.GetCounter(), playerGuid2.GetCounter(), newRank);
2598}
LowType GetCounter() const
Definition: ObjectGuid.h:147
LogHolder< EventLogEntry > m_eventLog
Definition: Guild.h:802

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
2579{
2580 if (const Member* member = GetMember(guid))
2581 {
2582 // Leader always has full rights
2583 if (member->IsRank(GR_GUILDMASTER) || m_leaderGuid == guid)
2584 return true;
2585 return (_GetRankBankTabRights(member->GetRankId(), tabId) & rights) == rights;
2586 }
2587 return false;
2588}

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

Referenced by _SendBankContent(), and _SendBankList().

◆ _ModifyBankMoney()

bool Guild::_ModifyBankMoney ( CharacterDatabaseTransaction  trans,
uint64  amount,
bool  add 
)
private
2458{
2459 if (add)
2460 m_bankMoney += amount;
2461 else
2462 {
2463 // Check if there is enough money in bank.
2464 if (m_bankMoney < amount)
2465 return false;
2466 m_bankMoney -= amount;
2467 }
2468
2470 stmt->SetData(0, m_bankMoney);
2471 stmt->SetData(1, m_id);
2472 trans->Append(stmt);
2473 return true;
2474}
@ CHAR_UPD_GUILD_BANK_MONEY
Definition: CharacterDatabase.h:175

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
2636{
2637 // 1. Initialize source item
2638 if (!pSrc->InitItem())
2639 return; // No source item
2640
2641 // 2. Check source item
2642 if (!pSrc->CheckItem(splitedAmount))
2643 return; // Source item or splited amount is invalid
2644
2645 // 3. Check destination rights
2646 if (!pDest->HasStoreRights(pSrc))
2647 return; // Player has no rights to store item in destination
2648
2649 // 4. Check source withdraw rights
2650 if (!pSrc->HasWithdrawRights(pDest))
2651 return; // Player has no rights to withdraw items from source
2652
2653 // 5. Check split
2654 if (splitedAmount)
2655 {
2656 // 5.1. Clone source item
2657 if (!pSrc->CloneItem(splitedAmount))
2658 return; // Item could not be cloned
2659
2660 // 5.2. Move splited item to destination
2661 _DoItemsMove(pSrc, pDest, true, splitedAmount);
2662 }
2663 else // 6. No split
2664 {
2665 // 6.1. Try to merge items in destination (pDest->GetItem() == nullptr)
2666 if (!_DoItemsMove(pSrc, pDest, false)) // Item could not be merged
2667 {
2668 // 6.2. Try to swap items
2669 // 6.2.1. Initialize destination item
2670 if (!pDest->InitItem())
2671 return;
2672
2673 // 6.2.2. Check rights to store item in source (opposite direction)
2674 if (!pSrc->HasStoreRights(pDest))
2675 return; // Player has no rights to store item in source (opposite direction)
2676
2677 if (!pDest->HasWithdrawRights(pSrc))
2678 return; // Player has no rights to withdraw item from destination (opposite direction)
2679
2680 // 6.2.3. Swap items (pDest->GetItem() != nullptr)
2681 _DoItemsMove(pSrc, pDest, true);
2682 }
2683 }
2684 // 7. Send changes
2685 _SendBankContentUpdate(pSrc, pDest);
2686}
bool _DoItemsMove(MoveItemData *pSrc, MoveItemData *pDest, bool sendError, uint32 splitedAmount=0)
Definition: Guild.cpp:2688
void _SendBankContentUpdate(MoveItemData *pSrc, MoveItemData *pDest) const
Definition: Guild.cpp:2746

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
2630{
2631 if (BankTab* pTab = GetBankTab(tabId))
2632 pTab->SetItem(trans, slotId, nullptr);
2633}

References GetBankTab().

◆ _SendBankContent()

void Guild::_SendBankContent ( WorldSession session,
uint8  tabId,
bool  sendAllSlots 
) const
private
2733{
2734 ObjectGuid guid = session->GetPlayer()->GetGUID();
2736 return;
2737
2738 _SendBankList(session, tabId, sendAllSlots);
2739}
Definition: ObjectGuid.h:120
void _SendBankList(WorldSession *session=nullptr, uint8 tabId=0, bool sendFullSlots=false, SlotIds *slots=nullptr) const
Definition: Guild.cpp:2807
bool _MemberHasTabRights(ObjectGuid guid, uint8 tabId, uint32 rights) const
Definition: Guild.cpp:2578
Player * GetPlayer() const
Definition: WorldSession.h:361

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
2747{
2748 ASSERT(pSrc->IsBank() || pDest->IsBank());
2749
2750 uint8 tabId = 0;
2751 SlotIds slots;
2752 if (pSrc->IsBank()) // B ->
2753 {
2754 tabId = pSrc->GetContainer();
2755 slots.insert(pSrc->GetSlotId());
2756 if (pDest->IsBank()) // B -> B
2757 {
2758 // Same tab - add destination slots to collection
2759 if (pDest->GetContainer() == pSrc->GetContainer())
2760 pDest->CopySlots(slots);
2761 else // Different tabs - send second message
2762 {
2763 SlotIds destSlots;
2764 pDest->CopySlots(destSlots);
2765 _SendBankContentUpdate(pDest->GetContainer(), destSlots);
2766 }
2767 }
2768 }
2769 else if (pDest->IsBank()) // C -> B
2770 {
2771 tabId = pDest->GetContainer();
2772 pDest->CopySlots(slots);
2773 }
2774
2775 _SendBankContentUpdate(tabId, slots);
2776}
#define ASSERT
Definition: Errors.h:68
std::set< uint8 > SlotIds
Definition: Guild.h:292

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
2779{
2780 _SendBankList(nullptr, tabId, false, &slots);
2781}

References _SendBankList().

◆ _SendBankList()

void Guild::_SendBankList ( WorldSession session = nullptr,
uint8  tabId = 0,
bool  sendFullSlots = false,
SlotIds slots = nullptr 
) const
private
2808{
2809 if (!sScriptMgr->CanGuildSendBankList(this, session, tabId, sendAllSlots))
2810 return;
2811
2813
2814 packet.Money = m_bankMoney;
2815 packet.Tab = int32(tabId);
2816 packet.FullUpdate = sendAllSlots;
2817
2818 if (sendAllSlots && !tabId)
2819 {
2820 packet.TabInfo.reserve(_GetPurchasedTabsSize());
2821 for (uint8 i = 0; i < _GetPurchasedTabsSize(); ++i)
2822 {
2824 tabInfo.Name = m_bankTabs[i].GetName();
2825 tabInfo.Icon = m_bankTabs[i].GetIcon();
2826 packet.TabInfo.push_back(tabInfo);
2827 }
2828 }
2829
2830 if (BankTab const* tab = GetBankTab(tabId))
2831 {
2832 auto fillItems = [&](auto begin, auto end, bool skipEmpty)
2833 {
2834 for (auto itr = begin; itr != end; ++itr)
2835 {
2836 if (Item* tabItem = tab->GetItem(*itr))
2837 {
2839
2840 itemInfo.Slot = *itr;
2841 itemInfo.ItemID = tabItem->GetEntry();
2842 itemInfo.Count = int32(tabItem->GetCount());
2843 itemInfo.Charges = int32(std::abs(tabItem->GetSpellCharges()));
2844 itemInfo.EnchantmentID = int32(tabItem->GetEnchantmentId(PERM_ENCHANTMENT_SLOT));
2845 itemInfo.Flags = tabItem->GetInt32Value(ITEM_FIELD_FLAGS);
2846 itemInfo.RandomPropertiesID = tabItem->GetItemRandomPropertyId();
2847 itemInfo.RandomPropertiesSeed = int32(tabItem->GetItemSuffixFactor());
2848
2849 for (uint32 socketSlot = 0; socketSlot < MAX_GEM_SOCKETS; ++socketSlot)
2850 {
2851 if (uint32 enchId = tabItem->GetEnchantmentId(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT + socketSlot)))
2852 {
2854 gem.SocketIndex = socketSlot;
2855 gem.SocketEnchantID = int32(enchId);
2856 itemInfo.SocketEnchant.push_back(gem);
2857 }
2858 }
2859
2860 packet.ItemInfo.push_back(itemInfo);
2861 }
2862 else if (!skipEmpty)
2863 {
2865
2866 itemInfo.Slot = *itr;
2867 itemInfo.ItemID = 0;
2868
2869 packet.ItemInfo.push_back(itemInfo);
2870 }
2871 }
2872
2873 };
2874
2875 if (sendAllSlots)
2876 fillItems(boost::make_counting_iterator(uint8(0)), boost::make_counting_iterator(uint8(GUILD_BANK_MAX_SLOTS)), true);
2877 else if (slots && !slots->empty())
2878 fillItems(slots->begin(), slots->end(), false);
2879 }
2880
2881 if (session)
2882 {
2883 if (Member const* member = GetMember(session->GetPlayer()->GetGUID()))
2884 packet.WithdrawalsRemaining = _GetMemberRemainingSlots(*member, tabId);
2885
2886 session->SendPacket(packet.Write());
2887 LOG_DEBUG("guild", "SMSG_GUILD_BANK_LIST [{}]: TabId: {}, FullSlots: {}, slots: {}",
2888 session->GetPlayerInfo(), tabId, sendAllSlots, packet.WithdrawalsRemaining);
2889 }
2890 else
2891 {
2892 packet.Write();
2893 for (auto const& [guid, member] : m_members)
2894 {
2895 if (!member.ShouldReceiveBankPartialUpdatePackets())
2896 continue;
2897
2898 if (!_MemberHasTabRights(member.GetGUID(), tabId, GUILD_BANK_RIGHT_VIEW_TAB))
2899 continue;
2900
2901 Player* player = member.FindPlayer();
2902 if (!player)
2903 continue;
2904
2906 player->SendDirectMessage(packet.GetRawPacket());
2907 LOG_DEBUG("guild", "SMSG_GUILD_BANK_LIST [{}]: TabId: {}, FullSlots: {}, slots: {}"
2908 , player->GetName(), tabId, sendAllSlots, packet.WithdrawalsRemaining);
2909 }
2910 }
2911}
std::uint32_t uint32
Definition: Define.h:108
#define MAX_GEM_SOCKETS
Definition: Item.h:182
EnchantmentSlot
Definition: Item.h:162
@ PERM_ENCHANTMENT_SLOT
Definition: Item.h:163
@ SOCK_ENCHANTMENT_SLOT
Definition: Item.h:165
@ ITEM_FIELD_FLAGS
Definition: UpdateFields.h:42
@ GUILD_BANK_MAX_SLOTS
Definition: Guild.h:46
std::string const & GetName() const
Definition: Object.h:446
Definition: Player.h:1046
void SendDirectMessage(WorldPacket const *data) const
Definition: Player.cpp:5594
int32 _GetMemberRemainingSlots(Member const &member, uint8 tabId) const
Definition: Guild.cpp:2538
std::unordered_map< uint32, Member > m_members
Definition: Guild.h:798
WorldPacket const * GetRawPacket() const
Definition: Packet.h:38
Definition: GuildPackets.h:457
uint8 SocketIndex
Definition: GuildPackets.h:458
int32 SocketEnchantID
Definition: GuildPackets.h:459
Definition: GuildPackets.h:463
int32 EnchantmentID
Definition: GuildPackets.h:469
int32 Flags
Definition: GuildPackets.h:471
std::vector< GuildBankSocketEnchant > SocketEnchant
Definition: GuildPackets.h:472
uint32 ItemID
Definition: GuildPackets.h:464
int32 Count
Definition: GuildPackets.h:468
int32 RandomPropertiesID
Definition: GuildPackets.h:466
int32 Charges
Definition: GuildPackets.h:470
int32 RandomPropertiesSeed
Definition: GuildPackets.h:465
uint8 Slot
Definition: GuildPackets.h:467
Definition: GuildPackets.h:476
std::string Name
Definition: GuildPackets.h:477
std::string Icon
Definition: GuildPackets.h:478
Definition: GuildPackets.h:482
int32 WithdrawalsRemaining
Definition: GuildPackets.h:490
bool FullUpdate
Definition: GuildPackets.h:493
WorldPacket const * Write() override
Definition: GuildPackets.cpp:285
void SetWithdrawalsRemaining(int32 withdrawalsRemaining)
Definition: GuildPackets.cpp:331
uint8 Tab
Definition: GuildPackets.h:491
std::vector< GuildBankTabInfo > TabInfo
Definition: GuildPackets.h:489
uint64 Money
Definition: GuildPackets.h:492
std::vector< GuildBankItemInfo > ItemInfo
Definition: GuildPackets.h:488
void SendPacket(WorldPacket const *packet)
Send a packet to the client.
Definition: WorldSession.cpp:207
std::string GetPlayerInfo() const
Definition: WorldSession.cpp:184

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
2742{
2743 _SendBankList(session);
2744}

References _SendBankList().

◆ _SetLeaderGUID()

void Guild::_SetLeaderGUID ( Member pLeader)
private
2477{
2478 m_leaderGuid = pLeader.GetGUID();
2479 pLeader.ChangeRank(GR_GUILDMASTER);
2480
2482 stmt->SetData(0, m_leaderGuid.GetCounter());
2483 stmt->SetData(1, m_id);
2484 CharacterDatabase.Execute(stmt);
2485}
@ CHAR_UPD_GUILD_LEADER
Definition: CharacterDatabase.h:170

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
2488{
2489 if (RankInfo* rankInfo = GetRankInfo(rankId))
2490 rankInfo->SetBankMoneyPerDay(moneyPerDay);
2491}

References GetRankInfo().

Referenced by HandleSetRankInfo().

◆ _SetRankBankTabRightsAndSlots()

void Guild::_SetRankBankTabRightsAndSlots ( uint8  rankId,
GuildBankRightsAndSlots  rightsAndSlots,
bool  saveToDB = true 
)
private
2494{
2495 if (rightsAndSlots.GetTabId() >= _GetPurchasedTabsSize())
2496 return;
2497
2498 if (RankInfo* rankInfo = GetRankInfo(rankId))
2499 rankInfo->SetBankTabSlotsAndRights(rightsAndSlots, saveToDB);
2500}
uint8 GetTabId() const
Definition: Guild.h:282

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

Referenced by HandleSetRankInfo(), and LoadBankRightFromDB().

◆ _UpdateAccountsNumber()

void Guild::_UpdateAccountsNumber ( )
private
2427{
2428 // We use a set to be sure each element will be unique
2429 std::unordered_set<uint32> accountsIdSet;
2430 for (auto const& [guid, member] : m_members)
2431 accountsIdSet.insert(member.GetAccountId());
2432
2433 m_accountsNumber = accountsIdSet.size();
2434}

References m_accountsNumber, and m_members.

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

◆ _UpdateMemberWithdrawSlots()

void Guild::_UpdateMemberWithdrawSlots ( CharacterDatabaseTransaction  trans,
ObjectGuid  guid,
uint8  tabId 
)
inlineprivate
2568{
2569 if (Member* member = GetMember(guid))
2570 {
2571 uint8 rankId = member->GetRankId();
2572 if (rankId != GR_GUILDMASTER
2573 && member->GetBankWithdrawValue(tabId) < _GetRankBankTabSlotsPerDay(rankId, tabId))
2574 member->UpdateBankWithdrawValue(trans, tabId, 1);
2575 }
2576}

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

◆ AddMember()

bool Guild::AddMember ( ObjectGuid  guid,
uint8  rankId = GUILD_RANK_NONE 
)
2160{
2162 // Player cannot be in guild
2163 if (player)
2164 {
2165 if (player->GetGuildId() != 0)
2166 return false;
2167 }
2168 else if (sCharacterCache->GetCharacterGuildIdByGuid(guid) != 0)
2169 return false;
2170
2171 // Remove all player signs from another petitions
2172 // This will be prevent attempt to join many guilds and corrupt guild data integrity
2174
2175 ObjectGuid::LowType lowguid = guid.GetCounter();
2176
2177 // If rank was not passed, assign lowest possible rank
2178 if (rankId == GUILD_RANK_NONE)
2179 rankId = _GetLowestRankId();
2180
2181 auto [memberIt, isNew] = m_members.try_emplace(lowguid, m_id, guid, rankId);
2182 if (!isNew)
2183 {
2184 LOG_ERROR("guild", "Tried to add {} to guild '{}'. Member already exists.", guid.ToString(), m_name);
2185 return false;
2186 }
2187
2188 Member& member = memberIt->second;
2189 std::string name;
2190 if (player)
2191 {
2192 player->SetInGuild(m_id);
2193 player->SetGuildIdInvited(0);
2194 player->SetRank(rankId);
2195 member.SetStats(player);
2196 SendLoginInfo(player->GetSession());
2197 name = player->GetName();
2198 }
2199 else
2200 {
2201 member.ResetFlags();
2202
2203 bool ok = false;
2204 // xinef: sync query
2205 // Player must exist
2207 stmt->SetData(0, guid.GetCounter());
2208 if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
2209 {
2210 Field* fields = result->Fetch();
2211 name = fields[0].Get<std::string>();
2212 member.SetStats(
2213 name,
2214 fields[1].Get<uint8>(),
2215 fields[2].Get<uint8>(),
2216 fields[3].Get<uint8>(),
2217 fields[4].Get<uint16>(),
2218 fields[5].Get<uint32>());
2219
2220 ok = member.CheckStats();
2221 }
2222 if (!ok)
2223 {
2224 m_members.erase(memberIt);
2225 return false;
2226 }
2227 sCharacterCache->UpdateCharacterGuildId(guid, m_id);
2228 }
2229
2230 CharacterDatabaseTransaction trans(nullptr);
2231 member.SaveToDB(trans);
2232
2235 _BroadcastEvent(GE_JOINED, guid, name);
2236
2237 // Call scripts if member was succesfully added (and stored to database)
2238 sScriptMgr->OnGuildAddMember(this, player, rankId);
2239
2240 return true;
2241}
std::uint16_t uint16
Definition: Define.h:109
#define LOG_ERROR(filterType__,...)
Definition: Log.h:159
std::shared_ptr< PreparedResultSet > PreparedQueryResult
Definition: DatabaseEnvFwd.h:46
@ CHAR_SEL_CHAR_DATA_FOR_GUILD
Definition: CharacterDatabase.h:181
#define sCharacterCache
Definition: CharacterCache.h:83
@ GE_JOINED
Definition: Guild.h:153
@ GUILD_RANK_NONE
Definition: Guild.h:50
@ GUILD_EVENT_LOG_JOIN_GUILD
Definition: Guild.h:214
@ GUILD_CHARTER_TYPE
Definition: WorldSession.h:222
Player * FindConnectedPlayer(ObjectGuid const guid)
Definition: ObjectAccessor.cpp:262
Class used to access individual fields of database query result.
Definition: Field.h:99
std::enable_if_t< std::is_arithmetic_v< T >, T > Get() const
Definition: Field.h:113
std::string ToString() const
Definition: ObjectGuid.cpp:47
uint32 LowType
Definition: ObjectGuid.h:124
void SetGuildIdInvited(uint32 GuildId)
Definition: Player.h:1850
uint32 GetGuildId() const
Definition: Player.h:1851
WorldSession * GetSession() const
Definition: Player.h:1948
void SetInGuild(uint32 GuildId)
Definition: Player.h:1842
void SetRank(uint8 rankId)
Definition: Player.h:1848
static void RemovePetitionsAndSigns(ObjectGuid guid, uint32 type)
Definition: Player.cpp:10006
void SendLoginInfo(WorldSession *session)
Definition: Guild.cpp:1862
std::string m_name
Definition: Guild.h:787
void _UpdateAccountsNumber()
Definition: Guild.cpp:2426
void _BroadcastEvent(GuildEvents guildEvent, ObjectGuid guid=ObjectGuid::Empty, Optional< std::string_view > param1={}, Optional< std::string_view > param2={}, Optional< std::string_view > param3={}) const
Definition: Guild.cpp:2783
void _LogEvent(GuildEventLogTypes eventType, ObjectGuid playerGuid1, ObjectGuid playerGuid2=ObjectGuid::Empty, uint8 newRank=0)
Definition: Guild.cpp:2591
uint8 _GetLowestRankId() const
Definition: Guild.h:817

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
2120{
2121 for (auto const& [guid, member] : m_members)
2122 if (Player* player = member.FindPlayer())
2123 player->GetSession()->SendPacket(packet);
2124}

References m_members.

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

◆ BroadcastPacketToRank()

void Guild::BroadcastPacketToRank ( WorldPacket const *  packet,
uint8  rankId 
) const
2112{
2113 for (auto const& [guid, member] : m_members)
2114 if (member.IsRank(rankId))
2115 if (Player* player = member.FindPlayer())
2116 player->GetSession()->SendPacket(packet);
2117}

References m_members.

◆ BroadcastToGuild()

void Guild::BroadcastToGuild ( WorldSession session,
bool  officerOnly,
std::string_view  msg,
uint32  language = LANG_UNIVERSAL 
) const
2099{
2100 if (session && session->GetPlayer() && _HasRankRight(session->GetPlayer(), officerOnly ? GR_RIGHT_OFFCHATSPEAK : GR_RIGHT_GCHATSPEAK))
2101 {
2102 WorldPacket data;
2103 ChatHandler::BuildChatPacket(data, officerOnly ? CHAT_MSG_OFFICER : CHAT_MSG_GUILD, Language(language), session->GetPlayer(), nullptr, msg);
2104 for (auto const& [guid, member] : m_members)
2105 if (Player* player = member.FindPlayer())
2106 if (_HasRankRight(player, officerOnly ? GR_RIGHT_OFFCHATLISTEN : GR_RIGHT_GCHATLISTEN) && !player->GetSocial()->HasIgnore(session->GetPlayer()->GetGUID()))
2107 player->GetSession()->SendPacket(&data);
2108 }
2109}
@ GR_RIGHT_OFFCHATSPEAK
Definition: Guild.h:83
@ GR_RIGHT_OFFCHATLISTEN
Definition: Guild.h:82
@ CHAT_MSG_GUILD
Definition: SharedDefines.h:3128
@ CHAT_MSG_OFFICER
Definition: SharedDefines.h:3129
Language
Definition: SharedDefines.h:706
static size_t BuildChatPacket(WorldPacket &data, ChatMsg chatType, Language language, ObjectGuid senderGUID, ObjectGuid receiverGUID, std::string_view message, uint8 chatTag, std::string const &senderName="", std::string const &receiverName="", uint32 achievementId=0, bool gmMessage=false, std::string const &channelName="")
Definition: Chat.cpp:192
bool _HasRankRight(Player *player, uint32 right) const
Definition: Guild.h:809
Definition: WorldPacket.h:27

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
755 {
756 for (auto const& m_member : m_members)
757 if (Player* player = m_member.second.FindPlayer())
758 if (player != except)
759 _do(player);
760 }

References m_members.

Referenced by AchievementMgr::SendAchievementEarned().

◆ ChangeMemberRank()

bool Guild::ChangeMemberRank ( ObjectGuid  guid,
uint8  newRank 
)
2305{
2306 if (newRank <= _GetLowestRankId()) // Validate rank (allow only existing ranks)
2307 if (Member* member = GetMember(guid))
2308 {
2309 member->ChangeRank(newRank);
2310
2311 if (newRank == GR_GUILDMASTER)
2312 {
2313 m_leaderGuid = guid;
2314
2316 stmt->SetData(0, m_leaderGuid.GetCounter());
2317 stmt->SetData(1, m_id);
2318 CharacterDatabase.Execute(stmt);
2319 }
2320
2321 return true;
2322 }
2323 return false;
2324}

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 
)
1047{
1048 // Check if guild with such name already exists
1049 if (sGuildMgr->GetGuildByName(name))
1050 return false;
1051
1052 WorldSession* pLeaderSession = pLeader->GetSession();
1053 if (!pLeaderSession)
1054 return false;
1055
1056 m_id = sGuildMgr->GenerateGuildId();
1057 m_leaderGuid = pLeader->GetGUID();
1058 m_name = name;
1059 m_info = "";
1060 m_motd = "No message set.";
1061 m_bankMoney = 0;
1063
1064 LOG_DEBUG("guild", "GUILD: creating guild [{}] for leader {} ({})",
1065 m_name, pLeader->GetName(), m_leaderGuid.ToString());
1066
1067 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
1068
1070 stmt->SetData(0, m_id);
1071 trans->Append(stmt);
1072
1073 uint8 index = 0;
1074 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD);
1075 stmt->SetData( index, m_id);
1076 stmt->SetData(++index, m_name);
1077 stmt->SetData(++index, m_leaderGuid.GetCounter());
1078 stmt->SetData(++index, m_info);
1079 stmt->SetData(++index, m_motd);
1080 stmt->SetData(++index, uint32(m_createdDate));
1081 stmt->SetData(++index, m_emblemInfo.GetStyle());
1082 stmt->SetData(++index, m_emblemInfo.GetColor());
1083 stmt->SetData(++index, m_emblemInfo.GetBorderStyle());
1084 stmt->SetData(++index, m_emblemInfo.GetBorderColor());
1085 stmt->SetData(++index, m_emblemInfo.GetBackgroundColor());
1086 stmt->SetData(++index, m_bankMoney);
1087 trans->Append(stmt);
1088
1089 CharacterDatabase.CommitTransaction(trans);
1090 _CreateDefaultGuildRanks(pLeaderSession->GetSessionDbLocaleIndex()); // Create default ranks
1091 bool ret = AddMember(m_leaderGuid, GR_GUILDMASTER); // Add guildmaster
1092
1093 for (short i = 0; i < static_cast<short>(sWorld->getIntConfig(CONFIG_GUILD_BANK_INITIAL_TABS)); i++)
1094 {
1096 }
1097
1098 if (ret)
1099 sScriptMgr->OnGuildCreate(this, pLeader, m_name);
1100
1101 return ret;
1102}
@ CHAR_INS_GUILD
Definition: CharacterDatabase.h:140
@ CHAR_DEL_GUILD_MEMBERS
Definition: CharacterDatabase.h:145
#define sGuildMgr
Definition: GuildMgr.h:51
@ CONFIG_GUILD_BANK_INITIAL_TABS
Definition: IWorld.h:398
#define sWorld
Definition: World.h:451
Seconds GetGameTime()
Definition: GameTime.cpp:38
uint32 GetStyle() const
Definition: Guild.h:250
uint32 GetColor() const
Definition: Guild.h:251
uint32 GetBackgroundColor() const
Definition: Guild.h:254
uint32 GetBorderStyle() const
Definition: Guild.h:252
uint32 GetBorderColor() const
Definition: Guild.h:253
void _CreateNewBankTab()
Definition: Guild.cpp:2365
bool AddMember(ObjectGuid guid, uint8 rankId=GUILD_RANK_NONE)
Definition: Guild.cpp:2159
std::string m_motd
Definition: Guild.h:789
EmblemInfo m_emblemInfo
Definition: Guild.h:793
std::string m_info
Definition: Guild.h:790
void _CreateDefaultGuildRanks(LocaleConstant loc)
Definition: Guild.cpp:2389
Player session in the World.
Definition: WorldSession.h:330
LocaleConstant GetSessionDbLocaleIndex() const
Definition: WorldSession.h:497

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 
)
2244{
2245 ObjectGuid::LowType lowguid = guid.GetCounter();
2247
2248 // Guild master can be deleted when loading guild and guid doesn't exist in characters table
2249 // or when he is removed from guild by gm command
2250 if (m_leaderGuid == guid && !isDisbanding)
2251 {
2252 Member* oldLeader = nullptr;
2253 Member* newLeader = nullptr;
2254 for (auto& [guid, member] : m_members)
2255 {
2256 if (guid == lowguid)
2257 oldLeader = &member;
2258 else if (!newLeader || newLeader->GetRankId() > member.GetRankId())
2259 newLeader = &member;
2260 }
2261
2262 if (!newLeader)
2263 {
2264 Disband();
2265 if (canDeleteGuild)
2266 delete this;
2267 return;
2268 }
2269
2270 _SetLeaderGUID(*newLeader);
2271
2272 // If player not online data in data field will be loaded from guild tabs no need to update it !!
2273 if (Player* newLeaderPlayer = newLeader->FindPlayer())
2274 newLeaderPlayer->SetRank(GR_GUILDMASTER);
2275
2276 // If leader does not exist (at guild loading with deleted leader) do not send broadcasts
2277 if (oldLeader)
2278 {
2279 _BroadcastEvent(GE_LEADER_CHANGED, ObjectGuid::Empty, oldLeader->GetName(), newLeader->GetName());
2280 _BroadcastEvent(GE_LEFT, guid, oldLeader->GetName());
2281 }
2282 }
2283 // Call script on remove before member is actually removed from guild (and database)
2284 sScriptMgr->OnGuildRemoveMember(this, player, isDisbanding, isKicked);
2285
2286 m_members.erase(lowguid);
2287
2288 // If player not online data in data field will be loaded from guild tabs no need to update it !!
2289 if (player)
2290 {
2291 player->SetInGuild(0);
2292 player->SetRank(0);
2293 }
2294 else
2295 {
2296 sCharacterCache->UpdateCharacterGuildId(guid, 0);
2297 }
2298
2300 if (!isDisbanding)
2302}
@ GE_LEFT
Definition: Guild.h:154
@ GE_LEADER_CHANGED
Definition: Guild.h:157
static ObjectGuid const Empty
Definition: ObjectGuid.h:122
void _SetLeaderGUID(Member &pLeader)
Definition: Guild.cpp:2476
void Disband()
Definition: Guild.cpp:1105
void _DeleteMemberFromDB(ObjectGuid::LowType lowguid) const
Definition: Guild.h:823

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 ( )
1106{
1107 // Call scripts before guild data removed from database
1108 sScriptMgr->OnGuildDisband(this);
1109
1111 // Remove all members
1112 while (!m_members.empty())
1113 {
1114 auto itr = m_members.begin();
1115 DeleteMember(itr->second.GetGUID(), true);
1116 }
1117
1118 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
1119
1121 stmt->SetData(0, m_id);
1122 trans->Append(stmt);
1123
1124 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_RANKS);
1125 stmt->SetData(0, m_id);
1126 trans->Append(stmt);
1127
1128 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_TABS);
1129 stmt->SetData(0, m_id);
1130 trans->Append(stmt);
1131
1132 // Free bank tab used memory and delete items stored in them
1133 _DeleteBankItems(trans, true);
1134
1135 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_ITEMS);
1136 stmt->SetData(0, m_id);
1137 trans->Append(stmt);
1138
1139 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS);
1140 stmt->SetData(0, m_id);
1141 trans->Append(stmt);
1142
1143 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_EVENTLOGS);
1144 stmt->SetData(0, m_id);
1145 trans->Append(stmt);
1146
1147 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_EVENTLOGS);
1148 stmt->SetData(0, m_id);
1149 trans->Append(stmt);
1150
1151 CharacterDatabase.CommitTransaction(trans);
1152 sGuildMgr->RemoveGuild(m_id);
1153}
@ CHAR_DEL_GUILD_BANK_TABS
Definition: CharacterDatabase.h:152
@ CHAR_DEL_GUILD
Definition: CharacterDatabase.h:141
@ CHAR_DEL_GUILD_BANK_EVENTLOGS
Definition: CharacterDatabase.h:161
@ CHAR_DEL_GUILD_BANK_ITEMS
Definition: CharacterDatabase.h:155
@ CHAR_DEL_GUILD_EVENTLOGS
Definition: CharacterDatabase.h:164
@ GE_DISBANDED
Definition: Guild.h:158
void DeleteMember(ObjectGuid guid, bool isDisbanding=false, bool isKicked=false, bool canDeleteGuild=false)
Definition: Guild.cpp:2243

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
820{ 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
821{ return tabId < m_bankTabs.size() ? &m_bankTabs[tabId] : nullptr; }

References m_bankTabs.

◆ GetCreatedDate()

time_t Guild::GetCreatedDate ( ) const
inline

◆ GetId()

◆ GetInfo()

std::string const & Guild::GetInfo ( ) const
inline
693{ return m_info; }

References m_info.

Referenced by guild_commandscript::HandleGuildInfoCommand().

◆ GetLeaderGUID()

◆ GetMember() [1/3]

Member * Guild::GetMember ( ObjectGuid  guid)
inline
390 {
391 auto itr = m_members.find(guid.GetCounter());
392 return (itr != m_members.end()) ? &itr->second : nullptr;
393 }

References ObjectGuid::GetCounter(), and m_members.

◆ GetMember() [2/3]

◆ GetMember() [3/3]

Member * Guild::GetMember ( std::string_view  name)
inline
395 {
396 for (auto & m_member : m_members)
397 if (m_member.second.GetName() == name)
398 return &m_member.second;
399
400 return nullptr;
401 }

References m_members.

◆ GetMemberCount()

uint32 Guild::GetMemberCount ( ) const
inline

◆ GetMemberSize()

uint32 Guild::GetMemberSize ( ) const
inline
783{ return m_members.size(); }

References m_members.

◆ GetMOTD()

std::string const & Guild::GetMOTD ( ) const
inline
692{ return m_motd; }

References m_motd.

Referenced by guild_commandscript::HandleGuildInfoCommand().

◆ GetName()

◆ GetRankInfo() [1/2]

RankInfo * Guild::GetRankInfo ( uint8  rankId)
inlineprivate
808{ return rankId < _GetRanksSize() ? &m_ranks[rankId] : nullptr; }

References _GetRanksSize(), and m_ranks.

◆ GetRankInfo() [2/2]

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

◆ GetTotalBankMoney()

uint64 Guild::GetTotalBankMoney ( ) const
inline

◆ HandleAcceptMember()

void Guild::HandleAcceptMember ( WorldSession session)
1483{
1484 Player* player = session->GetPlayer();
1485 if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeamId() != sCharacterCache->GetCharacterTeamByGuid(GetLeaderGUID()))
1486 {
1487 return;
1488 }
1489
1490 AddMember(player->GetGUID());
1491}
@ CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD
Definition: IWorld.h:81
TeamId GetTeamId(bool original=false) const
Definition: Player.h:2059
ObjectGuid GetLeaderGUID() const
Definition: Guild.h:690

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 
)
1609{
1610 uint8 size = _GetRanksSize();
1611 if (size >= GUILD_RANKS_MAX_COUNT)
1612 return;
1613
1614 // Only leader can add new rank
1615 if (_IsLeader(session->GetPlayer()))
1617 _BroadcastEvent(GE_RANK_UPDATED, ObjectGuid::Empty, std::to_string(size), name, std::to_string(m_ranks.size()));
1618}
@ GE_RANK_UPDATED
Definition: Guild.h:160
bool _IsLeader(Player *player) const
Definition: Guild.cpp:2439

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

1399{
1400 Player* player = session->GetPlayer();
1401 if (!player)
1402 return;
1403
1404 Member const* member = GetMember(player->GetGUID());
1405 if (!member)
1406 return;
1407
1409 return;
1410
1411 if (tabId != _GetPurchasedTabsSize())
1412 return;
1413
1414 uint32 tabCost = _GetGuildBankTabPrice(tabId);
1415 if (!tabCost)
1416 return;
1417
1418 if (!player->HasEnoughMoney(tabCost)) // Should not happen, this is checked by client
1419 return;
1420
1421 player->ModifyMoney(-int32(tabCost));
1422
1425 SendPermissions(session);
1426}
uint32 _GetGuildBankTabPrice(uint8 tabId)
Definition: Guild.cpp:94
@ GE_BANK_TAB_PURCHASED
Definition: Guild.h:165
bool ModifyMoney(int32 amount, bool sendError=true)
Definition: Player.cpp:11409
bool HasEnoughMoney(uint32 amount) const
Definition: Player.h:1569
void SendPermissions(WorldSession *session)
Definition: Guild.cpp:1818

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)
1739{
1740 // Only leader can disband guild
1741 if (_IsLeader(session->GetPlayer()))
1742 {
1743 Disband();
1744 LOG_DEBUG("guild", "Guild Successfully Disbanded");
1745 delete this;
1746 }
1747}

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

◆ HandleInviteMember()

void Guild::HandleInviteMember ( WorldSession session,
std::string const &  name 
)
1429{
1430 Player* pInvitee = ObjectAccessor::FindPlayerByName(name, false);
1431 if (!pInvitee)
1432 {
1434 return;
1435 }
1436
1437 Player* player = session->GetPlayer();
1438 // Do not show invitations from ignored players
1439 if (pInvitee->GetSocial()->HasIgnore(player->GetGUID()))
1440 return;
1441
1442 if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && pInvitee->GetTeamId(true) != player->GetTeamId(true))
1443 {
1445 return;
1446 }
1447 // Invited player cannot be in another guild
1448 if (pInvitee->GetGuildId())
1449 {
1451 return;
1452 }
1453 // Invited player cannot be invited
1454 if (pInvitee->GetGuildIdInvited())
1455 {
1457 return;
1458 }
1459 // Inviting player must have rights to invite
1460 if (!_HasRankRight(player, GR_RIGHT_INVITE))
1461 {
1463 return;
1464 }
1465
1467
1468 LOG_DEBUG("guild", "Player {} invited {} to join his Guild", player->GetName(), pInvitee->GetName());
1469
1470 pInvitee->SetGuildIdInvited(m_id);
1471 _LogEvent(GUILD_EVENT_LOG_INVITE_PLAYER, player->GetGUID(), pInvitee->GetGUID());
1472
1474
1475 invite.InviterName = player->GetName();
1476 invite.GuildName = GetName();
1477
1478 pInvitee->SendDirectMessage(invite.Write());
1479 LOG_DEBUG("guild", "SMSG_GUILD_INVITE [{}]", pInvitee->GetName());
1480}
@ GUILD_COMMAND_INVITE
Definition: Guild.h:103
@ ERR_GUILD_PERMISSIONS
Definition: Guild.h:131
@ ERR_ALREADY_IN_GUILD_S
Definition: Guild.h:125
@ ERR_GUILD_COMMAND_SUCCESS
Definition: Guild.h:122
@ ERR_GUILD_NOT_ALLIED
Definition: Guild.h:135
@ ERR_GUILD_PLAYER_NOT_FOUND_S
Definition: Guild.h:134
@ ERR_ALREADY_INVITED_TO_GUILD_S
Definition: Guild.h:127
@ GR_RIGHT_INVITE
Definition: Guild.h:84
@ GUILD_EVENT_LOG_INVITE_PLAYER
Definition: Guild.h:213
Player * FindPlayerByName(std::string const &name, bool checkInWorld=true)
Definition: ObjectAccessor.cpp:276
uint32 GetGuildIdInvited()
Definition: Player.h:1853
PlayerSocial * GetSocial()
Definition: Player.h:1121
bool HasIgnore(ObjectGuid ignore_guid) const
Definition: SocialMgr.cpp:193
std::string const & GetName() const
Definition: Guild.h:691
static void SendCommandResult(WorldSession *session, GuildCommandType type, GuildCommandError errCode, std::string_view param={})
Definition: Guild.cpp:115
Definition: GuildPackets.h:192
WorldPacket const * Write() override
Definition: GuildPackets.cpp:95
std::string InviterName
Definition: GuildPackets.h:198
std::string GuildName
Definition: GuildPackets.h:199

References _HasRankRight(), _LogEvent(), CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD, ERR_ALREADY_IN_GUILD_S, ERR_ALREADY_INVITED_TO_GUILD_S, ERR_GUILD_COMMAND_SUCCESS, ERR_GUILD_NOT_ALLIED, ERR_GUILD_PERMISSIONS, ERR_GUILD_PLAYER_NOT_FOUND_S, ObjectAccessor::FindPlayerByName(), Object::GetGUID(), Player::GetGuildId(), Player::GetGuildIdInvited(), WorldObject::GetName(), GetName(), WorldSession::GetPlayer(), 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, SendCommandResult(), Player::SendDirectMessage(), Player::SetGuildIdInvited(), sWorld, and WorldPackets::Guild::GuildInvite::Write().

◆ HandleLeaveMember()

void Guild::HandleLeaveMember ( WorldSession session)
1494{
1495 Player* player = session->GetPlayer();
1496 bool disband = false;
1497
1498 // If leader is leaving
1499 if (_IsLeader(player))
1500 {
1501 if (m_members.size() > 1)
1502 // Leader cannot leave if he is not the last member
1504 else
1505 {
1506 // Guild is disbanded if leader leaves.
1507 Disband();
1508 disband = true;
1509 }
1510 }
1511 else
1512 {
1513 DeleteMember(player->GetGUID(), false, false);
1514
1516 _BroadcastEvent(GE_LEFT, player->GetGUID(), player->GetName());
1517
1519 }
1520
1521 sCalendarMgr->RemovePlayerGuildEventsAndSignups(player->GetGUID(), GetId());
1522
1523 if (disband)
1524 delete this;
1525}
#define sCalendarMgr
Definition: CalendarMgr.h:344
@ GUILD_COMMAND_QUIT
Definition: Guild.h:104
@ ERR_GUILD_LEADER_LEAVE
Definition: Guild.h:130
@ GUILD_EVENT_LOG_LEAVE_GUILD
Definition: Guild.h:218
uint32 GetId() const
Definition: Guild.h:689

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 
)
1649{
1650 Player* player = session->GetPlayer();
1651
1652 // Call script after validation and before money transfer.
1653 sScriptMgr->OnGuildMemberDepositMoney(this, player, amount);
1654
1655 if (m_bankMoney > GUILD_BANK_MONEY_LIMIT - amount)
1656 {
1658 return;
1659 }
1660
1661 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
1662 _ModifyBankMoney(trans, amount, true);
1663
1664 player->ModifyMoney(-int32(amount));
1665 player->SaveGoldToDB(trans);
1666 _LogBankEvent(trans, GUILD_BANK_LOG_DEPOSIT_MONEY, uint8(0), player->GetGUID(), amount);
1667
1668 CharacterDatabase.CommitTransaction(trans);
1669
1670 std::string aux = Acore::Impl::ByteArrayToHexStr(reinterpret_cast<uint8*>(&m_bankMoney), 8, true);
1672
1673 if (amount > 10 * GOLD) // receiver_acc = Guild id, receiver_name = Guild name
1674 CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"(guild members: {}, new amount: {}, leader guid low: {}, sender level: {})\", NOW(), {})",
1675 session->GetAccountId(), player->GetGUID().GetCounter(), player->GetName(), session->GetRemoteAddress(), GetId(), GetName(), amount, GetMemberCount(), GetTotalBankMoney(), GetLeaderGUID().GetCounter(), player->GetLevel(), 3);
1676}
@ GE_BANK_MONEY_SET
Definition: Guild.h:167
constexpr uint64 GUILD_BANK_MONEY_LIMIT
Definition: Guild.h:57
@ GUILD_COMMAND_MOVE_ITEM
Definition: Guild.h:116
@ ERR_GUILD_BANK_FULL
Definition: Guild.h:144
@ GUILD_BANK_LOG_DEPOSIT_MONEY
Definition: Guild.h:203
@ GOLD
Definition: SharedDefines.h:225
AC_COMMON_API std::string ByteArrayToHexStr(uint8 const *bytes, size_t length, bool reverse=false)
Definition: Util.cpp:541
void SaveGoldToDB(CharacterDatabaseTransaction trans)
Definition: PlayerStorage.cpp:7144
uint8 GetLevel() const
Definition: Unit.h:1420
uint32 GetMemberCount() const
Definition: Guild.h:774
bool _ModifyBankMoney(CharacterDatabaseTransaction trans, uint64 amount, bool add)
Definition: Guild.cpp:2457
void _LogBankEvent(CharacterDatabaseTransaction trans, GuildBankEventLogTypes eventType, uint8 tabId, ObjectGuid playerGuid, uint32 itemOrMoney, uint16 itemStackCount=0, uint8 destTabId=0)
Definition: Guild.cpp:2601
uint64 GetTotalBankMoney() const
Definition: Guild.h:773
uint32 GetAccountId() const
Definition: WorldSession.h:360
std::string const & GetRemoteAddress()
Definition: WorldSession.h:370

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, m_bankMoney, Player::ModifyMoney(), Player::SaveGoldToDB(), SendCommandResult(), and sScriptMgr.

◆ HandleMemberLogout()

void Guild::HandleMemberLogout ( WorldSession session)
1727{
1728 Player* player = session->GetPlayer();
1729 if (Member* member = GetMember(player->GetGUID()))
1730 {
1731 member->SetStats(player);
1732 member->UpdateLogoutTime();
1733 member->ResetFlags();
1734 }
1735 _BroadcastEvent(GE_SIGNED_OFF, player->GetGUID(), player->GetName());
1736}
@ GE_SIGNED_OFF
Definition: Guild.h:163

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

◆ HandleMemberWithdrawMoney()

bool Guild::HandleMemberWithdrawMoney ( WorldSession session,
uint32  amount,
bool  repair = false 
)
1679{
1680 //clamp amount to MAX_MONEY_AMOUNT, Players can't hold more than that anyway
1681 amount = std::min(amount, uint32(MAX_MONEY_AMOUNT));
1682
1683 if (m_bankMoney < amount) // Not enough money in bank
1684 return false;
1685
1686 Player* player = session->GetPlayer();
1687
1688 Member* member = GetMember(player->GetGUID());
1689 if (!member)
1690 return false;
1691
1692 if (uint32(_GetMemberRemainingMoney(*member)) < amount) // Check if we have enough slot/money today
1693 return false;
1694
1695 // Call script after validation and before money transfer.
1696 sScriptMgr->OnGuildMemberWitdrawMoney(this, player, amount, repair);
1697
1698 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
1699 // Add money to player (if required)
1700 if (!repair)
1701 {
1702 if (!player->ModifyMoney(amount))
1703 return false;
1704
1705 player->SaveGoldToDB(trans);
1706 }
1707
1708 // Update remaining money amount
1709 member->UpdateBankWithdrawValue(trans, GUILD_BANK_MAX_TABS, amount);
1710 // Remove money from bank
1711 _ModifyBankMoney(trans, amount, false);
1712
1713 // Log guild bank event
1715 CharacterDatabase.CommitTransaction(trans);
1716
1717 if (amount > 10 * GOLD) // sender_acc = 0 (guild has no account), sender_guid = Guild id, sender_name = Guild name
1718 CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"(guild, members: {}, new amount: {}, leader guid low: {}, withdrawer level: {})\", NOW(), {})",
1719 0, GetId(), GetName(), session->GetRemoteAddress(), session->GetAccountId(), player->GetName(), amount, GetMemberCount(), GetTotalBankMoney(), GetLeaderGUID().GetCounter(), player->GetLevel(), 4);
1720
1721 std::string aux = Acore::Impl::ByteArrayToHexStr(reinterpret_cast<uint8*>(&m_bankMoney), 8, true);
1723 return true;
1724}
#define MAX_MONEY_AMOUNT
Definition: Player.h:922
@ GUILD_BANK_LOG_WITHDRAW_MONEY
Definition: Guild.h:204
@ GUILD_BANK_LOG_REPAIR_MONEY
Definition: Guild.h:205
int32 _GetMemberRemainingMoney(Member const &member) const
Definition: Guild.cpp:2552

References _BroadcastEvent(), _GetMemberRemainingMoney(), _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(), WorldSession::GetRemoteAddress(), GetTotalBankMoney(), GOLD, GUILD_BANK_LOG_REPAIR_MONEY, GUILD_BANK_LOG_WITHDRAW_MONEY, GUILD_BANK_MAX_TABS, m_bankMoney, MAX_MONEY_AMOUNT, Player::ModifyMoney(), Player::SaveGoldToDB(), sScriptMgr, and Guild::Member::UpdateBankWithdrawValue().

Referenced by Player::DurabilityRepair().

◆ HandleQuery()

void Guild::HandleQuery ( WorldSession session)
1246{
1248 response.GuildId = m_id;
1249
1255
1256 for (uint8 i = 0; i < _GetRanksSize(); ++i)
1257 response.Info.Ranks[i] = m_ranks[i].GetName();
1258
1259 response.Info.RankCount = _GetRanksSize();
1260
1261 response.Info.GuildName = m_name;
1262
1263 session->SendPacket(response.Write());
1264 LOG_DEBUG("guild", "SMSG_GUILD_QUERY_RESPONSE [{}]", session->GetPlayerInfo());
1265}
uint32 EmblemColor
Definition: GuildPackets.h:49
std::string GuildName
Definition: GuildPackets.h:43
uint32 EmblemStyle
Definition: GuildPackets.h:48
uint32 BackgroundColor
Definition: GuildPackets.h:52
uint32 BorderColor
Definition: GuildPackets.h:51
uint32 BorderStyle
Definition: GuildPackets.h:50
uint32 RankCount
Definition: GuildPackets.h:46
std::array< std::string, GUILD_RANKS_MAX_COUNT > Ranks
Definition: GuildPackets.h:45
Definition: GuildPackets.h:56
uint32 GuildId
Definition: GuildPackets.h:62
GuildInfo Info
Definition: GuildPackets.h:63
WorldPacket const * Write() override
Definition: GuildPackets.cpp:28

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)
1621{
1623}
void HandleRemoveRank(WorldSession *session, uint8 rankId)
Definition: Guild.cpp:1625

References _GetLowestRankId(), and HandleRemoveRank().

◆ HandleRemoveMember()

void Guild::HandleRemoveMember ( WorldSession session,
std::string_view  name 
)
1528{
1529 Player* player = session->GetPlayer();
1530 // Player must have rights to remove members
1531 if (!_HasRankRight(player, GR_RIGHT_REMOVE))
1533 else if (Member* member = GetMember(name))
1534 {
1535 // Guild masters cannot be removed
1536 if (member->IsRank(GR_GUILDMASTER))
1538 // Do not allow to remove player with the same rank or higher
1539 else
1540 {
1541 Member const* memberMe = GetMember(player->GetGUID());
1542 if (!memberMe || member->IsRankNotLower(memberMe->GetRankId()))
1544 else
1545 {
1546 ObjectGuid guid = member->GetGUID();
1547 // After call to DeleteMember pointer to member becomes invalid
1548 DeleteMember(guid, false, true);
1550 _BroadcastEvent(GE_REMOVED, ObjectGuid::Empty, member->GetName(), player->GetName());
1551 }
1552 }
1553 }
1554}
@ GE_REMOVED
Definition: Guild.h:155
@ GUILD_COMMAND_REMOVE
Definition: Guild.h:108
@ ERR_GUILD_RANK_TOO_HIGH_S
Definition: Guild.h:136
@ GR_RIGHT_REMOVE
Definition: Guild.h:85
@ GUILD_EVENT_LOG_UNINVITE_PLAYER
Definition: Guild.h:217

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 
)
1626{
1627 // Cannot remove rank if total count is minimum allowed by the client or is not leader
1628 if (_GetRanksSize() <= GUILD_RANKS_MIN_COUNT || rankId >= _GetRanksSize() || !_IsLeader(session->GetPlayer()))
1629 return;
1630
1631 // Delete bank rights for rank
1633 stmt->SetData(0, m_id);
1634 stmt->SetData(1, rankId);
1635 CharacterDatabase.Execute(stmt);
1636 // Delete rank
1637 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_LOWEST_RANK);
1638 stmt->SetData(0, m_id);
1639 stmt->SetData(1, rankId);
1640 CharacterDatabase.Execute(stmt);
1641
1642 // match what the sql statement does
1643 m_ranks.erase(m_ranks.begin() + rankId, m_ranks.end());
1644
1645 _BroadcastEvent(GE_RANK_DELETED, ObjectGuid::Empty, std::to_string(m_ranks.size()));
1646}
@ CHAR_DEL_GUILD_BANK_RIGHTS_FOR_RANK
Definition: CharacterDatabase.h:158
@ CHAR_DEL_GUILD_LOWEST_RANK
Definition: CharacterDatabase.h:149
@ GE_RANK_DELETED
Definition: Guild.h:161
@ GUILD_RANKS_MIN_COUNT
Definition: Guild.h:48

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)
1201{
1203
1204 for (RankInfo const& rank : m_ranks)
1205 {
1206 WorldPackets::Guild::GuildRankData& rankData = roster.RankData.emplace_back();
1207
1208 rankData.Flags = rank.GetRights();
1209 rankData.WithdrawGoldLimit = rank.GetBankMoneyPerDay();
1210 for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1211 {
1212 rankData.TabFlags[i] = rank.GetBankTabRights(i);
1213 rankData.TabWithdrawItemLimit[i] = rank.GetBankTabSlotsPerDay(i);
1214 }
1215 }
1216
1217 bool sendOfficerNote = _HasRankRight(session->GetPlayer(), GR_RIGHT_VIEWOFFNOTE);
1218 for (auto const& [guid, member] : m_members)
1219 {
1220 WorldPackets::Guild::GuildRosterMemberData& memberData = roster.MemberData.emplace_back();
1221
1222 memberData.Guid = member.GetGUID();
1223 memberData.RankID = int32(member.GetRankId());
1224 memberData.AreaID = int32(member.GetZoneId());
1225 memberData.LastSave = float(float(GameTime::GetGameTime().count() - member.GetLogoutTime()) / DAY);
1226
1227 memberData.Status = member.GetFlags();
1228 memberData.Level = member.GetLevel();
1229 memberData.ClassID = member.GetClass();
1230 memberData.Gender = member.GetGender();
1231
1232 memberData.Name = member.GetName();
1233 memberData.Note = member.GetPublicNote();
1234 if (sendOfficerNote)
1235 memberData.OfficerNote = member.GetOfficerNote();
1236 }
1237
1238 roster.WelcomeText = m_motd;
1239 roster.InfoText = m_info;
1240
1241 LOG_DEBUG("guild", "SMSG_GUILD_ROSTER [{}]", session->GetPlayerInfo());
1242 session->SendPacket(roster.Write());
1243}
constexpr auto DAY
Definition: Common.h:58
@ GR_RIGHT_VIEWOFFNOTE
Definition: Guild.h:90
Definition: GuildPackets.h:106
int32 RankID
Definition: GuildPackets.h:110
uint8 Level
Definition: GuildPackets.h:117
uint8 ClassID
Definition: GuildPackets.h:118
int32 AreaID
Definition: GuildPackets.h:111
ObjectGuid Guid
Definition: GuildPackets.h:107
std::string Note
Definition: GuildPackets.h:114
uint8 Status
Definition: GuildPackets.h:116
uint8 Gender
Definition: GuildPackets.h:119
float LastSave
Definition: GuildPackets.h:112
std::string Name
Definition: GuildPackets.h:113
std::string OfficerNote
Definition: GuildPackets.h:115
Definition: GuildPackets.h:123
uint32 WithdrawGoldLimit
Definition: GuildPackets.h:125
uint32 Flags
Definition: GuildPackets.h:124
uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS]
Definition: GuildPackets.h:127
uint32 TabFlags[GUILD_BANK_MAX_TABS]
Definition: GuildPackets.h:126
Definition: GuildPackets.h:131
WorldPacket const * Write() override
Definition: GuildPackets.cpp:60
std::string WelcomeText
Definition: GuildPackets.h:139
std::vector< GuildRankData > RankData
Definition: GuildPackets.h:138
std::vector< GuildRosterMemberData > MemberData
Definition: GuildPackets.h:137
std::string InfoText
Definition: GuildPackets.h:140

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 
)
1349{
1350 BankTab* tab = GetBankTab(tabId);
1351 if (!tab)
1352 {
1353 LOG_ERROR("guild", "Guild::HandleSetBankTabInfo: Player {} trying to change bank tab info from unexisting tab {}.",
1354 session->GetPlayerInfo(), tabId);
1355 return;
1356 }
1357
1358 tab->SetInfo(name, icon);
1359 _BroadcastEvent(GE_BANK_TAB_UPDATED, ObjectGuid::Empty, std::to_string(tabId), tab->GetName(), tab->GetIcon());
1360}
@ GE_BANK_TAB_UPDATED
Definition: Guild.h:166

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

◆ HandleSetEmblem()

void Guild::HandleSetEmblem ( WorldSession session,
const EmblemInfo emblemInfo 
)
1310{
1311 Player* player = session->GetPlayer();
1312 if (!_IsLeader(player))
1313 SendSaveEmblemResult(session, ERR_GUILDEMBLEM_NOTGUILDMASTER); // "Only guild leaders can create emblems."
1314 else if (!player->HasEnoughMoney(EMBLEM_PRICE))
1315 SendSaveEmblemResult(session, ERR_GUILDEMBLEM_NOTENOUGHMONEY); // "You can't afford to do that."
1316 else
1317 {
1318 player->ModifyMoney(-int32(EMBLEM_PRICE));
1319
1320 m_emblemInfo = emblemInfo;
1322
1323 SendSaveEmblemResult(session, ERR_GUILDEMBLEM_SUCCESS); // "Guild Emblem saved."
1324
1325 HandleQuery(session);
1326 }
1327}
#define EMBLEM_PRICE
Definition: Guild.cpp:42
@ ERR_GUILDEMBLEM_NOTGUILDMASTER
Definition: Guild.h:226
@ ERR_GUILDEMBLEM_NOTENOUGHMONEY
Definition: Guild.h:227
@ ERR_GUILDEMBLEM_SUCCESS
Definition: Guild.h:223
void SaveToDB(uint32 guildId) const
Definition: Guild.cpp:702
void HandleQuery(WorldSession *session)
Definition: Guild.cpp:1245
static void SendSaveEmblemResult(WorldSession *session, GuildEmblemError errCode)
Definition: Guild.cpp:126

References _IsLeader(), EMBLEM_PRICE, ERR_GUILDEMBLEM_NOTENOUGHMONEY, ERR_GUILDEMBLEM_NOTGUILDMASTER, ERR_GUILDEMBLEM_SUCCESS, WorldSession::GetPlayer(), HandleQuery(), Player::HasEnoughMoney(), m_emblemInfo, m_id, Player::ModifyMoney(), EmblemInfo::SaveToDB(), and SendSaveEmblemResult().

◆ HandleSetInfo()

void Guild::HandleSetInfo ( WorldSession session,
std::string_view  info 
)
1291{
1292 if (m_info == info)
1293 return;
1294
1295 // Player must have rights to set guild's info
1297 {
1298 m_info = info;
1299
1300 sScriptMgr->OnGuildInfoChanged(this, m_info);
1301
1303 stmt->SetData(0, m_info);
1304 stmt->SetData(1, m_id);
1305 CharacterDatabase.Execute(stmt);
1306 }
1307}
@ CHAR_UPD_GUILD_INFO
Definition: CharacterDatabase.h:169
@ GR_RIGHT_MODIFY_GUILD_INFO
Definition: Guild.h:92

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 
)
1330{
1331 Player* player = session->GetPlayer();
1332 // Only leader can assign new leader
1333 if (!_IsLeader(player))
1335 // Old leader must be a member of guild
1336 else if (Member* pOldLeader = GetMember(player->GetGUID()))
1337 {
1338 // New leader must be a member of guild
1339 if (Member* pNewLeader = GetMember(name))
1340 {
1341 _SetLeaderGUID(*pNewLeader);
1342 pOldLeader->ChangeRank(GR_OFFICER);
1343 _BroadcastEvent(GE_LEADER_CHANGED, ObjectGuid::Empty, player->GetName(), pNewLeader->GetName());
1344 }
1345 }
1346}
@ GUILD_COMMAND_CHANGE_LEADER
Definition: Guild.h:109
@ GR_OFFICER
Definition: Guild.h:69

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  officer 
)
1363{
1364 // Player must have rights to set public/officer note
1365 if (!_HasRankRight(session->GetPlayer(), isPublic ? GR_RIGHT_EPNOTE : GR_RIGHT_EOFFNOTE))
1367 else if (Member* member = GetMember(name))
1368 {
1369 if (isPublic)
1370 member->SetPublicNote(note);
1371 else
1372 member->SetOfficerNote(note);
1373
1374 HandleRoster(session);
1375 }
1376}
@ GUILD_COMMAND_PUBLIC_NOTE
Definition: Guild.h:114
@ GR_RIGHT_EOFFNOTE
Definition: Guild.h:91
@ GR_RIGHT_EPNOTE
Definition: Guild.h:89
void HandleRoster(WorldSession *session)
Definition: Guild.cpp:1200

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 
)
1268{
1269 if (m_motd == motd)
1270 return;
1271
1272 // Player must have rights to set MOTD
1273 if (!_HasRankRight(session->GetPlayer(), GR_RIGHT_SETMOTD))
1275 else
1276 {
1277 m_motd = motd;
1278
1279 sScriptMgr->OnGuildMOTDChanged(this, m_motd);
1280
1282 stmt->SetData(0, m_motd);
1283 stmt->SetData(1, m_id);
1284 CharacterDatabase.Execute(stmt);
1285
1287 }
1288}
@ CHAR_UPD_GUILD_MOTD
Definition: CharacterDatabase.h:168
@ GE_MOTD
Definition: Guild.h:152
@ GUILD_COMMAND_EDIT_MOTD
Definition: Guild.h:110
@ GR_RIGHT_SETMOTD
Definition: Guild.h:88

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()

void Guild::HandleSetRankInfo ( WorldSession session,
uint8  rankId,
std::string_view  name,
uint32  rights,
uint32  moneyPerDay,
std::array< GuildBankRightsAndSlots, GUILD_BANK_MAX_TABS > const &  rightsAndSlots 
)
1379{
1380 // Only leader can modify ranks
1381 if (!_IsLeader(session->GetPlayer()))
1383 else if (RankInfo* rankInfo = GetRankInfo(rankId))
1384 {
1385 rankInfo->SetName(name);
1386 rankInfo->SetRights(rights);
1387 _SetRankBankMoneyPerDay(rankId, moneyPerDay);
1388
1389 for (auto rightsAndSlot : rightsAndSlots)
1390 _SetRankBankTabRightsAndSlots(rankId, rightsAndSlot);
1391
1392 _BroadcastEvent(GE_RANK_UPDATED, ObjectGuid::Empty, std::to_string(rankId), rankInfo->GetName(), std::to_string(m_ranks.size()));
1393
1394 LOG_DEBUG("guild", "Changed RankName to '{}', rights to 0x{:08X}", rankInfo->GetName(), rights);
1395 }
1396}
@ GUILD_COMMAND_CHANGE_RANK
Definition: Guild.h:113
void _SetRankBankTabRightsAndSlots(uint8 rankId, GuildBankRightsAndSlots rightsAndSlots, bool saveToDB=true)
Definition: Guild.cpp:2493
void _SetRankBankMoneyPerDay(uint8 rankId, uint32 moneyPerDay)
Definition: Guild.cpp:2487

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 
)
1557{
1558 Player* player = session->GetPlayer();
1560 // Player must have rights to promote
1561 if (!_HasRankRight(player, demote ? GR_RIGHT_DEMOTE : GR_RIGHT_PROMOTE))
1563 // Promoted player must be a member of guild
1564 else if (Member* member = GetMember(name))
1565 {
1566 // Player cannot promote himself
1567 if (member->IsSamePlayer(player->GetGUID()))
1568 {
1570 return;
1571 }
1572
1573 Member const* memberMe = GetMember(player->GetGUID());
1574 uint8 rankId = memberMe->GetRankId();
1575 if (demote)
1576 {
1577 // Player can demote only lower rank members
1578 if (member->IsRankNotLower(rankId))
1579 {
1580 SendCommandResult(session, type, ERR_GUILD_RANK_TOO_HIGH_S, name);
1581 return;
1582 }
1583 // Lowest rank cannot be demoted
1584 if (member->GetRankId() >= _GetLowestRankId())
1585 {
1586 SendCommandResult(session, type, ERR_GUILD_RANK_TOO_LOW_S, name);
1587 return;
1588 }
1589 }
1590 else
1591 {
1592 // Allow to promote only to lower rank than member's rank
1593 // member->GetRankId() + 1 is the highest rank that current player can promote to
1594 if (member->IsRankNotLower(rankId + 1))
1595 {
1596 SendCommandResult(session, type, ERR_GUILD_RANK_TOO_HIGH_S, name);
1597 return;
1598 }
1599 }
1600
1601 uint32 newRankId = member->GetRankId() + (demote ? 1 : -1);
1602 member->ChangeRank(newRankId);
1603 _LogEvent(demote ? GUILD_EVENT_LOG_DEMOTE_PLAYER : GUILD_EVENT_LOG_PROMOTE_PLAYER, player->GetGUID(), member->GetGUID(), newRankId);
1604 _BroadcastEvent(demote ? GE_DEMOTION : GE_PROMOTION, ObjectGuid::Empty, player->GetName(), member->GetName(), _GetRankName(newRankId));
1605 }
1606}
@ GE_PROMOTION
Definition: Guild.h:150
@ GE_DEMOTION
Definition: Guild.h:151
GuildCommandType
Definition: Guild.h:101
@ GUILD_COMMAND_PROMOTE
Definition: Guild.h:106
@ GUILD_COMMAND_DEMOTE
Definition: Guild.h:107
@ ERR_GUILD_RANK_TOO_LOW_S
Definition: Guild.h:137
@ ERR_GUILD_NAME_INVALID
Definition: Guild.h:128
@ GR_RIGHT_DEMOTE
Definition: Guild.h:87
@ GR_RIGHT_PROMOTE
Definition: Guild.h:86
@ GUILD_EVENT_LOG_PROMOTE_PLAYER
Definition: Guild.h:215
@ GUILD_EVENT_LOG_DEMOTE_PLAYER
Definition: Guild.h:216
std::string _GetRankName(uint8 rankId) const
Definition: Guild.cpp:2502

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().

◆ LoadBankEventLogFromDB()

bool Guild::LoadBankEventLogFromDB ( Field fields)
1965{
1966 uint8 dbTabId = fields[1].Get<uint8>();
1967 bool isMoneyTab = (dbTabId == GUILD_BANK_MONEY_LOGS_TAB);
1968 if (dbTabId < _GetPurchasedTabsSize() || isMoneyTab)
1969 {
1970 uint8 tabId = isMoneyTab ? uint8(GUILD_BANK_MAX_TABS) : dbTabId;
1971 LogHolder<BankEventLogEntry>& bankLog = m_bankEventLog[tabId];
1972 if (bankLog.CanInsert())
1973 {
1974 ObjectGuid::LowType guid = fields[2].Get<uint32>();
1975 GuildBankEventLogTypes eventType = GuildBankEventLogTypes(fields[3].Get<uint8>());
1976 if (BankEventLogEntry::IsMoneyEvent(eventType))
1977 {
1978 if (!isMoneyTab)
1979 {
1980 LOG_ERROR("guild", "GuildBankEventLog ERROR: MoneyEvent(LogGuid: {}, Guild: {}) does not belong to money tab ({}), ignoring...", guid, m_id, dbTabId);
1981 return false;
1982 }
1983 }
1984 else if (isMoneyTab)
1985 {
1986 LOG_ERROR("guild", "GuildBankEventLog ERROR: non-money event (LogGuid: {}, Guild: {}) belongs to money tab, ignoring...", guid, m_id);
1987 return false;
1988 }
1989 bankLog.LoadEvent(
1990 m_id, // guild id
1991 guid, // guid
1992 time_t(fields[8].Get<uint32>()), // timestamp
1993 dbTabId, // tab id
1994 eventType, // event type
1995 ObjectGuid::Create<HighGuid::Player>(fields[4].Get<uint32>()), // player guid
1996 fields[5].Get<uint32>(), // item or money
1997 fields[6].Get<uint16>(), // itam stack count
1998 fields[7].Get<uint8>()); // dest tab id
1999 }
2000 }
2001 return true;
2002}
GuildBankEventLogTypes
Definition: Guild.h:199

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)
2014{
2015 uint8 tabId = fields[12].Get<uint8>();
2016 if (tabId >= _GetPurchasedTabsSize())
2017 {
2018 LOG_ERROR("guild", "Invalid tab for item (GUID: {}, id: #{}) in guild bank, skipped.",
2019 fields[14].Get<uint32>(), fields[15].Get<uint32>());
2020 return false;
2021 }
2022 return m_bankTabs[tabId].LoadItemFromDB(fields);
2023}

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

◆ LoadBankRightFromDB()

void Guild::LoadBankRightFromDB ( Field fields)
1940{
1941 // tabId rights slots
1942 GuildBankRightsAndSlots rightsAndSlots(fields[1].Get<uint8>(), fields[3].Get<uint8>(), fields[4].Get<uint32>());
1943 // rankId
1944 _SetRankBankTabRightsAndSlots(fields[2].Get<uint8>(), rightsAndSlots, false);
1945}
Definition: Guild.h:266

References _SetRankBankTabRightsAndSlots().

◆ LoadBankTabFromDB()

void Guild::LoadBankTabFromDB ( Field fields)
2005{
2006 uint8 tabId = fields[1].Get<uint8>();
2007 if (tabId >= _GetPurchasedTabsSize())
2008 LOG_ERROR("guild", "Invalid tab (tabId: {}) in guild bank, skipped.", tabId);
2009 else
2010 m_bankTabs[tabId].LoadFromDB(fields);
2011}

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

◆ LoadEventLogFromDB()

bool Guild::LoadEventLogFromDB ( Field fields)
1948{
1949 if (m_eventLog.CanInsert())
1950 {
1951 m_eventLog.LoadEvent(
1952 m_id, // guild id
1953 fields[1].Get<uint32>(), // guid
1954 time_t(fields[6].Get<uint32>()), // timestamp
1955 GuildEventLogTypes(fields[2].Get<uint8>()), // event type
1956 ObjectGuid::Create<HighGuid::Player>(fields[3].Get<uint32>()), // player guid 1
1957 ObjectGuid::Create<HighGuid::Player>(fields[4].Get<uint32>()), // player guid 2
1958 fields[5].Get<uint8>()); // rank
1959 return true;
1960 }
1961 return false;
1962}
GuildEventLogTypes
Definition: Guild.h:212

References m_eventLog, and m_id.

◆ LoadFromDB()

bool Guild::LoadFromDB ( Field fields)
1885{
1886 m_id = fields[0].Get<uint32>();
1887 m_name = fields[1].Get<std::string>();
1888 m_leaderGuid = ObjectGuid::Create<HighGuid::Player>(fields[2].Get<uint32>());
1889 m_emblemInfo.LoadFromDB(fields);
1890 m_info = fields[8].Get<std::string>();
1891 m_motd = fields[9].Get<std::string>();
1892 m_createdDate = time_t(fields[10].Get<uint32>());
1893 m_bankMoney = fields[11].Get<uint64>();
1894
1895 uint8 purchasedTabs = uint8(fields[12].Get<uint64>());
1896 if (purchasedTabs > GUILD_BANK_MAX_TABS)
1897 purchasedTabs = GUILD_BANK_MAX_TABS;
1898
1899 m_bankTabs.clear();
1900 m_bankTabs.reserve(purchasedTabs);
1901 for (uint8 i = 0; i < purchasedTabs; ++i)
1902 m_bankTabs.emplace_back(m_id, i);
1903 return true;
1904}
std::uint64_t uint64
Definition: Define.h:107
void LoadFromDB(Field *fields)
Definition: Guild.cpp:693

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)
1916{
1917 ObjectGuid::LowType lowguid = fields[1].Get<uint32>();
1918 ObjectGuid playerGuid(HighGuid::Player, lowguid);
1919
1920 auto [memberIt, isNew] = m_members.try_emplace(lowguid, m_id, playerGuid, fields[2].Get<uint8>());
1921 if (!isNew)
1922 {
1923 LOG_ERROR("guild", "Tried to add {} to guild '{}'. Member already exists.", playerGuid.ToString(), m_name);
1924 return false;
1925 }
1926
1927 Member& member = memberIt->second;
1928 if (!member.LoadFromDB(fields))
1929 {
1930 _DeleteMemberFromDB(lowguid);
1931 m_members.erase(memberIt);
1932 return false;
1933 }
1934
1935 sCharacterCache->UpdateCharacterGuildId(playerGuid, GetId());
1936 return true;
1937}

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

◆ LoadRankFromDB()

void Guild::LoadRankFromDB ( Field fields)
1907{
1908 RankInfo rankInfo(m_id);
1909
1910 rankInfo.LoadFromDB(fields);
1911
1912 m_ranks.push_back(rankInfo);
1913}

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

◆ MassInviteToEvent()

void Guild::MassInviteToEvent ( WorldSession session,
uint32  minLevel,
uint32  maxLevel,
uint32  minRank 
)
2127{
2128 uint32 count = 0;
2129
2131 data << uint32(count); // count placeholder
2132
2133 for (auto const& [guid, member] : m_members)
2134 {
2135 // not sure if needed, maybe client checks it as well
2136 if (count >= CALENDAR_MAX_INVITES)
2137 {
2138 if (Player* player = session->GetPlayer())
2139 sCalendarMgr->SendCalendarCommandResult(player->GetGUID(), CALENDAR_ERROR_INVITES_EXCEEDED);
2140 return;
2141 }
2142
2143 uint32 level = sCharacterCache->GetCharacterLevelByGuid(member.GetGUID());
2144
2145 if (member.GetGUID() != session->GetPlayer()->GetGUID() && level >= minLevel && level <= maxLevel && member.IsRankNotLower(minRank))
2146 {
2147 data.appendPackGUID(member.GetGUID().GetRawValue());
2148 data << uint8(0); // unk
2149 ++count;
2150 }
2151 }
2152
2153 data.put<uint32>(0, count);
2154
2155 session->SendPacket(&data);
2156}
@ CALENDAR_ERROR_INVITES_EXCEEDED
Definition: CalendarMgr.h:104
@ CALENDAR_MAX_INVITES
Definition: CalendarMgr.h:130
@ SMSG_CALENDAR_FILTER_GUILD
Definition: Opcodes.h:1110

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.

◆ ModifyBankMoney()

bool Guild::ModifyBankMoney ( CharacterDatabaseTransaction  trans,
const uint64 amount,
bool  add 
)
inline
782{ return _ModifyBankMoney(trans, amount, add); }

References _ModifyBankMoney().

◆ OnPlayerStatusChange()

void Guild::OnPlayerStatusChange ( Player player,
uint32  flag,
bool  state 
)
1176{
1177 if (Member* member = GetMember(player->GetGUID()))
1178 {
1179 if (state)
1180 member->AddFlag(flag);
1181 else member->RemFlag(flag);
1182 }
1183}

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

◆ ResetTimes()

void Guild::ResetTimes ( )
2914{
2915 for (auto& [guid, member] : m_members)
2916 member.ResetValues();
2917
2919}
@ GE_BANK_TAB_AND_MONEY_UPDATED
Definition: Guild.h:168

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

◆ SendBankLog()

void Guild::SendBankLog ( WorldSession session,
uint8  tabId 
) const
1777{
1778 // GUILD_BANK_MAX_TABS send by client for money log
1779 if (tabId < _GetPurchasedTabsSize() || tabId == GUILD_BANK_MAX_TABS)
1780 {
1781 std::list<BankEventLogEntry> const& bankEventLog = m_bankEventLog[tabId].GetGuildLog();
1782
1784 packet.Tab = tabId;
1785
1786 packet.Entry.reserve(bankEventLog.size());
1787 for (BankEventLogEntry const& entry : bankEventLog)
1788 entry.WritePacket(packet);
1789
1790 session->SendPacket(packet.Write());
1791 LOG_DEBUG("guild", "MSG_GUILD_BANK_LOG_QUERY [{}]", session->GetPlayerInfo());
1792 }
1793}
Definition: GuildPackets.h:546
uint8 Tab
Definition: GuildPackets.h:552
std::vector< GuildBankLogEntry > Entry
Definition: GuildPackets.h:553
WorldPacket const * Write() override
Definition: GuildPackets.cpp:385

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
1796{
1797 if (tabId < _GetPurchasedTabsSize())
1798 _SendBankContent(session, tabId, sendAllSlots);
1799}
void _SendBankContent(WorldSession *session, uint8 tabId, bool sendAllSlots) const
Definition: Guild.cpp:2732

References _GetPurchasedTabsSize(), and _SendBankContent().

◆ SendBankTabsInfo()

void Guild::SendBankTabsInfo ( WorldSession session,
bool  showTabs = false 
)
1802{
1803 Member* member = GetMember(session->GetPlayer()->GetGUID());
1804 if (!member)
1805 return;
1806
1807 member->SubscribeToGuildBankUpdatePackets();
1808
1809 _SendBankList(session, 0, sendAllSlots);
1810}

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

Referenced by WorldSession::HandleGuildBankerActivate().

◆ SendBankTabText()

void Guild::SendBankTabText ( WorldSession session,
uint8  tabId 
) const
1813{
1814 if (BankTab const* tab = GetBankTab(tabId))
1815 tab->SendText(this, session);
1816}

References GetBankTab().

◆ SendCommandResult()

void Guild::SendCommandResult ( WorldSession session,
GuildCommandType  type,
GuildCommandError  errCode,
std::string_view  param = {} 
)
static
116{
118 resultPacket.Command = type;
119 resultPacket.Result = errCode;
120 resultPacket.Name = param;
121 session->SendPacket(resultPacket.Write());
122
123 LOG_DEBUG("guild", "SMSG_GUILD_COMMAND_RESULT [{}]: Type: {}, code: {}, param: {}", session->GetPlayerInfo(), type, errCode, resultPacket.Name);
124}
Definition: GuildPackets.h:154
int32 Command
Definition: GuildPackets.h:162
std::string Name
Definition: GuildPackets.h:160
WorldPacket const * Write() override
Definition: GuildPackets.cpp:81
int32 Result
Definition: GuildPackets.h:161

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::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
1763{
1764 std::list<EventLogEntry> const& eventLog = m_eventLog.GetGuildLog();
1765
1767 packet.Entry.reserve(eventLog.size());
1768
1769 for (EventLogEntry const& entry : eventLog)
1770 entry.WritePacket(packet);
1771
1772 session->SendPacket(packet.Write());
1773 LOG_DEBUG("guild", "MSG_GUILD_EVENT_LOG_QUERY [{}]", session->GetPlayerInfo());
1774}
std::vector< GuildEventEntry > Entry
Definition: GuildPackets.h:238
WorldPacket const * Write() override
Definition: GuildPackets.cpp:144

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
1751{
1753 guildInfo.GuildName = m_name;
1754 guildInfo.CreateDate = m_createdDate;
1755 guildInfo.NumMembers = int32(m_members.size());
1756 guildInfo.NumAccounts = m_accountsNumber;
1757
1758 session->SendPacket(guildInfo.Write());
1759 LOG_DEBUG("guild", "SMSG_GUILD_INFO [{}]", session->GetPlayerInfo());
1760}
Definition: GuildPackets.h:85
time_t CreateDate
Definition: GuildPackets.h:92
int32 NumAccounts
Definition: GuildPackets.h:94
WorldPacket const * Write() override
Definition: GuildPackets.cpp:50
int32 NumMembers
Definition: GuildPackets.h:93
std::string GuildName
Definition: GuildPackets.h:91

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)
1863{
1865 motd.Type = GE_MOTD;
1866 motd.Params.emplace_back(m_motd);
1867 session->SendPacket(motd.Write());
1868
1869 LOG_DEBUG("guild", "SMSG_GUILD_EVENT [{}] MOTD", session->GetPlayerInfo());
1870
1871 Player* player = session->GetPlayer();
1872
1873 HandleRoster(session);
1874 _BroadcastEvent(GE_SIGNED_ON, player->GetGUID(), player->GetName());
1875
1876 if (Member* member = GetMember(player->GetGUID()))
1877 {
1878 member->SetStats(player);
1879 member->AddFlag(GUILDMEMBER_STATUS_ONLINE);
1880 }
1881}
@ GE_SIGNED_ON
Definition: Guild.h:162
@ GUILDMEMBER_STATUS_ONLINE
Definition: Guild.h:234
boost::container::static_vector< std::string_view, 3 > Params
Definition: GuildPackets.h:210

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
1848{
1849 Member const* member = GetMember(session->GetPlayer()->GetGUID());
1850 if (!member)
1851 return;
1852
1853 int32 amount = _GetMemberRemainingMoney(*member);
1854
1856 packet.RemainingWithdrawMoney = amount;
1857 session->SendPacket(packet.Write());
1858
1859 LOG_DEBUG("guild", "MSG_GUILD_BANK_MONEY_WITHDRAWN [{}] Money: {}", session->GetPlayerInfo(), amount);
1860}
int32 RemainingWithdrawMoney
Definition: GuildPackets.h:442
WorldPacket const * Write() override
Definition: GuildPackets.cpp:272

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)
1819{
1820 Member* member = GetMember(session->GetPlayer()->GetGUID());
1821 if (!member)
1822 return;
1823
1824 // We are unsubscribing here since it is the only reliable way to handle /reload from player as
1825 // GuildPermissionsQuery is sent on each reload, and we don't want to send partial changes while client
1826 // doesn't know the full state
1827 member->UnsubscribeFromGuildBankUpdatePackets();
1828
1829 uint8 rankId = member->GetRankId();
1830
1832 queryResult.RankID = rankId;
1833 queryResult.WithdrawGoldLimit = _GetRankBankMoneyPerDay(rankId);
1834 queryResult.Flags = _GetRankRights(rankId);
1835 queryResult.NumTabs = _GetPurchasedTabsSize();
1836
1837 for (uint8 tabId = 0; tabId < GUILD_BANK_MAX_TABS; ++tabId)
1838 {
1839 queryResult.Tab[tabId].Flags = _GetRankBankTabRights(rankId, tabId);
1840 queryResult.Tab[tabId].WithdrawItemLimit = _GetMemberRemainingSlots(*member, tabId);
1841 }
1842
1843 session->SendPacket(queryResult.Write());
1844 LOG_DEBUG("guild", "MSG_GUILD_PERMISSIONS [{}] Rank: {}", session->GetPlayerInfo(), rankId);
1845}
int32 Flags
Definition: GuildPackets.h:264
WorldPacket const * Write() override
Definition: GuildPackets.cpp:164
uint32 RankID
Definition: GuildPackets.h:265
int32 WithdrawGoldLimit
Definition: GuildPackets.h:263
int8 NumTabs
Definition: GuildPackets.h:262
std::array< GuildRankTabPermissions, GUILD_BANK_MAX_TABS > Tab
Definition: GuildPackets.h:266

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
127{
129 saveResponse.Error = int32(errCode);
130 session->SendPacket(saveResponse.Write());
131
132 LOG_DEBUG("guild", "MSG_SAVE_GUILD_EMBLEM [{}] Code: {}", session->GetPlayerInfo(), errCode);
133}
Definition: GuildPackets.h:614
WorldPacket const * Write() override
Definition: GuildPackets.cpp:453
int32 Error
Definition: GuildPackets.h:620

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 
)
2356{
2357 if (BankTab* pTab = GetBankTab(tabId))
2358 {
2359 pTab->SetText(text);
2360 pTab->SendText(this, nullptr);
2361 }
2362}

References GetBankTab().

◆ SetName()

bool Guild::SetName ( std::string_view const &  name)
1186{
1187 if (m_name == name || name.empty() || name.length() > 24 || sObjectMgr->IsReservedName(name) || sObjectMgr->IsProfanityName(name) || !ObjectMgr::IsValidCharterName(name))
1188 {
1189 return false;
1190 }
1191
1192 m_name = name;
1194 stmt->SetData(0, m_name);
1195 stmt->SetData(1, GetId());
1196 CharacterDatabase.Execute(stmt);
1197 return true;
1198}
@ CHAR_UPD_GUILD_NAME
Definition: CharacterDatabase.h:142
static bool IsValidCharterName(std::string_view name)
Definition: ObjectMgr.cpp:8415

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

Referenced by guild_commandscript::HandleGuildRenameCommand().

◆ SwapItems()

void Guild::SwapItems ( Player player,
uint8  tabId,
uint8  slotId,
uint8  destTabId,
uint8  destSlotId,
uint32  splitedAmount 
)
2328{
2329 if (tabId >= _GetPurchasedTabsSize() || slotId >= GUILD_BANK_MAX_SLOTS ||
2330 destTabId >= _GetPurchasedTabsSize() || destSlotId >= GUILD_BANK_MAX_SLOTS)
2331 return;
2332
2333 if (tabId == destTabId && slotId == destSlotId)
2334 return;
2335
2336 BankMoveItemData from(this, player, tabId, slotId);
2337 BankMoveItemData to(this, player, destTabId, destSlotId);
2338 _MoveItems(&from, &to, splitedAmount);
2339}
void _MoveItems(MoveItemData *pSrc, MoveItemData *pDest, uint32 splitedAmount)
Definition: Guild.cpp:2635

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 
)
2342{
2343 if ((slotId >= GUILD_BANK_MAX_SLOTS && slotId != NULL_SLOT) || tabId >= _GetPurchasedTabsSize())
2344 return;
2345
2346 BankMoveItemData bankData(this, player, tabId, slotId);
2347 PlayerMoveItemData charData(this, player, playerBag, playerSlotId);
2348 if (toChar)
2349 _MoveItems(&bankData, &charData, splitedAmount);
2350 else
2351 _MoveItems(&charData, &bankData, splitedAmount);
2352}
@ NULL_SLOT
Definition: Unit.h:211

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

Referenced by WorldSession::HandleGuildBankSwapItems().

◆ UpdateMemberData()

void Guild::UpdateMemberData ( Player player,
uint8  dataid,
uint32  value 
)
1156{
1157 if (Member* member = GetMember(player->GetGUID()))
1158 {
1159 switch (dataid)
1160 {
1162 member->SetZoneID(value);
1163 break;
1165 member->SetLevel(value);
1166 break;
1167 default:
1168 LOG_ERROR("guild", "Guild::UpdateMemberData: Called with incorrect DATAID {} (value {})", dataid, value);
1169 return;
1170 }
1171 //HandleRoster();
1172 }
1173}
@ GUILD_MEMBER_DATA_LEVEL
Definition: Guild.h:62
@ GUILD_MEMBER_DATA_ZONEID
Definition: Guild.h:61

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

◆ Validate()

bool Guild::Validate ( )
2027{
2028 // Validate ranks data
2029 // GUILD RANKS represent a sequence starting from 0 = GUILD_MASTER (ALL PRIVILEGES) to max 9 (lowest privileges).
2030 // The lower rank id is considered higher rank - so promotion does rank-- and demotion does rank++
2031 // Between ranks in sequence cannot be gaps - so 0, 1, 2, 4 is impossible
2032 // Min ranks count is 5 and max is 10.
2033 bool broken_ranks = false;
2034 uint8 ranks = _GetRanksSize();
2035 if (ranks < GUILD_RANKS_MIN_COUNT || ranks > GUILD_RANKS_MAX_COUNT)
2036 {
2037 LOG_ERROR("guild", "Guild {} has invalid number of ranks, creating new...", m_id);
2038 broken_ranks = true;
2039 }
2040 else
2041 {
2042 for (uint8 rankId = 0; rankId < ranks; ++rankId)
2043 {
2044 RankInfo* rankInfo = GetRankInfo(rankId);
2045 if (rankInfo->GetId() != rankId)
2046 {
2047 LOG_ERROR("guild", "Guild {} has broken rank id {}, creating default set of ranks...", m_id, rankId);
2048 broken_ranks = true;
2049 }
2050 else
2051 {
2052 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
2053 rankInfo->CreateMissingTabsIfNeeded(_GetPurchasedTabsSize(), trans, true);
2054 CharacterDatabase.CommitTransaction(trans);
2055 }
2056 }
2057 }
2058
2059 if (broken_ranks)
2060 {
2061 m_ranks.clear();
2063 }
2064
2065 // Validate members' data
2066 for (auto& [guid, member] : m_members)
2067 if (member.GetRankId() > _GetRanksSize())
2068 member.ChangeRank(_GetLowestRankId());
2069
2070 // Repair the structure of the guild.
2071 // If the guildmaster doesn't exist or isn't member of the guild
2072 // attempt to promote another member.
2073 Member* pLeader = GetMember(m_leaderGuid);
2074 if (!pLeader)
2075 {
2077 // If no more members left, disband guild
2078 if (m_members.empty())
2079 {
2080 Disband();
2081 return false;
2082 }
2083 }
2084 else if (!pLeader->IsRank(GR_GUILDMASTER))
2085 _SetLeaderGUID(*pLeader);
2086
2087 // Check config if multiple guildmasters are allowed
2088 if (!sConfigMgr->GetOption<bool>("Guild.AllowMultipleGuildMaster", 0))
2089 for (auto& [guid, member] : m_members)
2090 if ((member.GetRankId() == GR_GUILDMASTER) && !member.IsSamePlayer(m_leaderGuid))
2091 member.ChangeRank(GR_OFFICER);
2092
2094 return true;
2095}
#define DEFAULT_LOCALE
Definition: Common.h:88
#define sConfigMgr
Definition: Config.h:92

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

◆ m_bankMoney

◆ m_bankTabs

◆ m_createdDate

time_t Guild::m_createdDate
protected

◆ m_emblemInfo

EmblemInfo Guild::m_emblemInfo
protected

◆ m_eventLog

LogHolder<EventLogEntry> Guild::m_eventLog
protected

◆ m_id

◆ m_info

std::string Guild::m_info
protected

◆ m_leaderGuid

◆ m_members

◆ m_motd

std::string Guild::m_motd
protected

◆ m_name

◆ m_ranks