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