src/game/Channel.cpp

   1 /*
   2  * Copyright (C) 2005-2013 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 "Channel.h"
  20 #include "ObjectMgr.h"
  21 #include "World.h"
  22 #include "SocialMgr.h"
  23
  24 Channel::Channel(const std::string& name, uint32 channel_id)
  25     : m_announce(true), m_moderate(false), m_name(name), m_flags(0), m_channelId(channel_id)
  26 {
  27     // set special flags if built-in channel
  28     ChatChannelsEntry const* ch = GetChannelEntryFor(channel_id);
  29     if (ch)                                                 // it's built-in channel
  30     {
  31         channel_id = ch->ChannelID;                         // built-in channel
  32         m_announce = false;                                 // no join/leave announces
  33
  34         m_flags |= CHANNEL_FLAG_GENERAL;                    // for all built-in channels
  35
  36         if (ch->flags & CHANNEL_DBC_FLAG_TRADE)             // for trade channel
  37             m_flags |= CHANNEL_FLAG_TRADE;
  38
  39         if (ch->flags & CHANNEL_DBC_FLAG_CITY_ONLY2)        // for city only channels
  40             m_flags |= CHANNEL_FLAG_CITY;
  41
  42         if (ch->flags & CHANNEL_DBC_FLAG_LFG)               // for LFG channel
  43             m_flags |= CHANNEL_FLAG_LFG;
  44         else                                                // for all other channels
  45             m_flags |= CHANNEL_FLAG_NOT_LFG;
  46     }
  47     else                                                    // it's custom channel
  48     {
  49         m_flags |= CHANNEL_FLAG_CUSTOM;
  50     }
  51 }
  52
  53 void Channel::Join(ObjectGuid p, const char* pass)
  54 {
  55     WorldPacket data;
  56     if (IsOn(p))
  57     {
  58         if (!IsConstant())                                  // non send error message for built-in channels
  59         {
  60             MakePlayerAlreadyMember(&data, p);
  61             SendToOne(&data, p);
  62         }
  63         return;
  64     }
  65
  66     if (IsBanned(p))
  67     {
  68         MakeBanned(&data);
  69         SendToOne(&data, p);
  70         return;
  71     }
  72
  73     if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
  74     {
  75         MakeWrongPassword(&data);
  76         SendToOne(&data, p);
  77         return;
  78     }
  79
  80     Player* plr = sObjectMgr.GetPlayer(p);
  81
  82     if (plr)
  83     {
  84         if (HasFlag(CHANNEL_FLAG_LFG) && sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER)
  85         {
  86             MakeNotInLfg(&data);
  87             SendToOne(&data, p);
  88             return;
  89         }
  90
  91         if (plr->GetGuildId() && (GetFlags() == 0x38))
  92             return;
  93
  94         plr->JoinedChannel(this);
  95     }
  96
  97     if (m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
  98     {
  99         MakeJoined(&data, p);
 100         SendToAll(&data);
 101     }
 102
 103     data.clear();
 104
 105     PlayerInfo& pinfo = m_players[p];
 106     pinfo.player = p;
 107     pinfo.flags = 0;
 108
 109     MakeYouJoined(&data);
 110     SendToOne(&data, p);
 111
 112     JoinNotify(p);
 113
 114     // if no owner first logged will become
 115     if (!IsConstant() && !m_ownerGuid)
 116     {
 117         SetOwner(p, (m_players.size() > 1 ? true : false));
 118         m_players[p].SetModerator(true);
 119     }
 120 }
 121
 122 void Channel::Leave(ObjectGuid p, bool send)
 123 {
 124     if (!IsOn(p))
 125     {
 126         if (send)
 127         {
 128             WorldPacket data;
 129             MakeNotMember(&data);
 130             SendToOne(&data, p);
 131         }
 132     }
 133     else
 134     {
 135         Player* plr = sObjectMgr.GetPlayer(p);
 136
 137         if (send)
 138         {
 139             WorldPacket data;
 140             MakeYouLeft(&data);
 141             SendToOne(&data, p);
 142             if (plr)
 143                 plr->LeftChannel(this);
 144             data.clear();
 145         }
 146
 147         bool changeowner = m_players[p].IsOwner();
 148
 149         m_players.erase(p);
 150         if (m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
 151         {
 152             WorldPacket data;
 153             MakeLeft(&data, p);
 154             SendToAll(&data);
 155         }
 156
 157         LeaveNotify(p);
 158
 159         if (changeowner)
 160         {
 161             ObjectGuid newowner = !m_players.empty() ? m_players.begin()->second.player : ObjectGuid();
 162             SetOwner(newowner);
 163         }
 164     }
 165 }
 166
 167 void Channel::KickOrBan(ObjectGuid good, const char* badname, bool ban)
 168 {
 169     AccountTypes sec = SEC_PLAYER;
 170     Player* gplr = sObjectMgr.GetPlayer(good);
 171     if (gplr)
 172         sec = gplr->GetSession()->GetSecurity();
 173
 174     if (!IsOn(good))
 175     {
 176         WorldPacket data;
 177         MakeNotMember(&data);
 178         SendToOne(&data, good);
 179     }
 180     else if (!m_players[good].IsModerator() && sec < SEC_GAMEMASTER)
 181     {
 182         WorldPacket data;
 183         MakeNotModerator(&data);
 184         SendToOne(&data, good);
 185     }
 186     else
 187     {
 188         Player* bad = sObjectMgr.GetPlayer(badname);
 189         if (bad == NULL || !IsOn(bad->GetObjectGuid()))
 190         {
 191             WorldPacket data;
 192             MakePlayerNotFound(&data, badname);
 193             SendToOne(&data, good);
 194         }
 195         else if (sec < SEC_GAMEMASTER && bad->GetObjectGuid() == m_ownerGuid && good != m_ownerGuid)
 196         {
 197             WorldPacket data;
 198             MakeNotOwner(&data);
 199             SendToOne(&data, good);
 200         }
 201         else
 202         {
 203             bool changeowner = (m_ownerGuid == bad->GetObjectGuid());
 204
 205             WorldPacket data;
 206
 207             if (ban && !IsBanned(bad->GetObjectGuid()))
 208             {
 209                 m_banned.insert(bad->GetObjectGuid());
 210                 MakePlayerBanned(&data, bad->GetObjectGuid(), good);
 211             }
 212             else
 213                 MakePlayerKicked(&data, bad->GetObjectGuid(), good);
 214
 215             SendToAll(&data);
 216             m_players.erase(bad->GetObjectGuid());
 217             bad->LeftChannel(this);
 218
 219             if (changeowner)
 220             {
 221                 ObjectGuid newowner = !m_players.empty() ? good : ObjectGuid();
 222                 SetOwner(newowner);
 223             }
 224         }
 225     }
 226 }
 227
 228 void Channel::UnBan(ObjectGuid good, const char* badname)
 229 {
 230     uint32 sec = 0;
 231     Player* gplr = sObjectMgr.GetPlayer(good);
 232     if (gplr)
 233         sec = gplr->GetSession()->GetSecurity();
 234
 235     if (!IsOn(good))
 236     {
 237         WorldPacket data;
 238         MakeNotMember(&data);
 239         SendToOne(&data, good);
 240     }
 241     else if (!m_players[good].IsModerator() && sec < SEC_GAMEMASTER)
 242     {
 243         WorldPacket data;
 244         MakeNotModerator(&data);
 245         SendToOne(&data, good);
 246     }
 247     else
 248     {
 249         Player* bad = sObjectMgr.GetPlayer(badname);
 250         if (bad == NULL || !IsBanned(bad->GetObjectGuid()))
 251         {
 252             WorldPacket data;
 253             MakePlayerNotFound(&data, badname);
 254             SendToOne(&data, good);
 255         }
 256         else
 257         {
 258             m_banned.erase(bad->GetObjectGuid());
 259
 260             WorldPacket data;
 261             MakePlayerUnbanned(&data, bad->GetObjectGuid(), good);
 262             SendToAll(&data);
 263         }
 264     }
 265 }
 266
 267 void Channel::Password(ObjectGuid p, const char* pass)
 268 {
 269     uint32 sec = 0;
 270     Player* plr = sObjectMgr.GetPlayer(p);
 271     if (plr)
 272         sec = plr->GetSession()->GetSecurity();
 273
 274     if (!IsOn(p))
 275     {
 276         WorldPacket data;
 277         MakeNotMember(&data);
 278         SendToOne(&data, p);
 279     }
 280     else if (!m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
 281     {
 282         WorldPacket data;
 283         MakeNotModerator(&data);
 284         SendToOne(&data, p);
 285     }
 286     else
 287     {
 288         m_password = pass;
 289
 290         WorldPacket data;
 291         MakePasswordChanged(&data, p);
 292         SendToAll(&data);
 293     }
 294 }
 295
 296 void Channel::SetMode(ObjectGuid p, const char* p2n, bool mod, bool set)
 297 {
 298     Player* plr = sObjectMgr.GetPlayer(p);
 299     if (!plr)
 300         return;
 301
 302     uint32 sec = plr->GetSession()->GetSecurity();
 303
 304     if (!IsOn(p))
 305     {
 306         WorldPacket data;
 307         MakeNotMember(&data);
 308         SendToOne(&data, p);
 309     }
 310     else if (!m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
 311     {
 312         WorldPacket data;
 313         MakeNotModerator(&data);
 314         SendToOne(&data, p);
 315     }
 316     else
 317     {
 318         Player* newp = sObjectMgr.GetPlayer(p2n);
 319         if (!newp)
 320         {
 321             WorldPacket data;
 322             MakePlayerNotFound(&data, p2n);
 323             SendToOne(&data, p);
 324             return;
 325         }
 326
 327         PlayerInfo inf = m_players[newp->GetObjectGuid()];
 328         if (p == m_ownerGuid && newp->GetObjectGuid() == m_ownerGuid && mod)
 329             return;
 330
 331         if (!IsOn(newp->GetObjectGuid()))
 332         {
 333             WorldPacket data;
 334             MakePlayerNotFound(&data, p2n);
 335             SendToOne(&data, p);
 336             return;
 337         }
 338
 339         // allow make moderator from another team only if both is GMs
 340         // at this moment this only way to show channel post for GM from another team
 341         if ((plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || newp->GetSession()->GetSecurity() < SEC_GAMEMASTER) &&
 342                 plr->GetTeam() != newp->GetTeam() && !sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
 343         {
 344             WorldPacket data;
 345             MakePlayerNotFound(&data, p2n);
 346             SendToOne(&data, p);
 347             return;
 348         }
 349
 350         if (m_ownerGuid == newp->GetObjectGuid() && m_ownerGuid != p)
 351         {
 352             WorldPacket data;
 353             MakeNotOwner(&data);
 354             SendToOne(&data, p);
 355             return;
 356         }
 357
 358         if (mod)
 359             SetModerator(newp->GetObjectGuid(), set);
 360         else
 361             SetMute(newp->GetObjectGuid(), set);
 362     }
 363 }
 364
 365 void Channel::SetOwner(ObjectGuid p, const char* newname)
 366 {
 367     Player* plr = sObjectMgr.GetPlayer(p);
 368     if (!plr)
 369         return;
 370
 371     uint32 sec = plr->GetSession()->GetSecurity();
 372
 373     if (!IsOn(p))
 374     {
 375         WorldPacket data;
 376         MakeNotMember(&data);
 377         SendToOne(&data, p);
 378         return;
 379     }
 380
 381     if (sec < SEC_GAMEMASTER && p != m_ownerGuid)
 382     {
 383         WorldPacket data;
 384         MakeNotOwner(&data);
 385         SendToOne(&data, p);
 386         return;
 387     }
 388
 389     Player* newp = sObjectMgr.GetPlayer(newname);
 390     if (newp == NULL || !IsOn(newp->GetObjectGuid()))
 391     {
 392         WorldPacket data;
 393         MakePlayerNotFound(&data, newname);
 394         SendToOne(&data, p);
 395         return;
 396     }
 397
 398     if (newp->GetTeam() != plr->GetTeam() && !sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
 399     {
 400         WorldPacket data;
 401         MakePlayerNotFound(&data, newname);
 402         SendToOne(&data, p);
 403         return;
 404     }
 405
 406     m_players[newp->GetObjectGuid()].SetModerator(true);
 407     SetOwner(newp->GetObjectGuid());
 408 }
 409
 410 void Channel::SendWhoOwner(ObjectGuid p)
 411 {
 412     if (!IsOn(p))
 413     {
 414         WorldPacket data;
 415         MakeNotMember(&data);
 416         SendToOne(&data, p);
 417     }
 418     else
 419     {
 420         WorldPacket data;
 421         MakeChannelOwner(&data);
 422         SendToOne(&data, p);
 423     }
 424 }
 425
 426 void Channel::List(Player* player)
 427 {
 428     ObjectGuid p = player->GetObjectGuid();
 429
 430     if (!IsOn(p))
 431     {
 432         WorldPacket data;
 433         MakeNotMember(&data);
 434         SendToOne(&data, p);
 435     }
 436     else
 437     {
 438         WorldPacket data(SMSG_CHANNEL_LIST, 1 + (GetName().size() + 1) + 1 + 4 + m_players.size() * (8 + 1));
 439         data << uint8(1);                                   // channel type?
 440         data << GetName();                                  // channel name
 441         data << uint8(GetFlags());                          // channel flags?
 442
 443         size_t pos = data.wpos();
 444         data << uint32(0);                                  // size of list, placeholder
 445
 446         AccountTypes gmLevelInWhoList = (AccountTypes)sWorld.getConfig(CONFIG_UINT32_GM_LEVEL_IN_WHO_LIST);
 447
 448         uint32 count  = 0;
 449         for (PlayerList::const_iterator i = m_players.begin(); i != m_players.end(); ++i)
 450         {
 451             Player* plr = sObjectMgr.GetPlayer(i->first);
 452
 453             // PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
 454             // MODERATOR, GAME MASTER, ADMINISTRATOR can see all
 455             if (plr && (player->GetSession()->GetSecurity() > SEC_PLAYER || plr->GetSession()->GetSecurity() <= gmLevelInWhoList) &&
 456                     plr->IsVisibleGloballyFor(player))
 457             {
 458                 data << ObjectGuid(i->first);
 459                 data << uint8(i->second.flags);             // flags seems to be changed...
 460                 ++count;
 461             }
 462         }
 463
 464         data.put<uint32>(pos, count);
 465
 466         SendToOne(&data, p);
 467     }
 468 }
 469
 470 void Channel::Announce(ObjectGuid p)
 471 {
 472     uint32 sec = 0;
 473     Player* plr = sObjectMgr.GetPlayer(p);
 474     if (plr)
 475         sec = plr->GetSession()->GetSecurity();
 476
 477     if (!IsOn(p))
 478     {
 479         WorldPacket data;
 480         MakeNotMember(&data);
 481         SendToOne(&data, p);
 482     }
 483     else if (!m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
 484     {
 485         WorldPacket data;
 486         MakeNotModerator(&data);
 487         SendToOne(&data, p);
 488     }
 489     else
 490     {
 491         m_announce = !m_announce;
 492
 493         WorldPacket data;
 494         if (m_announce)
 495             MakeAnnouncementsOn(&data, p);
 496         else
 497             MakeAnnouncementsOff(&data, p);
 498         SendToAll(&data);
 499     }
 500 }
 501
 502 void Channel::Moderate(ObjectGuid p)
 503 {
 504     uint32 sec = 0;
 505     Player* plr = sObjectMgr.GetPlayer(p);
 506     if (plr)
 507         sec = plr->GetSession()->GetSecurity();
 508
 509     if (!IsOn(p))
 510     {
 511         WorldPacket data;
 512         MakeNotMember(&data);
 513         SendToOne(&data, p);
 514     }
 515     else if (!m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
 516     {
 517         WorldPacket data;
 518         MakeNotModerator(&data);
 519         SendToOne(&data, p);
 520     }
 521     else
 522     {
 523         m_moderate = !m_moderate;
 524
 525         WorldPacket data;
 526         if (m_moderate)
 527             MakeModerationOn(&data, p);
 528         else
 529             MakeModerationOff(&data, p);
 530         SendToAll(&data);
 531     }
 532 }
 533
 534 void Channel::Say(ObjectGuid p, const char* what, uint32 lang)
 535 {
 536     if (!what)
 537         return;
 538     if (sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
 539         lang = LANG_UNIVERSAL;
 540
 541     uint32 sec = 0;
 542     Player* plr = sObjectMgr.GetPlayer(p);
 543     if (plr)
 544         sec = plr->GetSession()->GetSecurity();
 545
 546     if (!IsOn(p))
 547     {
 548         WorldPacket data;
 549         MakeNotMember(&data);
 550         SendToOne(&data, p);
 551     }
 552     else if (m_players[p].IsMuted())
 553     {
 554         WorldPacket data;
 555         MakeMuted(&data);
 556         SendToOne(&data, p);
 557     }
 558     else if (m_moderate && !m_players[p].IsModerator() && sec < SEC_GAMEMASTER)
 559     {
 560         WorldPacket data;
 561         MakeNotModerator(&data);
 562         SendToOne(&data, p);
 563     }
 564     else
 565     {
 566         uint32 messageLength = strlen(what) + 1;
 567
 568         WorldPacket data(SMSG_MESSAGECHAT, 1 + 4 + 8 + 4 + m_name.size() + 1 + 8 + 4 + messageLength + 1);
 569         data << uint8(CHAT_MSG_CHANNEL);
 570         data << uint32(lang);
 571         data << ObjectGuid(p);                              // 2.1.0
 572         data << uint32(0);                                  // 2.1.0
 573         data << m_name;
 574         data << ObjectGuid(p);
 575         data << uint32(messageLength);
 576         data << what;
 577         data << uint8(plr ? plr->GetChatTag() : uint8(CHAT_TAG_NONE));
 578
 579         SendToAll(&data, !m_players[p].IsModerator() ? p : ObjectGuid());
 580     }
 581 }
 582
 583 void Channel::Invite(ObjectGuid p, const char* newname)
 584 {
 585     if (!IsOn(p))
 586     {
 587         WorldPacket data;
 588         MakeNotMember(&data);
 589         SendToOne(&data, p);
 590         return;
 591     }
 592
 593     Player* newp = sObjectMgr.GetPlayer(newname);
 594     if (!newp)
 595     {
 596         WorldPacket data;
 597         MakePlayerNotFound(&data, newname);
 598         SendToOne(&data, p);
 599         return;
 600     }
 601
 602     Player* plr = sObjectMgr.GetPlayer(p);
 603     if (!plr)
 604         return;
 605
 606     if (newp->GetTeam() != plr->GetTeam() && !sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
 607     {
 608         WorldPacket data;
 609         MakeInviteWrongFaction(&data);
 610         SendToOne(&data, p);
 611         return;
 612     }
 613
 614     if (IsOn(newp->GetObjectGuid()))
 615     {
 616         WorldPacket data;
 617         MakePlayerAlreadyMember(&data, newp->GetObjectGuid());
 618         SendToOne(&data, p);
 619         return;
 620     }
 621
 622     WorldPacket data;
 623     if (!newp->GetSocial()->HasIgnore(p))
 624     {
 625         MakeInvite(&data, p);
 626         SendToOne(&data, newp->GetObjectGuid());
 627         data.clear();
 628     }
 629     MakePlayerInvited(&data, newp->GetName());
 630     SendToOne(&data, p);
 631 }
 632
 633 void Channel::SetOwner(ObjectGuid guid, bool exclaim)
 634 {
 635     if (m_ownerGuid)
 636     {
 637         // [] will re-add player after it possible removed
 638         PlayerList::iterator p_itr = m_players.find(m_ownerGuid);
 639         if (p_itr != m_players.end())
 640             p_itr->second.SetOwner(false);
 641     }
 642
 643     m_ownerGuid = guid;
 644
 645     if (m_ownerGuid)
 646     {
 647         uint8 oldFlag = GetPlayerFlags(m_ownerGuid);
 648         m_players[m_ownerGuid].SetOwner(true);
 649
 650         WorldPacket data;
 651         MakeModeChange(&data, m_ownerGuid, oldFlag);
 652         SendToAll(&data);
 653
 654         if (exclaim)
 655         {
 656             MakeOwnerChanged(&data, m_ownerGuid);
 657             SendToAll(&data);
 658         }
 659     }
 660 }
 661
 662 void Channel::SendToAll(WorldPacket* data, ObjectGuid p)
 663 {
 664     for (PlayerList::const_iterator i = m_players.begin(); i != m_players.end(); ++i)
 665         if (Player* plr = sObjectMgr.GetPlayer(i->first))
 666             if (!p || !plr->GetSocial()->HasIgnore(p))
 667                 plr->GetSession()->SendPacket(data);
 668 }
 669
 670 void Channel::SendToOne(WorldPacket* data, ObjectGuid who)
 671 {
 672     if (Player* plr = ObjectMgr::GetPlayer(who))
 673         plr->GetSession()->SendPacket(data);
 674 }
 675
 676 void Channel::Voice(ObjectGuid /*guid1*/, ObjectGuid /*guid2*/)
 677 {
 678
 679 }
 680
 681 void Channel::DeVoice(ObjectGuid /*guid1*/, ObjectGuid /*guid2*/)
 682 {
 683
 684 }
 685
 686 // done
 687 void Channel::MakeNotifyPacket(WorldPacket* data, uint8 notify_type)
 688 {
 689     data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + m_name.size() + 1);
 690     *data << uint8(notify_type);
 691     *data << m_name;
 692 }
 693
 694 // done 0x00
 695 void Channel::MakeJoined(WorldPacket* data, ObjectGuid guid)
 696 {
 697     MakeNotifyPacket(data, CHAT_JOINED_NOTICE);
 698     *data << ObjectGuid(guid);
 699 }
 700
 701 // done 0x01
 702 void Channel::MakeLeft(WorldPacket* data, ObjectGuid guid)
 703 {
 704     MakeNotifyPacket(data, CHAT_LEFT_NOTICE);
 705     *data << ObjectGuid(guid);
 706 }
 707
 708 // done 0x02
 709 void Channel::MakeYouJoined(WorldPacket* data)
 710 {
 711     MakeNotifyPacket(data, CHAT_YOU_JOINED_NOTICE);
 712     *data << uint8(GetFlags());
 713     *data << uint32(GetChannelId());
 714     *data << uint32(0);
 715 }
 716
 717 // done 0x03
 718 void Channel::MakeYouLeft(WorldPacket* data)
 719 {
 720     MakeNotifyPacket(data, CHAT_YOU_LEFT_NOTICE);
 721     *data << uint32(GetChannelId());
 722     *data << uint8(0);                                      // can be 0x00 and 0x01
 723 }
 724
 725 // done 0x04
 726 void Channel::MakeWrongPassword(WorldPacket* data)
 727 {
 728     MakeNotifyPacket(data, CHAT_WRONG_PASSWORD_NOTICE);
 729 }
 730
 731 // done 0x05
 732 void Channel::MakeNotMember(WorldPacket* data)
 733 {
 734     MakeNotifyPacket(data, CHAT_NOT_MEMBER_NOTICE);
 735 }
 736
 737 // done 0x06
 738 void Channel::MakeNotModerator(WorldPacket* data)
 739 {
 740     MakeNotifyPacket(data, CHAT_NOT_MODERATOR_NOTICE);
 741 }
 742
 743 // done 0x07
 744 void Channel::MakePasswordChanged(WorldPacket* data, ObjectGuid guid)
 745 {
 746     MakeNotifyPacket(data, CHAT_PASSWORD_CHANGED_NOTICE);
 747     *data << ObjectGuid(guid);
 748 }
 749
 750 // done 0x08
 751 void Channel::MakeOwnerChanged(WorldPacket* data, ObjectGuid guid)
 752 {
 753     MakeNotifyPacket(data, CHAT_OWNER_CHANGED_NOTICE);
 754     *data << ObjectGuid(guid);
 755 }
 756
 757 // done 0x09
 758 void Channel::MakePlayerNotFound(WorldPacket* data, const std::string& name)
 759 {
 760     MakeNotifyPacket(data, CHAT_PLAYER_NOT_FOUND_NOTICE);
 761     *data << name;
 762 }
 763
 764 // done 0x0A
 765 void Channel::MakeNotOwner(WorldPacket* data)
 766 {
 767     MakeNotifyPacket(data, CHAT_NOT_OWNER_NOTICE);
 768 }
 769
 770 // done 0x0B
 771 void Channel::MakeChannelOwner(WorldPacket* data)
 772 {
 773     std::string name = "";
 774
 775     if (!sObjectMgr.GetPlayerNameByGUID(m_ownerGuid, name) || name.empty())
 776         name = "PLAYER_NOT_FOUND";
 777
 778     MakeNotifyPacket(data, CHAT_CHANNEL_OWNER_NOTICE);
 779     *data << ((IsConstant() || !m_ownerGuid) ? "Nobody" : name);
 780 }
 781
 782 // done 0x0C
 783 void Channel::MakeModeChange(WorldPacket* data, ObjectGuid guid, uint8 oldflags)
 784 {
 785     MakeNotifyPacket(data, CHAT_MODE_CHANGE_NOTICE);
 786     *data << ObjectGuid(guid);
 787     *data << uint8(oldflags);
 788     *data << uint8(GetPlayerFlags(guid));
 789 }
 790
 791 // done 0x0D
 792 void Channel::MakeAnnouncementsOn(WorldPacket* data, ObjectGuid guid)
 793 {
 794     MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_ON_NOTICE);
 795     *data << ObjectGuid(guid);
 796 }
 797
 798 // done 0x0E
 799 void Channel::MakeAnnouncementsOff(WorldPacket* data, ObjectGuid guid)
 800 {
 801     MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_OFF_NOTICE);
 802     *data << ObjectGuid(guid);
 803 }
 804
 805 // done 0x0F
 806 void Channel::MakeModerationOn(WorldPacket* data, ObjectGuid guid)
 807 {
 808     MakeNotifyPacket(data, CHAT_MODERATION_ON_NOTICE);
 809     *data << ObjectGuid(guid);
 810 }
 811
 812 // done 0x10
 813 void Channel::MakeModerationOff(WorldPacket* data, ObjectGuid guid)
 814 {
 815     MakeNotifyPacket(data, CHAT_MODERATION_OFF_NOTICE);
 816     *data << ObjectGuid(guid);
 817 }
 818
 819 // done 0x11
 820 void Channel::MakeMuted(WorldPacket* data)
 821 {
 822     MakeNotifyPacket(data, CHAT_MUTED_NOTICE);
 823 }
 824
 825 // done 0x12
 826 void Channel::MakePlayerKicked(WorldPacket* data, ObjectGuid bad, ObjectGuid good)
 827 {
 828     MakeNotifyPacket(data, CHAT_PLAYER_KICKED_NOTICE);
 829     *data << ObjectGuid(bad);
 830     *data << ObjectGuid(good);
 831 }
 832
 833 // done 0x13
 834 void Channel::MakeBanned(WorldPacket* data)
 835 {
 836     MakeNotifyPacket(data, CHAT_BANNED_NOTICE);
 837 }
 838
 839 // done 0x14
 840 void Channel::MakePlayerBanned(WorldPacket* data, ObjectGuid bad, ObjectGuid good)
 841 {
 842     MakeNotifyPacket(data, CHAT_PLAYER_BANNED_NOTICE);
 843     *data << ObjectGuid(bad);
 844     *data << ObjectGuid(good);
 845 }
 846
 847 // done 0x15
 848 void Channel::MakePlayerUnbanned(WorldPacket* data, ObjectGuid bad, ObjectGuid good)
 849 {
 850     MakeNotifyPacket(data, CHAT_PLAYER_UNBANNED_NOTICE);
 851     *data << ObjectGuid(bad);
 852     *data << ObjectGuid(good);
 853 }
 854
 855 // done 0x16
 856 void Channel::MakePlayerNotBanned(WorldPacket* data, ObjectGuid guid)
 857 {
 858     MakeNotifyPacket(data, CHAT_PLAYER_NOT_BANNED_NOTICE);
 859     *data << ObjectGuid(guid);                              // should be string!!
 860 }
 861
 862 // done 0x17
 863 void Channel::MakePlayerAlreadyMember(WorldPacket* data, ObjectGuid guid)
 864 {
 865     MakeNotifyPacket(data, CHAT_PLAYER_ALREADY_MEMBER_NOTICE);
 866     *data << ObjectGuid(guid);
 867 }
 868
 869 // done 0x18
 870 void Channel::MakeInvite(WorldPacket* data, ObjectGuid guid)
 871 {
 872     MakeNotifyPacket(data, CHAT_INVITE_NOTICE);
 873     *data << ObjectGuid(guid);
 874 }
 875
 876 // done 0x19
 877 void Channel::MakeInviteWrongFaction(WorldPacket* data)
 878 {
 879     MakeNotifyPacket(data, CHAT_INVITE_WRONG_FACTION_NOTICE);
 880 }
 881
 882 // done 0x1A
 883 void Channel::MakeWrongFaction(WorldPacket* data)
 884 {
 885     MakeNotifyPacket(data, CHAT_WRONG_FACTION_NOTICE);
 886 }
 887
 888 // done 0x1B
 889 void Channel::MakeInvalidName(WorldPacket* data)
 890 {
 891     MakeNotifyPacket(data, CHAT_INVALID_NAME_NOTICE);
 892 }
 893
 894 // done 0x1C
 895 void Channel::MakeNotModerated(WorldPacket* data)
 896 {
 897     MakeNotifyPacket(data, CHAT_NOT_MODERATED_NOTICE);
 898 }
 899
 900 // done 0x1D
 901 void Channel::MakePlayerInvited(WorldPacket* data, const std::string& name)
 902 {
 903     MakeNotifyPacket(data, CHAT_PLAYER_INVITED_NOTICE);
 904     *data << name;
 905 }
 906
 907 // done 0x1E
 908 void Channel::MakePlayerInviteBanned(WorldPacket* data, ObjectGuid guid)
 909 {
 910     MakeNotifyPacket(data, CHAT_PLAYER_INVITE_BANNED_NOTICE);
 911     *data << ObjectGuid(guid);                              // should be string!!
 912 }
 913
 914 // done 0x1F
 915 void Channel::MakeThrottled(WorldPacket* data)
 916 {
 917     MakeNotifyPacket(data, CHAT_THROTTLED_NOTICE);
 918 }
 919
 920 // done 0x20
 921 void Channel::MakeNotInArea(WorldPacket* data)
 922 {
 923     MakeNotifyPacket(data, CHAT_NOT_IN_AREA_NOTICE);
 924 }
 925
 926 // done 0x21
 927 void Channel::MakeNotInLfg(WorldPacket* data)
 928 {
 929     MakeNotifyPacket(data, CHAT_NOT_IN_LFG_NOTICE);
 930 }
 931
 932 // done 0x22
 933 void Channel::MakeVoiceOn(WorldPacket* data, ObjectGuid guid)
 934 {
 935     MakeNotifyPacket(data, CHAT_VOICE_ON_NOTICE);
 936     *data << ObjectGuid(guid);
 937 }
 938
 939 // done 0x23
 940 void Channel::MakeVoiceOff(WorldPacket* data, ObjectGuid guid)
 941 {
 942     MakeNotifyPacket(data, CHAT_VOICE_OFF_NOTICE);
 943     *data << ObjectGuid(guid);
 944 }
 945
 946 void Channel::JoinNotify(ObjectGuid guid)
 947 {
 948     WorldPacket data;
 949
 950     if (IsConstant())
 951         data.Initialize(SMSG_USERLIST_ADD, 8 + 1 + 1 + 4 + GetName().size() + 1);
 952     else
 953         data.Initialize(SMSG_USERLIST_UPDATE, 8 + 1 + 1 + 4 + GetName().size() + 1);
 954
 955     data << ObjectGuid(guid);
 956     data << uint8(GetPlayerFlags(guid));
 957     data << uint8(GetFlags());
 958     data << uint32(GetNumPlayers());
 959     data << GetName();
 960     SendToAll(&data);
 961 }
 962
 963 void Channel::LeaveNotify(ObjectGuid guid)
 964 {
 965     WorldPacket data(SMSG_USERLIST_REMOVE, 8 + 1 + 4 + GetName().size() + 1);
 966     data << ObjectGuid(guid);
 967     data << uint8(GetFlags());
 968     data << uint32(GetNumPlayers());
 969     data << GetName();
 970     SendToAll(&data);
 971 }