Merge branch 'master' into 303
[getmangos.git] / src / game / Guild.cpp
blobaf0de3c08d8bcdcce4d7e6fdad99d8eeee3d1e27
1 /*
2 * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #include "Database/DatabaseEnv.h"
20 #include "WorldPacket.h"
21 #include "WorldSession.h"
22 #include "MapManager.h"
23 #include "Player.h"
24 #include "Opcodes.h"
25 #include "ObjectMgr.h"
26 #include "Guild.h"
27 #include "Chat.h"
28 #include "SocialMgr.h"
29 #include "Util.h"
31 Guild::Guild()
33 Id = 0;
34 name = "";
35 leaderGuid = 0;
36 GINFO = MOTD = "";
37 EmblemStyle = 0;
38 EmblemColor = 0;
39 BorderStyle = 0;
40 BorderColor = 0;
41 BackgroundColor = 0;
43 CreatedYear = 0;
44 CreatedMonth = 0;
45 CreatedDay = 0;
48 Guild::~Guild()
53 bool Guild::create(uint64 lGuid, std::string gname)
55 std::string rname;
56 std::string lName;
58 if(!objmgr.GetPlayerNameByGUID(lGuid, lName))
59 return false;
60 if(objmgr.GetGuildByName(gname))
61 return false;
63 sLog.outDebug("GUILD: creating guild %s to leader: %u", gname.c_str(), GUID_LOPART(lGuid));
65 leaderGuid = lGuid;
66 name = gname;
67 GINFO = "";
68 MOTD = "No message set.";
69 guildbank_money = 0;
70 purchased_tabs = 0;
72 Id = objmgr.GenerateGuildId();
74 // gname already assigned to Guild::name, use it to encode string for DB
75 CharacterDatabase.escape_string(gname);
77 std::string dbGINFO = GINFO;
78 std::string dbMOTD = MOTD;
79 CharacterDatabase.escape_string(dbGINFO);
80 CharacterDatabase.escape_string(dbMOTD);
82 CharacterDatabase.BeginTransaction();
83 // CharacterDatabase.PExecute("DELETE FROM guild WHERE guildid='%u'", Id); - MAX(guildid)+1 not exist
84 CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid='%u'", Id);
85 CharacterDatabase.PExecute("DELETE FROM guild_member WHERE guildid='%u'", Id);
86 CharacterDatabase.PExecute("INSERT INTO guild (guildid,name,leaderguid,info,motd,createdate,EmblemStyle,EmblemColor,BorderStyle,BorderColor,BackgroundColor,BankMoney) "
87 "VALUES('%u','%s','%u', '%s', '%s', NOW(),'%u','%u','%u','%u','%u','" I64FMTD "')",
88 Id, gname.c_str(), GUID_LOPART(leaderGuid), dbGINFO.c_str(), dbMOTD.c_str(), EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor, guildbank_money);
89 CharacterDatabase.CommitTransaction();
91 rname = "Guild Master";
92 CreateRank(rname,GR_RIGHT_ALL);
93 rname = "Officer";
94 CreateRank(rname,GR_RIGHT_ALL);
95 rname = "Veteran";
96 CreateRank(rname,GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
97 rname = "Member";
98 CreateRank(rname,GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
99 rname = "Initiate";
100 CreateRank(rname,GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
102 return AddMember(lGuid, (uint32)GR_GUILDMASTER);
105 bool Guild::AddMember(uint64 plGuid, uint32 plRank)
107 Player* pl = objmgr.GetPlayer(plGuid);
108 if(pl)
110 if(pl->GetGuildId() != 0)
111 return false;
113 else
115 if(Player::GetGuildIdFromDB(plGuid) != 0) // player already in guild
116 return false;
119 // remove all player signs from another petitions
120 // this will be prevent attempt joining player to many guilds and corrupt guild data integrity
121 Player::RemovePetitionsAndSigns(plGuid, 9);
123 // fill player data
124 MemberSlot newmember;
126 if(!FillPlayerData(plGuid, &newmember)) // problems with player data collection
127 return false;
129 newmember.RankId = plRank;
130 newmember.OFFnote = (std::string)"";
131 newmember.Pnote = (std::string)"";
132 newmember.logout_time = time(NULL);
133 newmember.BankResetTimeMoney = 0; // this will force update at first query
134 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
135 newmember.BankResetTimeTab[i] = 0;
136 members[GUID_LOPART(plGuid)] = newmember;
138 std::string dbPnote = newmember.Pnote;
139 std::string dbOFFnote = newmember.OFFnote;
140 CharacterDatabase.escape_string(dbPnote);
141 CharacterDatabase.escape_string(dbOFFnote);
143 CharacterDatabase.PExecute("INSERT INTO guild_member (guildid,guid,rank,pnote,offnote) VALUES ('%u', '%u', '%u','%s','%s')",
144 Id, GUID_LOPART(plGuid), newmember.RankId, dbPnote.c_str(), dbOFFnote.c_str());
146 // If player not in game data in data field will be loaded from guild tables, no need to update it!!
147 if(pl)
149 pl->SetInGuild(Id);
150 pl->SetRank(newmember.RankId);
151 pl->SetGuildIdInvited(0);
153 return true;
156 void Guild::SetMOTD(std::string motd)
158 MOTD = motd;
160 // motd now can be used for encoding to DB
161 CharacterDatabase.escape_string(motd);
162 CharacterDatabase.PExecute("UPDATE guild SET motd='%s' WHERE guildid='%u'", motd.c_str(), Id);
165 void Guild::SetGINFO(std::string ginfo)
167 GINFO = ginfo;
169 // ginfo now can be used for encoding to DB
170 CharacterDatabase.escape_string(ginfo);
171 CharacterDatabase.PExecute("UPDATE guild SET info='%s' WHERE guildid='%u'", ginfo.c_str(), Id);
174 bool Guild::LoadGuildFromDB(uint32 GuildId)
176 if(!LoadRanksFromDB(GuildId))
177 return false;
179 if(!LoadMembersFromDB(GuildId))
180 return false;
182 QueryResult *result = CharacterDatabase.PQuery("SELECT MAX(TabId) FROM guild_bank_tab WHERE guildid='%u'", GuildId);
183 if(result)
185 Field *fields = result->Fetch();
186 purchased_tabs = fields[0].GetUInt8()+1; // Because TabId begins at 0
187 delete result;
189 else
190 purchased_tabs = 0;
192 LoadBankRightsFromDB(GuildId); // Must be after LoadRanksFromDB because it populates rank struct
194 // 0 1 2 3 4 5 6
195 result = CharacterDatabase.PQuery("SELECT guildid, name, leaderguid, EmblemStyle, EmblemColor, BorderStyle, BorderColor,"
196 // 7 8 9 10 11
197 "BackgroundColor, info, motd, createdate, BankMoney FROM guild WHERE guildid = '%u'", GuildId);
199 if(!result)
200 return false;
202 Field *fields = result->Fetch();
204 Id = fields[0].GetUInt32();
205 name = fields[1].GetCppString();
206 leaderGuid = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
208 EmblemStyle = fields[3].GetUInt32();
209 EmblemColor = fields[4].GetUInt32();
210 BorderStyle = fields[5].GetUInt32();
211 BorderColor = fields[6].GetUInt32();
212 BackgroundColor = fields[7].GetUInt32();
213 GINFO = fields[8].GetCppString();
214 MOTD = fields[9].GetCppString();
215 uint64 time = fields[10].GetUInt64(); //datetime is uint64 type ... YYYYmmdd:hh:mm:ss
216 guildbank_money = fields[11].GetUInt64();
218 delete result;
220 uint64 dTime = time /1000000;
221 CreatedDay = dTime%100;
222 CreatedMonth = (dTime/100)%100;
223 CreatedYear = (dTime/10000)%10000;
225 // If the leader does not exist attempt to promote another member
226 if(!objmgr.GetPlayerAccountIdByGUID(leaderGuid ))
228 DelMember(leaderGuid);
230 // check no members case (disbanded)
231 if(members.empty())
232 return false;
235 sLog.outDebug("Guild %u Creation time Loaded day: %u, month: %u, year: %u", GuildId, CreatedDay, CreatedMonth, CreatedYear);
236 m_bankloaded = false;
237 m_eventlogloaded = false;
238 m_onlinemembers = 0;
239 RenumBankLogs();
240 RenumGuildEventlog();
241 return true;
244 bool Guild::LoadRanksFromDB(uint32 GuildId)
246 Field *fields;
247 QueryResult *result = CharacterDatabase.PQuery("SELECT rname,rights,BankMoneyPerDay,rid FROM guild_rank WHERE guildid = '%u' ORDER BY rid ASC", GuildId);
249 if(!result)
250 return false;
252 bool broken_ranks = false;
256 fields = result->Fetch();
258 std::string rankName = fields[0].GetCppString();
259 uint32 rankRights = fields[1].GetUInt32();
260 uint32 rankMoney = fields[2].GetUInt32();
261 uint32 rankRID = fields[3].GetUInt32();
263 if(rankRID != m_ranks.size()+1) // guild_rank.rid always store rank+1
264 broken_ranks = true;
266 if(m_ranks.size()==GR_GUILDMASTER) // prevent loss leader rights
267 rankRights |= GR_RIGHT_ALL;
269 AddRank(rankName,rankRights,rankMoney);
270 }while( result->NextRow() );
271 delete result;
273 if(m_ranks.size()==0) // empty rank table?
275 AddRank("Guild Master",GR_RIGHT_ALL,0);
276 broken_ranks = true;
279 // guild_rank have wrong numbered ranks, repair
280 if(broken_ranks)
282 sLog.outError("Guild %u have broken `guild_rank` data, repairing...",GuildId);
283 CharacterDatabase.BeginTransaction();
284 CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid='%u'", GuildId);
285 for(size_t i =0; i < m_ranks.size(); ++i)
287 // guild_rank.rid always store rank+1
288 std::string name = m_ranks[i].name;
289 uint32 rights = m_ranks[i].rights;
290 CharacterDatabase.escape_string(name);
291 CharacterDatabase.PExecute( "INSERT INTO guild_rank (guildid,rid,rname,rights) VALUES ('%u', '%u', '%s', '%u')", GuildId, i+1, name.c_str(), rights);
293 CharacterDatabase.CommitTransaction();
296 return true;
299 bool Guild::LoadMembersFromDB(uint32 GuildId)
301 // 0 1 2 3 4 5
302 QueryResult *result = CharacterDatabase.PQuery("SELECT guild_member.guid,rank, pnote, offnote, BankResetTimeMoney,BankRemMoney,"
303 // 6 7 8 9 10 11
304 "BankResetTimeTab0, BankRemSlotsTab0, BankResetTimeTab1, BankRemSlotsTab1, BankResetTimeTab2, BankRemSlotsTab2,"
305 // 12 13 14 15 16 17
306 "BankResetTimeTab3, BankRemSlotsTab3, BankResetTimeTab4, BankRemSlotsTab4, BankResetTimeTab5, BankRemSlotsTab5,"
307 // 18
308 "logout_time FROM guild_member LEFT JOIN characters ON characters.guid = guild_member.guid WHERE guildid = '%u'", GuildId);
310 if(!result)
311 return false;
315 Field *fields = result->Fetch();
316 MemberSlot newmember;
317 newmember.RankId = fields[1].GetUInt32();
318 uint64 guid = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER);
320 // Player does not exist
321 if(!FillPlayerData(guid, &newmember))
322 continue;
324 newmember.Pnote = fields[2].GetCppString();
325 newmember.OFFnote = fields[3].GetCppString();
326 newmember.BankResetTimeMoney = fields[4].GetUInt32();
327 newmember.BankRemMoney = fields[5].GetUInt32();
328 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
330 newmember.BankResetTimeTab[i] = fields[6+(2*i)].GetUInt32();
331 newmember.BankRemSlotsTab[i] = fields[7+(2*i)].GetUInt32();
333 newmember.logout_time = fields[18].GetUInt64();
334 members[GUID_LOPART(guid)] = newmember;
336 }while( result->NextRow() );
337 delete result;
339 if(members.empty())
340 return false;
342 return true;
345 bool Guild::FillPlayerData(uint64 guid, MemberSlot* memslot)
347 std::string plName;
348 uint32 plLevel;
349 uint32 plClass;
350 uint32 plZone;
352 Player* pl = objmgr.GetPlayer(guid);
353 if(pl)
355 plName = pl->GetName();
356 plLevel = pl->getLevel();
357 plClass = pl->getClass();
358 plZone = pl->GetZoneId();
360 else
362 if(!objmgr.GetPlayerNameByGUID(guid, plName)) // player doesn't exist
363 return false;
365 plLevel = Player::GetUInt32ValueFromDB(UNIT_FIELD_LEVEL, guid);
366 if(plLevel<1||plLevel>255) // can be at broken `data` field
368 sLog.outError("Player (GUID: %u) has a broken data in field `characters`.`data`.",GUID_LOPART(guid));
369 return false;
371 plZone = Player::GetZoneIdFromDB(guid);
373 QueryResult *result = CharacterDatabase.PQuery("SELECT class FROM characters WHERE guid='%u'", GUID_LOPART(guid));
374 if(!result)
375 return false;
376 plClass = (*result)[0].GetUInt32();
377 if(plClass<CLASS_WARRIOR||plClass>=MAX_CLASSES) // can be at broken `class` field
379 sLog.outError("Player (GUID: %u) has a broken data in field `characters`.`class`.",GUID_LOPART(guid));
380 return false;
383 delete result;
386 memslot->name = plName;
387 memslot->level = plLevel;
388 memslot->Class = plClass;
389 memslot->zoneId = plZone;
391 return(true);
394 void Guild::LoadPlayerStatsByGuid(uint64 guid)
396 MemberList::iterator itr = members.find(GUID_LOPART(guid));
397 if (itr == members.end() )
398 return;
400 Player *pl = ObjectAccessor::FindPlayer(guid);
401 if(!pl)
402 return;
403 itr->second.name = pl->GetName();
404 itr->second.level = pl->getLevel();
405 itr->second.Class = pl->getClass();
408 void Guild::SetLeader(uint64 guid)
410 leaderGuid = guid;
411 ChangeRank(guid, GR_GUILDMASTER);
413 CharacterDatabase.PExecute("UPDATE guild SET leaderguid='%u' WHERE guildid='%u'", GUID_LOPART(guid), Id);
416 void Guild::DelMember(uint64 guid, bool isDisbanding)
418 if(leaderGuid == guid && !isDisbanding)
420 QueryResult *result = CharacterDatabase.PQuery("SELECT guid FROM guild_member WHERE guildid='%u' AND guid != '%u' ORDER BY rank ASC LIMIT 1", Id, GUID_LOPART(leaderGuid));
421 if( result )
423 uint64 newLeaderGUID;
424 Player *newLeader;
425 std::string newLeaderName, oldLeaderName;
427 newLeaderGUID = (*result)[0].GetUInt64();
428 delete result;
430 SetLeader(newLeaderGUID);
432 newLeader = objmgr.GetPlayer(newLeaderGUID);
434 // If player not online data in data field will be loaded from guild tabs no need to update it !!
435 if(newLeader)
437 newLeader->SetRank(GR_GUILDMASTER);
438 newLeaderName = newLeader->GetName();
440 else
441 objmgr.GetPlayerNameByGUID(newLeaderGUID, newLeaderName);
443 // when leader non-exist (at guild load with deleted leader only) not send broadcasts
444 if(objmgr.GetPlayerNameByGUID(guid, oldLeaderName))
446 WorldPacket data(SMSG_GUILD_EVENT, (1+1+oldLeaderName.size()+1+newLeaderName.size()+1));
447 data << (uint8)GE_LEADER_CHANGED;
448 data << (uint8)2;
449 data << oldLeaderName;
450 data << newLeaderName;
451 BroadcastPacket(&data);
453 data.Initialize(SMSG_GUILD_EVENT, (1+1+oldLeaderName.size()+1));
454 data << (uint8)GE_LEFT;
455 data << (uint8)1;
456 data << oldLeaderName;
457 BroadcastPacket(&data);
460 sLog.outDebug( "WORLD: Sent (SMSG_GUILD_EVENT)" );
462 else
464 Disband();
465 return;
469 members.erase(GUID_LOPART(guid));
471 Player *player = objmgr.GetPlayer(guid);
472 // If player not online data in data field will be loaded from guild tabs no need to update it !!
473 if(player)
475 player->SetInGuild(0);
476 player->SetRank(0);
479 CharacterDatabase.PExecute("DELETE FROM guild_member WHERE guid = '%u'", GUID_LOPART(guid));
482 void Guild::ChangeRank(uint64 guid, uint32 newRank)
484 MemberList::iterator itr = members.find(GUID_LOPART(guid));
485 if( itr != members.end() )
486 itr->second.RankId = newRank;
488 Player *player = objmgr.GetPlayer(guid);
489 // If player not online data in data field will be loaded from guild tabs no need to update it !!
490 if(player)
491 player->SetRank(newRank);
493 CharacterDatabase.PExecute( "UPDATE guild_member SET rank='%u' WHERE guid='%u'", newRank, GUID_LOPART(guid) );
496 void Guild::SetPNOTE(uint64 guid,std::string pnote)
498 MemberList::iterator itr = members.find(GUID_LOPART(guid));
499 if( itr == members.end() )
500 return;
502 itr->second.Pnote = pnote;
504 // pnote now can be used for encoding to DB
505 CharacterDatabase.escape_string(pnote);
506 CharacterDatabase.PExecute("UPDATE guild_member SET pnote = '%s' WHERE guid = '%u'", pnote.c_str(), itr->first);
509 void Guild::SetOFFNOTE(uint64 guid,std::string offnote)
511 MemberList::iterator itr = members.find(GUID_LOPART(guid));
512 if( itr == members.end() )
513 return;
514 itr->second.OFFnote = offnote;
515 // offnote now can be used for encoding to DB
516 CharacterDatabase.escape_string(offnote);
517 CharacterDatabase.PExecute("UPDATE guild_member SET offnote = '%s' WHERE guid = '%u'", offnote.c_str(), itr->first);
520 void Guild::BroadcastToGuild(WorldSession *session, std::string msg, uint32 language)
522 if (session && session->GetPlayer() && HasRankRight(session->GetPlayer()->GetRank(),GR_RIGHT_GCHATSPEAK))
524 WorldPacket data;
525 ChatHandler(session).FillMessageData(&data, CHAT_MSG_GUILD, language, 0, msg.c_str());
527 for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
529 Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
531 if (pl && pl->GetSession() && HasRankRight(pl->GetRank(),GR_RIGHT_GCHATLISTEN) && !pl->GetSocial()->HasIgnore(session->GetPlayer()->GetGUIDLow()) )
532 pl->GetSession()->SendPacket(&data);
537 void Guild::BroadcastToOfficers(WorldSession *session, std::string msg, uint32 language)
539 if (session && session->GetPlayer() && HasRankRight(session->GetPlayer()->GetRank(),GR_RIGHT_OFFCHATSPEAK))
541 for(MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
543 WorldPacket data;
544 ChatHandler::FillMessageData(&data, session, CHAT_MSG_OFFICER, language, NULL, 0, msg.c_str(),NULL);
546 Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
548 if (pl && pl->GetSession() && HasRankRight(pl->GetRank(),GR_RIGHT_OFFCHATLISTEN) && !pl->GetSocial()->HasIgnore(session->GetPlayer()->GetGUIDLow()))
549 pl->GetSession()->SendPacket(&data);
554 void Guild::BroadcastPacket(WorldPacket *packet)
556 for(MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
558 Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
559 if(player)
560 player->GetSession()->SendPacket(packet);
564 void Guild::BroadcastPacketToRank(WorldPacket *packet, uint32 rankId)
566 for(MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
568 if (itr->second.RankId == rankId)
570 Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
571 if(player)
572 player->GetSession()->SendPacket(packet);
577 void Guild::CreateRank(std::string name_,uint32 rights)
579 if(m_ranks.size() >= GUILD_MAX_RANKS)
580 return;
582 AddRank(name_,rights,0);
584 for (int i = 0; i < purchased_tabs; ++i)
586 CreateBankRightForTab(m_ranks.size()-1, uint8(i));
589 // guild_rank.rid always store rank+1 value
591 // name now can be used for encoding to DB
592 CharacterDatabase.escape_string(name_);
593 CharacterDatabase.PExecute( "INSERT INTO guild_rank (guildid,rid,rname,rights) VALUES ('%u', '%u', '%s', '%u')", Id, m_ranks.size(), name_.c_str(), rights );
596 void Guild::AddRank(std::string name_,uint32 rights, uint32 money)
598 m_ranks.push_back(RankInfo(name_,rights,money));
601 void Guild::DelRank()
603 if(m_ranks.empty())
604 return;
606 // guild_rank.rid always store rank+1 value
607 uint32 rank = m_ranks.size()-1;
608 CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE rid>='%u' AND guildid='%u'", (rank+1), Id);
610 m_ranks.pop_back();
613 std::string Guild::GetRankName(uint32 rankId)
615 if(rankId >= m_ranks.size())
616 return "<unknown>";
618 return m_ranks[rankId].name;
621 uint32 Guild::GetRankRights(uint32 rankId)
623 if(rankId >= m_ranks.size())
624 return 0;
626 return m_ranks[rankId].rights;
629 void Guild::SetRankName(uint32 rankId, std::string name_)
631 if(rankId >= m_ranks.size())
632 return;
634 m_ranks[rankId].name = name_;
636 // name now can be used for encoding to DB
637 CharacterDatabase.escape_string(name_);
638 CharacterDatabase.PExecute("UPDATE guild_rank SET rname='%s' WHERE rid='%u' AND guildid='%u'", name_.c_str(), (rankId+1), Id);
641 void Guild::SetRankRights(uint32 rankId, uint32 rights)
643 if(rankId >= m_ranks.size())
644 return;
646 m_ranks[rankId].rights = rights;
648 CharacterDatabase.PExecute("UPDATE guild_rank SET rights='%u' WHERE rid='%u' AND guildid='%u'", rights, (rankId+1), Id);
651 int32 Guild::GetRank(uint32 LowGuid)
653 MemberList::iterator itr = members.find(LowGuid);
654 if (itr==members.end())
655 return -1;
657 return itr->second.RankId;
660 void Guild::Disband()
662 WorldPacket data(SMSG_GUILD_EVENT, 1);
663 data << (uint8)GE_DISBANDED;
664 BroadcastPacket(&data);
666 while (!members.empty())
668 MemberList::iterator itr = members.begin();
669 DelMember(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER), true);
672 CharacterDatabase.BeginTransaction();
673 CharacterDatabase.PExecute("DELETE FROM guild WHERE guildid = '%u'",Id);
674 CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid = '%u'",Id);
675 CharacterDatabase.PExecute("DELETE FROM guild_bank_tab WHERE guildid = '%u'",Id);
676 CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid = '%u'",Id);
677 CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid = '%u'",Id);
678 CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid = '%u'",Id);
679 CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid = '%u'",Id);
680 CharacterDatabase.CommitTransaction();
681 objmgr.RemoveGuild(this);
684 void Guild::Roster(WorldSession *session)
686 // we can only guess size
687 WorldPacket data(SMSG_GUILD_ROSTER, (4+MOTD.length()+1+GINFO.length()+1+4+m_ranks.size()*(4+4+GUILD_BANK_MAX_TABS*(4+4))+members.size()*50));
688 data << (uint32)members.size();
689 data << MOTD;
690 data << GINFO;
692 data << (uint32)m_ranks.size();
693 for (RankList::iterator ritr = m_ranks.begin(); ritr != m_ranks.end();++ritr)
695 data << (uint32)ritr->rights;
696 data << (uint32)ritr->BankMoneyPerDay; // count of: withdraw gold(gold/day) Note: in game set gold, in packet set bronze.
697 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
699 data << (uint32)ritr->TabRight[i]; // for TAB_i rights: view tabs = 0x01, deposit items =0x02
700 data << (uint32)ritr->TabSlotPerDay[i]; // for TAB_i count of: withdraw items(stack/day)
703 for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
705 if (Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER)))
707 data << (uint64)pl->GetGUID();
708 data << (uint8)1;
709 data << (std::string)pl->GetName();
710 data << (uint32)itr->second.RankId;
711 data << (uint8)pl->getLevel();
712 data << (uint8)pl->getClass();
713 data << (uint8)0; // new 2.4.0
714 data << (uint32)pl->GetZoneId();
715 data << itr->second.Pnote;
716 data << itr->second.OFFnote;
718 else
720 data << uint64(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
721 data << (uint8)0;
722 data << itr->second.name;
723 data << (uint32)itr->second.RankId;
724 data << (uint8)itr->second.level;
725 data << (uint8)itr->second.Class;
726 data << (uint8)0; // new 2.4.0
727 data << (uint32)itr->second.zoneId;
728 data << (float(time(NULL)-itr->second.logout_time) / DAY);
729 data << itr->second.Pnote;
730 data << itr->second.OFFnote;
733 session->SendPacket(&data);;
734 sLog.outDebug( "WORLD: Sent (SMSG_GUILD_ROSTER)" );
737 void Guild::Query(WorldSession *session)
739 WorldPacket data(SMSG_GUILD_QUERY_RESPONSE, (8*32+200));// we can only guess size
741 data << Id;
742 data << name;
743 RankList::iterator itr;
744 for (size_t i = 0 ; i < 10; ++i) // show always 10 ranks
746 if(i < m_ranks.size())
747 data << m_ranks[i].name;
748 else
749 data << (uint8)0; // null string
752 data << uint32(EmblemStyle);
753 data << uint32(EmblemColor);
754 data << uint32(BorderStyle);
755 data << uint32(BorderColor);
756 data << uint32(BackgroundColor);
757 data << uint32(0); // something new in WotLK
759 session->SendPacket( &data );
760 sLog.outDebug( "WORLD: Sent (SMSG_GUILD_QUERY_RESPONSE)" );
763 void Guild::SetEmblem(uint32 emblemStyle, uint32 emblemColor, uint32 borderStyle, uint32 borderColor, uint32 backgroundColor)
765 EmblemStyle = emblemStyle;
766 EmblemColor = emblemColor;
767 BorderStyle = borderStyle;
768 BorderColor = borderColor;
769 BackgroundColor = backgroundColor;
771 CharacterDatabase.PExecute("UPDATE guild SET EmblemStyle=%u, EmblemColor=%u, BorderStyle=%u, BorderColor=%u, BackgroundColor=%u WHERE guildid = %u", EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor, Id);
774 void Guild::UpdateLogoutTime(uint64 guid)
776 MemberList::iterator itr = members.find(GUID_LOPART(guid));
777 if (itr == members.end() )
778 return;
780 itr->second.logout_time = time(NULL);
782 if (m_onlinemembers > 0)
783 --m_onlinemembers;
784 else
786 UnloadGuildBank();
787 UnloadGuildEventlog();
791 // *************************************************
792 // Guild Eventlog part
793 // *************************************************
794 // Display guild eventlog
795 void Guild::DisplayGuildEventlog(WorldSession *session)
797 // Load guild eventlog, if not already done
798 if (!m_eventlogloaded)
799 LoadGuildEventLogFromDB();
801 // Sending result
802 WorldPacket data(MSG_GUILD_EVENT_LOG_QUERY, 0);
803 // count, max count == 100
804 data << uint8(m_GuildEventlog.size());
805 for (GuildEventlog::const_iterator itr = m_GuildEventlog.begin(); itr != m_GuildEventlog.end(); ++itr)
807 // Event type
808 data << uint8((*itr)->EventType);
809 // Player 1
810 data << uint64((*itr)->PlayerGuid1);
811 // Player 2 not for left/join guild events
812 if( (*itr)->EventType != GUILD_EVENT_LOG_JOIN_GUILD && (*itr)->EventType != GUILD_EVENT_LOG_LEAVE_GUILD )
813 data << uint64((*itr)->PlayerGuid2);
814 // New Rank - only for promote/demote guild events
815 if( (*itr)->EventType == GUILD_EVENT_LOG_PROMOTE_PLAYER || (*itr)->EventType == GUILD_EVENT_LOG_DEMOTE_PLAYER )
816 data << uint8((*itr)->NewRank);
817 // Event timestamp
818 data << uint32(time(NULL)-(*itr)->TimeStamp);
820 session->SendPacket(&data);
821 sLog.outDebug("WORLD: Sent (MSG_GUILD_EVENT_LOG_QUERY)");
824 // Load guild eventlog from DB
825 void Guild::LoadGuildEventLogFromDB()
827 // Return if already loaded
828 if (m_eventlogloaded)
829 return;
831 QueryResult *result = CharacterDatabase.PQuery("SELECT LogGuid, EventType, PlayerGuid1, PlayerGuid2, NewRank, TimeStamp FROM guild_eventlog WHERE guildid=%u ORDER BY LogGuid DESC LIMIT %u", Id, GUILD_EVENTLOG_MAX_ENTRIES);
832 if(!result)
833 return;
836 Field *fields = result->Fetch();
837 GuildEventlogEntry *NewEvent = new GuildEventlogEntry;
838 // Fill entry
839 NewEvent->LogGuid = fields[0].GetUInt32();
840 NewEvent->EventType = fields[1].GetUInt8();
841 NewEvent->PlayerGuid1 = fields[2].GetUInt32();
842 NewEvent->PlayerGuid2 = fields[3].GetUInt32();
843 NewEvent->NewRank = fields[4].GetUInt8();
844 NewEvent->TimeStamp = fields[5].GetUInt64();
845 // Add entry to map
846 m_GuildEventlog.push_front(NewEvent);
848 } while( result->NextRow() );
849 delete result;
851 // Check lists size in case to many event entries in db
852 // This cases can happen only if a crash occured somewhere and table has too many log entries
853 if (!m_GuildEventlog.empty())
855 CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid=%u AND LogGuid < %u", Id, m_GuildEventlog.front()->LogGuid);
857 m_eventlogloaded = true;
860 // Unload guild eventlog
861 void Guild::UnloadGuildEventlog()
863 if (!m_eventlogloaded)
864 return;
865 GuildEventlogEntry *EventLogEntry;
866 if( !m_GuildEventlog.empty() )
870 EventLogEntry = *(m_GuildEventlog.begin());
871 m_GuildEventlog.pop_front();
872 delete EventLogEntry;
873 }while( !m_GuildEventlog.empty() );
875 m_eventlogloaded = false;
878 // This will renum guids used at load to prevent always going up until infinit
879 void Guild::RenumGuildEventlog()
881 QueryResult *result = CharacterDatabase.PQuery("SELECT Min(LogGuid), Max(LogGuid) FROM guild_eventlog WHERE guildid = %u", Id);
882 if(!result)
883 return;
885 Field *fields = result->Fetch();
886 CharacterDatabase.PExecute("UPDATE guild_eventlog SET LogGuid=LogGuid-%u+1 WHERE guildid=%u ORDER BY LogGuid %s",fields[0].GetUInt32(), Id, fields[0].GetUInt32()?"ASC":"DESC");
887 GuildEventlogMaxGuid = fields[1].GetUInt32()+1;
888 delete result;
891 // Add entry to guild eventlog
892 void Guild::LogGuildEvent(uint8 EventType, uint32 PlayerGuid1, uint32 PlayerGuid2, uint8 NewRank)
894 GuildEventlogEntry *NewEvent = new GuildEventlogEntry;
895 // Fill entry
896 NewEvent->LogGuid = GuildEventlogMaxGuid++;
897 NewEvent->EventType = EventType;
898 NewEvent->PlayerGuid1 = PlayerGuid1;
899 NewEvent->PlayerGuid2 = PlayerGuid2;
900 NewEvent->NewRank = NewRank;
901 NewEvent->TimeStamp = uint32(time(NULL));
902 // Check max entry limit and delete from db if needed
903 if (m_GuildEventlog.size() > GUILD_EVENTLOG_MAX_ENTRIES)
905 GuildEventlogEntry *OldEvent = *(m_GuildEventlog.begin());
906 m_GuildEventlog.pop_front();
907 CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
908 delete OldEvent;
910 // Add entry to map
911 m_GuildEventlog.push_back(NewEvent);
912 // Add new eventlog entry into DB
913 CharacterDatabase.PExecute("INSERT INTO guild_eventlog (guildid, LogGuid, EventType, PlayerGuid1, PlayerGuid2, NewRank, TimeStamp) VALUES ('%u','%u','%u','%u','%u','%u','" I64FMTD "')",
914 Id, NewEvent->LogGuid, uint32(NewEvent->EventType), NewEvent->PlayerGuid1, NewEvent->PlayerGuid2, uint32(NewEvent->NewRank), NewEvent->TimeStamp);
917 // *************************************************
918 // Guild Bank part
919 // *************************************************
920 // Bank content related
921 void Guild::DisplayGuildBankContent(WorldSession *session, uint8 TabId)
923 WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
925 GuildBankTab const* tab = GetBankTab(TabId);
926 if (!tab)
927 return;
929 if(!IsMemberHaveRights(session->GetPlayer()->GetGUIDLow(),TabId,GUILD_BANK_RIGHT_VIEW_TAB))
930 return;
932 data << uint64(GetGuildBankMoney());
933 data << uint8(TabId);
934 // remaining slots for today
935 data << uint32(GetMemberSlotWithdrawRem(session->GetPlayer()->GetGUIDLow(), TabId));
936 data << uint8(0); // Tell client this is a tab content packet
938 data << uint8(GUILD_BANK_MAX_SLOTS);
940 for (int i=0; i<GUILD_BANK_MAX_SLOTS; ++i)
941 AppendDisplayGuildBankSlot(data, tab, i);
943 session->SendPacket(&data);
945 sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
948 void Guild::DisplayGuildBankMoneyUpdate()
950 WorldPacket data(SMSG_GUILD_BANK_LIST, 8+1+4+1+1);
952 data << uint64(GetGuildBankMoney());
953 data << uint8(0); // TabId, default 0
954 data << uint32(0); // slot withdrow, default 0
955 data << uint8(0); // Tell client this is a tab content packet
956 data << uint8(0); // not send items
957 BroadcastPacket(&data);
959 sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
962 void Guild::DisplayGuildBankContentUpdate(uint8 TabId, int32 slot1, int32 slot2)
964 GuildBankTab const* tab = GetBankTab(TabId);
965 if (!tab)
966 return;
968 WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
970 data << uint64(GetGuildBankMoney());
971 data << uint8(TabId);
972 // remaining slots for today
974 size_t rempos = data.wpos();
975 data << uint32(0); // will be filled later
976 data << uint8(0); // Tell client this is a tab content packet
978 if(slot2==-1) // single item in slot1
980 data << uint8(1);
982 AppendDisplayGuildBankSlot(data, tab, slot1);
984 else // 2 items (in slot1 and slot2)
986 data << uint8(2);
988 if(slot1 > slot2)
989 std::swap(slot1,slot2);
991 AppendDisplayGuildBankSlot(data, tab, slot1);
992 AppendDisplayGuildBankSlot(data, tab, slot2);
995 for(MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
997 Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
998 if(!player)
999 continue;
1001 if(!IsMemberHaveRights(itr->first,TabId,GUILD_BANK_RIGHT_VIEW_TAB))
1002 continue;
1004 data.put<uint32>(rempos,uint32(GetMemberSlotWithdrawRem(player->GetGUIDLow(), TabId)));
1006 player->GetSession()->SendPacket(&data);
1009 sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1012 void Guild::DisplayGuildBankContentUpdate(uint8 TabId, GuildItemPosCountVec const& slots)
1014 GuildBankTab const* tab = GetBankTab(TabId);
1015 if (!tab)
1016 return;
1018 WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
1020 data << uint64(GetGuildBankMoney());
1021 data << uint8(TabId);
1022 // remaining slots for today
1024 size_t rempos = data.wpos();
1025 data << uint32(0); // will be filled later
1026 data << uint8(0); // Tell client this is a tab content packet
1028 data << uint8(slots.size()); // updates count
1030 for(GuildItemPosCountVec::const_iterator itr = slots.begin(); itr != slots.end(); ++itr)
1031 AppendDisplayGuildBankSlot(data, tab, itr->slot);
1033 for(MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
1035 Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
1036 if(!player)
1037 continue;
1039 if(!IsMemberHaveRights(itr->first,TabId,GUILD_BANK_RIGHT_VIEW_TAB))
1040 continue;
1042 data.put<uint32>(rempos,uint32(GetMemberSlotWithdrawRem(player->GetGUIDLow(), TabId)));
1044 player->GetSession()->SendPacket(&data);
1047 sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1050 Item* Guild::GetItem(uint8 TabId, uint8 SlotId)
1052 if (TabId >= m_TabListMap.size() || SlotId >= GUILD_BANK_MAX_SLOTS)
1053 return NULL;
1054 return m_TabListMap[TabId]->Slots[SlotId];
1057 // *************************************************
1058 // Tab related
1060 void Guild::DisplayGuildBankTabsInfo(WorldSession *session)
1062 // Time to load bank if not already done
1063 if (!m_bankloaded)
1064 LoadGuildBankFromDB();
1066 WorldPacket data(SMSG_GUILD_BANK_LIST, 500);
1068 data << uint64(GetGuildBankMoney());
1069 data << uint8(0); // TabInfo packet must be for TabId 0
1070 data << uint32(0xFFFFFFFF); // bit 9 must be set for this packet to work
1071 data << uint8(1); // Tell Client this is a TabInfo packet
1073 data << uint8(purchased_tabs); // here is the number of tabs
1075 for(int i = 0; i < purchased_tabs; ++i)
1077 data << m_TabListMap[i]->Name.c_str();
1078 data << m_TabListMap[i]->Icon.c_str();
1080 data << uint8(0); // Do not send tab content
1081 session->SendPacket(&data);
1083 sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1086 void Guild::CreateNewBankTab()
1088 if (purchased_tabs >= GUILD_BANK_MAX_TABS)
1089 return;
1091 ++purchased_tabs;
1093 GuildBankTab* AnotherTab = new GuildBankTab;
1094 memset(AnotherTab->Slots, 0, GUILD_BANK_MAX_SLOTS * sizeof(Item*));
1095 m_TabListMap.resize(purchased_tabs);
1096 m_TabListMap[purchased_tabs-1] = AnotherTab;
1098 CharacterDatabase.BeginTransaction();
1099 CharacterDatabase.PExecute("DELETE FROM guild_bank_tab WHERE guildid='%u' AND TabId='%u'", Id, uint32(purchased_tabs-1));
1100 CharacterDatabase.PExecute("INSERT INTO guild_bank_tab (guildid,TabId) VALUES ('%u','%u')", Id, uint32(purchased_tabs-1));
1101 CharacterDatabase.CommitTransaction();
1104 void Guild::SetGuildBankTabInfo(uint8 TabId, std::string Name, std::string Icon)
1106 if (TabId >= GUILD_BANK_MAX_TABS)
1107 return;
1108 if (TabId >= m_TabListMap.size())
1109 return;
1111 if (!m_TabListMap[TabId])
1112 return;
1114 if(m_TabListMap[TabId]->Name == Name && m_TabListMap[TabId]->Icon == Icon)
1115 return;
1117 m_TabListMap[TabId]->Name = Name;
1118 m_TabListMap[TabId]->Icon = Icon;
1120 CharacterDatabase.escape_string(Name);
1121 CharacterDatabase.escape_string(Icon);
1122 CharacterDatabase.PExecute("UPDATE guild_bank_tab SET TabName='%s',TabIcon='%s' WHERE guildid='%u' AND TabId='%u'", Name.c_str(), Icon.c_str(), Id, uint32(TabId));
1125 void Guild::CreateBankRightForTab(uint32 rankId, uint8 TabId)
1127 sLog.outDebug("CreateBankRightForTab. rank: %u, TabId: %u", rankId, uint32(TabId));
1128 if (rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1129 return;
1131 m_ranks[rankId].TabRight[TabId]=0;
1132 m_ranks[rankId].TabSlotPerDay[TabId]=0;
1133 CharacterDatabase.BeginTransaction();
1134 CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid = '%u' AND TabId = '%u' AND rid = '%u'", Id, uint32(TabId), rankId);
1135 CharacterDatabase.PExecute("INSERT INTO guild_bank_right (guildid,TabId,rid) VALUES ('%u','%u','%u')", Id, uint32(TabId), rankId);
1136 CharacterDatabase.CommitTransaction();
1139 uint32 Guild::GetBankRights(uint32 rankId, uint8 TabId) const
1141 if(rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1142 return 0;
1144 return m_ranks[rankId].TabRight[TabId];
1147 // *************************************************
1148 // Guild bank loading/unloading related
1150 // This load should be called when the bank is first accessed by a guild member
1151 void Guild::LoadGuildBankFromDB()
1153 if (m_bankloaded)
1154 return;
1156 m_bankloaded = true;
1157 LoadGuildBankEventLogFromDB();
1159 // 0 1 2 3
1160 QueryResult *result = CharacterDatabase.PQuery("SELECT TabId, TabName, TabIcon, TabText FROM guild_bank_tab WHERE guildid='%u' ORDER BY TabId", Id);
1161 if(!result)
1163 purchased_tabs = 0;
1164 return;
1167 m_TabListMap.resize(purchased_tabs);
1170 Field *fields = result->Fetch();
1171 uint8 TabId = fields[0].GetUInt8();
1173 GuildBankTab *NewTab = new GuildBankTab;
1174 memset(NewTab->Slots, 0, GUILD_BANK_MAX_SLOTS * sizeof(Item*));
1176 NewTab->Name = fields[1].GetCppString();
1177 NewTab->Icon = fields[2].GetCppString();
1178 NewTab->Text = fields[3].GetCppString();
1180 m_TabListMap[TabId] = NewTab;
1181 }while( result->NextRow() );
1183 delete result;
1185 // 0 1 2 3
1186 result = CharacterDatabase.PQuery("SELECT TabId, SlotId, item_guid, item_entry FROM guild_bank_item WHERE guildid='%u' ORDER BY TabId", Id);
1187 if(!result)
1188 return;
1192 Field *fields = result->Fetch();
1193 uint8 TabId = fields[0].GetUInt8();
1194 uint8 SlotId = fields[1].GetUInt8();
1195 uint32 ItemGuid = fields[2].GetUInt32();
1196 uint32 ItemEntry = fields[3].GetUInt32();
1198 if (TabId >= purchased_tabs || TabId >= GUILD_BANK_MAX_TABS)
1200 sLog.outError( "Guild::LoadGuildBankFromDB: Invalid tab for item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1201 continue;
1204 if (SlotId >= GUILD_BANK_MAX_SLOTS)
1206 sLog.outError( "Guild::LoadGuildBankFromDB: Invalid slot for item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1207 continue;
1210 ItemPrototype const *proto = objmgr.GetItemPrototype(ItemEntry);
1212 if(!proto)
1214 sLog.outError( "Guild::LoadGuildBankFromDB: Unknown item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1215 continue;
1218 Item *pItem = NewItemOrBag(proto);
1219 if(!pItem->LoadFromDB(ItemGuid, 0))
1221 CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid='%u' AND TabId='%u' AND SlotId='%u'", Id, uint32(TabId), uint32(SlotId));
1222 sLog.outError("Item GUID %u not found in item_instance, deleting from Guild Bank!", ItemGuid);
1223 delete pItem;
1224 continue;
1227 pItem->AddToWorld();
1228 m_TabListMap[TabId]->Slots[SlotId] = pItem;
1229 }while( result->NextRow() );
1231 delete result;
1234 // This unload should be called when the last member of the guild gets offline
1235 void Guild::UnloadGuildBank()
1237 if (!m_bankloaded)
1238 return;
1239 for (uint8 i = 0 ; i < purchased_tabs ; ++i )
1241 for (uint8 j = 0 ; j < GUILD_BANK_MAX_SLOTS ; ++j)
1243 if (m_TabListMap[i]->Slots[j])
1245 m_TabListMap[i]->Slots[j]->RemoveFromWorld();
1246 delete m_TabListMap[i]->Slots[j];
1249 delete m_TabListMap[i];
1251 m_TabListMap.clear();
1253 UnloadGuildBankEventLog();
1254 m_bankloaded = false;
1257 // *************************************************
1258 // Money deposit/withdraw related
1260 void Guild::SendMoneyInfo(WorldSession *session, uint32 LowGuid)
1262 WorldPacket data(MSG_GUILD_BANK_MONEY_WITHDRAWN, 4);
1263 data << uint32(GetMemberMoneyWithdrawRem(LowGuid));
1264 session->SendPacket(&data);
1265 sLog.outDebug("WORLD: Sent MSG_GUILD_BANK_MONEY_WITHDRAWN");
1268 bool Guild::MemberMoneyWithdraw(uint32 amount, uint32 LowGuid)
1270 uint32 MoneyWithDrawRight = GetMemberMoneyWithdrawRem(LowGuid);
1272 if (MoneyWithDrawRight < amount || GetGuildBankMoney() < amount)
1273 return false;
1275 SetBankMoney(GetGuildBankMoney()-amount);
1277 if (MoneyWithDrawRight < WITHDRAW_MONEY_UNLIMITED)
1279 MemberList::iterator itr = members.find(LowGuid);
1280 if (itr == members.end() )
1281 return false;
1282 itr->second.BankRemMoney -= amount;
1283 CharacterDatabase.PExecute("UPDATE guild_member SET BankRemMoney='%u' WHERE guildid='%u' AND guid='%u'",
1284 itr->second.BankRemMoney, Id, LowGuid);
1286 return true;
1289 void Guild::SetBankMoney(int64 money)
1291 if (money < 0) // I don't know how this happens, it does!!
1292 money = 0;
1293 guildbank_money = money;
1295 CharacterDatabase.PExecute("UPDATE guild SET BankMoney='" I64FMTD "' WHERE guildid='%u'", money, Id);
1298 // *************************************************
1299 // Item per day and money per day related
1301 bool Guild::MemberItemWithdraw(uint8 TabId, uint32 LowGuid)
1303 uint32 SlotsWithDrawRight = GetMemberSlotWithdrawRem(LowGuid, TabId);
1305 if (SlotsWithDrawRight == 0)
1306 return false;
1308 if (SlotsWithDrawRight < WITHDRAW_SLOT_UNLIMITED)
1310 MemberList::iterator itr = members.find(LowGuid);
1311 if (itr == members.end() )
1312 return false;
1313 --itr->second.BankRemSlotsTab[TabId];
1314 CharacterDatabase.PExecute("UPDATE guild_member SET BankRemSlotsTab%u='%u' WHERE guildid='%u' AND guid='%u'",
1315 uint32(TabId), itr->second.BankRemSlotsTab[TabId], Id, LowGuid);
1317 return true;
1320 bool Guild::IsMemberHaveRights(uint32 LowGuid, uint8 TabId, uint32 rights) const
1322 MemberList::const_iterator itr = members.find(LowGuid);
1323 if (itr == members.end() )
1324 return false;
1326 if (itr->second.RankId == GR_GUILDMASTER)
1327 return true;
1329 return (GetBankRights(itr->second.RankId,TabId) & rights)==rights;
1332 uint32 Guild::GetMemberSlotWithdrawRem(uint32 LowGuid, uint8 TabId)
1334 MemberList::iterator itr = members.find(LowGuid);
1335 if (itr == members.end() )
1336 return 0;
1338 if (itr->second.RankId == GR_GUILDMASTER)
1339 return WITHDRAW_SLOT_UNLIMITED;
1341 if((GetBankRights(itr->second.RankId,TabId) & GUILD_BANK_RIGHT_VIEW_TAB)!=GUILD_BANK_RIGHT_VIEW_TAB)
1342 return 0;
1344 uint32 curTime = uint32(time(NULL)/MINUTE);
1345 if (curTime - itr->second.BankResetTimeTab[TabId] >= 24*HOUR/MINUTE)
1347 itr->second.BankResetTimeTab[TabId] = curTime;
1348 itr->second.BankRemSlotsTab[TabId] = GetBankSlotPerDay(itr->second.RankId, TabId);
1349 CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeTab%u='%u',BankRemSlotsTab%u='%u' WHERE guildid='%u' AND guid='%u'",
1350 uint32(TabId), itr->second.BankResetTimeTab[TabId], uint32(TabId), itr->second.BankRemSlotsTab[TabId], Id, LowGuid);
1352 return itr->second.BankRemSlotsTab[TabId];
1355 uint32 Guild::GetMemberMoneyWithdrawRem(uint32 LowGuid)
1357 MemberList::iterator itr = members.find(LowGuid);
1358 if (itr == members.end() )
1359 return 0;
1361 if (itr->second.RankId == GR_GUILDMASTER)
1362 return WITHDRAW_MONEY_UNLIMITED;
1364 uint32 curTime = uint32(time(NULL)/MINUTE); // minutes
1365 // 24 hours
1366 if (curTime > itr->second.BankResetTimeMoney + 24*HOUR/MINUTE)
1368 itr->second.BankResetTimeMoney = curTime;
1369 itr->second.BankRemMoney = GetBankMoneyPerDay(itr->second.RankId);
1370 CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeMoney='%u',BankRemMoney='%u' WHERE guildid='%u' AND guid='%u'",
1371 itr->second.BankResetTimeMoney, itr->second.BankRemMoney, Id, LowGuid);
1373 return itr->second.BankRemMoney;
1376 void Guild::SetBankMoneyPerDay(uint32 rankId, uint32 money)
1378 if (rankId >= m_ranks.size())
1379 return;
1381 if (rankId == GR_GUILDMASTER)
1382 money = WITHDRAW_MONEY_UNLIMITED;
1384 m_ranks[rankId].BankMoneyPerDay = money;
1386 for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
1387 if (itr->second.RankId == rankId)
1388 itr->second.BankResetTimeMoney = 0;
1390 CharacterDatabase.PExecute("UPDATE guild_rank SET BankMoneyPerDay='%u' WHERE rid='%u' AND guildid='%u'", money, (rankId+1), Id);
1391 CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeMoney='0' WHERE guildid='%u' AND rank='%u'", Id, rankId);
1394 void Guild::SetBankRightsAndSlots(uint32 rankId, uint8 TabId, uint32 right, uint32 nbSlots, bool db)
1396 if(rankId >= m_ranks.size() ||
1397 TabId >= GUILD_BANK_MAX_TABS ||
1398 TabId >= purchased_tabs)
1399 return;
1401 if (rankId == GR_GUILDMASTER)
1403 nbSlots = WITHDRAW_SLOT_UNLIMITED;
1404 right = GUILD_BANK_RIGHT_FULL;
1407 m_ranks[rankId].TabSlotPerDay[TabId]=nbSlots;
1408 m_ranks[rankId].TabRight[TabId]=right;
1410 if (db)
1412 for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
1413 if (itr->second.RankId == rankId)
1414 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1415 itr->second.BankResetTimeTab[i] = 0;
1417 CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid='%u' AND TabId='%u' AND rid='%u'", Id, uint32(TabId), rankId);
1418 CharacterDatabase.PExecute("INSERT INTO guild_bank_right (guildid,TabId,rid,gbright,SlotPerDay) VALUES "
1419 "('%u','%u','%u','%u','%u')", Id, uint32(TabId), rankId, m_ranks[rankId].TabRight[TabId], m_ranks[rankId].TabSlotPerDay[TabId]);
1420 CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeTab%u='0' WHERE guildid='%u' AND rank='%u'", uint32(TabId), Id, rankId);
1424 uint32 Guild::GetBankMoneyPerDay(uint32 rankId)
1426 if(rankId >= m_ranks.size())
1427 return 0;
1429 if (rankId == GR_GUILDMASTER)
1430 return WITHDRAW_MONEY_UNLIMITED;
1431 return m_ranks[rankId].BankMoneyPerDay;
1434 uint32 Guild::GetBankSlotPerDay(uint32 rankId, uint8 TabId)
1436 if(rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1437 return 0;
1439 if (rankId == GR_GUILDMASTER)
1440 return WITHDRAW_SLOT_UNLIMITED;
1441 return m_ranks[rankId].TabSlotPerDay[TabId];
1444 // *************************************************
1445 // Rights per day related
1447 void Guild::LoadBankRightsFromDB(uint32 GuildId)
1449 // 0 1 2 3
1450 QueryResult *result = CharacterDatabase.PQuery("SELECT TabId, rid, gbright, SlotPerDay FROM guild_bank_right WHERE guildid = '%u' ORDER BY TabId", GuildId);
1452 if(!result)
1453 return;
1457 Field *fields = result->Fetch();
1458 uint8 TabId = fields[0].GetUInt8();
1459 uint32 rankId = fields[1].GetUInt32();
1460 uint16 right = fields[2].GetUInt16();
1461 uint16 SlotPerDay = fields[3].GetUInt16();
1463 SetBankRightsAndSlots(rankId, TabId, right, SlotPerDay, false);
1465 }while( result->NextRow() );
1466 delete result;
1468 return;
1471 // *************************************************
1472 // Bank log related
1474 void Guild::LoadGuildBankEventLogFromDB()
1476 // We can't add a limit as in Guild::LoadGuildEventLogFromDB since we fetch both money and bank log and know nothing about the composition
1477 // 0 1 2 3 4 5 6 7
1478 QueryResult *result = CharacterDatabase.PQuery("SELECT LogGuid, LogEntry, TabId, PlayerGuid, ItemOrMoney, ItemStackCount, DestTabId, TimeStamp FROM guild_bank_eventlog WHERE guildid='%u' ORDER BY TimeStamp DESC", Id);
1479 if(!result)
1480 return;
1484 Field *fields = result->Fetch();
1485 GuildBankEvent *NewEvent = new GuildBankEvent;
1487 NewEvent->LogGuid = fields[0].GetUInt32();
1488 NewEvent->LogEntry = fields[1].GetUInt8();
1489 uint8 TabId = fields[2].GetUInt8();
1490 NewEvent->PlayerGuid = fields[3].GetUInt32();
1491 NewEvent->ItemOrMoney = fields[4].GetUInt32();
1492 NewEvent->ItemStackCount = fields[5].GetUInt8();
1493 NewEvent->DestTabId = fields[6].GetUInt8();
1494 NewEvent->TimeStamp = fields[7].GetUInt64();
1496 if (TabId >= GUILD_BANK_MAX_TABS)
1498 sLog.outError( "Guild::LoadGuildBankEventLogFromDB: Invalid tabid '%u' for guild bank log entry (guild: '%s', LogGuid: %u), skipped.", TabId, GetName().c_str(), NewEvent->LogGuid);
1499 delete NewEvent;
1500 continue;
1502 if (NewEvent->isMoneyEvent() && m_GuildBankEventLog_Money.size() >= GUILD_BANK_MAX_LOGS
1503 || m_GuildBankEventLog_Item[TabId].size() >= GUILD_BANK_MAX_LOGS)
1505 delete NewEvent;
1506 continue;
1508 if (NewEvent->isMoneyEvent())
1509 m_GuildBankEventLog_Money.push_front(NewEvent);
1510 else
1511 m_GuildBankEventLog_Item[TabId].push_front(NewEvent);
1513 }while( result->NextRow() );
1514 delete result;
1516 // Check lists size in case to many event entries in db for a tab or for money
1517 // This cases can happen only if a crash occured somewhere and table has too many log entries
1518 if (!m_GuildBankEventLog_Money.empty())
1520 CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid=%u AND LogGuid < %u",
1521 Id, m_GuildBankEventLog_Money.front()->LogGuid);
1523 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1525 if (!m_GuildBankEventLog_Item[i].empty())
1527 CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid=%u AND LogGuid < %u",
1528 Id, m_GuildBankEventLog_Item[i].front()->LogGuid);
1533 void Guild::UnloadGuildBankEventLog()
1535 GuildBankEvent *EventLogEntry;
1536 if( !m_GuildBankEventLog_Money.empty() )
1540 EventLogEntry = *(m_GuildBankEventLog_Money.begin());
1541 m_GuildBankEventLog_Money.pop_front();
1542 delete EventLogEntry;
1543 }while( !m_GuildBankEventLog_Money.empty() );
1546 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1548 if( !m_GuildBankEventLog_Item[i].empty() )
1552 EventLogEntry = *(m_GuildBankEventLog_Item[i].begin());
1553 m_GuildBankEventLog_Item[i].pop_front();
1554 delete EventLogEntry;
1555 }while( !m_GuildBankEventLog_Item[i].empty() );
1560 void Guild::DisplayGuildBankLogs(WorldSession *session, uint8 TabId)
1562 if (TabId > GUILD_BANK_MAX_TABS)
1563 return;
1565 if (TabId == GUILD_BANK_MAX_TABS)
1567 // Here we display money logs
1568 WorldPacket data(MSG_GUILD_BANK_LOG_QUERY, m_GuildBankEventLog_Money.size()*(4*4+1)+1+1);
1569 data << uint8(TabId); // Here GUILD_BANK_MAX_TABS
1570 data << uint8(m_GuildBankEventLog_Money.size()); // number of log entries
1571 for (GuildBankEventLog::const_iterator itr = m_GuildBankEventLog_Money.begin(); itr != m_GuildBankEventLog_Money.end(); ++itr)
1573 data << uint8((*itr)->LogEntry);
1574 data << uint64(MAKE_NEW_GUID((*itr)->PlayerGuid,0,HIGHGUID_PLAYER));
1575 if ((*itr)->LogEntry == GUILD_BANK_LOG_DEPOSIT_MONEY ||
1576 (*itr)->LogEntry == GUILD_BANK_LOG_WITHDRAW_MONEY ||
1577 (*itr)->LogEntry == GUILD_BANK_LOG_REPAIR_MONEY ||
1578 (*itr)->LogEntry == GUILD_BANK_LOG_UNK1 ||
1579 (*itr)->LogEntry == GUILD_BANK_LOG_UNK2)
1581 data << uint32((*itr)->ItemOrMoney);
1583 else
1585 data << uint32((*itr)->ItemOrMoney);
1586 data << uint32((*itr)->ItemStackCount);
1587 if ((*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM || (*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM2)
1588 data << uint8((*itr)->DestTabId); // moved tab
1590 data << uint32(time(NULL)-(*itr)->TimeStamp);
1592 session->SendPacket(&data);
1594 else
1596 // here we display current tab logs
1597 WorldPacket data(MSG_GUILD_BANK_LOG_QUERY, m_GuildBankEventLog_Item[TabId].size()*(4*4+1+1)+1+1);
1598 data << uint8(TabId); // Here a real Tab Id
1599 // number of log entries
1600 data << uint8(m_GuildBankEventLog_Item[TabId].size());
1601 for (GuildBankEventLog::const_iterator itr = m_GuildBankEventLog_Item[TabId].begin(); itr != m_GuildBankEventLog_Item[TabId].end(); ++itr)
1603 data << uint8((*itr)->LogEntry);
1604 data << uint64(MAKE_NEW_GUID((*itr)->PlayerGuid,0,HIGHGUID_PLAYER));
1605 if ((*itr)->LogEntry == GUILD_BANK_LOG_DEPOSIT_MONEY ||
1606 (*itr)->LogEntry == GUILD_BANK_LOG_WITHDRAW_MONEY ||
1607 (*itr)->LogEntry == GUILD_BANK_LOG_REPAIR_MONEY ||
1608 (*itr)->LogEntry == GUILD_BANK_LOG_UNK1 ||
1609 (*itr)->LogEntry == GUILD_BANK_LOG_UNK2)
1611 data << uint32((*itr)->ItemOrMoney);
1613 else
1615 data << uint32((*itr)->ItemOrMoney);
1616 data << uint32((*itr)->ItemStackCount);
1617 if ((*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM || (*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM2)
1618 data << uint8((*itr)->DestTabId); // moved tab
1620 data << uint32(time(NULL)-(*itr)->TimeStamp);
1622 session->SendPacket(&data);
1624 sLog.outDebug("WORLD: Sent (MSG_GUILD_BANK_LOG_QUERY)");
1627 void Guild::LogBankEvent(uint8 LogEntry, uint8 TabId, uint32 PlayerGuidLow, uint32 ItemOrMoney, uint8 ItemStackCount, uint8 DestTabId)
1629 GuildBankEvent *NewEvent = new GuildBankEvent;
1631 NewEvent->LogGuid = LogMaxGuid++;
1632 NewEvent->LogEntry = LogEntry;
1633 NewEvent->PlayerGuid = PlayerGuidLow;
1634 NewEvent->ItemOrMoney = ItemOrMoney;
1635 NewEvent->ItemStackCount = ItemStackCount;
1636 NewEvent->DestTabId = DestTabId;
1637 NewEvent->TimeStamp = uint32(time(NULL));
1639 if (NewEvent->isMoneyEvent())
1641 if (m_GuildBankEventLog_Money.size() > GUILD_BANK_MAX_LOGS)
1643 GuildBankEvent *OldEvent = *(m_GuildBankEventLog_Money.begin());
1644 m_GuildBankEventLog_Money.pop_front();
1645 CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
1646 delete OldEvent;
1648 m_GuildBankEventLog_Money.push_back(NewEvent);
1650 else
1652 if (m_GuildBankEventLog_Item[TabId].size() > GUILD_BANK_MAX_LOGS)
1654 GuildBankEvent *OldEvent = *(m_GuildBankEventLog_Item[TabId].begin());
1655 m_GuildBankEventLog_Item[TabId].pop_front();
1656 CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
1657 delete OldEvent;
1659 m_GuildBankEventLog_Item[TabId].push_back(NewEvent);
1661 CharacterDatabase.PExecute("INSERT INTO guild_bank_eventlog (guildid,LogGuid,LogEntry,TabId,PlayerGuid,ItemOrMoney,ItemStackCount,DestTabId,TimeStamp) VALUES ('%u','%u','%u','%u','%u','%u','%u','%u','" I64FMTD "')",
1662 Id, NewEvent->LogGuid, uint32(NewEvent->LogEntry), uint32(TabId), NewEvent->PlayerGuid, NewEvent->ItemOrMoney, uint32(NewEvent->ItemStackCount), uint32(NewEvent->DestTabId), NewEvent->TimeStamp);
1665 // This will renum guids used at load to prevent always going up until infinit
1666 void Guild::RenumBankLogs()
1668 QueryResult *result = CharacterDatabase.PQuery("SELECT Min(LogGuid), Max(LogGuid) FROM guild_bank_eventlog WHERE guildid = %u", Id);
1669 if(!result)
1670 return;
1672 Field *fields = result->Fetch();
1673 CharacterDatabase.PExecute("UPDATE guild_bank_eventlog SET LogGuid=LogGuid-%u+1 WHERE guildid=%u ORDER BY LogGuid %s",fields[0].GetUInt32(), Id, fields[0].GetUInt32()?"ASC":"DESC");
1674 LogMaxGuid = fields[1].GetUInt32()+1;
1675 delete result;
1678 bool Guild::AddGBankItemToDB(uint32 GuildId, uint32 BankTab , uint32 BankTabSlot , uint32 GUIDLow, uint32 Entry )
1680 CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid = '%u' AND TabId = '%u'AND SlotId = '%u'", GuildId, BankTab, BankTabSlot);
1681 CharacterDatabase.PExecute("INSERT INTO guild_bank_item (guildid,TabId,SlotId,item_guid,item_entry) "
1682 "VALUES ('%u', '%u', '%u', '%u', '%u')", GuildId, BankTab, BankTabSlot, GUIDLow, Entry);
1683 return true;
1686 void Guild::AppendDisplayGuildBankSlot( WorldPacket& data, GuildBankTab const *tab, int slot )
1688 Item *pItem = tab->Slots[slot];
1689 uint32 entry = pItem ? pItem->GetEntry() : 0;
1691 data << uint8(slot);
1692 data << uint32(entry);
1693 if (entry)
1695 // random item property id +8
1696 data << (uint32) pItem->GetItemRandomPropertyId();
1697 if (pItem->GetItemRandomPropertyId())
1698 // SuffixFactor +4
1699 data << (uint32) pItem->GetItemSuffixFactor();
1700 // +12 // ITEM_FIELD_STACK_COUNT
1701 data << uint32(pItem->GetCount());
1702 data << uint32(0); // +16 // Unknown value
1703 data << uint8(0); // unknown 2.4.2
1704 if (uint32 Enchant0 = pItem->GetEnchantmentId(PERM_ENCHANTMENT_SLOT))
1706 data << uint8(1); // number of enchantments (max 3) why max 3?
1707 data << uint8(PERM_ENCHANTMENT_SLOT); // enchantment slot (range: 0:2)
1708 data << uint32(Enchant0); // enchantment id
1710 else
1711 data << uint8(0); // no enchantments (0)
1715 Item* Guild::StoreItem(uint8 tabId, GuildItemPosCountVec const& dest, Item* pItem )
1717 if( !pItem )
1718 return NULL;
1720 Item* lastItem = pItem;
1722 for(GuildItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); )
1724 uint8 slot = itr->slot;
1725 uint32 count = itr->count;
1727 ++itr;
1729 if(itr == dest.end())
1731 lastItem = _StoreItem(tabId,slot,pItem,count,false);
1732 break;
1735 lastItem = _StoreItem(tabId,slot,pItem,count,true);
1738 return lastItem;
1741 // Return stored item (if stored to stack, it can diff. from pItem). And pItem ca be deleted in this case.
1742 Item* Guild::_StoreItem( uint8 tab, uint8 slot, Item *pItem, uint32 count, bool clone )
1744 if( !pItem )
1745 return NULL;
1747 sLog.outDebug( "GUILD STORAGE: StoreItem tab = %u, slot = %u, item = %u, count = %u", tab, slot, pItem->GetEntry(), count);
1749 Item* pItem2 = m_TabListMap[tab]->Slots[slot];
1751 if( !pItem2 )
1753 if(clone)
1754 pItem = pItem->CloneItem(count);
1755 else
1756 pItem->SetCount(count);
1758 if(!pItem)
1759 return NULL;
1761 m_TabListMap[tab]->Slots[slot] = pItem;
1763 pItem->SetUInt64Value(ITEM_FIELD_CONTAINED, 0);
1764 pItem->SetUInt64Value(ITEM_FIELD_OWNER, 0);
1765 AddGBankItemToDB(GetId(), tab, slot, pItem->GetGUIDLow(), pItem->GetEntry());
1766 pItem->FSetState(ITEM_NEW);
1767 pItem->SaveToDB(); // not in onventory and can be save standalone
1769 return pItem;
1771 else
1773 pItem2->SetCount( pItem2->GetCount() + count );
1774 pItem2->FSetState(ITEM_CHANGED);
1775 pItem2->SaveToDB(); // not in onventory and can be save standalone
1777 if(!clone)
1779 pItem->RemoveFromWorld();
1780 pItem->DeleteFromDB();
1781 delete pItem;
1784 return pItem2;
1788 void Guild::RemoveItem(uint8 tab, uint8 slot )
1790 m_TabListMap[tab]->Slots[slot] = NULL;
1791 CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid='%u' AND TabId='%u' AND SlotId='%u'",
1792 GetId(), uint32(tab), uint32(slot));
1795 uint8 Guild::_CanStoreItem_InSpecificSlot( uint8 tab, uint8 slot, GuildItemPosCountVec &dest, uint32& count, bool swap, Item* pSrcItem ) const
1797 Item* pItem2 = m_TabListMap[tab]->Slots[slot];
1799 // ignore move item (this slot will be empty at move)
1800 if(pItem2==pSrcItem)
1801 pItem2 = NULL;
1803 uint32 need_space;
1805 // empty specific slot - check item fit to slot
1806 if( !pItem2 || swap )
1808 // non empty stack with space
1809 need_space = pSrcItem->GetMaxStackCount();
1811 // non empty slot, check item type
1812 else
1814 // check item type
1815 if(pItem2->GetEntry() != pSrcItem->GetEntry())
1816 return EQUIP_ERR_ITEM_CANT_STACK;
1818 // check free space
1819 if(pItem2->GetCount() >= pSrcItem->GetMaxStackCount())
1820 return EQUIP_ERR_ITEM_CANT_STACK;
1822 need_space = pSrcItem->GetMaxStackCount() - pItem2->GetCount();
1825 if(need_space > count)
1826 need_space = count;
1828 GuildItemPosCount newPosition = GuildItemPosCount(slot,need_space);
1829 if(!newPosition.isContainedIn(dest))
1831 dest.push_back(newPosition);
1832 count -= need_space;
1835 return EQUIP_ERR_OK;
1838 uint8 Guild::_CanStoreItem_InTab( uint8 tab, GuildItemPosCountVec &dest, uint32& count, bool merge, Item* pSrcItem, uint8 skip_slot ) const
1840 for(uint32 j = 0; j < GUILD_BANK_MAX_SLOTS; j++)
1842 // skip specific slot already processed in first called _CanStoreItem_InSpecificSlot
1843 if(j==skip_slot)
1844 continue;
1846 Item* pItem2 = m_TabListMap[tab]->Slots[j];
1848 // ignore move item (this slot will be empty at move)
1849 if(pItem2==pSrcItem)
1850 pItem2 = NULL;
1852 // if merge skip empty, if !merge skip non-empty
1853 if((pItem2!=NULL)!=merge)
1854 continue;
1856 if( pItem2 )
1858 if(pItem2->GetEntry() == pSrcItem->GetEntry() && pItem2->GetCount() < pSrcItem->GetMaxStackCount() )
1860 uint32 need_space = pSrcItem->GetMaxStackCount() - pItem2->GetCount();
1861 if(need_space > count)
1862 need_space = count;
1864 GuildItemPosCount newPosition = GuildItemPosCount(j,need_space);
1865 if(!newPosition.isContainedIn(dest))
1867 dest.push_back(newPosition);
1868 count -= need_space;
1870 if(count==0)
1871 return EQUIP_ERR_OK;
1875 else
1877 uint32 need_space = pSrcItem->GetMaxStackCount();
1878 if(need_space > count)
1879 need_space = count;
1881 GuildItemPosCount newPosition = GuildItemPosCount(j,need_space);
1882 if(!newPosition.isContainedIn(dest))
1884 dest.push_back(newPosition);
1885 count -= need_space;
1887 if(count==0)
1888 return EQUIP_ERR_OK;
1892 return EQUIP_ERR_OK;
1895 uint8 Guild::CanStoreItem( uint8 tab, uint8 slot, GuildItemPosCountVec &dest, uint32 count, Item *pItem, bool swap ) const
1897 sLog.outDebug( "GUILD STORAGE: CanStoreItem tab = %u, slot = %u, item = %u, count = %u", tab, slot, pItem->GetEntry(), count);
1899 if(count > pItem->GetCount())
1900 return EQUIP_ERR_COULDNT_SPLIT_ITEMS;
1902 if(pItem->IsSoulBound())
1903 return EQUIP_ERR_CANT_DROP_SOULBOUND;
1905 // in specific slot
1906 if( slot != NULL_SLOT )
1908 uint8 res = _CanStoreItem_InSpecificSlot(tab,slot,dest,count,swap,pItem);
1909 if(res!=EQUIP_ERR_OK)
1910 return res;
1912 if(count==0)
1913 return EQUIP_ERR_OK;
1916 // not specific slot or have spece for partly store only in specific slot
1918 // search stack in tab for merge to
1919 if( pItem->GetMaxStackCount() > 1 )
1921 uint8 res = _CanStoreItem_InTab(tab,dest,count,true,pItem,slot);
1922 if(res!=EQUIP_ERR_OK)
1923 return res;
1925 if(count==0)
1926 return EQUIP_ERR_OK;
1929 // search free slot in bag for place to
1930 uint8 res = _CanStoreItem_InTab(tab,dest,count,false,pItem,slot);
1931 if(res!=EQUIP_ERR_OK)
1932 return res;
1934 if(count==0)
1935 return EQUIP_ERR_OK;
1937 return EQUIP_ERR_BANK_FULL;
1940 void Guild::SetGuildBankTabText(uint8 TabId, std::string text)
1942 if (TabId >= GUILD_BANK_MAX_TABS)
1943 return;
1944 if (TabId >= m_TabListMap.size())
1945 return;
1946 if (!m_TabListMap[TabId])
1947 return;
1949 if(m_TabListMap[TabId]->Text==text)
1950 return;
1952 utf8truncate(text,500); // DB and client size limitation
1954 m_TabListMap[TabId]->Text = text;
1956 CharacterDatabase.escape_string(text);
1957 CharacterDatabase.PExecute("UPDATE guild_bank_tab SET TabText='%s' WHERE guildid='%u' AND TabId='%u'", text.c_str(), Id, uint32(TabId));
1960 void Guild::SendGuildBankTabText(WorldSession *session, uint8 TabId)
1962 if (TabId > GUILD_BANK_MAX_TABS)
1963 return;
1965 GuildBankTab const *tab = GetBankTab(TabId);
1966 if (!tab)
1967 return;
1969 WorldPacket data(MSG_QUERY_GUILD_BANK_TEXT, 1+tab->Text.size()+1);
1970 data << uint8(TabId);
1971 data << tab->Text;
1972 session->SendPacket(&data);
1975 bool GuildItemPosCount::isContainedIn(GuildItemPosCountVec const &vec) const
1977 for(GuildItemPosCountVec::const_iterator itr = vec.begin(); itr != vec.end();++itr)
1978 if(itr->slot == slot)
1979 return true;
1981 return false;