src/game/GuildHandler.cpp

   1 /*
   2  * Copyright (C) 2005-2010 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 "Common.h"
  20 #include "WorldPacket.h"
  21 #include "WorldSession.h"
  22 #include "World.h"
  23 #include "ObjectMgr.h"
  24 #include "Log.h"
  25 #include "Opcodes.h"
  26 #include "Guild.h"
  27 #include "GossipDef.h"
  28 #include "SocialMgr.h"
  29
  30 void WorldSession::HandleGuildQueryOpcode(WorldPacket& recvPacket)
  31 {
  32     sLog.outDebug("WORLD: Received CMSG_GUILD_QUERY");
  33
  34     uint32 guildId;
  35     recvPacket >> guildId;
  36
  37     if(Guild *guild = sObjectMgr.GetGuildById(guildId))
  38     {
  39         guild->Query(this);
  40         return;
  41     }
  42
  43     SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
  44 }
  45
  46 void WorldSession::HandleGuildCreateOpcode(WorldPacket& recvPacket)
  47 {
  48     sLog.outDebug("WORLD: Received CMSG_GUILD_CREATE");
  49
  50     std::string gname;
  51     recvPacket >> gname;
  52
  53     if(GetPlayer()->GetGuildId())                           // already in guild
  54         return;
  55
  56     Guild *guild = new Guild;
  57     if(!guild->Create(GetPlayer(), gname))
  58     {
  59         delete guild;
  60         return;
  61     }
  62
  63     sObjectMgr.AddGuild(guild);
  64 }
  65
  66 void WorldSession::HandleGuildInviteOpcode(WorldPacket& recvPacket)
  67 {
  68     sLog.outDebug("WORLD: Received CMSG_GUILD_INVITE");
  69
  70     std::string Invitedname, plname;
  71     Player * player = NULL;
  72
  73     recvPacket >> Invitedname;
  74
  75     if(normalizePlayerName(Invitedname))
  76         player = ObjectAccessor::FindPlayerByName(Invitedname.c_str());
  77
  78     if(!player)
  79     {
  80         SendGuildCommandResult(GUILD_INVITE_S, Invitedname, ERR_GUILD_PLAYER_NOT_FOUND_S);
  81         return;
  82     }
  83
  84     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
  85     if(!guild)
  86     {
  87         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
  88         return;
  89     }
  90
  91     // OK result but not send invite
  92     if(player->GetSocial()->HasIgnore(GetPlayer()->GetGUIDLow()))
  93         return;
  94
  95     // not let enemies sign guild charter
  96     if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeam() != GetPlayer()->GetTeam())
  97     {
  98         SendGuildCommandResult(GUILD_INVITE_S, Invitedname, ERR_GUILD_NOT_ALLIED);
  99         return;
 100     }
 101
 102     if(player->GetGuildId())
 103     {
 104         plname = player->GetName();
 105         SendGuildCommandResult(GUILD_INVITE_S, plname, ERR_ALREADY_IN_GUILD_S);
 106         return;
 107     }
 108
 109     if(player->GetGuildIdInvited())
 110     {
 111         plname = player->GetName();
 112         SendGuildCommandResult(GUILD_INVITE_S, plname, ERR_ALREADY_INVITED_TO_GUILD_S);
 113         return;
 114     }
 115
 116     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_INVITE))
 117     {
 118         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 119         return;
 120     }
 121
 122     sLog.outDebug("Player %s Invited %s to Join his Guild", GetPlayer()->GetName(), Invitedname.c_str());
 123
 124     player->SetGuildIdInvited(GetPlayer()->GetGuildId());
 125     // Put record into guildlog
 126     guild->LogGuildEvent(GUILD_EVENT_LOG_INVITE_PLAYER, GetPlayer()->GetGUIDLow(), player->GetGUIDLow(), 0);
 127
 128     WorldPacket data(SMSG_GUILD_INVITE, (8+10));            // guess size
 129     data << GetPlayer()->GetName();
 130     data << guild->GetName();
 131     player->GetSession()->SendPacket(&data);
 132
 133     sLog.outDebug("WORLD: Sent (SMSG_GUILD_INVITE)");
 134 }
 135
 136 void WorldSession::HandleGuildRemoveOpcode(WorldPacket& recvPacket)
 137 {
 138     sLog.outDebug("WORLD: Received CMSG_GUILD_REMOVE");
 139
 140     std::string plName;
 141     recvPacket >> plName;
 142
 143     if(!normalizePlayerName(plName))
 144         return;
 145
 146     Guild* guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 147     if(!guild)
 148     {
 149         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 150         return;
 151     }
 152
 153     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_REMOVE))
 154     {
 155         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 156         return;
 157     }
 158
 159     uint64 plGuid;
 160     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 161     if(!slot)
 162     {
 163         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 164         return;
 165     }
 166
 167     if(slot->RankId == GR_GUILDMASTER)
 168     {
 169         SendGuildCommandResult(GUILD_QUIT_S, "", ERR_GUILD_LEADER_LEAVE);
 170         return;
 171     }
 172
 173     // do not allow to kick player with same or higher rights
 174     if(GetPlayer()->GetRank() >= slot->RankId)
 175     {
 176         SendGuildCommandResult(GUILD_QUIT_S, plName, ERR_GUILD_RANK_TOO_HIGH_S);
 177         return;
 178     }
 179
 180     guild->DelMember(plGuid);
 181     // Put record into guild log
 182     guild->LogGuildEvent(GUILD_EVENT_LOG_UNINVITE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), 0);
 183
 184     guild->BroadcastEvent(GE_REMOVED, 0, 2, plName, _player->GetName(), "");
 185 }
 186
 187 void WorldSession::HandleGuildAcceptOpcode(WorldPacket& /*recvPacket*/)
 188 {
 189     Guild *guild;
 190     Player *player = GetPlayer();
 191
 192     sLog.outDebug("WORLD: Received CMSG_GUILD_ACCEPT");
 193
 194     guild = sObjectMgr.GetGuildById(player->GetGuildIdInvited());
 195     if(!guild || player->GetGuildId())
 196         return;
 197
 198     // not let enemies sign guild charter
 199     if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeam() != sObjectMgr.GetPlayerTeamByGUID(guild->GetLeader()))
 200         return;
 201
 202     if(!guild->AddMember(GetPlayer()->GetGUID(),guild->GetLowestRank()))
 203         return;
 204     // Put record into guild log
 205     guild->LogGuildEvent(GUILD_EVENT_LOG_JOIN_GUILD, GetPlayer()->GetGUIDLow(), 0, 0);
 206
 207     guild->BroadcastEvent(GE_JOINED, player->GetGUID(), 1, player->GetName(), "", "");
 208 }
 209
 210 void WorldSession::HandleGuildDeclineOpcode(WorldPacket& /*recvPacket*/)
 211 {
 212     sLog.outDebug("WORLD: Received CMSG_GUILD_DECLINE");
 213
 214     GetPlayer()->SetGuildIdInvited(0);
 215     GetPlayer()->SetInGuild(0);
 216 }
 217
 218 void WorldSession::HandleGuildInfoOpcode(WorldPacket& /*recvPacket*/)
 219 {
 220     sLog.outDebug("WORLD: Received CMSG_GUILD_INFO");
 221
 222     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 223     if(!guild)
 224     {
 225         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 226         return;
 227     }
 228
 229     WorldPacket data(SMSG_GUILD_INFO, (5*4 + guild->GetName().size() + 1));
 230     data << guild->GetName();
 231     data << guild->GetCreatedDay();
 232     data << guild->GetCreatedMonth();
 233     data << guild->GetCreatedYear();
 234     data << guild->GetMemberSize();
 235     data << guild->GetMemberSize();
 236
 237     SendPacket(&data);
 238 }
 239
 240 void WorldSession::HandleGuildRosterOpcode(WorldPacket& /*recvPacket*/)
 241 {
 242     sLog.outDebug("WORLD: Received CMSG_GUILD_ROSTER");
 243
 244     if(Guild* guild = sObjectMgr.GetGuildById(_player->GetGuildId()))
 245         guild->Roster(this);
 246 }
 247
 248 void WorldSession::HandleGuildPromoteOpcode(WorldPacket& recvPacket)
 249 {
 250     sLog.outDebug("WORLD: Received CMSG_GUILD_PROMOTE");
 251
 252     std::string plName;
 253     recvPacket >> plName;
 254
 255     if(!normalizePlayerName(plName))
 256         return;
 257
 258     Guild* guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 259     if(!guild)
 260     {
 261         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 262         return;
 263     }
 264     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_PROMOTE))
 265     {
 266         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 267         return;
 268     }
 269
 270     uint64 plGuid;
 271     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 272
 273     if(!slot)
 274     {
 275         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 276         return;
 277     }
 278
 279     if(plGuid == GetPlayer()->GetGUID())
 280     {
 281         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_NAME_INVALID);
 282         return;
 283     }
 284
 285     // allow to promote only to lower rank than member's rank
 286     // guildmaster's rank = 0
 287     // GetPlayer()->GetRank() + 1 is highest rank that current player can promote to
 288     if(GetPlayer()->GetRank() + 1 >= slot->RankId)
 289     {
 290         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_RANK_TOO_HIGH_S);
 291         return;
 292     }
 293
 294     uint32 newRankId = slot->RankId - 1;                    //when promoting player, rank is decreased
 295
 296     guild->ChangeRank(plGuid, newRankId);
 297     // Put record into guild log
 298     guild->LogGuildEvent(GUILD_EVENT_LOG_PROMOTE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), newRankId);
 299
 300     guild->BroadcastEvent(GE_PROMOTION, 0, 3, _player->GetName(), plName, guild->GetRankName(newRankId));
 301 }
 302
 303 void WorldSession::HandleGuildDemoteOpcode(WorldPacket& recvPacket)
 304 {
 305     sLog.outDebug("WORLD: Received CMSG_GUILD_DEMOTE");
 306
 307     std::string plName;
 308     recvPacket >> plName;
 309
 310     if(!normalizePlayerName(plName))
 311         return;
 312
 313     Guild* guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 314
 315     if(!guild)
 316     {
 317         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 318         return;
 319     }
 320
 321     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_DEMOTE))
 322     {
 323         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 324         return;
 325     }
 326
 327     uint64 plGuid;
 328     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 329
 330     if (!slot)
 331     {
 332         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 333         return;
 334     }
 335
 336     if(plGuid == GetPlayer()->GetGUID())
 337     {
 338         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_NAME_INVALID);
 339         return;
 340     }
 341
 342     // do not allow to demote same or higher rank
 343     if(GetPlayer()->GetRank() >= slot->RankId)
 344     {
 345         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_RANK_TOO_HIGH_S);
 346         return;
 347     }
 348
 349     // do not allow to demote lowest rank
 350     if(slot->RankId >= guild->GetLowestRank())
 351     {
 352         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_RANK_TOO_LOW_S);
 353         return;
 354     }
 355
 356     uint32 newRankId = slot->RankId + 1;                    //when demoting player, rank is increased
 357
 358     guild->ChangeRank(plGuid, newRankId);
 359     // Put record into guild log
 360     guild->LogGuildEvent(GUILD_EVENT_LOG_DEMOTE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), newRankId);
 361
 362     guild->BroadcastEvent(GE_DEMOTION, 0, 3, _player->GetName(), plName, guild->GetRankName(slot->RankId));
 363 }
 364
 365 void WorldSession::HandleGuildLeaveOpcode(WorldPacket& /*recvPacket*/)
 366 {
 367     sLog.outDebug("WORLD: Received CMSG_GUILD_LEAVE");
 368
 369     Guild *guild = sObjectMgr.GetGuildById(_player->GetGuildId());
 370     if(!guild)
 371     {
 372         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 373         return;
 374     }
 375
 376     if(_player->GetGUID() == guild->GetLeader() && guild->GetMemberSize() > 1)
 377     {
 378         SendGuildCommandResult(GUILD_QUIT_S, "", ERR_GUILD_LEADER_LEAVE);
 379         return;
 380     }
 381
 382     if(_player->GetGUID() == guild->GetLeader())
 383     {
 384         guild->Disband();
 385         return;
 386     }
 387
 388     guild->DelMember(_player->GetGUID());
 389     // Put record into guild log
 390     guild->LogGuildEvent(GUILD_EVENT_LOG_LEAVE_GUILD, _player->GetGUIDLow(), 0, 0);
 391
 392     guild->BroadcastEvent(GE_LEFT, _player->GetGUID(), 1, _player->GetName(), "", "");
 393
 394     SendGuildCommandResult(GUILD_QUIT_S, guild->GetName(), ERR_PLAYER_NO_MORE_IN_GUILD);
 395 }
 396
 397 void WorldSession::HandleGuildDisbandOpcode(WorldPacket& /*recvPacket*/)
 398 {
 399     sLog.outDebug("WORLD: Received CMSG_GUILD_DISBAND");
 400
 401     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 402     if(!guild)
 403     {
 404         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 405         return;
 406     }
 407
 408     if(GetPlayer()->GetGUID() != guild->GetLeader())
 409     {
 410         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 411         return;
 412     }
 413
 414     guild->Disband();
 415
 416     sLog.outDebug("WORLD: Guild Successfully Disbanded");
 417 }
 418
 419 void WorldSession::HandleGuildLeaderOpcode(WorldPacket& recvPacket)
 420 {
 421     sLog.outDebug("WORLD: Received CMSG_GUILD_LEADER");
 422
 423     std::string name;
 424     recvPacket >> name;
 425
 426     Player *oldLeader = GetPlayer();
 427
 428     if(!normalizePlayerName(name))
 429         return;
 430
 431     Guild *guild = sObjectMgr.GetGuildById(oldLeader->GetGuildId());
 432
 433     if (!guild)
 434     {
 435         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 436         return;
 437     }
 438
 439     if (oldLeader->GetGUID() != guild->GetLeader())
 440     {
 441         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 442         return;
 443     }
 444
 445     uint64 newLeaderGUID;
 446     MemberSlot* slot = guild->GetMemberSlot(name, newLeaderGUID);
 447
 448     if (!slot)
 449     {
 450         SendGuildCommandResult(GUILD_INVITE_S, name, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 451         return;
 452     }
 453
 454     guild->SetLeader(newLeaderGUID);
 455     guild->ChangeRank(oldLeader->GetGUID(), GR_OFFICER);
 456
 457     guild->BroadcastEvent(GE_LEADER_CHANGED, 0, 2, oldLeader->GetName(), name, "");
 458 }
 459
 460 void WorldSession::HandleGuildMOTDOpcode(WorldPacket& recvPacket)
 461 {
 462     sLog.outDebug("WORLD: Received CMSG_GUILD_MOTD");
 463
 464     std::string MOTD;
 465
 466     if(!recvPacket.empty())
 467         recvPacket >> MOTD;
 468     else
 469         MOTD = "";
 470
 471     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 472     if(!guild)
 473     {
 474         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 475         return;
 476     }
 477     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_SETMOTD))
 478     {
 479         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 480         return;
 481     }
 482
 483     guild->SetMOTD(MOTD);
 484
 485     guild->BroadcastEvent(GE_MOTD, 0, 1, MOTD, "", "");
 486 }
 487
 488 void WorldSession::HandleGuildSetPublicNoteOpcode(WorldPacket& recvPacket)
 489 {
 490     sLog.outDebug("WORLD: Received CMSG_GUILD_SET_PUBLIC_NOTE");
 491
 492     std::string name,PNOTE;
 493     recvPacket >> name;
 494
 495     if(!normalizePlayerName(name))
 496         return;
 497
 498     Guild* guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 499
 500     if (!guild)
 501     {
 502         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 503         return;
 504     }
 505
 506     if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_EPNOTE))
 507     {
 508         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 509         return;
 510     }
 511
 512     uint64 plGuid;
 513     MemberSlot* slot = guild->GetMemberSlot(name, plGuid);
 514
 515     if (!slot)
 516     {
 517         SendGuildCommandResult(GUILD_INVITE_S, name, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 518         return;
 519     }
 520
 521     recvPacket >> PNOTE;
 522     guild->SetPNOTE(plGuid, PNOTE);
 523
 524     guild->Roster(this);
 525 }
 526
 527 void WorldSession::HandleGuildSetOfficerNoteOpcode(WorldPacket& recvPacket)
 528 {
 529     sLog.outDebug("WORLD: Received CMSG_GUILD_SET_OFFICER_NOTE");
 530
 531     std::string plName, OFFNOTE;
 532     recvPacket >> plName;
 533
 534     if (!normalizePlayerName(plName))
 535         return;
 536
 537     Guild* guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 538
 539     if (!guild)
 540     {
 541         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 542         return;
 543     }
 544     if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_EOFFNOTE))
 545     {
 546         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 547         return;
 548     }
 549
 550     uint64 plGuid;
 551     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 552
 553     if (!slot)
 554     {
 555         SendGuildCommandResult(GUILD_INVITE_S, plName, ERR_GUILD_PLAYER_NOT_IN_GUILD_S);
 556         return;
 557     }
 558
 559     recvPacket >> OFFNOTE;
 560     guild->SetOFFNOTE(plGuid, OFFNOTE);
 561
 562     guild->Roster(this);
 563 }
 564
 565 void WorldSession::HandleGuildRankOpcode(WorldPacket& recvPacket)
 566 {
 567     std::string rankname;
 568     uint32 rankId;
 569     uint32 rights, MoneyPerDay;
 570
 571     sLog.outDebug("WORLD: Received CMSG_GUILD_RANK");
 572
 573     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 574     if(!guild)
 575     {
 576         recvPacket.rpos(recvPacket.wpos());                 // set to end to avoid warnings spam
 577         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 578         return;
 579     }
 580     else if(GetPlayer()->GetGUID() != guild->GetLeader())
 581     {
 582         recvPacket.rpos(recvPacket.wpos());                 // set to end to avoid warnings spam
 583         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 584         return;
 585     }
 586
 587     recvPacket >> rankId;
 588     recvPacket >> rights;
 589     recvPacket >> rankname;
 590     recvPacket >> MoneyPerDay;
 591
 592     for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 593     {
 594         uint32 BankRights;
 595         uint32 BankSlotPerDay;
 596
 597         recvPacket >> BankRights;
 598         recvPacket >> BankSlotPerDay;
 599         guild->SetBankRightsAndSlots(rankId, uint8(i), uint16(BankRights & 0xFF), uint16(BankSlotPerDay), true);
 600     }
 601
 602     sLog.outDebug("WORLD: Changed RankName to %s , Rights to 0x%.4X", rankname.c_str(), rights);
 603
 604     guild->SetBankMoneyPerDay(rankId, MoneyPerDay);
 605     guild->SetRankName(rankId, rankname);
 606
 607     if (rankId == GR_GUILDMASTER)                           // prevent loss leader rights
 608         rights = GR_RIGHT_ALL;
 609
 610     guild->SetRankRights(rankId, rights);
 611
 612     guild->Query(this);
 613     guild->Roster();                                        // broadcast for tab rights update
 614 }
 615
 616 void WorldSession::HandleGuildAddRankOpcode(WorldPacket& recvPacket)
 617 {
 618     sLog.outDebug("WORLD: Received CMSG_GUILD_ADD_RANK");
 619
 620     std::string rankname;
 621     recvPacket >> rankname;
 622
 623     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 624     if(!guild)
 625     {
 626         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 627         return;
 628     }
 629
 630     if(GetPlayer()->GetGUID() != guild->GetLeader())
 631     {
 632         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 633         return;
 634     }
 635
 636     if(guild->GetRanksSize() >= GUILD_RANKS_MAX_COUNT)      // client not let create more 10 than ranks
 637         return;
 638
 639     guild->CreateRank(rankname, GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
 640
 641     guild->Query(this);
 642     guild->Roster();                                        // broadcast for tab rights update
 643 }
 644
 645 void WorldSession::HandleGuildDelRankOpcode(WorldPacket& /*recvPacket*/)
 646 {
 647     sLog.outDebug("WORLD: Received CMSG_GUILD_DEL_RANK");
 648
 649     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 650     if(!guild)
 651     {
 652         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 653         return;
 654     }
 655     else if(GetPlayer()->GetGUID() != guild->GetLeader())
 656     {
 657         SendGuildCommandResult(GUILD_INVITE_S, "", ERR_GUILD_PERMISSIONS);
 658         return;
 659     }
 660
 661     guild->DelRank();
 662
 663     guild->Query(this);
 664     guild->Roster();                                        // broadcast for tab rights update
 665 }
 666
 667 void WorldSession::SendGuildCommandResult(uint32 typecmd, const std::string& str,uint32 cmdresult)
 668 {
 669     WorldPacket data(SMSG_GUILD_COMMAND_RESULT, (8+str.size()+1));
 670     data << typecmd;
 671     data << str;
 672     data << cmdresult;
 673     SendPacket(&data);
 674
 675     sLog.outDebug("WORLD: Sent (SMSG_GUILD_COMMAND_RESULT)");
 676 }
 677
 678 void WorldSession::HandleGuildChangeInfoTextOpcode(WorldPacket& recvPacket)
 679 {
 680     sLog.outDebug("WORLD: Received CMSG_GUILD_INFO_TEXT");
 681
 682     std::string GINFO;
 683     recvPacket >> GINFO;
 684
 685     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 686     if(!guild)
 687     {
 688         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 689         return;
 690     }
 691
 692     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_MODIFY_GUILD_INFO))
 693     {
 694         SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PERMISSIONS);
 695         return;
 696     }
 697
 698     guild->SetGINFO(GINFO);
 699 }
 700
 701 void WorldSession::HandleSaveGuildEmblemOpcode(WorldPacket& recvPacket)
 702 {
 703     sLog.outDebug("WORLD: Received MSG_SAVE_GUILD_EMBLEM");
 704
 705     uint64 vendorGuid;
 706     uint32 EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor;
 707
 708     recvPacket >> vendorGuid;
 709     recvPacket >> EmblemStyle >> EmblemColor >> BorderStyle >> BorderColor >> BackgroundColor;
 710
 711     Creature *pCreature = GetPlayer()->GetNPCIfCanInteractWith(vendorGuid,UNIT_NPC_FLAG_TABARDDESIGNER);
 712     if (!pCreature)
 713     {
 714         //"That's not an emblem vendor!"
 715         SendSaveGuildEmblem(ERR_GUILDEMBLEM_INVALIDVENDOR);
 716         sLog.outDebug("WORLD: HandleSaveGuildEmblemOpcode - Unit (GUID: %u) not found or you can't interact with him.", GUID_LOPART(vendorGuid));
 717         return;
 718     }
 719
 720     // remove fake death
 721     if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
 722         GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
 723
 724     Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
 725     if(!guild)
 726     {
 727         //"You are not part of a guild!";
 728         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOGUILD);
 729         return;
 730     }
 731
 732     if (guild->GetLeader() != GetPlayer()->GetGUID())
 733     {
 734         //"Only guild leaders can create emblems."
 735         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOTGUILDMASTER);
 736         return;
 737     }
 738
 739     if(GetPlayer()->GetMoney() < 10*GOLD)
 740     {
 741         //"You can't afford to do that."
 742         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOTENOUGHMONEY);
 743         return;
 744     }
 745
 746     GetPlayer()->ModifyMoney(-10*GOLD);
 747     guild->SetEmblem(EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor);
 748
 749     //"Guild Emblem saved."
 750     SendSaveGuildEmblem(ERR_GUILDEMBLEM_SUCCESS);
 751
 752     guild->Query(this);
 753 }
 754
 755 void WorldSession::HandleGuildEventLogQueryOpcode(WorldPacket& /* recvPacket */)
 756 {
 757                                                             // empty
 758     sLog.outDebug("WORLD: Received (MSG_GUILD_EVENT_LOG_QUERY)");
 759
 760     if(uint32 GuildId = GetPlayer()->GetGuildId())
 761         if(Guild *pGuild = sObjectMgr.GetGuildById(GuildId))
 762             pGuild->DisplayGuildEventLog(this);
 763 }
 764
 765 /******  GUILD BANK  *******/
 766
 767 void WorldSession::HandleGuildBankMoneyWithdrawn( WorldPacket & /* recv_data */ )
 768 {
 769     sLog.outDebug("WORLD: Received (MSG_GUILD_BANK_MONEY_WITHDRAWN)");
 770
 771     if(uint32 GuildId = GetPlayer()->GetGuildId())
 772         if(Guild *pGuild = sObjectMgr.GetGuildById(GuildId))
 773             pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
 774 }
 775
 776 void WorldSession::HandleGuildPermissions( WorldPacket& /* recv_data */ )
 777 {
 778     sLog.outDebug("WORLD: Received (MSG_GUILD_PERMISSIONS)");
 779
 780     if(uint32 GuildId = GetPlayer()->GetGuildId())
 781     {
 782         if(Guild *pGuild = sObjectMgr.GetGuildById(GuildId))
 783         {
 784             uint32 rankId = GetPlayer()->GetRank();
 785
 786             WorldPacket data(MSG_GUILD_PERMISSIONS, 4*15+1);
 787             data << uint32(rankId);                                 // guild rank id
 788             data << uint32(pGuild->GetRankRights(rankId));          // rank rights
 789             // money per day left
 790             data << uint32(pGuild->GetMemberMoneyWithdrawRem(GetPlayer()->GetGUIDLow()));
 791             data << uint8(pGuild->GetPurchasedTabs());              // tabs count
 792             // why sending all info when not all tabs are purchased???
 793             for(int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 794             {
 795                 data << uint32(pGuild->GetBankRights(rankId, uint8(i)));
 796                 data << uint32(pGuild->GetMemberSlotWithdrawRem(GetPlayer()->GetGUIDLow(), uint8(i)));
 797             }
 798             SendPacket(&data);
 799             sLog.outDebug("WORLD: Sent (MSG_GUILD_PERMISSIONS)");
 800         }
 801     }
 802 }
 803
 804 /* Called when clicking on Guild bank gameobject */
 805 void WorldSession::HandleGuildBankerActivate( WorldPacket & recv_data )
 806 {
 807     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANKER_ACTIVATE)");
 808
 809     uint64 GoGuid;
 810     uint8  unk;
 811     recv_data >> GoGuid >> unk;
 812
 813     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
 814         return;
 815
 816     if (uint32 GuildId = GetPlayer()->GetGuildId())
 817     {
 818         if(Guild *pGuild = sObjectMgr.GetGuildById(GuildId))
 819         {
 820             pGuild->DisplayGuildBankTabsInfo(this);         // this also will load guild bank if not yet
 821             return;
 822         }
 823     }
 824
 825     SendGuildCommandResult(GUILD_UNK1, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
 826 }
 827
 828 /* Called when opening guild bank tab only (first one) */
 829 void WorldSession::HandleGuildBankQueryTab( WorldPacket & recv_data )
 830 {
 831     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_QUERY_TAB)");
 832
 833     uint64 GoGuid;
 834     uint8 TabId, unk1;
 835     recv_data >> GoGuid >> TabId >> unk1;
 836
 837     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
 838         return;
 839
 840     uint32 GuildId = GetPlayer()->GetGuildId();
 841     if (!GuildId)
 842         return;
 843
 844     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
 845     if (!pGuild)
 846         return;
 847
 848     if (TabId >= pGuild->GetPurchasedTabs())
 849         return;
 850
 851     // Let's update the amount of gold the player can withdraw before displaying the content
 852     // This is useful if money withdraw right has changed
 853     pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
 854     pGuild->DisplayGuildBankContent(this, TabId);
 855 }
 856
 857 void WorldSession::HandleGuildBankDepositMoney( WorldPacket & recv_data )
 858 {
 859     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_DEPOSIT_MONEY)");
 860
 861     uint64 GoGuid;
 862     uint32 money;
 863     recv_data >> GoGuid >> money;
 864
 865     if (!money)
 866         return;
 867
 868     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
 869         return;
 870
 871     if (GetPlayer()->GetMoney() < money)
 872         return;
 873
 874     uint32 GuildId = GetPlayer()->GetGuildId();
 875     if (!GuildId)
 876         return;
 877
 878     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
 879     if (!pGuild)
 880         return;
 881
 882     if (!pGuild->GetPurchasedTabs())
 883         return;
 884
 885     CharacterDatabase.BeginTransaction();
 886
 887     pGuild->SetBankMoney(pGuild->GetGuildBankMoney()+money);
 888     GetPlayer()->ModifyMoney(-int(money));
 889     GetPlayer()->SaveGoldToDB();
 890
 891     CharacterDatabase.CommitTransaction();
 892
 893     // logging money
 894     if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_BOOL_GM_LOG_TRADE))
 895     {
 896         sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit money (Amount: %u) to guild bank (Guild ID %u)",
 897             _player->GetName(),_player->GetSession()->GetAccountId(),money,GuildId);
 898     }
 899
 900     // log
 901     pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_MONEY, uint8(0), GetPlayer()->GetGUIDLow(), money);
 902
 903     pGuild->DisplayGuildBankTabsInfo(this);
 904     pGuild->DisplayGuildBankContent(this, 0);
 905     pGuild->DisplayGuildBankMoneyUpdate(this);
 906 }
 907
 908 void WorldSession::HandleGuildBankWithdrawMoney( WorldPacket & recv_data )
 909 {
 910     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_WITHDRAW_MONEY)");
 911
 912     uint64 GoGuid;
 913     uint32 money;
 914     recv_data >> GoGuid >> money;
 915
 916     if (!money)
 917         return;
 918
 919     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
 920         return;
 921
 922     uint32 GuildId = GetPlayer()->GetGuildId();
 923     if (GuildId == 0)
 924         return;
 925
 926     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
 927     if(!pGuild)
 928         return;
 929
 930     if (!pGuild->GetPurchasedTabs())
 931         return;
 932
 933     if (pGuild->GetGuildBankMoney()<money)                  // not enough money in bank
 934         return;
 935
 936     if (!pGuild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_WITHDRAW_GOLD))
 937         return;
 938
 939     CharacterDatabase.BeginTransaction();
 940
 941     if (!pGuild->MemberMoneyWithdraw(money, GetPlayer()->GetGUIDLow()))
 942     {
 943         CharacterDatabase.RollbackTransaction();
 944         return;
 945     }
 946
 947     GetPlayer()->ModifyMoney(money);
 948     GetPlayer()->SaveGoldToDB();
 949
 950     CharacterDatabase.CommitTransaction();
 951
 952     // Log
 953     pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_MONEY, uint8(0), GetPlayer()->GetGUIDLow(), money);
 954
 955     pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
 956     pGuild->DisplayGuildBankTabsInfo(this);
 957     pGuild->DisplayGuildBankContent(this, 0);
 958     pGuild->DisplayGuildBankMoneyUpdate(this);
 959 }
 960
 961 void WorldSession::HandleGuildBankSwapItems( WorldPacket & recv_data )
 962 {
 963     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_SWAP_ITEMS)");
 964
 965     uint64 GoGuid;
 966     uint8 BankToBank;
 967
 968     uint8 BankTab, BankTabSlot, AutoStore;
 969     uint8 PlayerSlot = NULL_SLOT;
 970     uint8 PlayerBag = NULL_BAG;
 971     uint8 BankTabDst, BankTabSlotDst, unk2;
 972     uint8 ToChar = 1;
 973     uint32 ItemEntry, unk1;
 974     uint32 AutoStoreCount = 0;
 975     uint32 SplitedAmount = 0;
 976
 977     recv_data >> GoGuid >> BankToBank;
 978
 979     uint32 GuildId = GetPlayer()->GetGuildId();
 980     if (!GuildId)
 981     {
 982         recv_data.rpos(recv_data.wpos());                   // prevent additional spam at rejected packet
 983         return;
 984     }
 985
 986     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
 987     if (!pGuild)
 988     {
 989         recv_data.rpos(recv_data.wpos());                   // prevent additional spam at rejected packet
 990         return;
 991     }
 992
 993     if (BankToBank)
 994     {
 995         recv_data >> BankTabDst;
 996         recv_data >> BankTabSlotDst;
 997         recv_data >> unk1;                                  // always 0
 998         recv_data >> BankTab;
 999         recv_data >> BankTabSlot;
1000         recv_data >> ItemEntry;
1001         recv_data >> unk2;                                  // always 0
1002         recv_data >> SplitedAmount;
1003
1004         if (BankTabSlotDst >= GUILD_BANK_MAX_SLOTS ||
1005             (BankTabDst == BankTab && BankTabSlotDst == BankTabSlot) ||
1006             BankTab >= pGuild->GetPurchasedTabs() ||
1007             BankTabDst >= pGuild->GetPurchasedTabs())
1008         {
1009             recv_data.rpos(recv_data.wpos());               // prevent additional spam at rejected packet
1010             return;
1011         }
1012     }
1013     else
1014     {
1015         recv_data >> BankTab;
1016         recv_data >> BankTabSlot;
1017         recv_data >> ItemEntry;
1018         recv_data >> AutoStore;
1019         if (AutoStore)
1020         {
1021             recv_data >> AutoStoreCount;
1022             recv_data.read_skip<uint8>();                   // ToChar (?), always and expected to be 1 (autostore only triggered in guild->ToChar)
1023             recv_data.read_skip<uint32>();                  // unknown, always 0
1024         }
1025         else
1026         {
1027             recv_data >> PlayerBag;
1028             recv_data >> PlayerSlot;
1029             recv_data >> ToChar;
1030             recv_data >> SplitedAmount;
1031         }
1032
1033         if ((BankTabSlot >= GUILD_BANK_MAX_SLOTS && BankTabSlot != 0xFF) ||
1034             BankTab >= pGuild->GetPurchasedTabs())
1035         {
1036             recv_data.rpos(recv_data.wpos());               // prevent additional spam at rejected packet
1037             return;
1038         }
1039     }
1040
1041     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
1042         return;
1043
1044     // Bank <-> Bank
1045     if (BankToBank)
1046     {
1047         pGuild->SwapItems(_player, BankTab, BankTabSlot, BankTabDst, BankTabSlotDst, SplitedAmount);
1048         return;
1049     }
1050
1051     // Player <-> Bank
1052
1053     // allow work with inventory only
1054     if(!Player::IsInventoryPos(PlayerBag, PlayerSlot) && !(PlayerBag == NULL_BAG && PlayerSlot == NULL_SLOT) )
1055     {
1056         _player->SendEquipError( EQUIP_ERR_NONE, NULL, NULL );
1057         return;
1058     }
1059
1060     // BankToChar swap or char to bank remaining
1061     if (ToChar)                                             // Bank -> Char cases
1062         pGuild->MoveFromBankToChar(_player, BankTab, BankTabSlot, PlayerBag, PlayerSlot, SplitedAmount);
1063     else                                                    // Char -> Bank cases
1064         pGuild->MoveFromCharToBank(_player, PlayerBag, PlayerSlot, BankTab, BankTabSlot, SplitedAmount);
1065 }
1066
1067 void WorldSession::HandleGuildBankBuyTab( WorldPacket & recv_data )
1068 {
1069     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_BUY_TAB)");
1070
1071     uint64 GoGuid;
1072     uint8 TabId;
1073
1074     recv_data >> GoGuid;
1075     recv_data >> TabId;
1076
1077     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
1078         return;
1079
1080     uint32 GuildId = GetPlayer()->GetGuildId();
1081     if (!GuildId)
1082         return;
1083
1084     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
1085     if(!pGuild)
1086         return;
1087
1088     // m_PurchasedTabs = 0 when buying Tab 0, that is why this check can be made
1089     if (TabId != pGuild->GetPurchasedTabs())
1090         return;
1091
1092     uint32 TabCost = GetGuildBankTabPrice(TabId) * GOLD;
1093     if (!TabCost)
1094         return;
1095
1096     if (GetPlayer()->GetMoney() < TabCost)                  // Should not happen, this is checked by client
1097         return;
1098
1099     // Go on with creating tab
1100     pGuild->CreateNewBankTab();
1101     GetPlayer()->ModifyMoney(-int(TabCost));
1102     pGuild->SetBankRightsAndSlots(GetPlayer()->GetRank(), TabId, GUILD_BANK_RIGHT_FULL, WITHDRAW_SLOT_UNLIMITED, true);
1103     pGuild->Roster();                                       // broadcast for tab rights update
1104     pGuild->DisplayGuildBankTabsInfo(this);
1105 }
1106
1107 void WorldSession::HandleGuildBankUpdateTab( WorldPacket & recv_data )
1108 {
1109     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_UPDATE_TAB)");
1110
1111     uint64 GoGuid;
1112     uint8 TabId;
1113     std::string Name;
1114     std::string IconIndex;
1115
1116     recv_data >> GoGuid;
1117     recv_data >> TabId;
1118     recv_data >> Name;
1119     recv_data >> IconIndex;
1120
1121     if(Name.empty())
1122         return;
1123
1124     if(IconIndex.empty())
1125         return;
1126
1127     if (!GetPlayer()->GetGameObjectIfCanInteractWith(GoGuid, GAMEOBJECT_TYPE_GUILD_BANK))
1128         return;
1129
1130     uint32 GuildId = GetPlayer()->GetGuildId();
1131     if (!GuildId)
1132         return;
1133
1134     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
1135     if (!pGuild)
1136         return;
1137
1138     if (TabId >= pGuild->GetPurchasedTabs())
1139         return;
1140
1141     pGuild->SetGuildBankTabInfo(TabId, Name, IconIndex);
1142     pGuild->DisplayGuildBankTabsInfo(this);
1143     pGuild->DisplayGuildBankContent(this, TabId);
1144 }
1145
1146 void WorldSession::HandleGuildBankLogQuery( WorldPacket & recv_data )
1147 {
1148     sLog.outDebug("WORLD: Received (MSG_GUILD_BANK_LOG_QUERY)");
1149
1150     uint8 TabId;
1151     recv_data >> TabId;
1152
1153     uint32 GuildId = GetPlayer()->GetGuildId();
1154     if (!GuildId)
1155         return;
1156
1157     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
1158     if (!pGuild)
1159         return;
1160
1161     // GUILD_BANK_MAX_TABS send by client for money log
1162     if (TabId >= pGuild->GetPurchasedTabs() && TabId != GUILD_BANK_MAX_TABS)
1163         return;
1164
1165     pGuild->DisplayGuildBankLogs(this, TabId);
1166 }
1167
1168 void WorldSession::HandleQueryGuildBankTabText(WorldPacket &recv_data)
1169 {
1170     sLog.outDebug("WORLD: Received MSG_QUERY_GUILD_BANK_TEXT");
1171
1172     uint8 TabId;
1173     recv_data >> TabId;
1174
1175     uint32 GuildId = GetPlayer()->GetGuildId();
1176     if (!GuildId)
1177         return;
1178
1179     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
1180     if (!pGuild)
1181         return;
1182
1183     if (TabId >= pGuild->GetPurchasedTabs())
1184         return;
1185
1186     pGuild->SendGuildBankTabText(this, TabId);
1187 }
1188
1189 void WorldSession::HandleSetGuildBankTabText(WorldPacket &recv_data)
1190 {
1191     sLog.outDebug("WORLD: Received CMSG_SET_GUILD_BANK_TEXT");
1192
1193     uint8 TabId;
1194     std::string Text;
1195     recv_data >> TabId;
1196     recv_data >> Text;
1197
1198     uint32 GuildId = GetPlayer()->GetGuildId();
1199     if (!GuildId)
1200         return;
1201
1202     Guild *pGuild = sObjectMgr.GetGuildById(GuildId);
1203     if (!pGuild)
1204         return;
1205
1206     if (TabId >= pGuild->GetPurchasedTabs())
1207         return;
1208
1209     pGuild->SetGuildBankTabText(TabId, Text);
1210 }
1211
1212 void WorldSession::SendSaveGuildEmblem( uint32 msg )
1213 {
1214     WorldPacket data(MSG_SAVE_GUILD_EMBLEM, 4);
1215     data << uint32(msg);                                    // not part of guild
1216     SendPacket( &data );
1217 }