#include <Guild.h>

Classes
class	BankEventLogEntry

class	BankMoveItemData

class	BankTab

class	EventLogEntry

class	LogEntry

class	LogHolder

class	Member

class	MoveItemData

class	NewsLogEntry

class	PlayerMoveItemData

class	RankInfo

Public Member Functions
	Guild ()

	~Guild ()

bool	Create (Player *pLeader, std::string const &name)

void	Disband ()

void	SaveToDB ()

ObjectGuid::LowType	GetId () const

ObjectGuid	GetGUID () const

ObjectGuid	GetLeaderGUID () const

std::string const &	GetName () const

std::string const &	GetMOTD () const

std::string const &	GetInfo () const

time_t	GetCreatedDate () const

uint64	GetBankMoney () const

bool	SetName (std::string const &name)

void	HandleRoster (WorldSession *session)

void	SendQueryResponse (WorldSession *session)

void	HandleSetAchievementTracking (WorldSession *session, std::set< uint32 > const &achievementIds)

void	HandleSetMOTD (WorldSession *session, std::string const &motd)

void	HandleSetInfo (WorldSession *session, std::string const &info)

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

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

void	HandleSetBankTabInfo (WorldSession *session, uint8 tabId, std::string const &name, std::string const &icon)

void	HandleSetMemberNote (WorldSession *session, std::string const &note, ObjectGuid guid, bool isPublic)

void	HandleSetRankInfo (WorldSession *session, uint8 rankId, std::string const &name, uint32 rights, uint32 moneyPerDay, GuildBankRightsAndSlotsVec 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, ObjectGuid guid)

void	HandleUpdateMemberRank (WorldSession *session, ObjectGuid guid, bool demote)

void	HandleSetMemberRank (WorldSession *session, ObjectGuid guid, ObjectGuid setterGuid, uint32 rank)

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

void	HandleRemoveRank (WorldSession *session, uint8 rankId)

void	HandleMemberDepositMoney (WorldSession *session, uint64 amount, bool cashFlow=false)

bool	HandleMemberWithdrawMoney (WorldSession *session, uint64 amount, bool repair=false)

void	HandleMemberLogout (WorldSession *session)

void	HandleDelete (WorldSession *session)

void	HandleGuildPartyRequest (WorldSession *session)

void	HandleNewsSetSticky (WorldSession *session, uint32 newsId, bool sticky)

void	HandleGuildRequestChallengeUpdate (WorldSession *session)

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

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

void	SendGuildRankInfo (WorldSession *session) const

void	SendEventLog (WorldSession *session) const

void	SendBankLog (WorldSession *session, uint8 tabId) const

void	SendBankList (WorldSession *session, uint8 tabId, bool fullUpdate) const

void	SendBankTabText (WorldSession *session, uint8 tabId) const

void	SendPermissions (WorldSession *session) const

void	SendMoneyInfo (WorldSession *session) const

void	SendLoginInfo (WorldSession *session)

void	SendNewsUpdate (WorldSession *session)

void	SendEventBankMoneyChanged ()

void	SendEventMOTD (WorldSession *session, bool broadcast=false)

void	SendEventNewLeader (Member newLeader, Member oldLeader, bool isSelfPromoted=false)

void	SendEventPlayerLeft (Member leaver, Member remover=nullptr, bool isRemoved=false)

void	SendEventPresenceChanged (WorldSession *session, bool loggedOn, bool broadcast=false)

bool	LoadFromDB (Field *fields)

void	LoadGuildNewsLogFromDB (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 const &msg, uint32 language=LANG_UNIVERSAL) const

void	BroadcastAddonToGuild (WorldSession *session, bool officerOnly, std::string const &msg, std::string const &prefix) const

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

void	BroadcastPacket (WorldPacket const *packet) const

void	BroadcastPacketIfTrackingAchievement (WorldPacket const *packet, uint32 criteriaId) const

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

template<class Do >
void	BroadcastWorker (Do &_do, Player *except=NULL)

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)

bool	IsMember (ObjectGuid guid) const

uint32	GetMembersCount () const

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)

void	SetBankTabText (uint8 tabId, std::string const &text)

AchievementMgr< Guild > &	GetAchievementMgr ()

AchievementMgr< Guild > const &	GetAchievementMgr () const

uint8	GetLevel () const

void	AddGuildNews (uint8 type, ObjectGuid guid, uint32 flags, uint32 value)

EmblemInfo const &	GetEmblemInfo () const

void	ResetTimes (bool weekly)

bool	HasAchieved (uint32 achievementId) const

void	UpdateAchievementCriteria (AchievementCriteriaTypes type, uint64 miscValue1, uint64 miscValue2, uint64 miscValue3, Unit unit, Player player)

Static Public Member Functions
static void	SendCommandResult (WorldSession *session, GuildCommandType type, GuildCommandError errCode, std::string const &param="")

static void	SendSaveEmblemResult (WorldSession *session, GuildEmblemError errCode)

Protected Attributes
ObjectGuid::LowType	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

Ranks	m_ranks

Members	m_members

BankTabs	m_bankTabs

LogHolder *	m_eventLog

LogHolder *	m_bankEventLog [GUILD_BANK_MAX_TABS+1]

LogHolder *	m_newsLog

AchievementMgr< Guild >	m_achievementMgr

uint8	_level

Private Types
typedef std::list< LogEntry * >	GuildLog

typedef std::unordered_map < ObjectGuid, Member * >	Members

typedef std::vector< RankInfo >	Ranks

typedef std::vector< BankTab * >	BankTabs

Private Member Functions
uint8	_GetRanksSize () const

const RankInfo *	GetRankInfo (uint8 rankId) const

RankInfo *	GetRankInfo (uint8 rankId)

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

uint8	_GetLowestRankId () const

uint8	_GetPurchasedTabsSize () const

BankTab *	GetBankTab (uint8 tabId)

const BankTab *	GetBankTab (uint8 tabId) const

const Member *	GetMember (ObjectGuid guid) const

Member *	GetMember (ObjectGuid guid)

Member *	GetMember (std::string const &name)

void	_DeleteMemberFromDB (ObjectGuid::LowType lowguid) const

void	_CreateLogHolders ()

void	_CreateNewBankTab ()

void	_CreateDefaultGuildRanks (LocaleConstant loc)

bool	_CreateRank (std::string const &name, uint32 rights)

void	_UpdateAccountsNumber ()

bool	_IsLeader (Player *player) const

void	_DeleteBankItems (SQLTransaction &trans, bool removeItemsFromDB=false)

