src/game/Channel.cpp

   1 /*
   2  * Copyright (C) 2005,2006,2007 MaNGOS <http://www.mangosproject.org/>
   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
  22 void Channel::Join(Player *p, const char *pass)
  23 {
  24     WorldPacket data;
  25     if(IsOn(p))
  26     {
  27         MakeAlreadyOn(&data,p);
  28         SendToOne(&data,p);
  29     }
  30     else if(IsBanned(p->GetGUID()))
  31     {
  32         MakeYouAreBanned(&data);
  33         SendToOne(&data,p);
  34     }
  35     else if(password.length() > 0 && strcmp(pass,password.c_str()))
  36     {
  37         MakeWrongPass(&data);
  38         SendToOne(&data,p);
  39     }
  40     else
  41     {
  42         PlayerInfo pinfo;
  43         pinfo.player = p;
  44         pinfo.muted = false;
  45         pinfo.owner = false;
  46         pinfo.moderator = false;
  47
  48         //MakeJoined(&data,p);
  49         p->JoinedChannel(this);
  50         /*if(announce)
  51             SendToAll(&data);*/
  52
  53         data.clear();
  54         players[p] = pinfo;
  55
  56         MakeYouJoined(&data,p);
  57         SendToOne(&data,p);
  58
  59         // if no owner first logged will become
  60         //        if(!constant && owner == NULL)
  61         //        {
  62         //            SetOwner(p);
  63         //            players[p].moderator = true;
  64         //        }
  65
  66     }
  67 }
  68
  69 void Channel::Leave(Player *p, bool send)
  70 {
  71     WorldPacket data;
  72     if(!IsOn(p))
  73     {
  74         MakeNotOn(&data);
  75         if(send) SendToOne(&data,p);
  76     }
  77     else
  78     {
  79         MakeYouLeft(&data);
  80         if(send)
  81         {
  82             SendToOne(&data,p);
  83             p->LeftChannel(this);
  84         }
  85         data.clear();
  86
  87         players.erase(p);
  88         /*MakeLeft(&data,p);
  89         if(announce)
  90             SendToAll(&data);
  91
  92         if(changeowner)
  93         {
  94             Player *newowner = players.size() > 0 ? players.begin()->second.player : NULL;
  95             SetOwner(newowner);
  96         }*/
  97     }
  98 }
  99
 100 void Channel::KickOrBan(Player *good, const char *badname, bool ban)
 101 {
 102     WorldPacket data;
 103     if(!IsOn(good))
 104     {
 105         MakeNotOn(&data);
 106         SendToOne(&data,good);
 107     }
 108     else if(!players[good].moderator && good->GetSession()->GetSecurity() < 2)
 109     {
 110         MakeNotModerator(&data);
 111         SendToOne(&data,good);
 112     }
 113     else
 114     {
 115         Player *bad = objmgr.GetPlayer(badname);
 116         if(bad == NULL || !IsOn(bad))
 117         {
 118             MakeNotOn(&data,badname);
 119             SendToOne(&data,good);
 120         }
 121         else if(good->GetSession()->GetSecurity() < 2 && bad == owner && good != owner)
 122         {
 123             MakeNotOwner(&data);
 124             SendToOne(&data,good);
 125         }
 126         else
 127         {
 128             bool changeowner = (owner == bad);
 129
 130             if(ban && !IsBanned(bad->GetGUID()))
 131             {
 132                 banned.push_back(bad->GetGUID());
 133                 MakeBanned(&data,good,bad);
 134             }
 135             else
 136                 MakeKicked(&data,good,bad);
 137
 138             SendToAll(&data);
 139             players.erase(bad);
 140
 141             if(changeowner)
 142             {
 143                 Player *newowner = players.size() > 0 ? good : NULL;
 144                 SetOwner(newowner);
 145             }
 146         }
 147     }
 148 }
 149
 150 void Channel::UnBan(Player *good, const char *badname)
 151 {
 152     WorldPacket data;
 153     if(!IsOn(good))
 154     {
 155         MakeNotOn(&data);
 156         SendToOne(&data,good);
 157     }
 158     else if(!players[good].moderator && good->GetSession()->GetSecurity() < 2)
 159     {
 160         MakeNotModerator(&data);
 161         SendToOne(&data,good);
 162     }
 163     else
 164     {
 165         Player *bad = objmgr.GetPlayer(badname);
 166         if(bad == NULL || !IsBanned(bad->GetGUID()))
 167         {
 168             MakeNotOn(&data,badname);
 169             SendToOne(&data,good);
 170         }
 171         else
 172         {
 173             banned.remove(bad->GetGUID());
 174             MakeUnbanned(&data,good,bad);
 175             SendToAll(&data);
 176         }
 177     }
 178 }
 179
 180 void Channel::Password(Player *p, const char *pass)
 181 {
 182     WorldPacket data;
 183     if(!IsOn(p))
 184     {
 185         MakeNotOn(&data);
 186         SendToOne(&data,p);
 187     }
 188     else if(!players[p].moderator && p->GetSession()->GetSecurity() < 2)
 189     {
 190         MakeNotModerator(&data);
 191         SendToOne(&data,p);
 192     }
 193     else
 194     {
 195         password = pass;
 196         MakeSetPassword(&data,p);
 197         SendToAll(&data);
 198     }
 199 }
 200
 201 void Channel::SetMode(Player *p, const char *p2n, bool mod, bool set)
 202 {
 203     WorldPacket data;
 204     if(!IsOn(p))
 205     {
 206         MakeNotOn(&data);
 207         SendToOne(&data,p);
 208     }
 209     else if(!players[p].moderator && p->GetSession()->GetSecurity() < 2)
 210     {
 211         MakeNotModerator(&data);
 212         SendToOne(&data,p);
 213     }
 214     else
 215     {
 216         Player *newp = objmgr.GetPlayer(p2n);
 217         PlayerInfo inf = players[newp];
 218         if(p == owner && newp == owner && mod)
 219             return;
 220         if(newp == NULL || !IsOn(newp))
 221         {
 222             MakeNotOn(&data,p2n);
 223             SendToOne(&data,p);
 224         }
 225         else if(owner == newp && owner != p)
 226         {
 227             MakeNotOwner(&data);
 228             SendToOne(&data,p);
 229         }
 230         else
 231         {
 232             if(mod)
 233                 SetModerator(newp,set);
 234             else
 235                 SetMute(newp,set);
 236         }
 237     }
 238 }
 239
 240 void Channel::SetOwner(Player *p, const char *newname)
 241 {
 242     WorldPacket data;
 243     if(!IsOn(p))
 244     {
 245         MakeNotOn(&data);
 246         SendToOne(&data,p);
 247     }
 248     else if(p->GetSession()->GetSecurity() < 2 && p != owner)
 249     {
 250         MakeNotOwner(&data);
 251         SendToOne(&data,p);
 252     }
 253     else
 254     {
 255         Player *newp = objmgr.GetPlayer(newname);
 256         if(newp == NULL || !IsOn(newp))
 257         {
 258             MakeNotOn(&data,newname);
 259             SendToOne(&data,p);
 260         }
 261         else
 262         {
 263             MakeChangeOwner(&data,newp);
 264             SendToAll(&data);
 265
 266             SetModerator(newp,true);
 267             owner = newp;
 268         }
 269     }
 270 }
 271
 272 void Channel::GetOwner(Player *p)
 273 {
 274     WorldPacket data;
 275     if(!IsOn(p))
 276     {
 277         MakeNotOn(&data);
 278         SendToOne(&data,p);
 279     }
 280     else
 281     {
 282         MakeWhoOwner(&data);
 283         SendToOne(&data,p);
 284     }
 285 }
 286
 287 void Channel::List(Player *p)
 288 {
 289     WorldPacket data;
 290     if(!IsOn(p))
 291     {
 292         MakeNotOn(&data);
 293         SendToOne(&data,p);
 294     }
 295     else
 296     {
 297         data.Initialize(SMSG_CHANNEL_LIST);
 298         data << (uint8)3 << (uint32)players.size();
 299
 300         PlayerList::iterator i;
 301         uint8 mode;
 302         for(i = players.begin(); i!=players.end(); i++)
 303         {
 304             data << i->first->GetGUID();
 305             mode = 0x00;
 306             if(i->second.muted)
 307                 mode |= 0x04;
 308             if(i->second.moderator)
 309                 mode |= 0x02;
 310             data << mode;
 311         }
 312         SendToOne(&data,p);
 313     }
 314 }
 315
 316 void Channel::Announce(Player *p)
 317 {
 318     WorldPacket data;
 319     if(!IsOn(p))
 320     {
 321         MakeNotOn(&data);
 322         SendToOne(&data,p);
 323     }
 324     else if(!players[p].moderator && p->GetSession()->GetSecurity() < 2)
 325     {
 326         MakeNotModerator(&data);
 327         SendToOne(&data,p);
 328     }
 329     else
 330     {
 331         announce = !announce;
 332         MakeAnnounce(&data,p,announce);
 333         SendToAll(&data);
 334     }
 335 }
 336
 337 void Channel::Moderate(Player *p)
 338 {
 339     WorldPacket data;
 340     if(!IsOn(p))
 341     {
 342         MakeNotOn(&data);
 343         SendToOne(&data,p);
 344     }
 345     else if(!players[p].moderator && p->GetSession()->GetSecurity() < 2)
 346     {
 347         MakeNotModerator(&data);
 348         SendToOne(&data,p);
 349     }
 350     else
 351     {
 352         moderate = !moderate;
 353         MakeModerate(&data,p,moderate);
 354         SendToAll(&data);
 355     }
 356 }
 357
 358 void Channel::Say(Player *p, const char *what, uint32 lang)
 359 {
 360     if(!what)
 361         return;
 362     if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
 363         lang = LANG_UNIVERSAL;
 364
 365     WorldPacket data;
 366     if(!IsOn(p))
 367     {
 368         MakeNotOn(&data);
 369         SendToOne(&data,p);
 370     }
 371     else if(players[p].muted)
 372     {
 373         MakeYouCantSpeak(&data);
 374         SendToOne(&data,p);
 375     }
 376     else if(moderate && !players[p].moderator && p->GetSession()->GetSecurity() < 2)
 377     {
 378         MakeNotModerator(&data);
 379         SendToOne(&data,p);
 380     }
 381     else
 382     {
 383         uint32 messageLength = strlen(what) + 1;
 384
 385         data.Initialize(SMSG_MESSAGECHAT);
 386         data << (uint8)14;
 387         data << (uint32)lang;                               //language
 388         data << name.c_str();
 389         data << (uint32)0;
 390         data << p->GetGUID();
 391         data << messageLength;
 392         data << what;
 393         data << p->chatTag();
 394
 395         SendToAll(&data,!players[p].moderator ? p : NULL);
 396     }
 397 }
 398
 399 void Channel::Invite(Player *p, const char *newname)
 400 {
 401     WorldPacket data;
 402     if(!IsOn(p))
 403     {
 404         MakeNotOn(&data);
 405         SendToOne(&data,p);
 406     }
 407     else
 408     {
 409         Player *newp = objmgr.GetPlayer(newname);
 410         if(newp == NULL)
 411         {
 412             MakeNotOn(&data,newname);
 413             SendToOne(&data,p);
 414         }
 415         else if(IsOn(newp))
 416         {
 417             MakeAlreadyOn(&data,newp);
 418             SendToOne(&data,p);
 419         }
 420         else
 421         {
 422             if(!newp->HasInIgnoreList(p->GetGUID()))
 423             {
 424                 MakeInvited(&data,p);
 425                 SendToOne(&data,newp);
 426                 data.clear();
 427             }
 428             MakeYouInvited(&data,newp);
 429             SendToOne(&data,p);
 430         }
 431     }
 432 }