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