bool	_ModifyBankMoney (SQLTransaction &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 (SQLTransaction &trans, ObjectGuid guid, uint8 tabId)

bool	_MemberHasTabRights (ObjectGuid guid, uint8 tabId, int32 rights) const

void	_LogEvent (GuildEventLogTypes eventType, ObjectGuid::LowType playerGuid1, ObjectGuid::LowType playerGuid2=UI64LIT(0), uint8 newRank=0)

void	_LogBankEvent (SQLTransaction &trans, GuildBankEventLogTypes eventType, uint8 tabId, ObjectGuid::LowType playerGuid, uint64 itemOrMoney, uint16 itemStackCount=0, uint8 destTabId=0)

Item *	_GetItem (uint8 tabId, uint8 slotId) const

void	_RemoveItem (SQLTransaction &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	_SendBankContentUpdate (MoveItemData pSrc, MoveItemData pDest) const

void	_SendBankContentUpdate (uint8 tabId, SlotIds slots) const

void	SendGuildRanksUpdate (ObjectGuid setterGuid, ObjectGuid targetGuid, uint32 rank)

Member Typedef Documentation

typedef std::vector<BankTab*> Guild::BankTabs

private

typedef std::list<LogEntry*> Guild::GuildLog

private

typedef std::unordered_map<ObjectGuid, Member*> Guild::Members

private

typedef std::vector<RankInfo> Guild::Ranks

private

Constructor & Destructor Documentation

Guild::Guild ( )

  :
  m_id(UI64LIT(0)),
  m_leaderGuid(),
  m_createdDate(0),
  m_accountsNumber(0),
  m_bankMoney(0),
  m_eventLog(NULL),
  m_newsLog(NULL),
  m_achievementMgr(this),
  _level(1)
 {
  memset(&m_bankEventLog, 0, (GUILD_BANK_MAX_TABS + 1) * sizeof(LogHolder*));
 }

Guild::~Guild ( )

 {
  SQLTransaction temp(NULL);
  _DeleteBankItems(temp);
 
  // Cleanup
  delete m_eventLog;
  m_eventLog = NULL;
  delete m_newsLog;
  m_newsLog = NULL;
 
  for (uint8 tabId = 0; tabId <= GUILD_BANK_MAX_TABS; ++tabId)
  {
  delete m_bankEventLog[tabId];
  m_bankEventLog[tabId] = NULL;
  }
 
  for (Members::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
  {
  delete itr->second;
  itr->second = NULL;
  }
 }

Here is the call graph for this function:

Member Function Documentation

void Guild::_CreateDefaultGuildRanks ( LocaleConstant loc )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::_CreateLogHolders ( )

private

 {
  m_eventLog = new LogHolder(sWorld->getIntConfig(CONFIG_GUILD_EVENT_LOG_COUNT));
  m_newsLog = new LogHolder(sWorld->getIntConfig(CONFIG_GUILD_NEWS_LOG_COUNT));
  for (uint8 tabId = 0; tabId <= GUILD_BANK_MAX_TABS; ++tabId)
  m_bankEventLog[tabId] = new LogHolder(sWorld->getIntConfig(CONFIG_GUILD_BANK_EVENT_LOG_COUNT));
 }

Here is the caller graph for this function:

void Guild::_CreateNewBankTab ( )

private

 {
  uint8 tabId = _GetPurchasedTabsSize(); // Next free id
  m_bankTabs.push_back(new BankTab(m_id, tabId));
 
  SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_TAB);
  stmt->setUInt64(0, m_id);
  stmt->setUInt8 (1, tabId);
  trans->Append(stmt);
 
  stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD_BANK_TAB);
  stmt->setUInt64(0, m_id);
  stmt->setUInt8 (1, tabId);
  trans->Append(stmt);
 
  ++tabId;
  for (Ranks::iterator itr = m_ranks.begin(); itr != m_ranks.end(); ++itr)
  (*itr).CreateMissingTabsIfNeeded(tabId, trans, false);
 
  CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Guild::_CreateRank	(	std::string const &	name,
		uint32	rights
	)

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::_DeleteBankItems	(	SQLTransaction &	trans,
		bool	removeItemsFromDB = `false`
	)

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

uint8 Guild::_GetLowestRankId ( ) const

inlineprivate

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

Guild::m_ranks

Ranks m_ranks

Definition: Guild.h:894

G3D::uint8

uint8_t uint8

Definition: g3dmath.h:164

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Guild::_GetPurchasedTabsSize ( ) const

inlineprivate

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

Guild::m_bankTabs

BankTabs m_bankTabs

Definition: Guild.h:896

G3D::uint8

uint8_t uint8

Definition: g3dmath.h:164

Here is the caller graph for this function:

int32 Guild::_GetRankBankMoneyPerDay ( uint8 rankId ) const

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

uint32 Guild::_GetRankRights ( uint8 rankId ) const

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Guild::_GetRanksSize ( ) const

inlineprivate

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

Guild::m_ranks

Ranks m_ranks

Definition: Guild.h:894

G3D::uint8

uint8_t uint8

Definition: g3dmath.h:164

Here is the caller graph for this function:

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

inlineprivate

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

Here is the caller graph for this function:

bool Guild::_IsLeader ( Player * player ) const

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::_LogBankEvent	(	SQLTransaction &	trans,
		GuildBankEventLogTypes	eventType,
		uint8	tabId,
		ObjectGuid::LowType	playerGuid,
		uint64	itemOrMoney,
		uint16	itemStackCount = `0`,
		uint8	destTabId = `0`
	)

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool Guild::_ModifyBankMoney	(	SQLTransaction &	trans,
		uint64	amount,
		bool	add
	)

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

 {
  // 1. Initialize source item
  if (!pSrc->InitItem())
  return; // No source item
 
  // 2. Check source item
  if (!pSrc->CheckItem(splitedAmount))
  return; // Source item or splited amount is invalid
  /*
  if (pItemSrc->GetCount() == 0)
  {
  TC_LOG_FATAL("guild", "Guild::SwapItems: Player %s(GUIDLow: %u) tried to move item %u from tab %u slot %u to tab %u slot %u, but item %u has a stack of zero!",
  player->GetName(), player->GetGUIDLow(), pItemSrc->GetEntry(), tabId, slotId, destTabId, destSlotId, pItemSrc->GetEntry());
  //return; // Commented out for now, uncomment when it's verified that this causes a crash!!
  }
  // */
 
  // 3. Check destination rights
  if (!pDest->HasStoreRights(pSrc))
  return; // Player has no rights to store item in destination
 
  // 4. Check source withdraw rights
  if (!pSrc->HasWithdrawRights(pDest))
  return; // Player has no rights to withdraw items from source
 
  // 5. Check split
  if (splitedAmount)
  {
  // 5.1. Clone source item
  if (!pSrc->CloneItem(splitedAmount))
  return; // Item could not be cloned
 
  // 5.2. Move splited item to destination
  _DoItemsMove(pSrc, pDest, true, splitedAmount);
  }
  else // 6. No split
  {
  // 6.1. Try to merge items in destination (pDest->GetItem() == NULL)
  if (!_DoItemsMove(pSrc, pDest, false)) // Item could not be merged
  {
  // 6.2. Try to swap items
  // 6.2.1. Initialize destination item
  if (!pDest->InitItem())
  return;
 
  // 6.2.2. Check rights to store item in source (opposite direction)
  if (!pSrc->HasStoreRights(pDest))
  return; // Player has no rights to store item in source (opposite direction)
 
  if (!pDest->HasWithdrawRights(pSrc))
  return; // Player has no rights to withdraw item from destination (opposite direction)
 
  // 6.2.3. Swap items (pDest->GetItem() != NULL)
  _DoItemsMove(pSrc, pDest, true);
  }
  }
  // 7. Send changes
  _SendBankContentUpdate(pSrc, pDest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::_RemoveItem	(	SQLTransaction &	trans,
		uint8	tabId,
		uint8	slotId
	)

inlineprivate

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

Here is the call graph for this function:

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

 {
     if (BankTab const* tab = GetBankTab(tabId))
     {
         WorldPackets::Guild::GuildBankQueryResults packet;
         packet.FullUpdate = true;          // @todo
         packet.Tab = int32(tabId);
         packet.Money = m_bankMoney;
 
         for (SlotIds::const_iterator itr = slots.begin(); itr != slots.end(); ++itr)
         {
             Item const* tabItem = tab->GetItem(*itr);
 
             WorldPackets::Guild::GuildBankItemInfo itemInfo;
 
             itemInfo.Slot = int32(*itr);
             itemInfo.Item.ItemID = int32(tabItem ? tabItem->GetEntry() : 0);
             itemInfo.Count = int32(tabItem ? tabItem->GetCount() : 0);
             itemInfo.Charges = int32(tabItem ? abs(tabItem->GetSpellCharges()) : 0);
             itemInfo.OnUseEnchantmentID = 0/*int32(tabItem->GetItemSuffixFactor())*/;
             itemInfo.Flags = 0;
             itemInfo.Locked = false;
 
             if (tabItem)
             {
                 uint32 enchants = 0;
                 for (uint32 ench = 0; ench < MAX_ENCHANTMENT_SLOT; ++ench)
                     if (tabItem->GetEnchantmentId(EnchantmentSlot(ench)))
                         ++enchants;
 
                 itemInfo.SocketEnchant.reserve(enchants);
                 for (uint32 ench = 0; ench < MAX_ENCHANTMENT_SLOT; ++ench)
                 {
                     if (uint32 enchantId = tabItem->GetEnchantmentId(EnchantmentSlot(ench)))
                     {
                         WorldPackets::Guild::GuildBankItemInfo::GuildBankSocketEnchant socketEnchant;
                         socketEnchant.SocketEnchantID = int32(enchantId);
                         socketEnchant.SocketIndex = int32(ench);
                         itemInfo.SocketEnchant.push_back(socketEnchant);
                     }
                 }
             }
 
             packet.ItemInfo.push_back(itemInfo);
         }
 
         for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
             if (_MemberHasTabRights(itr->second->GetGUID(), tabId, GUILD_BANK_RIGHT_VIEW_TAB))
                 if (Player* player = itr->second->FindPlayer())
                 {
                     packet.WithdrawalsRemaining = int32(_GetMemberRemainingSlots(itr->second, tabId));
                     player->GetSession()->SendPacket(packet.Write());
                 }
 
         TC_LOG_DEBUG("guild", "WORLD: Sent SMSG_GUILD_BANK_QUERY_RESULTS");
     }
 }

Here is the call graph for this function:

void Guild::_SetLeaderGUID ( Member * pLeader )

private

 {
     if (!pLeader)
         return;
 
     m_leaderGuid = pLeader->GetGUID();
     pLeader->ChangeRank(GR_GUILDMASTER);
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_LEADER);
     stmt->setUInt64(0, m_leaderGuid.GetCounter());
     stmt->setUInt64(1, m_id);
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::_UpdateAccountsNumber ( )

private

 {
     // We use a set to be sure each element will be unique
     std::set<uint32> accountsIdSet;
     for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
         accountsIdSet.insert(itr->second->GetAccountId());
 
     m_accountsNumber = accountsIdSet.size();
 }

Here is the caller graph for this function:

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

inlineprivate

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

Here is the call graph for this function:

void Guild::AddGuildNews	(	uint8	type,
		ObjectGuid	guid,
		uint32	flags,
		uint32	value
	)

 {
     NewsLogEntry* news = new NewsLogEntry(m_id, m_newsLog->GetNextGUID(), GuildNews(type), guid, flags, value);
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     m_newsLog->AddEvent(trans, news);
     CharacterDatabase.CommitTransaction(trans);
 
     WorldPackets::Guild::GuildNews newsPacket;
     newsPacket.NewsEvents.reserve(1);
     news->WritePacket(newsPacket);
     BroadcastPacket(newsPacket.Write());
 }

Here is the call graph for this function:

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

 {
     Player* player = ObjectAccessor::FindConnectedPlayer(guid);
     // Player cannot be in guild
     if (player)
     {
         if (player->GetGuildId())
             return false;
     }
     else if (Player::GetGuildIdFromDB(guid))
         return false;
 
     // Remove all player signs from another petitions
     // This will be prevent attempt to join many guilds and corrupt guild data integrity
     Player::RemovePetitionsAndSigns(guid);
 
     ObjectGuid::LowType lowguid = guid.GetCounter();
 
     // If rank was not passed, assign lowest possible rank
     if (rankId == GUILD_RANK_NONE)
         rankId = _GetLowestRankId();
 
     Member* member = new Member(m_id, guid, rankId);
     std::string name;
     if (player)
     {
         m_members[guid] = member;
         player->SetInGuild(m_id);
         player->SetGuildIdInvited(UI64LIT(0));
         player->SetRank(rankId);
         player->SetGuildLevel(GetLevel());
         SendLoginInfo(player->GetSession());
         name = player->GetName();
     }
     else
     {
         member->ResetFlags();
 
         bool ok = false;
         // Player must exist
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_DATA_FOR_GUILD);
         stmt->setUInt64(0, lowguid);
         if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
         {
             Field* fields = result->Fetch();
             name = fields[0].GetString();
             member->SetStats(
                 name,
                 fields[1].GetUInt8(),
                 fields[2].GetUInt8(),
                 fields[3].GetUInt8(),
                 fields[4].GetUInt16(),
                 fields[5].GetUInt32(),
                 0);
 
             ok = member->CheckStats();
         }
 
         if (!ok)
         {
             delete member;
             return false;
         }
         m_members[guid] = member;
     }
 
     SQLTransaction trans(NULL);
     member->SaveToDB(trans);
 
     _UpdateAccountsNumber();
     _LogEvent(GUILD_EVENT_LOG_JOIN_GUILD, lowguid);
 
     WorldPackets::Guild::GuildEventPlayerJoined joinNotificationPacket;
     joinNotificationPacket.Guid = guid;
     joinNotificationPacket.Name = name;
     joinNotificationPacket.VirtualRealmAddress = GetVirtualRealmAddress();
     BroadcastPacket(joinNotificationPacket.Write());
 
     sGuildFinderMgr->RemoveAllMembershipRequestsFromPlayer(guid);
 
     // Call scripts if member was succesfully added (and stored to database)
     sScriptMgr->OnGuildAddMember(this, player, rankId);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::BroadcastAddonToGuild	(	WorldSession *	session,
		bool	officerOnly,
		std::string const &	msg,
		std::string const &	prefix
	)		const

 {
     if (session && session->GetPlayer() && _HasRankRight(session->GetPlayer(), officerOnly ? GR_RIGHT_OFFCHATSPEAK : GR_RIGHT_GCHATSPEAK))
     {
         WorldPackets::Chat::Chat packet;
         packet.Initialize(officerOnly ? CHAT_MSG_OFFICER : CHAT_MSG_GUILD, LANG_ADDON, session->GetPlayer(), nullptr, msg, 0, "", DEFAULT_LOCALE, prefix);
         WorldPacket const* data = packet.Write();
         for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
             if (Player* player = itr->second->FindPlayer())
                 if (player->GetSession() && _HasRankRight(player, officerOnly ? GR_RIGHT_OFFCHATLISTEN : GR_RIGHT_GCHATLISTEN) &&
                     !player->GetSocial()->HasIgnore(session->GetPlayer()->GetGUID()) &&
                     player->GetSession()->IsAddonRegistered(prefix))
                         player->GetSession()->SendPacket(data);
     }
 }

Here is the call graph for this function:

void Guild::BroadcastPacket ( WorldPacket const * packet ) const

 {
     for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
         if (Player* player = itr->second->FindPlayer())
             player->GetSession()->SendPacket(packet);
 }

Here is the caller graph for this function:

void Guild::BroadcastPacketIfTrackingAchievement	(	WorldPacket const *	packet,
		uint32	criteriaId
	)		const

 {
     for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
         if (itr->second->IsTrackingCriteriaId(criteriaId))
             if (Player* player = itr->second->FindPlayer())
                 player->GetSession()->SendPacket(packet);
 }

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

 {
     for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
         if (itr->second->IsRank(rankId))
             if (Player* player = itr->second->FindConnectedPlayer())
                 player->GetSession()->SendPacket(packet);
 }

Here is the caller graph for this function:

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

 {
     if (session && session->GetPlayer() && _HasRankRight(session->GetPlayer(), officerOnly ? GR_RIGHT_OFFCHATSPEAK : GR_RIGHT_GCHATSPEAK))
     {
         WorldPackets::Chat::Chat packet;
         packet.Initialize(officerOnly ? CHAT_MSG_OFFICER : CHAT_MSG_GUILD, Language(language), session->GetPlayer(), nullptr, msg);
         WorldPacket const* data = packet.Write();
         for (Members::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
             if (Player* player = itr->second->FindConnectedPlayer())
                 if (player->GetSession() && _HasRankRight(player, officerOnly ? GR_RIGHT_OFFCHATLISTEN : GR_RIGHT_GCHATLISTEN) &&
                     !player->GetSocial()->HasIgnore(session->GetPlayer()->GetGUID()))
                     player->GetSession()->SendPacket(data);
     }
 }

Here is the call graph for this function:

template<class Do >

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

inline

     {
         for (Members::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
             if (Player* player = itr->second->FindConnectedPlayer())
                 if (player != except)
                     _do(player);
     }

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

 {
     if (newRank <= _GetLowestRankId())                    // Validate rank (allow only existing ranks)
         if (Member* member = GetMember(guid))
         {
             member->ChangeRank(newRank);
             return true;
         }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Guild::Create	(	Player *	pLeader,
		std::string const &	name
	)

 {
     // Check if guild with such name already exists
     if (sGuildMgr->GetGuildByName(name))
         return false;
 
     WorldSession* pLeaderSession = pLeader->GetSession();
     if (!pLeaderSession)
         return false;
 
     m_id = sGuildMgr->GenerateGuildId();
     m_leaderGuid = pLeader->GetGUID();
     m_name = name;
     m_info = "";
     m_motd = "No message set.";
     m_bankMoney = 0;
     m_createdDate = ::time(NULL);
     _level = 1;
     _CreateLogHolders();
 
     TC_LOG_DEBUG("guild", "GUILD: creating guild [%s] for leader %s (%s)",
         name.c_str(), pLeader->GetName().c_str(), m_leaderGuid.ToString().c_str());
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_MEMBERS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     uint8 index = 0;
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD);
     stmt->setUInt64(  index, m_id);
     stmt->setString(++index, name);
     stmt->setUInt64(++index, m_leaderGuid.GetCounter());
     stmt->setString(++index, m_info);
     stmt->setString(++index, m_motd);
     stmt->setUInt64(++index, uint32(m_createdDate));
     stmt->setUInt32(++index, m_emblemInfo.GetStyle());
     stmt->setUInt32(++index, m_emblemInfo.GetColor());
     stmt->setUInt32(++index, m_emblemInfo.GetBorderStyle());
     stmt->setUInt32(++index, m_emblemInfo.GetBorderColor());
     stmt->setUInt32(++index, m_emblemInfo.GetBackgroundColor());
     stmt->setUInt64(++index, m_bankMoney);
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
     _CreateDefaultGuildRanks(pLeaderSession->GetSessionDbLocaleIndex()); // Create default ranks
     bool ret = AddMember(m_leaderGuid, GR_GUILDMASTER);                  // Add guildmaster
 
     if (ret)
     {
         Member* leader = GetMember(m_leaderGuid);
         if (leader)
             SendEventNewLeader(leader, NULL);
 
         sScriptMgr->OnGuildCreate(this, pLeader, name);
     }
 
     return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Guild master can be deleted when loading guild and guid doesn't exist in characters table
     // or when he is removed from guild by gm command
     if (m_leaderGuid == guid && !isDisbanding)
     {
         Member* oldLeader = NULL;
         Member* newLeader = NULL;
         for (Guild::Members::iterator i = m_members.begin(); i != m_members.end(); ++i)
         {
             if (i->first == guid)
                 oldLeader = i->second;
             else if (!newLeader || newLeader->GetRankId() > i->second->GetRankId())
                 newLeader = i->second;
         }
 
         if (!newLeader)
         {
             Disband();
             if (canDeleteGuild)
                 delete this;
             return;
         }
 
         _SetLeaderGUID(newLeader);
 
         // If player not online data in data field will be loaded from guild tabs no need to update it !!
         if (Player* newLeaderPlayer = newLeader->FindPlayer())
             newLeaderPlayer->SetRank(GR_GUILDMASTER);
 
         // If leader does not exist (at guild loading with deleted leader) do not send broadcasts
         if (oldLeader)
         {
             SendEventNewLeader(newLeader, oldLeader, true);
             SendEventPlayerLeft(oldLeader);
         }
     }
     // Call script on remove before member is actually removed from guild (and database)
     sScriptMgr->OnGuildRemoveMember(this, guid, isDisbanding, isKicked);
 
     if (Member* member = GetMember(guid))
         delete member;
     m_members.erase(guid);
 
     // If player not online data in data field will be loaded from guild tabs no need to update it !!
     Player* player = ObjectAccessor::FindConnectedPlayer(guid);
     if (player)
     {
         player->SetInGuild(UI64LIT(0));
         player->SetRank(0);
         player->SetGuildLevel(0);
 
         for (GuildPerkSpellsEntry const* entry : sGuildPerkSpellsStore)
             if (entry->GuildLevel <= GetLevel())
                 player->RemoveSpell(entry->SpellID, false, false);
     }
 
     _DeleteMemberFromDB(guid.GetCounter());
     if (!isDisbanding)
         _UpdateAccountsNumber();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::Disband ( )

 {
     // Call scripts before guild data removed from database
     sScriptMgr->OnGuildDisband(this);
 
     WorldPackets::Guild::GuildEventDisbanded packet;
     BroadcastPacket(packet.Write());
 
     // Remove all members
     while (!m_members.empty())
     {
         Members::const_iterator itr = m_members.begin();
         DeleteMember(itr->second->GetGUID(), true);
     }
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_RANKS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_TABS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     // Free bank tab used memory and delete items stored in them
     _DeleteBankItems(trans, true);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_ITEMS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_EVENTLOGS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_EVENTLOGS);
     stmt->setUInt64(0, m_id);
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 
     sGuildFinderMgr->DeleteGuild(GetGUID());
 
     sGuildMgr->RemoveGuild(m_id);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AchievementMgr<Guild>& Guild::GetAchievementMgr ( )

inline

868 { return m_achievementMgr; }

Guild::m_achievementMgr

AchievementMgr< Guild > m_achievementMgr

Definition: Guild.h:902

Here is the caller graph for this function:

AchievementMgr<Guild> const& Guild::GetAchievementMgr ( ) const

inline

869 { return m_achievementMgr; }

Guild::m_achievementMgr

AchievementMgr< Guild > m_achievementMgr

Definition: Guild.h:902

uint64 Guild::GetBankMoney ( ) const

inline

770 { return m_bankMoney; }

Guild::m_bankMoney

uint64 m_bankMoney

Definition: Guild.h:892

Here is the caller graph for this function:

BankTab* Guild::GetBankTab ( uint8 tabId )

inlineprivate

921 { return tabId < m_bankTabs.size() ? m_bankTabs[tabId] : NULL; }

Guild::m_bankTabs

BankTabs m_bankTabs

Definition: Guild.h:896

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Here is the caller graph for this function:

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

inlineprivate

922 { return tabId < m_bankTabs.size() ? m_bankTabs[tabId] : NULL; }

Guild::m_bankTabs

BankTabs m_bankTabs

Definition: Guild.h:896

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

time_t Guild::GetCreatedDate ( ) const

inline

769 { return m_createdDate; }

Guild::m_createdDate

time_t m_createdDate

Definition: Guild.h:888

Here is the caller graph for this function:

EmblemInfo const& Guild::GetEmblemInfo ( ) const

inline

876 { return m_emblemInfo; }

Guild::m_emblemInfo

EmblemInfo m_emblemInfo

Definition: Guild.h:890

Here is the caller graph for this function:

ObjectGuid Guild::GetGUID ( ) const

inline

764 { return ObjectGuid::Create<HighGuid::Guild>(m_id); }

Guild::m_id

ObjectGuid::LowType m_id

Definition: Guild.h:883

Here is the caller graph for this function:

ObjectGuid::LowType Guild::GetId ( ) const

inline

763 { return m_id; }

Guild::m_id

ObjectGuid::LowType m_id

Definition: Guild.h:883

Here is the caller graph for this function:

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

inline

768 { return m_info; }

Guild::m_info

std::string m_info

Definition: Guild.h:887

Here is the caller graph for this function:

ObjectGuid Guild::GetLeaderGUID ( ) const

inline

765 { return m_leaderGuid; }

Guild::m_leaderGuid

ObjectGuid m_leaderGuid

Definition: Guild.h:885

Here is the caller graph for this function:

uint8 Guild::GetLevel ( ) const

inline

872 { return _level; }

Guild::_level

uint8 _level

Definition: Guild.h:904

Here is the caller graph for this function:

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

inlineprivate

     {
         Members::const_iterator itr = m_members.find(guid);
         return itr != m_members.end() ? itr->second : NULL;
     }

Here is the caller graph for this function:

Member* Guild::GetMember ( ObjectGuid guid )

inlineprivate

     {
         Members::iterator itr = m_members.find(guid);
         return itr != m_members.end() ? itr->second : NULL;
     }

Member* Guild::GetMember ( std::string const & name )

inlineprivate

     {
         for (Members::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
             if (itr->second->GetName() == name)
                 return itr->second;
 
         return NULL;
     }

uint32 Guild::GetMembersCount ( ) const

inline

859 { return uint32(m_members.size()); }

Guild::m_members

Members m_members

Definition: Guild.h:895

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

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

inline

767 { return m_motd; }

Guild::m_motd

std::string m_motd

Definition: Guild.h:886

Here is the caller graph for this function:

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

inline

766 { return m_name; }

Guild::m_name

std::string m_name

Definition: Guild.h:884

Here is the caller graph for this function:

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

inlineprivate

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

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Guild::_GetRanksSize

uint8 _GetRanksSize() const

Definition: Guild.h:907

Guild::m_ranks

Ranks m_ranks

Definition: Guild.h:894

Here is the caller graph for this function:

RankInfo* Guild::GetRankInfo ( uint8 rankId )

inlineprivate

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

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Guild::_GetRanksSize

uint8 _GetRanksSize() const

Definition: Guild.h:907

Guild::m_ranks

Ranks m_ranks

Definition: Guild.h:894

void Guild::HandleAcceptMember ( WorldSession * session )

 {
     Player* player = session->GetPlayer();
     if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) &&
         player->GetTeam() != ObjectMgr::GetPlayerTeamByGUID(GetLeaderGUID()))
         return;
 
     AddMember(player->GetGUID());
 }

Here is the call graph for this function:

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

 {
     uint8 size = _GetRanksSize();
     if (size >= GUILD_RANKS_MAX_COUNT)
         return;
 
     // Only leader can add new rank
     if (_IsLeader(session->GetPlayer()))
     {
         if (_CreateRank(name, GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK))
         {
             WorldPackets::Guild::GuildEventRanksUpdated eventPacket;
             BroadcastPacket(eventPacket.Write());
         }
     }
 }

Here is the call graph for this function:

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

Hack to force client to update permissions

 {
     Player* player = session->GetPlayer();
     if (!player)
         return;
 
     Member const* member = GetMember(player->GetGUID());
     if (!member)
         return;
 
     if (_GetPurchasedTabsSize() >= GUILD_BANK_MAX_TABS)
         return;
 
     if (tabId != _GetPurchasedTabsSize())
         return;
 
     // Do not get money for bank tabs that the GM bought, we had to buy them already.
     // This is just a speedup check, GetGuildBankTabPrice will return 0.
     if (tabId < GUILD_BANK_MAX_TABS - 2) // 7th tab is actually the 6th
     {
         uint32 tabCost = _GetGuildBankTabPrice(tabId) * GOLD;
         if (!tabCost)
             return;
 
         if (!player->HasEnoughMoney(uint64(tabCost)))                   // Should not happen, this is checked by client
             return;
 
         player->ModifyMoney(-int64(tabCost));
     }
 
     _CreateNewBankTab();
 
     WorldPackets::Guild::GuildEventTabAdded packet;
     BroadcastPacket(packet.Write());
 
     SendPermissions(session); 
 }

Here is the call graph for this function:

void Guild::HandleDelete ( WorldSession * session )

 {
     // Only leader can disband guild
     if (_IsLeader(session->GetPlayer()))
     {
         Disband();
         TC_LOG_DEBUG("guild", "%s successfully deleted", GetGUID().ToString().c_str());
         delete this;
     }
 }

Here is the call graph for this function:

void Guild::HandleGuildPartyRequest ( WorldSession * session )

 {
     Player* player = session->GetPlayer();
     Group* group = player->GetGroup();
 
     // Make sure player is a member of the guild and that he is in a group.
     if (!IsMember(player->GetGUID()) || !group)
         return;
 
     WorldPackets::Guild::GuildPartyState partyStateResponse;
     partyStateResponse.InGuildParty = (player->GetMap()->GetOwnerGuildId(player->GetTeam()) == GetId());
     partyStateResponse.NumMembers = 0;
     partyStateResponse.NumRequired = 0;
     partyStateResponse.GuildXPEarnedMult = 0.0f;
     session->SendPacket(partyStateResponse.Write());
 
     TC_LOG_DEBUG("guild", "SMSG_GUILD_PARTY_STATE_RESPONSE [%s]", session->GetPlayerInfo().c_str());
 }

Here is the call graph for this function:

void Guild::HandleGuildRequestChallengeUpdate ( WorldSession * session )

Todo:: current count

 {
     WorldPackets::Guild::GuildChallengeUpdate updatePacket;
 
     for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
         updatePacket.CurrentCount[i] = int32(0); 
 
     for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
         updatePacket.MaxCount[i] = int32(GuildChallengesMaxCount[i]);
 
     for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
         updatePacket.MaxLevelGold[i] = int32(GuildChallengeMaxLevelGoldReward[i]);
 
     for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
         updatePacket.Gold[i] = int32(GuildChallengeGoldReward[i]);
 
     session->SendPacket(updatePacket.Write());
 }

Here is the call graph for this function:

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

 {
     Player* pInvitee = ObjectAccessor::FindPlayerByName(name);
     if (!pInvitee)
     {
         SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_GUILD_PLAYER_NOT_FOUND_S, name);
         return;
     }
 
     Player* player = session->GetPlayer();
     // Do not show invitations from ignored players
     if (pInvitee->GetSocial()->HasIgnore(player->GetGUID()))
         return;
 
     if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && pInvitee->GetTeam() != player->GetTeam())
     {
         SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_GUILD_NOT_ALLIED, name);
         return;
     }
 
     // Invited player cannot be in another guild
     if (pInvitee->GetGuildId())
     {
         SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_IN_GUILD_S, name);
         return;
     }
 
     // Invited player cannot be invited
     if (pInvitee->GetGuildIdInvited())
     {
         SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_INVITED_TO_GUILD_S, name);
         return;
     }
 
     // Inviting player must have rights to invite
     if (!_HasRankRight(player, GR_RIGHT_INVITE))
     {
         SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_GUILD_PERMISSIONS);
         return;
     }
 
     SendCommandResult(session, GUILD_COMMAND_INVITE_PLAYER, ERR_GUILD_COMMAND_SUCCESS, name);
 
     TC_LOG_DEBUG("guild", "Player %s invited %s to join his Guild", player->GetName().c_str(), name.c_str());
 
     pInvitee->SetGuildIdInvited(m_id);
     _LogEvent(GUILD_EVENT_LOG_INVITE_PLAYER, player->GetGUID().GetCounter(), pInvitee->GetGUID().GetCounter());
 
     WorldPackets::Guild::GuildInvite invite;
 
     invite.InviterVirtualRealmAddress = GetVirtualRealmAddress();
     invite.GuildVirtualRealmAddress = GetVirtualRealmAddress();
     invite.GuildGUID = GetGUID();
 
     invite.EmblemStyle = uint32(m_emblemInfo.GetStyle());
     invite.EmblemColor = uint32(m_emblemInfo.GetColor());
     invite.BorderStyle = uint32(m_emblemInfo.GetBorderStyle());
     invite.BorderColor = uint32(m_emblemInfo.GetBorderColor());
     invite.Background = uint32(m_emblemInfo.GetBackgroundColor());
     invite.Level = int32(GetLevel());
 
     invite.InviterName = player->GetName();
     invite.GuildName = GetName();
 
     if (Guild* oldGuild = pInvitee->GetGuild())
     {
         invite.OldGuildGUID = oldGuild->GetGUID();
         invite.OldGuildName = oldGuild->GetName();
         invite.OldGuildVirtualRealmAddress = GetVirtualRealmAddress();
     }
 
     pInvitee->GetSession()->SendPacket(invite.Write());
     TC_LOG_DEBUG("guild", "SMSG_GUILD_INVITE [%s]", pInvitee->GetName().c_str());
 }

