src/game/Guild.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18
  19 #include "Database/DatabaseEnv.h"
  20 #include "WorldPacket.h"
  21 #include "WorldSession.h"
  22 #include "Player.h"
  23 #include "Opcodes.h"
  24 #include "ObjectMgr.h"
  25 #include "Guild.h"
  26 #include "Chat.h"
  27 #include "SocialMgr.h"
  28 #include "Util.h"
  29 #include "Language.h"
  30
  31 Guild::Guild()
  32 {
  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;
  42
  43     CreatedYear = 0;
  44     CreatedMonth = 0;
  45     CreatedDay = 0;
  46 }
  47
  48 Guild::~Guild()
  49 {
  50
  51 }
  52
  53 bool Guild::create(Player* leader, std::string gname)
  54 {
  55     if(objmgr.GetGuildByName(gname))
  56         return false;
  57
  58     WorldSession* lSession = leader->GetSession();
  59     if(!lSession)
  60         return false;
  61
  62     leaderGuid = leader->GetGUID();
  63     name = gname;
  64     GINFO = "";
  65     MOTD = "No message set.";
  66     guildbank_money = 0;
  67     purchased_tabs = 0;
  68     Id = objmgr.GenerateGuildId();
  69
  70     sLog.outDebug("GUILD: creating guild %s to leader: %u", gname.c_str(), GUID_LOPART(leaderGuid));
  71
  72     // gname already assigned to Guild::name, use it to encode string for DB
  73     CharacterDatabase.escape_string(gname);
  74
  75     std::string dbGINFO = GINFO;
  76     std::string dbMOTD = MOTD;
  77     CharacterDatabase.escape_string(dbGINFO);
  78     CharacterDatabase.escape_string(dbMOTD);
  79
  80     CharacterDatabase.BeginTransaction();
  81     // CharacterDatabase.PExecute("DELETE FROM guild WHERE guildid='%u'", Id); - MAX(guildid)+1 not exist
  82     CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid='%u'", Id);
  83     CharacterDatabase.PExecute("DELETE FROM guild_member WHERE guildid='%u'", Id);
  84     CharacterDatabase.PExecute("INSERT INTO guild (guildid,name,leaderguid,info,motd,createdate,EmblemStyle,EmblemColor,BorderStyle,BorderColor,BackgroundColor,BankMoney) "
  85         "VALUES('%u','%s','%u', '%s', '%s', NOW(),'%u','%u','%u','%u','%u','" I64FMTD "')",
  86         Id, gname.c_str(), GUID_LOPART(leaderGuid), dbGINFO.c_str(), dbMOTD.c_str(), EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor, guildbank_money);
  87     CharacterDatabase.CommitTransaction();
  88
  89     CreateRank(lSession->GetMangosString(LANG_GUILD_MASTER),  GR_RIGHT_ALL);
  90     CreateRank(lSession->GetMangosString(LANG_GUILD_OFFICER), GR_RIGHT_ALL);
  91     CreateRank(lSession->GetMangosString(LANG_GUILD_VETERAN), GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
  92     CreateRank(lSession->GetMangosString(LANG_GUILD_MEMBER),  GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
  93     CreateRank(lSession->GetMangosString(LANG_GUILD_INITIATE),GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
  94
  95     return AddMember(leaderGuid, (uint32)GR_GUILDMASTER);
  96 }
  97
  98 bool Guild::AddMember(uint64 plGuid, uint32 plRank)
  99 {
 100     Player* pl = objmgr.GetPlayer(plGuid);
 101     if(pl)
 102     {
 103         if(pl->GetGuildId() != 0)
 104             return false;
 105     }
 106     else
 107     {
 108         if(Player::GetGuildIdFromDB(plGuid) != 0)           // player already in guild
 109             return false;
 110     }
 111
 112     // remove all player signs from another petitions
 113     // this will be prevent attempt joining player to many guilds and corrupt guild data integrity
 114     Player::RemovePetitionsAndSigns(plGuid, 9);
 115
 116     // fill player data
 117     MemberSlot newmember;
 118
 119     if(!FillPlayerData(plGuid, &newmember))                 // problems with player data collection
 120         return false;
 121
 122     newmember.RankId = plRank;
 123     newmember.OFFnote = (std::string)"";
 124     newmember.Pnote = (std::string)"";
 125     newmember.logout_time = time(NULL);
 126     newmember.BankResetTimeMoney = 0;                       // this will force update at first query
 127     for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 128         newmember.BankResetTimeTab[i] = 0;
 129     members[GUID_LOPART(plGuid)] = newmember;
 130
 131     std::string dbPnote = newmember.Pnote;
 132     std::string dbOFFnote = newmember.OFFnote;
 133     CharacterDatabase.escape_string(dbPnote);
 134     CharacterDatabase.escape_string(dbOFFnote);
 135
 136     CharacterDatabase.PExecute("INSERT INTO guild_member (guildid,guid,rank,pnote,offnote) VALUES ('%u', '%u', '%u','%s','%s')",
 137         Id, GUID_LOPART(plGuid), newmember.RankId, dbPnote.c_str(), dbOFFnote.c_str());
 138
 139     // If player not in game data in data field will be loaded from guild tables, no need to update it!!
 140     if(pl)
 141     {
 142         pl->SetInGuild(Id);
 143         pl->SetRank(newmember.RankId);
 144         pl->SetGuildIdInvited(0);
 145     }
 146     return true;
 147 }
 148
 149 void Guild::SetMOTD(std::string motd)
 150 {
 151     MOTD = motd;
 152
 153     // motd now can be used for encoding to DB
 154     CharacterDatabase.escape_string(motd);
 155     CharacterDatabase.PExecute("UPDATE guild SET motd='%s' WHERE guildid='%u'", motd.c_str(), Id);
 156 }
 157
 158 void Guild::SetGINFO(std::string ginfo)
 159 {
 160     GINFO = ginfo;
 161
 162     // ginfo now can be used for encoding to DB
 163     CharacterDatabase.escape_string(ginfo);
 164     CharacterDatabase.PExecute("UPDATE guild SET info='%s' WHERE guildid='%u'", ginfo.c_str(), Id);
 165 }
 166
 167 bool Guild::LoadGuildFromDB(uint32 GuildId)
 168 {
 169     if(!LoadRanksFromDB(GuildId))
 170         return false;
 171
 172     if(!LoadMembersFromDB(GuildId))
 173         return false;
 174
 175     QueryResult *result = CharacterDatabase.PQuery("SELECT MAX(TabId) FROM guild_bank_tab WHERE guildid='%u'", GuildId);
 176     if(result)
 177     {
 178         Field *fields = result->Fetch();
 179         purchased_tabs = fields[0].GetUInt8()+1;            // Because TabId begins at 0
 180         delete result;
 181     }
 182     else
 183         purchased_tabs = 0;
 184
 185     LoadBankRightsFromDB(GuildId);                          // Must be after LoadRanksFromDB because it populates rank struct
 186
 187     //                                        0        1     2           3            4            5           6
 188     result = CharacterDatabase.PQuery("SELECT guildid, name, leaderguid, EmblemStyle, EmblemColor, BorderStyle, BorderColor,"
 189     //   7                8     9     10          11
 190         "BackgroundColor, info, motd, createdate, BankMoney FROM guild WHERE guildid = '%u'", GuildId);
 191
 192     if(!result)
 193         return false;
 194
 195     Field *fields = result->Fetch();
 196
 197     Id = fields[0].GetUInt32();
 198     name = fields[1].GetCppString();
 199     leaderGuid  = MAKE_NEW_GUID(fields[2].GetUInt32(), 0, HIGHGUID_PLAYER);
 200
 201     EmblemStyle = fields[3].GetUInt32();
 202     EmblemColor = fields[4].GetUInt32();
 203     BorderStyle = fields[5].GetUInt32();
 204     BorderColor = fields[6].GetUInt32();
 205     BackgroundColor = fields[7].GetUInt32();
 206     GINFO = fields[8].GetCppString();
 207     MOTD = fields[9].GetCppString();
 208     uint64 time = fields[10].GetUInt64();                   //datetime is uint64 type ... YYYYmmdd:hh:mm:ss
 209     guildbank_money = fields[11].GetUInt64();
 210
 211     delete result;
 212
 213     uint64 dTime = time /1000000;
 214     CreatedDay   = dTime%100;
 215     CreatedMonth = (dTime/100)%100;
 216     CreatedYear  = (dTime/10000)%10000;
 217
 218     // If the leader does not exist attempt to promote another member
 219     if(!objmgr.GetPlayerAccountIdByGUID(leaderGuid ))
 220     {
 221         DelMember(leaderGuid);
 222
 223         // check no members case (disbanded)
 224         if(members.empty())
 225             return false;
 226     }
 227
 228     sLog.outDebug("Guild %u Creation time Loaded day: %u, month: %u, year: %u", GuildId, CreatedDay, CreatedMonth, CreatedYear);
 229     m_bankloaded = false;
 230     m_eventlogloaded = false;
 231     m_onlinemembers = 0;
 232     RenumBankLogs();
 233     RenumGuildEventlog();
 234     return true;
 235 }
 236
 237 bool Guild::LoadRanksFromDB(uint32 GuildId)
 238 {
 239     Field *fields;
 240     QueryResult *result = CharacterDatabase.PQuery("SELECT rname,rights,BankMoneyPerDay,rid FROM guild_rank WHERE guildid = '%u' ORDER BY rid ASC", GuildId);
 241
 242     if(!result)
 243         return false;
 244
 245     bool broken_ranks = false;
 246
 247     do
 248     {
 249         fields = result->Fetch();
 250
 251         std::string rankName = fields[0].GetCppString();
 252         uint32 rankRights    = fields[1].GetUInt32();
 253         uint32 rankMoney     = fields[2].GetUInt32();
 254         uint32 rankRID       = fields[3].GetUInt32();
 255
 256         if(rankRID != m_ranks.size()+1)                     // guild_rank.rid always store rank+1
 257             broken_ranks =  true;
 258
 259         if(m_ranks.size()==GR_GUILDMASTER)                  // prevent loss leader rights
 260             rankRights |= GR_RIGHT_ALL;
 261
 262         AddRank(rankName,rankRights,rankMoney);
 263     }while( result->NextRow() );
 264     delete result;
 265
 266     if(m_ranks.size()==0)                                   // empty rank table?
 267     {
 268         AddRank("Guild Master",GR_RIGHT_ALL,0);
 269         broken_ranks = true;
 270     }
 271
 272     // guild_rank have wrong numbered ranks, repair
 273     if(broken_ranks)
 274     {
 275         sLog.outError("Guild %u have broken `guild_rank` data, repairing...",GuildId);
 276         CharacterDatabase.BeginTransaction();
 277         CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid='%u'", GuildId);
 278         for(size_t i =0; i < m_ranks.size(); ++i)
 279         {
 280             // guild_rank.rid always store rank+1
 281             std::string name = m_ranks[i].name;
 282             uint32 rights = m_ranks[i].rights;
 283             CharacterDatabase.escape_string(name);
 284             CharacterDatabase.PExecute( "INSERT INTO guild_rank (guildid,rid,rname,rights) VALUES ('%u', '%u', '%s', '%u')", GuildId, i+1, name.c_str(), rights);
 285         }
 286         CharacterDatabase.CommitTransaction();
 287     }
 288
 289     return true;
 290 }
 291
 292 bool Guild::LoadMembersFromDB(uint32 GuildId)
 293 {
 294     //                                                     0                 1     2      3        4                  5
 295     QueryResult *result = CharacterDatabase.PQuery("SELECT guild_member.guid,rank, pnote, offnote, BankResetTimeMoney,BankRemMoney,"
 296     //   6                  7                 8                  9                 10                 11
 297         "BankResetTimeTab0, BankRemSlotsTab0, BankResetTimeTab1, BankRemSlotsTab1, BankResetTimeTab2, BankRemSlotsTab2,"
 298     //   12                 13                14                 15                16                 17
 299         "BankResetTimeTab3, BankRemSlotsTab3, BankResetTimeTab4, BankRemSlotsTab4, BankResetTimeTab5, BankRemSlotsTab5,"
 300     //   18
 301         "logout_time FROM guild_member LEFT JOIN characters ON characters.guid = guild_member.guid WHERE guildid = '%u'", GuildId);
 302
 303     if(!result)
 304         return false;
 305
 306     do
 307     {
 308         Field *fields = result->Fetch();
 309         MemberSlot newmember;
 310         newmember.RankId = fields[1].GetUInt32();
 311         uint64 guid = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER);
 312
 313         // Player does not exist
 314         if(!FillPlayerData(guid, &newmember))
 315             continue;
 316
 317         newmember.Pnote                 = fields[2].GetCppString();
 318         newmember.OFFnote               = fields[3].GetCppString();
 319         newmember.BankResetTimeMoney    = fields[4].GetUInt32();
 320         newmember.BankRemMoney          = fields[5].GetUInt32();
 321         for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 322         {
 323             newmember.BankResetTimeTab[i] = fields[6+(2*i)].GetUInt32();
 324             newmember.BankRemSlotsTab[i]  = fields[7+(2*i)].GetUInt32();
 325         }
 326         newmember.logout_time           = fields[18].GetUInt64();
 327         members[GUID_LOPART(guid)]      = newmember;
 328
 329     }while( result->NextRow() );
 330     delete result;
 331
 332     if(members.empty())
 333         return false;
 334
 335     return true;
 336 }
 337
 338 bool Guild::FillPlayerData(uint64 guid, MemberSlot* memslot)
 339 {
 340     std::string plName;
 341     uint32 plLevel;
 342     uint32 plClass;
 343     uint32 plZone;
 344
 345     Player* pl = objmgr.GetPlayer(guid);
 346     if(pl)
 347     {
 348         plName  = pl->GetName();
 349         plLevel = pl->getLevel();
 350         plClass = pl->getClass();
 351         plZone  = pl->GetZoneId();
 352     }
 353     else
 354     {
 355         QueryResult *result = CharacterDatabase.PQuery("SELECT name,data,zone,class FROM characters WHERE guid = '%u'", GUID_LOPART(guid));
 356         if(!result)
 357             return false;                                   // player doesn't exist
 358
 359         Field *fields = result->Fetch();
 360
 361         plName = fields[0].GetCppString();
 362
 363         Tokens data = StrSplit(fields[1].GetCppString(), " ");
 364         plLevel = Player::GetUInt32ValueFromArray(data,UNIT_FIELD_LEVEL);
 365
 366         plZone = fields[2].GetUInt32();
 367         plClass = fields[3].GetUInt32();
 368         delete result;
 369
 370         if(plLevel<1||plLevel>STRONG_MAX_LEVEL)             // can be at broken `data` field
 371         {
 372             sLog.outError("Player (GUID: %u) has a broken data in field `characters`.`data`.",GUID_LOPART(guid));
 373             return false;
 374         }
 375
 376         if(!plZone)
 377         {
 378             sLog.outError("Player (GUID: %u) has broken zone-data",GUID_LOPART(guid));
 379             //here it will also try the same, to get the zone from characters-table, but additional it tries to find
 380             plZone = Player::GetZoneIdFromDB(guid);
 381             //the zone through xy coords.. this is a bit redundant, but
 382             //shouldn't be called often
 383         }
 384
 385         if(plClass<CLASS_WARRIOR||plClass>=MAX_CLASSES)     // can be at broken `class` field
 386         {
 387             sLog.outError("Player (GUID: %u) has a broken data in field `characters`.`class`.",GUID_LOPART(guid));
 388             return false;
 389         }
 390     }
 391
 392     memslot->name = plName;
 393     memslot->level = plLevel;
 394     memslot->Class = plClass;
 395     memslot->zoneId = plZone;
 396
 397     return(true);
 398 }
 399
 400 void Guild::LoadPlayerStatsByGuid(uint64 guid)
 401 {
 402     MemberList::iterator itr = members.find(GUID_LOPART(guid));
 403     if (itr == members.end() )
 404         return;
 405
 406     Player *pl = ObjectAccessor::FindPlayer(guid);
 407     if(!pl)
 408         return;
 409     itr->second.name  = pl->GetName();
 410     itr->second.level = pl->getLevel();
 411     itr->second.Class = pl->getClass();
 412 }
 413
 414 void Guild::SetLeader(uint64 guid)
 415 {
 416     leaderGuid = guid;
 417     ChangeRank(guid, GR_GUILDMASTER);
 418
 419     CharacterDatabase.PExecute("UPDATE guild SET leaderguid='%u' WHERE guildid='%u'", GUID_LOPART(guid), Id);
 420 }
 421
 422 void Guild::DelMember(uint64 guid, bool isDisbanding)
 423 {
 424     if(leaderGuid == guid && !isDisbanding)
 425     {
 426         MemberSlot* oldLeader = NULL;
 427         MemberSlot* best = NULL;
 428         uint64 newLeaderGUID = 0;
 429         for(Guild::MemberList::iterator i = members.begin(); i != members.end(); ++i)
 430         {
 431             if(i->first == GUID_LOPART(guid))
 432             {
 433                 oldLeader = &(i->second);
 434                 continue;
 435             }
 436
 437             if(!best || best->RankId > i->second.RankId)
 438             {
 439                 best = &(i->second);
 440                 newLeaderGUID = i->first;
 441             }
 442         }
 443         if(!best)
 444         {
 445             Disband();
 446             return;
 447         }
 448
 449         SetLeader(newLeaderGUID);
 450
 451         // If player not online data in data field will be loaded from guild tabs no need to update it !!
 452         if(Player *newLeader = objmgr.GetPlayer(newLeaderGUID))
 453             newLeader->SetRank(GR_GUILDMASTER);
 454
 455         // when leader non-exist (at guild load with deleted leader only) not send broadcasts
 456         if(oldLeader)
 457         {
 458             WorldPacket data(SMSG_GUILD_EVENT, (1+1+(oldLeader->name).size()+1+(best->name).size()+1));
 459             data << (uint8)GE_LEADER_CHANGED;
 460             data << (uint8)2;
 461             data << oldLeader->name;
 462             data << best->name;
 463             BroadcastPacket(&data);
 464
 465             data.Initialize(SMSG_GUILD_EVENT, (1+1+(oldLeader->name).size()+1));
 466             data << (uint8)GE_LEFT;
 467             data << (uint8)1;
 468             data << oldLeader->name;
 469             BroadcastPacket(&data);
 470         }
 471
 472         sLog.outDebug( "WORLD: Sent (SMSG_GUILD_EVENT)" );
 473     }
 474
 475     members.erase(GUID_LOPART(guid));
 476
 477     Player *player = objmgr.GetPlayer(guid);
 478     // If player not online data in data field will be loaded from guild tabs no need to update it !!
 479     if(player)
 480     {
 481         player->SetInGuild(0);
 482         player->SetRank(0);
 483     }
 484
 485     CharacterDatabase.PExecute("DELETE FROM guild_member WHERE guid = '%u'", GUID_LOPART(guid));
 486 }
 487
 488 void Guild::ChangeRank(uint64 guid, uint32 newRank)
 489 {
 490     MemberList::iterator itr = members.find(GUID_LOPART(guid));
 491     if( itr != members.end() )
 492         itr->second.RankId = newRank;
 493
 494     Player *player = objmgr.GetPlayer(guid);
 495     // If player not online data in data field will be loaded from guild tabs no need to update it !!
 496     if(player)
 497         player->SetRank(newRank);
 498
 499     CharacterDatabase.PExecute( "UPDATE guild_member SET rank='%u' WHERE guid='%u'", newRank, GUID_LOPART(guid) );
 500 }
 501
 502 void Guild::SetPNOTE(uint64 guid,std::string pnote)
 503 {
 504     MemberList::iterator itr = members.find(GUID_LOPART(guid));
 505     if( itr == members.end() )
 506         return;
 507
 508     itr->second.Pnote = pnote;
 509
 510     // pnote now can be used for encoding to DB
 511     CharacterDatabase.escape_string(pnote);
 512     CharacterDatabase.PExecute("UPDATE guild_member SET pnote = '%s' WHERE guid = '%u'", pnote.c_str(), itr->first);
 513 }
 514
 515 void Guild::SetOFFNOTE(uint64 guid,std::string offnote)
 516 {
 517     MemberList::iterator itr = members.find(GUID_LOPART(guid));
 518     if( itr == members.end() )
 519         return;
 520     itr->second.OFFnote = offnote;
 521     // offnote now can be used for encoding to DB
 522     CharacterDatabase.escape_string(offnote);
 523     CharacterDatabase.PExecute("UPDATE guild_member SET offnote = '%s' WHERE guid = '%u'", offnote.c_str(), itr->first);
 524 }
 525
 526 void Guild::BroadcastToGuild(WorldSession *session, const std::string& msg, uint32 language)
 527 {
 528     if (session && session->GetPlayer() && HasRankRight(session->GetPlayer()->GetRank(),GR_RIGHT_GCHATSPEAK))
 529     {
 530         WorldPacket data;
 531         ChatHandler(session).FillMessageData(&data, CHAT_MSG_GUILD, language, 0, msg.c_str());
 532
 533         for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 534         {
 535             Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
 536
 537             if (pl && pl->GetSession() && HasRankRight(pl->GetRank(),GR_RIGHT_GCHATLISTEN) && !pl->GetSocial()->HasIgnore(session->GetPlayer()->GetGUIDLow()) )
 538                 pl->GetSession()->SendPacket(&data);
 539         }
 540     }
 541 }
 542
 543 void Guild::BroadcastToOfficers(WorldSession *session, const std::string& msg, uint32 language)
 544 {
 545     if (session && session->GetPlayer() && HasRankRight(session->GetPlayer()->GetRank(),GR_RIGHT_OFFCHATSPEAK))
 546     {
 547         for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 548         {
 549             WorldPacket data;
 550             ChatHandler::FillMessageData(&data, session, CHAT_MSG_OFFICER, language, NULL, 0, msg.c_str(),NULL);
 551
 552             Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
 553
 554             if (pl && pl->GetSession() && HasRankRight(pl->GetRank(),GR_RIGHT_OFFCHATLISTEN) && !pl->GetSocial()->HasIgnore(session->GetPlayer()->GetGUIDLow()))
 555                 pl->GetSession()->SendPacket(&data);
 556         }
 557     }
 558 }
 559
 560 void Guild::BroadcastPacket(WorldPacket *packet)
 561 {
 562     for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 563     {
 564         Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
 565         if(player)
 566             player->GetSession()->SendPacket(packet);
 567     }
 568 }
 569
 570 void Guild::BroadcastPacketToRank(WorldPacket *packet, uint32 rankId)
 571 {
 572     for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 573     {
 574         if (itr->second.RankId == rankId)
 575         {
 576             Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
 577             if(player)
 578                 player->GetSession()->SendPacket(packet);
 579         }
 580     }
 581 }
 582
 583 void Guild::CreateRank(std::string name_,uint32 rights)
 584 {
 585     if(m_ranks.size() >= GUILD_MAX_RANKS)
 586         return;
 587
 588     AddRank(name_,rights,0);
 589
 590     for (int i = 0; i < purchased_tabs; ++i)
 591     {
 592         CreateBankRightForTab(m_ranks.size()-1, uint8(i));
 593     }
 594
 595     // guild_rank.rid always store rank+1 value
 596
 597     // name now can be used for encoding to DB
 598     CharacterDatabase.escape_string(name_);
 599     CharacterDatabase.PExecute( "INSERT INTO guild_rank (guildid,rid,rname,rights) VALUES ('%u', '%u', '%s', '%u')", Id, (unsigned int)m_ranks.size(), name_.c_str(), rights );
 600 }
 601
 602 void Guild::AddRank(const std::string& name_,uint32 rights, uint32 money)
 603 {
 604     m_ranks.push_back(RankInfo(name_,rights,money));
 605 }
 606
 607 void Guild::DelRank()
 608 {
 609     if(m_ranks.empty())
 610         return;
 611
 612     // guild_rank.rid always store rank+1 value
 613     uint32 rank = m_ranks.size()-1;
 614     CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE rid>='%u' AND guildid='%u'", (rank+1), Id);
 615
 616     m_ranks.pop_back();
 617 }
 618
 619 std::string Guild::GetRankName(uint32 rankId)
 620 {
 621     if(rankId >= m_ranks.size())
 622         return "<unknown>";
 623
 624     return m_ranks[rankId].name;
 625 }
 626
 627 uint32 Guild::GetRankRights(uint32 rankId)
 628 {
 629     if(rankId >= m_ranks.size())
 630         return 0;
 631
 632     return m_ranks[rankId].rights;
 633 }
 634
 635 void Guild::SetRankName(uint32 rankId, std::string name_)
 636 {
 637     if(rankId >= m_ranks.size())
 638         return;
 639
 640     m_ranks[rankId].name = name_;
 641
 642     // name now can be used for encoding to DB
 643     CharacterDatabase.escape_string(name_);
 644     CharacterDatabase.PExecute("UPDATE guild_rank SET rname='%s' WHERE rid='%u' AND guildid='%u'", name_.c_str(), (rankId+1), Id);
 645 }
 646
 647 void Guild::SetRankRights(uint32 rankId, uint32 rights)
 648 {
 649     if(rankId >= m_ranks.size())
 650         return;
 651
 652     m_ranks[rankId].rights = rights;
 653
 654     CharacterDatabase.PExecute("UPDATE guild_rank SET rights='%u' WHERE rid='%u' AND guildid='%u'", rights, (rankId+1), Id);
 655 }
 656
 657 int32 Guild::GetRank(uint32 LowGuid)
 658 {
 659     MemberList::const_iterator itr = members.find(LowGuid);
 660     if (itr==members.end())
 661         return -1;
 662
 663     return itr->second.RankId;
 664 }
 665
 666 void Guild::Disband()
 667 {
 668     WorldPacket data(SMSG_GUILD_EVENT, 1);
 669     data << (uint8)GE_DISBANDED;
 670     BroadcastPacket(&data);
 671
 672     while (!members.empty())
 673     {
 674         MemberList::const_iterator itr = members.begin();
 675         DelMember(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER), true);
 676     }
 677
 678     CharacterDatabase.BeginTransaction();
 679     CharacterDatabase.PExecute("DELETE FROM guild WHERE guildid = '%u'",Id);
 680     CharacterDatabase.PExecute("DELETE FROM guild_rank WHERE guildid = '%u'",Id);
 681     CharacterDatabase.PExecute("DELETE FROM guild_bank_tab WHERE guildid = '%u'",Id);
 682     CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid = '%u'",Id);
 683     CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid = '%u'",Id);
 684     CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid = '%u'",Id);
 685     CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid = '%u'",Id);
 686     CharacterDatabase.CommitTransaction();
 687     objmgr.RemoveGuild(Id);
 688 }
 689
 690 void Guild::Roster(WorldSession *session)
 691 {
 692                                                             // we can only guess size
 693     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));
 694     data << (uint32)members.size();
 695     data << MOTD;
 696     data << GINFO;
 697
 698     data << (uint32)m_ranks.size();
 699     for (RankList::const_iterator ritr = m_ranks.begin(); ritr != m_ranks.end(); ++ritr)
 700     {
 701         data << (uint32)ritr->rights;
 702         data << (uint32)ritr->BankMoneyPerDay;              // count of: withdraw gold(gold/day) Note: in game set gold, in packet set bronze.
 703         for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 704         {
 705             data << (uint32)ritr->TabRight[i];              // for TAB_i rights: view tabs = 0x01, deposit items =0x02
 706             data << (uint32)ritr->TabSlotPerDay[i];         // for TAB_i count of: withdraw items(stack/day)
 707         }
 708     }
 709     for (MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
 710     {
 711         if (Player *pl = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER)))
 712         {
 713             data << (uint64)pl->GetGUID();
 714             data << (uint8)1;
 715             data << (std::string)pl->GetName();
 716             data << (uint32)itr->second.RankId;
 717             data << (uint8)pl->getLevel();
 718             data << (uint8)pl->getClass();
 719             data << (uint8)0;                               // new 2.4.0
 720             data << (uint32)pl->GetZoneId();
 721             data << itr->second.Pnote;
 722             data << itr->second.OFFnote;
 723         }
 724         else
 725         {
 726             data << uint64(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
 727             data << (uint8)0;
 728             data << itr->second.name;
 729             data << (uint32)itr->second.RankId;
 730             data << (uint8)itr->second.level;
 731             data << (uint8)itr->second.Class;
 732             data << (uint8)0;                               // new 2.4.0
 733             data << (uint32)itr->second.zoneId;
 734             data << (float(time(NULL)-itr->second.logout_time) / DAY);
 735             data << itr->second.Pnote;
 736             data << itr->second.OFFnote;
 737         }
 738     }
 739     session->SendPacket(&data);;
 740     sLog.outDebug( "WORLD: Sent (SMSG_GUILD_ROSTER)" );
 741 }
 742
 743 void Guild::Query(WorldSession *session)
 744 {
 745     WorldPacket data(SMSG_GUILD_QUERY_RESPONSE, (8*32+200));// we can only guess size
 746
 747     data << Id;
 748     data << name;
 749
 750     for (size_t i = 0 ; i < 10; ++i)                        // show always 10 ranks
 751     {
 752         if(i < m_ranks.size())
 753             data << m_ranks[i].name;
 754         else
 755             data << (uint8)0;                               // null string
 756     }
 757
 758     data << uint32(EmblemStyle);
 759     data << uint32(EmblemColor);
 760     data << uint32(BorderStyle);
 761     data << uint32(BorderColor);
 762     data << uint32(BackgroundColor);
 763     data << uint32(0);                                      // something new in WotLK
 764
 765     session->SendPacket( &data );
 766     sLog.outDebug( "WORLD: Sent (SMSG_GUILD_QUERY_RESPONSE)" );
 767 }
 768
 769 void Guild::SetEmblem(uint32 emblemStyle, uint32 emblemColor, uint32 borderStyle, uint32 borderColor, uint32 backgroundColor)
 770 {
 771     EmblemStyle = emblemStyle;
 772     EmblemColor = emblemColor;
 773     BorderStyle = borderStyle;
 774     BorderColor = borderColor;
 775     BackgroundColor = backgroundColor;
 776
 777     CharacterDatabase.PExecute("UPDATE guild SET EmblemStyle=%u, EmblemColor=%u, BorderStyle=%u, BorderColor=%u, BackgroundColor=%u WHERE guildid = %u", EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor, Id);
 778 }
 779
 780 void Guild::UpdateLogoutTime(uint64 guid)
 781 {
 782     MemberList::iterator itr = members.find(GUID_LOPART(guid));
 783     if (itr == members.end() )
 784         return;
 785
 786     itr->second.logout_time = time(NULL);
 787
 788     if (m_onlinemembers > 0)
 789         --m_onlinemembers;
 790     else
 791     {
 792         UnloadGuildBank();
 793         UnloadGuildEventlog();
 794     }
 795 }
 796
 797 // *************************************************
 798 // Guild Eventlog part
 799 // *************************************************
 800 // Display guild eventlog
 801 void Guild::DisplayGuildEventlog(WorldSession *session)
 802 {
 803     // Load guild eventlog, if not already done
 804     if (!m_eventlogloaded)
 805         LoadGuildEventLogFromDB();
 806
 807     // Sending result
 808     WorldPacket data(MSG_GUILD_EVENT_LOG_QUERY, 0);
 809     // count, max count == 100
 810     data << uint8(m_GuildEventlog.size());
 811     for (GuildEventlog::const_iterator itr = m_GuildEventlog.begin(); itr != m_GuildEventlog.end(); ++itr)
 812     {
 813         // Event type
 814         data << uint8((*itr)->EventType);
 815         // Player 1
 816         data << uint64((*itr)->PlayerGuid1);
 817         // Player 2 not for left/join guild events
 818         if( (*itr)->EventType != GUILD_EVENT_LOG_JOIN_GUILD && (*itr)->EventType != GUILD_EVENT_LOG_LEAVE_GUILD )
 819             data << uint64((*itr)->PlayerGuid2);
 820         // New Rank - only for promote/demote guild events
 821         if( (*itr)->EventType == GUILD_EVENT_LOG_PROMOTE_PLAYER || (*itr)->EventType == GUILD_EVENT_LOG_DEMOTE_PLAYER )
 822             data << uint8((*itr)->NewRank);
 823         // Event timestamp
 824         data << uint32(time(NULL)-(*itr)->TimeStamp);
 825     }
 826     session->SendPacket(&data);
 827     sLog.outDebug("WORLD: Sent (MSG_GUILD_EVENT_LOG_QUERY)");
 828 }
 829
 830 // Load guild eventlog from DB
 831 void Guild::LoadGuildEventLogFromDB()
 832 {
 833     // Return if already loaded
 834     if (m_eventlogloaded)
 835         return;
 836
 837     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);
 838     if(!result)
 839         return;
 840     do
 841     {
 842         Field *fields = result->Fetch();
 843         GuildEventlogEntry *NewEvent = new GuildEventlogEntry;
 844         // Fill entry
 845         NewEvent->LogGuid = fields[0].GetUInt32();
 846         NewEvent->EventType = fields[1].GetUInt8();
 847         NewEvent->PlayerGuid1 = fields[2].GetUInt32();
 848         NewEvent->PlayerGuid2 = fields[3].GetUInt32();
 849         NewEvent->NewRank = fields[4].GetUInt8();
 850         NewEvent->TimeStamp = fields[5].GetUInt64();
 851         // Add entry to map
 852         m_GuildEventlog.push_front(NewEvent);
 853
 854     } while( result->NextRow() );
 855     delete result;
 856
 857     // Check lists size in case to many event entries in db
 858     // This cases can happen only if a crash occured somewhere and table has too many log entries
 859     if (!m_GuildEventlog.empty())
 860     {
 861         CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid=%u AND LogGuid < %u", Id, m_GuildEventlog.front()->LogGuid);
 862     }
 863     m_eventlogloaded = true;
 864 }
 865
 866 // Unload guild eventlog
 867 void Guild::UnloadGuildEventlog()
 868 {
 869     if (!m_eventlogloaded)
 870         return;
 871     GuildEventlogEntry *EventLogEntry;
 872     if( !m_GuildEventlog.empty() )
 873     {
 874         do
 875         {
 876             EventLogEntry = *(m_GuildEventlog.begin());
 877             m_GuildEventlog.pop_front();
 878             delete EventLogEntry;
 879         }while( !m_GuildEventlog.empty() );
 880     }
 881     m_eventlogloaded = false;
 882 }
 883
 884 // This will renum guids used at load to prevent always going up until infinit
 885 void Guild::RenumGuildEventlog()
 886 {
 887     QueryResult *result = CharacterDatabase.PQuery("SELECT Min(LogGuid), Max(LogGuid) FROM guild_eventlog WHERE guildid = %u", Id);
 888     if(!result)
 889         return;
 890
 891     Field *fields = result->Fetch();
 892     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");
 893     GuildEventlogMaxGuid = fields[1].GetUInt32()+1;
 894     delete result;
 895 }
 896
 897 // Add entry to guild eventlog
 898 void Guild::LogGuildEvent(uint8 EventType, uint32 PlayerGuid1, uint32 PlayerGuid2, uint8 NewRank)
 899 {
 900     GuildEventlogEntry *NewEvent = new GuildEventlogEntry;
 901     // Fill entry
 902     NewEvent->LogGuid = GuildEventlogMaxGuid++;
 903     NewEvent->EventType = EventType;
 904     NewEvent->PlayerGuid1 = PlayerGuid1;
 905     NewEvent->PlayerGuid2 = PlayerGuid2;
 906     NewEvent->NewRank = NewRank;
 907     NewEvent->TimeStamp = uint32(time(NULL));
 908     // Check max entry limit and delete from db if needed
 909     if (m_GuildEventlog.size() > GUILD_EVENTLOG_MAX_ENTRIES)
 910     {
 911         GuildEventlogEntry *OldEvent = *(m_GuildEventlog.begin());
 912         m_GuildEventlog.pop_front();
 913         CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
 914         delete OldEvent;
 915     }
 916     // Add entry to map
 917     m_GuildEventlog.push_back(NewEvent);
 918     // Add new eventlog entry into DB
 919     CharacterDatabase.PExecute("INSERT INTO guild_eventlog (guildid, LogGuid, EventType, PlayerGuid1, PlayerGuid2, NewRank, TimeStamp) VALUES ('%u','%u','%u','%u','%u','%u','" I64FMTD "')",
 920         Id, NewEvent->LogGuid, uint32(NewEvent->EventType), NewEvent->PlayerGuid1, NewEvent->PlayerGuid2, uint32(NewEvent->NewRank), NewEvent->TimeStamp);
 921 }
 922
 923 // *************************************************
 924 // Guild Bank part
 925 // *************************************************
 926 // Bank content related
 927 void Guild::DisplayGuildBankContent(WorldSession *session, uint8 TabId)
 928 {
 929     WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
 930
 931     GuildBankTab const* tab = GetBankTab(TabId);
 932     if (!tab)
 933         return;
 934
 935     if(!IsMemberHaveRights(session->GetPlayer()->GetGUIDLow(),TabId,GUILD_BANK_RIGHT_VIEW_TAB))
 936         return;
 937
 938     data << uint64(GetGuildBankMoney());
 939     data << uint8(TabId);
 940                                                             // remaining slots for today
 941     data << uint32(GetMemberSlotWithdrawRem(session->GetPlayer()->GetGUIDLow(), TabId));
 942     data << uint8(0);                                       // Tell client this is a tab content packet
 943
 944     data << uint8(GUILD_BANK_MAX_SLOTS);
 945
 946     for (int i=0; i<GUILD_BANK_MAX_SLOTS; ++i)
 947         AppendDisplayGuildBankSlot(data, tab, i);
 948
 949     session->SendPacket(&data);
 950
 951     sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
 952 }
 953
 954 void Guild::DisplayGuildBankMoneyUpdate()
 955 {
 956     WorldPacket data(SMSG_GUILD_BANK_LIST, 8+1+4+1+1);
 957
 958     data << uint64(GetGuildBankMoney());
 959     data << uint8(0);                                       // TabId, default 0
 960     data << uint32(0);                                      // slot withdrow, default 0
 961     data << uint8(0);                                       // Tell client this is a tab content packet
 962     data << uint8(0);                                       // not send items
 963     BroadcastPacket(&data);
 964
 965     sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
 966 }
 967
 968 void Guild::DisplayGuildBankContentUpdate(uint8 TabId, int32 slot1, int32 slot2)
 969 {
 970     GuildBankTab const* tab = GetBankTab(TabId);
 971     if (!tab)
 972         return;
 973
 974     WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
 975
 976     data << uint64(GetGuildBankMoney());
 977     data << uint8(TabId);
 978     // remaining slots for today
 979
 980     size_t rempos = data.wpos();
 981     data << uint32(0);                                      // will be filled later
 982     data << uint8(0);                                       // Tell client this is a tab content packet
 983
 984     if(slot2==-1)                                           // single item in slot1
 985     {
 986         data << uint8(1);
 987
 988         AppendDisplayGuildBankSlot(data, tab, slot1);
 989     }
 990     else                                                    // 2 items (in slot1 and slot2)
 991     {
 992         data << uint8(2);
 993
 994         if(slot1 > slot2)
 995             std::swap(slot1,slot2);
 996
 997         AppendDisplayGuildBankSlot(data, tab, slot1);
 998         AppendDisplayGuildBankSlot(data, tab, slot2);
 999     }
1000
1001     for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
1002     {
1003         Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
1004         if(!player)
1005             continue;
1006
1007         if(!IsMemberHaveRights(itr->first,TabId,GUILD_BANK_RIGHT_VIEW_TAB))
1008             continue;
1009
1010         data.put<uint32>(rempos,uint32(GetMemberSlotWithdrawRem(player->GetGUIDLow(), TabId)));
1011
1012         player->GetSession()->SendPacket(&data);
1013     }
1014
1015     sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1016 }
1017
1018 void Guild::DisplayGuildBankContentUpdate(uint8 TabId, GuildItemPosCountVec const& slots)
1019 {
1020     GuildBankTab const* tab = GetBankTab(TabId);
1021     if (!tab)
1022         return;
1023
1024     WorldPacket data(SMSG_GUILD_BANK_LIST,1200);
1025
1026     data << uint64(GetGuildBankMoney());
1027     data << uint8(TabId);
1028     // remaining slots for today
1029
1030     size_t rempos = data.wpos();
1031     data << uint32(0);                                      // will be filled later
1032     data << uint8(0);                                       // Tell client this is a tab content packet
1033
1034     data << uint8(slots.size());                            // updates count
1035
1036     for(GuildItemPosCountVec::const_iterator itr = slots.begin(); itr != slots.end(); ++itr)
1037         AppendDisplayGuildBankSlot(data, tab, itr->slot);
1038
1039     for(MemberList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
1040     {
1041         Player *player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER));
1042         if(!player)
1043             continue;
1044
1045         if(!IsMemberHaveRights(itr->first,TabId,GUILD_BANK_RIGHT_VIEW_TAB))
1046             continue;
1047
1048         data.put<uint32>(rempos,uint32(GetMemberSlotWithdrawRem(player->GetGUIDLow(), TabId)));
1049
1050         player->GetSession()->SendPacket(&data);
1051     }
1052
1053     sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1054 }
1055
1056 Item* Guild::GetItem(uint8 TabId, uint8 SlotId)
1057 {
1058     if (TabId >= m_TabListMap.size() || SlotId >= GUILD_BANK_MAX_SLOTS)
1059         return NULL;
1060     return m_TabListMap[TabId]->Slots[SlotId];
1061 }
1062
1063 // *************************************************
1064 // Tab related
1065
1066 void Guild::DisplayGuildBankTabsInfo(WorldSession *session)
1067 {
1068     // Time to load bank if not already done
1069     if (!m_bankloaded)
1070         LoadGuildBankFromDB();
1071
1072     WorldPacket data(SMSG_GUILD_BANK_LIST, 500);
1073
1074     data << uint64(GetGuildBankMoney());
1075     data << uint8(0);                                       // TabInfo packet must be for TabId 0
1076     data << uint32(0xFFFFFFFF);                             // bit 9 must be set for this packet to work
1077     data << uint8(1);                                       // Tell Client this is a TabInfo packet
1078
1079     data << uint8(purchased_tabs);                          // here is the number of tabs
1080
1081     for(int i = 0; i < purchased_tabs; ++i)
1082     {
1083         data << m_TabListMap[i]->Name.c_str();
1084         data << m_TabListMap[i]->Icon.c_str();
1085     }
1086     data << uint8(0);                                       // Do not send tab content
1087     session->SendPacket(&data);
1088
1089     sLog.outDebug("WORLD: Sent (SMSG_GUILD_BANK_LIST)");
1090 }
1091
1092 void Guild::CreateNewBankTab()
1093 {
1094     if (purchased_tabs >= GUILD_BANK_MAX_TABS)
1095         return;
1096
1097     ++purchased_tabs;
1098
1099     GuildBankTab* AnotherTab = new GuildBankTab;
1100     memset(AnotherTab->Slots, 0, GUILD_BANK_MAX_SLOTS * sizeof(Item*));
1101     m_TabListMap.resize(purchased_tabs);
1102     m_TabListMap[purchased_tabs-1] = AnotherTab;
1103
1104     CharacterDatabase.BeginTransaction();
1105     CharacterDatabase.PExecute("DELETE FROM guild_bank_tab WHERE guildid='%u' AND TabId='%u'", Id, uint32(purchased_tabs-1));
1106     CharacterDatabase.PExecute("INSERT INTO guild_bank_tab (guildid,TabId) VALUES ('%u','%u')", Id, uint32(purchased_tabs-1));
1107     CharacterDatabase.CommitTransaction();
1108 }
1109
1110 void Guild::SetGuildBankTabInfo(uint8 TabId, std::string Name, std::string Icon)
1111 {
1112     if (TabId >= GUILD_BANK_MAX_TABS)
1113         return;
1114     if (TabId >= m_TabListMap.size())
1115         return;
1116
1117     if (!m_TabListMap[TabId])
1118         return;
1119
1120     if(m_TabListMap[TabId]->Name == Name && m_TabListMap[TabId]->Icon == Icon)
1121         return;
1122
1123     m_TabListMap[TabId]->Name = Name;
1124     m_TabListMap[TabId]->Icon = Icon;
1125
1126     CharacterDatabase.escape_string(Name);
1127     CharacterDatabase.escape_string(Icon);
1128     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));
1129 }
1130
1131 void Guild::CreateBankRightForTab(uint32 rankId, uint8 TabId)
1132 {
1133     sLog.outDebug("CreateBankRightForTab. rank: %u, TabId: %u", rankId, uint32(TabId));
1134     if (rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1135         return;
1136
1137     m_ranks[rankId].TabRight[TabId]=0;
1138     m_ranks[rankId].TabSlotPerDay[TabId]=0;
1139     CharacterDatabase.BeginTransaction();
1140     CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid = '%u' AND TabId = '%u' AND rid = '%u'", Id, uint32(TabId), rankId);
1141     CharacterDatabase.PExecute("INSERT INTO guild_bank_right (guildid,TabId,rid) VALUES ('%u','%u','%u')", Id, uint32(TabId), rankId);
1142     CharacterDatabase.CommitTransaction();
1143 }
1144
1145 uint32 Guild::GetBankRights(uint32 rankId, uint8 TabId) const
1146 {
1147     if(rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1148         return 0;
1149
1150     return m_ranks[rankId].TabRight[TabId];
1151 }
1152
1153 // *************************************************
1154 // Guild bank loading/unloading related
1155
1156 // This load should be called when the bank is first accessed by a guild member
1157 void Guild::LoadGuildBankFromDB()
1158 {
1159     if (m_bankloaded)
1160         return;
1161
1162     m_bankloaded = true;
1163     LoadGuildBankEventLogFromDB();
1164
1165     //                                                     0      1        2        3
1166     QueryResult *result = CharacterDatabase.PQuery("SELECT TabId, TabName, TabIcon, TabText FROM guild_bank_tab WHERE guildid='%u' ORDER BY TabId", Id);
1167     if(!result)
1168     {
1169         purchased_tabs = 0;
1170         return;
1171     }
1172
1173     m_TabListMap.resize(purchased_tabs);
1174     do
1175     {
1176         Field *fields = result->Fetch();
1177         uint8 TabId = fields[0].GetUInt8();
1178
1179         GuildBankTab *NewTab = new GuildBankTab;
1180         memset(NewTab->Slots, 0, GUILD_BANK_MAX_SLOTS * sizeof(Item*));
1181
1182         NewTab->Name = fields[1].GetCppString();
1183         NewTab->Icon = fields[2].GetCppString();
1184         NewTab->Text = fields[3].GetCppString();
1185
1186         m_TabListMap[TabId] = NewTab;
1187     }while( result->NextRow() );
1188
1189     delete result;
1190
1191     // data needs to be at first place for Item::LoadFromDB
1192     //                                        0     1      2       3          4
1193     result = CharacterDatabase.PQuery("SELECT data, TabId, SlotId, item_guid, item_entry FROM guild_bank_item JOIN item_instance ON item_guid = guid WHERE guildid='%u' ORDER BY TabId", Id);
1194     if(!result)
1195         return;
1196
1197     do
1198     {
1199         Field *fields = result->Fetch();
1200         uint8 TabId = fields[1].GetUInt8();
1201         uint8 SlotId = fields[2].GetUInt8();
1202         uint32 ItemGuid = fields[3].GetUInt32();
1203         uint32 ItemEntry = fields[4].GetUInt32();
1204
1205         if (TabId >= purchased_tabs || TabId >= GUILD_BANK_MAX_TABS)
1206         {
1207             sLog.outError( "Guild::LoadGuildBankFromDB: Invalid tab for item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1208             continue;
1209         }
1210
1211         if (SlotId >= GUILD_BANK_MAX_SLOTS)
1212         {
1213             sLog.outError( "Guild::LoadGuildBankFromDB: Invalid slot for item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1214             continue;
1215         }
1216
1217         ItemPrototype const *proto = objmgr.GetItemPrototype(ItemEntry);
1218
1219         if(!proto)
1220         {
1221             sLog.outError( "Guild::LoadGuildBankFromDB: Unknown item (GUID: %u id: #%u) in guild bank, skipped.", ItemGuid,ItemEntry);
1222             continue;
1223         }
1224
1225         Item *pItem = NewItemOrBag(proto);
1226         if(!pItem->LoadFromDB(ItemGuid, 0, result))
1227         {
1228             CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid='%u' AND TabId='%u' AND SlotId='%u'", Id, uint32(TabId), uint32(SlotId));
1229             sLog.outError("Item GUID %u not found in item_instance, deleting from Guild Bank!", ItemGuid);
1230             delete pItem;
1231             continue;
1232         }
1233
1234         pItem->AddToWorld();
1235         m_TabListMap[TabId]->Slots[SlotId] = pItem;
1236     }while( result->NextRow() );
1237
1238     delete result;
1239 }
1240
1241 // This unload should be called when the last member of the guild gets offline
1242 void Guild::UnloadGuildBank()
1243 {
1244     if (!m_bankloaded)
1245         return;
1246     for (uint8 i = 0 ; i < purchased_tabs ; ++i )
1247     {
1248         for (uint8 j = 0 ; j < GUILD_BANK_MAX_SLOTS ; ++j)
1249         {
1250             if (m_TabListMap[i]->Slots[j])
1251             {
1252                 m_TabListMap[i]->Slots[j]->RemoveFromWorld();
1253                 delete m_TabListMap[i]->Slots[j];
1254             }
1255         }
1256         delete m_TabListMap[i];
1257     }
1258     m_TabListMap.clear();
1259
1260     UnloadGuildBankEventLog();
1261     m_bankloaded = false;
1262 }
1263
1264 // *************************************************
1265 // Money deposit/withdraw related
1266
1267 void Guild::SendMoneyInfo(WorldSession *session, uint32 LowGuid)
1268 {
1269     WorldPacket data(MSG_GUILD_BANK_MONEY_WITHDRAWN, 4);
1270     data << uint32(GetMemberMoneyWithdrawRem(LowGuid));
1271     session->SendPacket(&data);
1272     sLog.outDebug("WORLD: Sent MSG_GUILD_BANK_MONEY_WITHDRAWN");
1273 }
1274
1275 bool Guild::MemberMoneyWithdraw(uint32 amount, uint32 LowGuid)
1276 {
1277     uint32 MoneyWithDrawRight = GetMemberMoneyWithdrawRem(LowGuid);
1278
1279     if (MoneyWithDrawRight < amount || GetGuildBankMoney() < amount)
1280         return false;
1281
1282     SetBankMoney(GetGuildBankMoney()-amount);
1283
1284     if (MoneyWithDrawRight < WITHDRAW_MONEY_UNLIMITED)
1285     {
1286         MemberList::iterator itr = members.find(LowGuid);
1287         if (itr == members.end() )
1288             return false;
1289         itr->second.BankRemMoney -= amount;
1290         CharacterDatabase.PExecute("UPDATE guild_member SET BankRemMoney='%u' WHERE guildid='%u' AND guid='%u'",
1291             itr->second.BankRemMoney, Id, LowGuid);
1292     }
1293     return true;
1294 }
1295
1296 void Guild::SetBankMoney(int64 money)
1297 {
1298     if (money < 0)                                          // I don't know how this happens, it does!!
1299         money = 0;
1300     guildbank_money = money;
1301
1302     CharacterDatabase.PExecute("UPDATE guild SET BankMoney='" I64FMTD "' WHERE guildid='%u'", money, Id);
1303 }
1304
1305 // *************************************************
1306 // Item per day and money per day related
1307
1308 bool Guild::MemberItemWithdraw(uint8 TabId, uint32 LowGuid)
1309 {
1310     uint32 SlotsWithDrawRight = GetMemberSlotWithdrawRem(LowGuid, TabId);
1311
1312     if (SlotsWithDrawRight == 0)
1313         return false;
1314
1315     if (SlotsWithDrawRight < WITHDRAW_SLOT_UNLIMITED)
1316     {
1317         MemberList::iterator itr = members.find(LowGuid);
1318         if (itr == members.end() )
1319             return false;
1320         --itr->second.BankRemSlotsTab[TabId];
1321         CharacterDatabase.PExecute("UPDATE guild_member SET BankRemSlotsTab%u='%u' WHERE guildid='%u' AND guid='%u'",
1322             uint32(TabId), itr->second.BankRemSlotsTab[TabId], Id, LowGuid);
1323     }
1324     return true;
1325 }
1326
1327 bool Guild::IsMemberHaveRights(uint32 LowGuid, uint8 TabId, uint32 rights) const
1328 {
1329     MemberList::const_iterator itr = members.find(LowGuid);
1330     if (itr == members.end() )
1331         return false;
1332
1333     if (itr->second.RankId == GR_GUILDMASTER)
1334         return true;
1335
1336     return (GetBankRights(itr->second.RankId,TabId) & rights)==rights;
1337 }
1338
1339 uint32 Guild::GetMemberSlotWithdrawRem(uint32 LowGuid, uint8 TabId)
1340 {
1341     MemberList::iterator itr = members.find(LowGuid);
1342     if (itr == members.end() )
1343         return 0;
1344
1345     if (itr->second.RankId == GR_GUILDMASTER)
1346         return WITHDRAW_SLOT_UNLIMITED;
1347
1348     if((GetBankRights(itr->second.RankId,TabId) & GUILD_BANK_RIGHT_VIEW_TAB)!=GUILD_BANK_RIGHT_VIEW_TAB)
1349         return 0;
1350
1351     uint32 curTime = uint32(time(NULL)/MINUTE);
1352     if (curTime - itr->second.BankResetTimeTab[TabId] >= 24*HOUR/MINUTE)
1353     {
1354         itr->second.BankResetTimeTab[TabId] = curTime;
1355         itr->second.BankRemSlotsTab[TabId] = GetBankSlotPerDay(itr->second.RankId, TabId);
1356         CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeTab%u='%u',BankRemSlotsTab%u='%u' WHERE guildid='%u' AND guid='%u'",
1357             uint32(TabId), itr->second.BankResetTimeTab[TabId], uint32(TabId), itr->second.BankRemSlotsTab[TabId], Id, LowGuid);
1358     }
1359     return itr->second.BankRemSlotsTab[TabId];
1360 }
1361
1362 uint32 Guild::GetMemberMoneyWithdrawRem(uint32 LowGuid)
1363 {
1364     MemberList::iterator itr = members.find(LowGuid);
1365     if (itr == members.end() )
1366         return 0;
1367
1368     if (itr->second.RankId == GR_GUILDMASTER)
1369         return WITHDRAW_MONEY_UNLIMITED;
1370
1371     uint32 curTime = uint32(time(NULL)/MINUTE);             // minutes
1372                                                             // 24 hours
1373     if (curTime > itr->second.BankResetTimeMoney + 24*HOUR/MINUTE)
1374     {
1375         itr->second.BankResetTimeMoney = curTime;
1376         itr->second.BankRemMoney = GetBankMoneyPerDay(itr->second.RankId);
1377         CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeMoney='%u',BankRemMoney='%u' WHERE guildid='%u' AND guid='%u'",
1378             itr->second.BankResetTimeMoney, itr->second.BankRemMoney, Id, LowGuid);
1379     }
1380     return itr->second.BankRemMoney;
1381 }
1382
1383 void Guild::SetBankMoneyPerDay(uint32 rankId, uint32 money)
1384 {
1385     if (rankId >= m_ranks.size())
1386         return;
1387
1388     if (rankId == GR_GUILDMASTER)
1389         money = WITHDRAW_MONEY_UNLIMITED;
1390
1391     m_ranks[rankId].BankMoneyPerDay = money;
1392
1393     for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
1394         if (itr->second.RankId == rankId)
1395             itr->second.BankResetTimeMoney = 0;
1396
1397     CharacterDatabase.PExecute("UPDATE guild_rank SET BankMoneyPerDay='%u' WHERE rid='%u' AND guildid='%u'", money, (rankId+1), Id);
1398     CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeMoney='0' WHERE guildid='%u' AND rank='%u'", Id, rankId);
1399 }
1400
1401 void Guild::SetBankRightsAndSlots(uint32 rankId, uint8 TabId, uint32 right, uint32 nbSlots, bool db)
1402 {
1403     if(rankId >= m_ranks.size() ||
1404         TabId >= GUILD_BANK_MAX_TABS ||
1405         TabId >= purchased_tabs)
1406         return;
1407
1408     if (rankId == GR_GUILDMASTER)
1409     {
1410         nbSlots = WITHDRAW_SLOT_UNLIMITED;
1411         right = GUILD_BANK_RIGHT_FULL;
1412     }
1413
1414     m_ranks[rankId].TabSlotPerDay[TabId]=nbSlots;
1415     m_ranks[rankId].TabRight[TabId]=right;
1416
1417     if (db)
1418     {
1419         for (MemberList::iterator itr = members.begin(); itr != members.end(); ++itr)
1420             if (itr->second.RankId == rankId)
1421                 for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1422                     itr->second.BankResetTimeTab[i] = 0;
1423
1424         CharacterDatabase.PExecute("DELETE FROM guild_bank_right WHERE guildid='%u' AND TabId='%u' AND rid='%u'", Id, uint32(TabId), rankId);
1425         CharacterDatabase.PExecute("INSERT INTO guild_bank_right (guildid,TabId,rid,gbright,SlotPerDay) VALUES "
1426             "('%u','%u','%u','%u','%u')", Id, uint32(TabId), rankId, m_ranks[rankId].TabRight[TabId], m_ranks[rankId].TabSlotPerDay[TabId]);
1427         CharacterDatabase.PExecute("UPDATE guild_member SET BankResetTimeTab%u='0' WHERE guildid='%u' AND rank='%u'", uint32(TabId), Id, rankId);
1428     }
1429 }
1430
1431 uint32 Guild::GetBankMoneyPerDay(uint32 rankId)
1432 {
1433     if(rankId >= m_ranks.size())
1434         return 0;
1435
1436     if (rankId == GR_GUILDMASTER)
1437         return WITHDRAW_MONEY_UNLIMITED;
1438     return m_ranks[rankId].BankMoneyPerDay;
1439 }
1440
1441 uint32 Guild::GetBankSlotPerDay(uint32 rankId, uint8 TabId)
1442 {
1443     if(rankId >= m_ranks.size() || TabId >= GUILD_BANK_MAX_TABS)
1444         return 0;
1445
1446     if (rankId == GR_GUILDMASTER)
1447         return WITHDRAW_SLOT_UNLIMITED;
1448     return m_ranks[rankId].TabSlotPerDay[TabId];
1449 }
1450
1451 // *************************************************
1452 // Rights per day related
1453
1454 void Guild::LoadBankRightsFromDB(uint32 GuildId)
1455 {
1456     //                                                     0      1    2        3
1457     QueryResult *result = CharacterDatabase.PQuery("SELECT TabId, rid, gbright, SlotPerDay FROM guild_bank_right WHERE guildid = '%u' ORDER BY TabId", GuildId);
1458
1459     if(!result)
1460         return;
1461
1462     do
1463     {
1464         Field *fields = result->Fetch();
1465         uint8 TabId = fields[0].GetUInt8();
1466         uint32 rankId = fields[1].GetUInt32();
1467         uint16 right = fields[2].GetUInt16();
1468         uint16 SlotPerDay = fields[3].GetUInt16();
1469
1470         SetBankRightsAndSlots(rankId, TabId, right, SlotPerDay, false);
1471
1472     }while( result->NextRow() );
1473     delete result;
1474
1475     return;
1476 }
1477
1478 // *************************************************
1479 // Bank log related
1480
1481 void Guild::LoadGuildBankEventLogFromDB()
1482 {
1483     // We can't add a limit as in Guild::LoadGuildEventLogFromDB since we fetch both money and bank log and know nothing about the composition
1484     //                                                     0        1         2      3           4            5               6          7
1485     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);
1486     if(!result)
1487         return;
1488
1489     do
1490     {
1491         Field *fields = result->Fetch();
1492         GuildBankEvent *NewEvent = new GuildBankEvent;
1493
1494         NewEvent->LogGuid = fields[0].GetUInt32();
1495         NewEvent->LogEntry = fields[1].GetUInt8();
1496         uint8 TabId = fields[2].GetUInt8();
1497         NewEvent->PlayerGuid = fields[3].GetUInt32();
1498         NewEvent->ItemOrMoney = fields[4].GetUInt32();
1499         NewEvent->ItemStackCount = fields[5].GetUInt8();
1500         NewEvent->DestTabId = fields[6].GetUInt8();
1501         NewEvent->TimeStamp = fields[7].GetUInt64();
1502
1503         if (TabId >= GUILD_BANK_MAX_TABS)
1504         {
1505             sLog.outError( "Guild::LoadGuildBankEventLogFromDB: Invalid tabid '%u' for guild bank log entry (guild: '%s', LogGuid: %u), skipped.", TabId, GetName().c_str(), NewEvent->LogGuid);
1506             delete NewEvent;
1507             continue;
1508         }
1509         if (NewEvent->isMoneyEvent() && m_GuildBankEventLog_Money.size() >= GUILD_BANK_MAX_LOGS
1510                 || m_GuildBankEventLog_Item[TabId].size() >= GUILD_BANK_MAX_LOGS)
1511         {
1512             delete NewEvent;
1513             continue;
1514         }
1515         if (NewEvent->isMoneyEvent())
1516             m_GuildBankEventLog_Money.push_front(NewEvent);
1517         else
1518             m_GuildBankEventLog_Item[TabId].push_front(NewEvent);
1519
1520     }while( result->NextRow() );
1521     delete result;
1522
1523     // Check lists size in case to many event entries in db for a tab or for money
1524     // This cases can happen only if a crash occured somewhere and table has too many log entries
1525     if (!m_GuildBankEventLog_Money.empty())
1526     {
1527         CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid=%u AND LogGuid < %u",
1528             Id, m_GuildBankEventLog_Money.front()->LogGuid);
1529     }
1530     for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1531     {
1532         if (!m_GuildBankEventLog_Item[i].empty())
1533         {
1534             CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid=%u AND LogGuid < %u",
1535                 Id, m_GuildBankEventLog_Item[i].front()->LogGuid);
1536         }
1537     }
1538 }
1539
1540 void Guild::UnloadGuildBankEventLog()
1541 {
1542     GuildBankEvent *EventLogEntry;
1543     if( !m_GuildBankEventLog_Money.empty() )
1544     {
1545         do
1546         {
1547             EventLogEntry = *(m_GuildBankEventLog_Money.begin());
1548             m_GuildBankEventLog_Money.pop_front();
1549             delete EventLogEntry;
1550         }while( !m_GuildBankEventLog_Money.empty() );
1551     }
1552
1553     for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
1554     {
1555         if( !m_GuildBankEventLog_Item[i].empty() )
1556         {
1557             do
1558             {
1559                 EventLogEntry = *(m_GuildBankEventLog_Item[i].begin());
1560                 m_GuildBankEventLog_Item[i].pop_front();
1561                 delete EventLogEntry;
1562             }while( !m_GuildBankEventLog_Item[i].empty() );
1563         }
1564     }
1565 }
1566
1567 void Guild::DisplayGuildBankLogs(WorldSession *session, uint8 TabId)
1568 {
1569     if (TabId > GUILD_BANK_MAX_TABS)
1570         return;
1571
1572     if (TabId == GUILD_BANK_MAX_TABS)
1573     {
1574         // Here we display money logs
1575         WorldPacket data(MSG_GUILD_BANK_LOG_QUERY, m_GuildBankEventLog_Money.size()*(4*4+1)+1+1);
1576         data << uint8(TabId);                               // Here GUILD_BANK_MAX_TABS
1577         data << uint8(m_GuildBankEventLog_Money.size());    // number of log entries
1578         for (GuildBankEventLog::const_iterator itr = m_GuildBankEventLog_Money.begin(); itr != m_GuildBankEventLog_Money.end(); ++itr)
1579         {
1580             data << uint8((*itr)->LogEntry);
1581             data << uint64(MAKE_NEW_GUID((*itr)->PlayerGuid,0,HIGHGUID_PLAYER));
1582             if ((*itr)->LogEntry == GUILD_BANK_LOG_DEPOSIT_MONEY ||
1583                 (*itr)->LogEntry == GUILD_BANK_LOG_WITHDRAW_MONEY ||
1584                 (*itr)->LogEntry == GUILD_BANK_LOG_REPAIR_MONEY ||
1585                 (*itr)->LogEntry == GUILD_BANK_LOG_UNK1 ||
1586                 (*itr)->LogEntry == GUILD_BANK_LOG_UNK2)
1587             {
1588                 data << uint32((*itr)->ItemOrMoney);
1589             }
1590             else
1591             {
1592                 data << uint32((*itr)->ItemOrMoney);
1593                 data << uint32((*itr)->ItemStackCount);
1594                 if ((*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM || (*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM2)
1595                     data << uint8((*itr)->DestTabId);       // moved tab
1596             }
1597             data << uint32(time(NULL)-(*itr)->TimeStamp);
1598         }
1599         session->SendPacket(&data);
1600     }
1601     else
1602     {
1603         // here we display current tab logs
1604         WorldPacket data(MSG_GUILD_BANK_LOG_QUERY, m_GuildBankEventLog_Item[TabId].size()*(4*4+1+1)+1+1);
1605         data << uint8(TabId);                               // Here a real Tab Id
1606                                                             // number of log entries
1607         data << uint8(m_GuildBankEventLog_Item[TabId].size());
1608         for (GuildBankEventLog::const_iterator itr = m_GuildBankEventLog_Item[TabId].begin(); itr != m_GuildBankEventLog_Item[TabId].end(); ++itr)
1609         {
1610             data << uint8((*itr)->LogEntry);
1611             data << uint64(MAKE_NEW_GUID((*itr)->PlayerGuid,0,HIGHGUID_PLAYER));
1612             if ((*itr)->LogEntry == GUILD_BANK_LOG_DEPOSIT_MONEY ||
1613                 (*itr)->LogEntry == GUILD_BANK_LOG_WITHDRAW_MONEY ||
1614                 (*itr)->LogEntry == GUILD_BANK_LOG_REPAIR_MONEY ||
1615                 (*itr)->LogEntry == GUILD_BANK_LOG_UNK1 ||
1616                 (*itr)->LogEntry == GUILD_BANK_LOG_UNK2)
1617             {
1618                 data << uint32((*itr)->ItemOrMoney);
1619             }
1620             else
1621             {
1622                 data << uint32((*itr)->ItemOrMoney);
1623                 data << uint32((*itr)->ItemStackCount);
1624                 if ((*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM || (*itr)->LogEntry == GUILD_BANK_LOG_MOVE_ITEM2)
1625                     data << uint8((*itr)->DestTabId);       // moved tab
1626             }
1627             data << uint32(time(NULL)-(*itr)->TimeStamp);
1628         }
1629         session->SendPacket(&data);
1630     }
1631     sLog.outDebug("WORLD: Sent (MSG_GUILD_BANK_LOG_QUERY)");
1632 }
1633
1634 void Guild::LogBankEvent(uint8 LogEntry, uint8 TabId, uint32 PlayerGuidLow, uint32 ItemOrMoney, uint8 ItemStackCount, uint8 DestTabId)
1635 {
1636     GuildBankEvent *NewEvent = new GuildBankEvent;
1637
1638     NewEvent->LogGuid = LogMaxGuid++;
1639     NewEvent->LogEntry = LogEntry;
1640     NewEvent->PlayerGuid = PlayerGuidLow;
1641     NewEvent->ItemOrMoney = ItemOrMoney;
1642     NewEvent->ItemStackCount = ItemStackCount;
1643     NewEvent->DestTabId = DestTabId;
1644     NewEvent->TimeStamp = uint32(time(NULL));
1645
1646     if (NewEvent->isMoneyEvent())
1647     {
1648         if (m_GuildBankEventLog_Money.size() > GUILD_BANK_MAX_LOGS)
1649         {
1650             GuildBankEvent *OldEvent = *(m_GuildBankEventLog_Money.begin());
1651             m_GuildBankEventLog_Money.pop_front();
1652             CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
1653             delete OldEvent;
1654         }
1655         m_GuildBankEventLog_Money.push_back(NewEvent);
1656     }
1657     else
1658     {
1659         if (m_GuildBankEventLog_Item[TabId].size() > GUILD_BANK_MAX_LOGS)
1660         {
1661             GuildBankEvent *OldEvent = *(m_GuildBankEventLog_Item[TabId].begin());
1662             m_GuildBankEventLog_Item[TabId].pop_front();
1663             CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE guildid='%u' AND LogGuid='%u'", Id, OldEvent->LogGuid);
1664             delete OldEvent;
1665         }
1666         m_GuildBankEventLog_Item[TabId].push_back(NewEvent);
1667     }
1668     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 "')",
1669         Id, NewEvent->LogGuid, uint32(NewEvent->LogEntry), uint32(TabId), NewEvent->PlayerGuid, NewEvent->ItemOrMoney, uint32(NewEvent->ItemStackCount), uint32(NewEvent->DestTabId), NewEvent->TimeStamp);
1670 }
1671
1672 // This will renum guids used at load to prevent always going up until infinit
1673 void Guild::RenumBankLogs()
1674 {
1675     QueryResult *result = CharacterDatabase.PQuery("SELECT Min(LogGuid), Max(LogGuid) FROM guild_bank_eventlog WHERE guildid = %u", Id);
1676     if(!result)
1677         return;
1678
1679     Field *fields = result->Fetch();
1680     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");
1681     LogMaxGuid = fields[1].GetUInt32()+1;
1682     delete result;
1683 }
1684
1685 bool Guild::AddGBankItemToDB(uint32 GuildId, uint32 BankTab , uint32 BankTabSlot , uint32 GUIDLow, uint32 Entry )
1686 {
1687     CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid = '%u' AND TabId = '%u'AND SlotId = '%u'", GuildId, BankTab, BankTabSlot);
1688     CharacterDatabase.PExecute("INSERT INTO guild_bank_item (guildid,TabId,SlotId,item_guid,item_entry) "
1689         "VALUES ('%u', '%u', '%u', '%u', '%u')", GuildId, BankTab, BankTabSlot, GUIDLow, Entry);
1690     return true;
1691 }
1692
1693 void Guild::AppendDisplayGuildBankSlot( WorldPacket& data, GuildBankTab const *tab, int slot )
1694 {
1695     Item *pItem = tab->Slots[slot];
1696     uint32 entry = pItem ? pItem->GetEntry() : 0;
1697
1698     data << uint8(slot);
1699     data << uint32(entry);
1700     if (entry)
1701     {
1702         // random item property id +8
1703         data << (uint32) pItem->GetItemRandomPropertyId();
1704         if (pItem->GetItemRandomPropertyId())
1705             // SuffixFactor +4
1706             data << (uint32) pItem->GetItemSuffixFactor();
1707         // +12 // ITEM_FIELD_STACK_COUNT
1708         data << uint32(pItem->GetCount());
1709         data << uint32(0);                                  // +16 // Unknown value
1710         data << uint8(0);                                   // unknown 2.4.2
1711         if (uint32 Enchant0 = pItem->GetEnchantmentId(PERM_ENCHANTMENT_SLOT))
1712         {
1713             data << uint8(1);                               // number of enchantments (max 3) why max 3?
1714             data << uint8(PERM_ENCHANTMENT_SLOT);           // enchantment slot (range: 0:2)
1715             data << uint32(Enchant0);                       // enchantment id
1716         }
1717         else
1718             data << uint8(0);                               // no enchantments (0)
1719     }
1720 }
1721
1722 Item* Guild::StoreItem(uint8 tabId, GuildItemPosCountVec const& dest, Item* pItem )
1723 {
1724     if( !pItem )
1725         return NULL;
1726
1727     Item* lastItem = pItem;
1728
1729     for(GuildItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); )
1730     {
1731         uint8 slot = itr->slot;
1732         uint32 count = itr->count;
1733
1734         ++itr;
1735
1736         if(itr == dest.end())
1737         {
1738             lastItem = _StoreItem(tabId,slot,pItem,count,false);
1739             break;
1740         }
1741
1742         lastItem = _StoreItem(tabId,slot,pItem,count,true);
1743     }
1744
1745     return lastItem;
1746 }
1747
1748 // Return stored item (if stored to stack, it can diff. from pItem). And pItem ca be deleted in this case.
1749 Item* Guild::_StoreItem( uint8 tab, uint8 slot, Item *pItem, uint32 count, bool clone )
1750 {
1751     if( !pItem )
1752         return NULL;
1753
1754     sLog.outDebug( "GUILD STORAGE: StoreItem tab = %u, slot = %u, item = %u, count = %u", tab, slot, pItem->GetEntry(), count);
1755
1756     Item* pItem2 = m_TabListMap[tab]->Slots[slot];
1757
1758     if( !pItem2 )
1759     {
1760         if(clone)
1761             pItem = pItem->CloneItem(count);
1762         else
1763             pItem->SetCount(count);
1764
1765         if(!pItem)
1766             return NULL;
1767
1768         m_TabListMap[tab]->Slots[slot] = pItem;
1769
1770         pItem->SetUInt64Value(ITEM_FIELD_CONTAINED, 0);
1771         pItem->SetUInt64Value(ITEM_FIELD_OWNER, 0);
1772         AddGBankItemToDB(GetId(), tab, slot, pItem->GetGUIDLow(), pItem->GetEntry());
1773         pItem->FSetState(ITEM_NEW);
1774         pItem->SaveToDB();                                  // not in onventory and can be save standalone
1775
1776         return pItem;
1777     }
1778     else
1779     {
1780         pItem2->SetCount( pItem2->GetCount() + count );
1781         pItem2->FSetState(ITEM_CHANGED);
1782         pItem2->SaveToDB();                                 // not in onventory and can be save standalone
1783
1784         if(!clone)
1785         {
1786             pItem->RemoveFromWorld();
1787             pItem->DeleteFromDB();
1788             delete pItem;
1789         }
1790
1791         return pItem2;
1792     }
1793 }
1794
1795 void Guild::RemoveItem(uint8 tab, uint8 slot )
1796 {
1797     m_TabListMap[tab]->Slots[slot] = NULL;
1798     CharacterDatabase.PExecute("DELETE FROM guild_bank_item WHERE guildid='%u' AND TabId='%u' AND SlotId='%u'",
1799         GetId(), uint32(tab), uint32(slot));
1800 }
1801
1802 uint8 Guild::_CanStoreItem_InSpecificSlot( uint8 tab, uint8 slot, GuildItemPosCountVec &dest, uint32& count, bool swap, Item* pSrcItem ) const
1803 {
1804     Item* pItem2 = m_TabListMap[tab]->Slots[slot];
1805
1806     // ignore move item (this slot will be empty at move)
1807     if(pItem2==pSrcItem)
1808         pItem2 = NULL;
1809
1810     uint32 need_space;
1811
1812     // empty specific slot - check item fit to slot
1813     if( !pItem2 || swap )
1814     {
1815         // non empty stack with space
1816         need_space = pSrcItem->GetMaxStackCount();
1817     }
1818     // non empty slot, check item type
1819     else
1820     {
1821         // check item type
1822         if(pItem2->GetEntry() != pSrcItem->GetEntry())
1823             return EQUIP_ERR_ITEM_CANT_STACK;
1824
1825         // check free space
1826         if(pItem2->GetCount() >= pSrcItem->GetMaxStackCount())
1827             return EQUIP_ERR_ITEM_CANT_STACK;
1828
1829         need_space = pSrcItem->GetMaxStackCount() - pItem2->GetCount();
1830     }
1831
1832     if(need_space > count)
1833         need_space = count;
1834
1835     GuildItemPosCount newPosition = GuildItemPosCount(slot,need_space);
1836     if(!newPosition.isContainedIn(dest))
1837     {
1838         dest.push_back(newPosition);
1839         count -= need_space;
1840     }
1841
1842     return EQUIP_ERR_OK;
1843 }
1844
1845 uint8 Guild::_CanStoreItem_InTab( uint8 tab, GuildItemPosCountVec &dest, uint32& count, bool merge, Item* pSrcItem, uint8 skip_slot ) const
1846 {
1847     for(uint32 j = 0; j < GUILD_BANK_MAX_SLOTS; j++)
1848     {
1849         // skip specific slot already processed in first called _CanStoreItem_InSpecificSlot
1850         if(j==skip_slot)
1851             continue;
1852
1853         Item* pItem2 = m_TabListMap[tab]->Slots[j];
1854
1855         // ignore move item (this slot will be empty at move)
1856         if(pItem2==pSrcItem)
1857             pItem2 = NULL;
1858
1859         // if merge skip empty, if !merge skip non-empty
1860         if((pItem2!=NULL)!=merge)
1861             continue;
1862
1863         if( pItem2 )
1864         {
1865             if(pItem2->GetEntry() == pSrcItem->GetEntry() && pItem2->GetCount() < pSrcItem->GetMaxStackCount() )
1866             {
1867                 uint32 need_space = pSrcItem->GetMaxStackCount() - pItem2->GetCount();
1868                 if(need_space > count)
1869                     need_space = count;
1870
1871                 GuildItemPosCount newPosition = GuildItemPosCount(j,need_space);
1872                 if(!newPosition.isContainedIn(dest))
1873                 {
1874                     dest.push_back(newPosition);
1875                     count -= need_space;
1876
1877                     if(count==0)
1878                         return EQUIP_ERR_OK;
1879                 }
1880             }
1881         }
1882         else
1883         {
1884             uint32 need_space = pSrcItem->GetMaxStackCount();
1885             if(need_space > count)
1886                 need_space = count;
1887
1888             GuildItemPosCount newPosition = GuildItemPosCount(j,need_space);
1889             if(!newPosition.isContainedIn(dest))
1890             {
1891                 dest.push_back(newPosition);
1892                 count -= need_space;
1893
1894                 if(count==0)
1895                     return EQUIP_ERR_OK;
1896             }
1897         }
1898     }
1899     return EQUIP_ERR_OK;
1900 }
1901
1902 uint8 Guild::CanStoreItem( uint8 tab, uint8 slot, GuildItemPosCountVec &dest, uint32 count, Item *pItem, bool swap ) const
1903 {
1904     sLog.outDebug( "GUILD STORAGE: CanStoreItem tab = %u, slot = %u, item = %u, count = %u", tab, slot, pItem->GetEntry(), count);
1905
1906     if(count > pItem->GetCount())
1907         return EQUIP_ERR_COULDNT_SPLIT_ITEMS;
1908
1909     if(pItem->IsSoulBound())
1910         return EQUIP_ERR_CANT_DROP_SOULBOUND;
1911
1912     // in specific slot
1913     if( slot != NULL_SLOT )
1914     {
1915         uint8 res = _CanStoreItem_InSpecificSlot(tab,slot,dest,count,swap,pItem);
1916         if(res!=EQUIP_ERR_OK)
1917             return res;
1918
1919         if(count==0)
1920             return EQUIP_ERR_OK;
1921     }
1922
1923     // not specific slot or have spece for partly store only in specific slot
1924
1925     // search stack in tab for merge to
1926     if( pItem->GetMaxStackCount() > 1 )
1927     {
1928         uint8 res = _CanStoreItem_InTab(tab,dest,count,true,pItem,slot);
1929         if(res!=EQUIP_ERR_OK)
1930             return res;
1931
1932         if(count==0)
1933             return EQUIP_ERR_OK;
1934     }
1935
1936     // search free slot in bag for place to
1937     uint8 res = _CanStoreItem_InTab(tab,dest,count,false,pItem,slot);
1938     if(res!=EQUIP_ERR_OK)
1939         return res;
1940
1941     if(count==0)
1942         return EQUIP_ERR_OK;
1943
1944     return EQUIP_ERR_BANK_FULL;
1945 }
1946
1947 void Guild::SetGuildBankTabText(uint8 TabId, std::string text)
1948 {
1949     if (TabId >= GUILD_BANK_MAX_TABS)
1950         return;
1951     if (TabId >= m_TabListMap.size())
1952         return;
1953     if (!m_TabListMap[TabId])
1954         return;
1955
1956     if(m_TabListMap[TabId]->Text==text)
1957         return;
1958
1959     utf8truncate(text,500);                                 // DB and client size limitation
1960
1961     m_TabListMap[TabId]->Text = text;
1962
1963     CharacterDatabase.escape_string(text);
1964     CharacterDatabase.PExecute("UPDATE guild_bank_tab SET TabText='%s' WHERE guildid='%u' AND TabId='%u'", text.c_str(), Id, uint32(TabId));
1965
1966     // announce
1967     SendGuildBankTabText(NULL,TabId);
1968 }
1969
1970 void Guild::SendGuildBankTabText(WorldSession *session, uint8 TabId)
1971 {
1972     if (TabId > GUILD_BANK_MAX_TABS)
1973         return;
1974
1975     GuildBankTab const *tab = GetBankTab(TabId);
1976     if (!tab)
1977         return;
1978
1979     WorldPacket data(MSG_QUERY_GUILD_BANK_TEXT, 1+tab->Text.size()+1);
1980     data << uint8(TabId);
1981     data << tab->Text;
1982
1983     if(session)
1984         session->SendPacket(&data);
1985     else
1986         BroadcastPacket(&data);
1987
1988 }
1989
1990 bool GuildItemPosCount::isContainedIn(GuildItemPosCountVec const &vec) const
1991 {
1992     for(GuildItemPosCountVec::const_iterator itr = vec.begin(); itr != vec.end();++itr)
1993         if(itr->slot == slot)
1994             return true;
1995
1996     return false;
1997 }