Here is the call graph for this function:

void Guild::HandleLeaveMember ( WorldSession * session )

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

Here is the call graph for this function:

void Guild::HandleMemberDepositMoney	(	WorldSession *	session,
		uint64	amount,
		bool	cashFlow = `false`
	)

 {
     Player* player = session->GetPlayer();
 
     // Call script after validation and before money transfer.
     sScriptMgr->OnGuildMemberDepositMoney(this, player, amount);
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     _ModifyBankMoney(trans, amount, true);
     if (!cashFlow)
     {
         player->ModifyMoney(-int64(amount));
         player->SaveGoldToDB(trans);
     }
 
     _LogBankEvent(trans, cashFlow ? GUILD_BANK_LOG_CASH_FLOW_DEPOSIT : GUILD_BANK_LOG_DEPOSIT_MONEY, uint8(0), player->GetGUID().GetCounter(), amount);
     CharacterDatabase.CommitTransaction(trans);
 
     SendEventBankMoneyChanged();
 
     if (player->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
     {
         sLog->outCommand(player->GetSession()->GetAccountId(),
             "GM %s (Account: %u) deposit money (Amount: " UI64FMTD ") to guild bank (Guild ID " UI64FMTD ")",
             player->GetName().c_str(), player->GetSession()->GetAccountId(), amount, m_id);
     }
 }

Here is the call graph for this function:

void Guild::HandleMemberLogout ( WorldSession * session )

 {
     Player* player = session->GetPlayer();
     if (Member* member = GetMember(player->GetGUID()))
     {
         member->SetStats(player);
         member->UpdateLogoutTime();
         member->ResetFlags();
     }
 
     SendEventPresenceChanged(session, false, true);
     SaveToDB();
 }

Here is the call graph for this function:

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

 {
     // clamp amount to MAX_MONEY_AMOUNT, Players can't hold more than that anyway
     amount = std::min(amount, uint64(MAX_MONEY_AMOUNT));
 
     if (m_bankMoney < amount)                               // Not enough money in bank
         return false;
 
     Player* player = session->GetPlayer();
 
     Member* member = GetMember(player->GetGUID());
     if (!member)
         return false;
 
    if (uint64(_GetMemberRemainingMoney(member)) < amount)   // Check if we have enough slot/money today
        return false;
 
     // Call script after validation and before money transfer.
     sScriptMgr->OnGuildMemberWitdrawMoney(this, player, amount, repair);
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     // Add money to player (if required)
     if (!repair)
     {
         if (!player->ModifyMoney(amount))
             return false;
 
         player->SaveGoldToDB(trans);
     }
 
     // Update remaining money amount
     member->UpdateBankWithdrawValue(trans, GUILD_BANK_MAX_TABS, amount);
     // Remove money from bank
     _ModifyBankMoney(trans, amount, false);
 
     // Log guild bank event
     _LogBankEvent(trans, repair ? GUILD_BANK_LOG_REPAIR_MONEY : GUILD_BANK_LOG_WITHDRAW_MONEY, uint8(0), player->GetGUID().GetCounter(), amount);
     CharacterDatabase.CommitTransaction(trans);
 
     SendEventBankMoneyChanged();
     return true;
 }

Here is the call graph for this function:

void Guild::HandleNewsSetSticky	(	WorldSession *	session,
		uint32	newsId,
		bool	sticky
	)

 {
     GuildLog* logs = m_newsLog->GetGuildLog();
     GuildLog::iterator itr = logs->begin();
     while (itr != logs->end() && (*itr)->GetGUID() != newsId)
         ++itr;
 
     if (itr == logs->end())
     {
         TC_LOG_DEBUG("guild", "HandleNewsSetSticky: [%s] requested unknown newsId %u - Sticky: %u",
             session->GetPlayerInfo().c_str(), newsId, sticky);
         return;
     }
 
     NewsLogEntry* news = (NewsLogEntry*)(*itr);
     news->SetSticky(sticky);
 
     TC_LOG_DEBUG("guild", "HandleNewsSetSticky: [%s] changed newsId %u sticky to %u",
         session->GetPlayerInfo().c_str(), newsId, sticky);
 
     WorldPackets::Guild::GuildNews newsPacket;
     newsPacket.NewsEvents.reserve(1);
     news->WritePacket(newsPacket);
     session->SendPacket(newsPacket.Write());
 }

Here is the call graph for this function:

void Guild::HandleRemoveMember	(	WorldSession *	session,
		ObjectGuid	guid
	)

 {
     Player* player = session->GetPlayer();
 
     // Player must have rights to remove members
     if (!_HasRankRight(player, GR_RIGHT_REMOVE))
         SendCommandResult(session, GUILD_COMMAND_REMOVE_PLAYER, ERR_GUILD_PERMISSIONS);
     else if (Member* member = GetMember(guid))
     {
         std::string name = member->GetName();
 
         // Guild masters cannot be removed
         if (member->IsRank(GR_GUILDMASTER))
             SendCommandResult(session, GUILD_COMMAND_REMOVE_PLAYER, ERR_GUILD_LEADER_LEAVE);
         // Do not allow to remove player with the same rank or higher
         else
         {
             Member* memberMe = GetMember(player->GetGUID());
             if (!memberMe || member->IsRankNotLower(memberMe->GetRankId()))
                 SendCommandResult(session, GUILD_COMMAND_REMOVE_PLAYER, ERR_GUILD_RANK_TOO_HIGH_S, name);
             else
             {
                 _LogEvent(GUILD_EVENT_LOG_UNINVITE_PLAYER, player->GetGUID().GetCounter(), guid.GetCounter());
                 SendEventPlayerLeft(member, memberMe, true);
 
                 // After call to DeleteMember pointer to member becomes invalid
                 DeleteMember(guid, false, true);
 
                 SendCommandResult(session, GUILD_COMMAND_REMOVE_PLAYER, ERR_GUILD_COMMAND_SUCCESS, name);
             }
         }
     }
 }

Here is the call graph for this function:

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

 {
     // Cannot remove rank if total count is minimum allowed by the client or is not leader
     if (_GetRanksSize() <= GUILD_RANKS_MIN_COUNT || rankId >= _GetRanksSize() || !_IsLeader(session->GetPlayer()))
         return;
 
     // Delete bank rights for rank
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_RIGHTS_FOR_RANK);
     stmt->setUInt64(0, m_id);
     stmt->setUInt8(1, rankId);
     CharacterDatabase.Execute(stmt);
 
     // Delete rank
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_RANK);
     stmt->setUInt64(0, m_id);
     stmt->setUInt8(1, rankId);
     CharacterDatabase.Execute(stmt);
 
     m_ranks.erase(m_ranks.begin() + rankId);
 
     WorldPackets::Guild::GuildEventRanksUpdated eventPacket;
     BroadcastPacket(eventPacket.Write());
 }

Here is the call graph for this function:

void Guild::HandleRoster ( WorldSession * session )

 {
     WorldPackets::Guild::GuildRoster roster;
 
     roster.NumAccounts = int32(m_accountsNumber);
     roster.CreateDate = uint32(m_createdDate);
     roster.GuildFlags = 0;
 
     roster.MemberData.reserve(m_members.size());
 
     for (auto itr : m_members)
     {
         Member* member = itr.second;
 
         WorldPackets::Guild::GuildRosterMemberData memberData;
 
         memberData.Guid = member->GetGUID();
         memberData.RankID = int32(member->GetRankId());
         memberData.AreaID = int32(member->GetZoneId());
         memberData.PersonalAchievementPoints = int32(member->GetAchievementPoints());
         memberData.GuildReputation = int32(member->GetTotalReputation());
         memberData.LastSave = float(member->IsOnline() ? 0.0f : float(::time(NULL) - member->GetLogoutTime()) / DAY);
 
         //GuildRosterProfessionData
 
         memberData.VirtualRealmAddress = GetVirtualRealmAddress();
         memberData.Status = member->GetFlags();
         memberData.Level = member->GetLevel();
         memberData.ClassID = member->GetClass();
         memberData.Gender = member->GetGender();
 
         memberData.Authenticated = false;
         memberData.SorEligible = false;
 
         memberData.Name = member->GetName();
         memberData.Note = member->GetPublicNote();
         memberData.OfficerNote = member->GetOfficerNote();
 
         roster.MemberData.push_back(memberData);
     }
 
     roster.WelcomeText = m_motd;
     roster.InfoText = m_info;
 
     TC_LOG_DEBUG("guild", "SMSG_GUILD_ROSTER [%s]", session->GetPlayerInfo().c_str());
     session->SendPacket(roster.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Guild::HandleSetAchievementTracking	(	WorldSession *	session,
		std::set< uint32 > const &	achievementIds
	)

 {
     Player* player = session->GetPlayer();
 
     if (Member* member = GetMember(player->GetGUID()))
     {
         std::set<uint32> criteriaIds;
 
         for (uint32 achievementId : achievementIds)
         {
             if (AchievementEntry const* achievement = sAchievementMgr->GetAchievement(achievementId))
             {
                 if (AchievementCriteriaTree const* tree = sAchievementMgr->GetAchievementCriteriaTree(achievement->CriteriaTree))
                 {
                     sAchievementMgr->WalkCriteriaTree(tree, [&criteriaIds](AchievementCriteriaTree const* node)
                     {
                         if (node->Criteria)
                             criteriaIds.insert(node->Criteria->ID);
                     });
                 }
             }
         }
 
         member->SetTrackedCriteriaIds(criteriaIds);
         m_achievementMgr.SendAllTrackedCriterias(player, member->GetTrackedCriteriaIds());
     }
 }

Here is the call graph for this function:

void Guild::HandleSetBankTabInfo	(	WorldSession *	session,
		uint8	tabId,
		std::string const &	name,
		std::string const &	icon
	)

 {
     BankTab* tab = GetBankTab(tabId);
     if (!tab)
     {
         TC_LOG_ERROR("guild", "Guild::HandleSetBankTabInfo: Player %s trying to change bank tab info from unexisting tab %d.",
                        session->GetPlayerInfo().c_str(), tabId);
         return;
     }
 
     tab->SetInfo(name, icon);
 
     WorldPackets::Guild::GuildEventTabModified packet;
     packet.Tab = tabId;
     packet.Name = name;
     packet.Icon = icon;
     BroadcastPacket(packet.Write());
 }

Here is the call graph for this function:

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

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

Here is the call graph for this function:

void Guild::HandleSetInfo	(	WorldSession *	session,
		std::string const &	info
	)

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

Here is the call graph for this function:

void Guild::HandleSetMemberNote	(	WorldSession *	session,
		std::string const &	note,
		ObjectGuid	guid,
		bool	isPublic
	)

 {
     // Player must have rights to set public/officer note
     if (!_HasRankRight(session->GetPlayer(), isPublic ? GR_RIGHT_EDIT_PUBLIC_NOTE : GR_RIGHT_EOFFNOTE))
         SendCommandResult(session, GUILD_COMMAND_EDIT_PUBLIC_NOTE, ERR_GUILD_PERMISSIONS);
     else if (Member* member = GetMember(guid))
     {
         if (isPublic)
             member->SetPublicNote(note);
         else
             member->SetOfficerNote(note);
 
         HandleRoster(session); // FIXME - We should send SMSG_GUILD_MEMBER_UPDATE_NOTE
 
         WorldPackets::Guild::GuildMemberUpdateNote updateNote;
         updateNote.Member = guid;
         updateNote.IsPublic = isPublic;
         updateNote.Note = note;
         session->SendPacket(updateNote.Write()); // @todo - Verify receiver of this packet...
     }
 }

Here is the call graph for this function:

void Guild::HandleSetMemberRank	(	WorldSession *	session,
		ObjectGuid	guid,
		ObjectGuid	setterGuid,
		uint32	rank
	)

div class="fragment"> {
     Player* player = session->GetPlayer();
     Member* member = GetMember(targetGuid);
     if (!member)
         return;
     GuildRankRights rights = GR_RIGHT_PROMOTE;
     GuildCommandType type = GUILD_COMMAND_PROMOTE_PLAYER;
 
     if (rank > member->GetRankId())
     {
         rights = GR_RIGHT_DEMOTE;
         type = GUILD_COMMAND_DEMOTE_PLAYER;
     }
 
     // Promoted player must be a member of guild
     if (!_HasRankRight(player, rights))
     {
         SendCommandResult(session, type, ERR_GUILD_PERMISSIONS);
         return;
     }
 
     // Player cannot promote himself
     if (member->IsSamePlayer(player->GetGUID()))
     {
         SendCommandResult(session, type, ERR_GUILD_NAME_INVALID);
         return;
     }
 
     SendGuildRanksUpdate(setterGuid, targetGuid, rank);
 }

Here is the call graph for this function:

void Guild::SendEventNewLeader	(	Member *	newLeader,
		Member *	oldLeader,
		bool	isSelfPromoted = `false`
	)

void Guild::SendEventPlayerLeft	(	Member *	leaver,
		Member *	remover = `nullptr`,
		bool	isRemoved = `false`
	)

void Guild::HandleSetMOTD	(	WorldSession *	session,
		std::string const &	motd
	)

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

void Guild::HandleSetRankInfo	(	WorldSession *	session,
		uint8	rankId,
		std::string const &	name,
		uint32	rights,
		uint32	moneyPerDay,
		GuildBankRightsAndSlotsVec const &	rightsAndSlots
	)

void Guild::HandleUpdateMemberRank	(	WorldSession *	session,
		ObjectGuid	guid,
		bool	demote
	)

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

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

void Guild::SendBankList	(	WorldSession *	session,
		uint8	tabId,
		bool	fullUpdate
	)		const

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

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

void Guild::SendEventMOTD	(	WorldSession *	session,
		bool	broadcast = `false`
	)

void Guild::SendEventPresenceChanged	(	WorldSession *	session,
		bool	loggedOn,
		bool	broadcast = `false`
	)

void Guild::SetBankTabText	(	uint8	tabId,
		std::string const &	text
	)

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

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

void Guild::UpdateAchievementCriteria	(	AchievementCriteriaTypes	type,
		uint64	miscValue1,
		uint64	miscValue2,
		uint64	miscValue3,
		Unit *	unit,
		Player *	player
	)

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

Classes

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation