src/game/LFGHandler.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 "WorldSession.h"
  20 #include "Log.h"
  21 #include "Database/DatabaseEnv.h"
  22 #include "Player.h"
  23 #include "WorldPacket.h"
  24 #include "ObjectMgr.h"
  25 #include "World.h"
  26
  27 static void AttemptJoin(Player* _player)
  28 {
  29     // skip not can autojoin cases and player group case
  30     if(!_player->m_lookingForGroup.canAutoJoin() || _player->GetGroup())
  31         return;
  32
  33     //TODO: Guard Player Map
  34     HashMapHolder<Player>::MapType const& players = ObjectAccessor::Instance().GetPlayers();
  35     for(HashMapHolder<Player>::MapType::const_iterator iter = players.begin(); iter != players.end(); ++iter)
  36     {
  37         Player *plr = iter->second;
  38
  39         // skip enemies and self
  40         if(!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
  41             continue;
  42
  43         // skip not auto add, not group leader cases
  44         if(!plr->GetSession()->LookingForGroup_auto_add || plr->GetGroup() && plr->GetGroup()->GetLeaderGUID()!=plr->GetGUID())
  45             continue;
  46
  47         // skip non auto-join or empty slots, or non compatible slots
  48         if(!plr->m_lookingForGroup.more.canAutoJoin() || !_player->m_lookingForGroup.HaveInSlot(plr->m_lookingForGroup.more))
  49             continue;
  50
  51         // attempt create group, or skip
  52         if(!plr->GetGroup())
  53         {
  54             Group* group = new Group;
  55             if(!group->Create(plr->GetGUID(), plr->GetName()))
  56             {
  57                 delete group;
  58                 continue;
  59             }
  60
  61             objmgr.AddGroup(group);
  62         }
  63
  64         // stop at success join
  65         if(plr->GetGroup()->AddMember(_player->GetGUID(), _player->GetName()))
  66         {
  67             if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
  68                 _player->LeaveLFGChannel();
  69             break;
  70         }
  71         // full
  72         else
  73         {
  74             if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER )
  75                 plr->LeaveLFGChannel();
  76         }
  77     }
  78 }
  79
  80 static void AttemptAddMore(Player* _player)
  81 {
  82     // skip not group leader case
  83     if(_player->GetGroup() && _player->GetGroup()->GetLeaderGUID()!=_player->GetGUID())
  84         return;
  85
  86     if(!_player->m_lookingForGroup.more.canAutoJoin())
  87         return;
  88
  89     //TODO: Guard Player map
  90     HashMapHolder<Player>::MapType const& players = ObjectAccessor::Instance().GetPlayers();
  91     for(HashMapHolder<Player>::MapType::const_iterator iter = players.begin(); iter != players.end(); ++iter)
  92     {
  93         Player *plr = iter->second;
  94
  95         // skip enemies and self
  96         if(!plr || plr==_player || plr->GetTeam() != _player->GetTeam())
  97             continue;
  98
  99         // skip not auto join or in group
 100         if(!plr->GetSession()->LookingForGroup_auto_join || plr->GetGroup() )
 101             continue;
 102
 103         if(!plr->m_lookingForGroup.HaveInSlot(_player->m_lookingForGroup.more))
 104             continue;
 105
 106         // attempt create group if need, or stop attempts
 107         if(!_player->GetGroup())
 108         {
 109             Group* group = new Group;
 110             if(!group->Create(_player->GetGUID(), _player->GetName()))
 111             {
 112                 delete group;
 113                 return;                                     // can't create group (??)
 114             }
 115
 116             objmgr.AddGroup(group);
 117         }
 118
 119         // stop at join fail (full)
 120         if(!_player->GetGroup()->AddMember(plr->GetGUID(), plr->GetName()) )
 121         {
 122             if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
 123                 _player->LeaveLFGChannel();
 124
 125             break;
 126         }
 127
 128         // joined
 129         if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER )
 130             plr->LeaveLFGChannel();
 131
 132         // and group full
 133         if(_player->GetGroup()->IsFull() )
 134         {
 135             if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
 136                 _player->LeaveLFGChannel();
 137
 138             break;
 139         }
 140     }
 141 }
 142
 143 void WorldSession::HandleLfgSetAutoJoinOpcode( WorldPacket & /*recv_data*/ )
 144 {
 145     sLog.outDebug("CMSG_LFG_SET_AUTOJOIN");
 146     LookingForGroup_auto_join = true;
 147
 148     if(!_player)                                            // needed because STATUS_AUTHED
 149         return;
 150
 151     AttemptJoin(_player);
 152 }
 153
 154 void WorldSession::HandleLfgClearAutoJoinOpcode( WorldPacket & /*recv_data*/ )
 155 {
 156     sLog.outDebug("CMSG_LFG_CLEAR_AUTOJOIN");
 157     LookingForGroup_auto_join = false;
 158 }
 159
 160 void WorldSession::HandleLfmSetAutoFillOpcode( WorldPacket & /*recv_data*/ )
 161 {
 162     sLog.outDebug("CMSG_LFM_SET_AUTOFILL");
 163     LookingForGroup_auto_add = true;
 164
 165     if(!_player)                                            // needed because STATUS_AUTHED
 166         return;
 167
 168     AttemptAddMore(_player);
 169 }
 170
 171 void WorldSession::HandleLfmClearAutoFillOpcode( WorldPacket & /*recv_data*/ )
 172 {
 173     sLog.outDebug("CMSG_LFM_CLEAR_AUTOFILL");
 174     LookingForGroup_auto_add = false;
 175 }
 176
 177 void WorldSession::HandleLfgClearOpcode( WorldPacket & /*recv_data */ )
 178 {
 179     // empty packet
 180     sLog.outDebug("CMSG_CLEAR_LOOKING_FOR_GROUP");
 181
 182     for(int i = 0; i < MAX_LOOKING_FOR_GROUP_SLOT; ++i)
 183         _player->m_lookingForGroup.slots[i].Clear();
 184
 185     if( sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && _player->GetSession()->GetSecurity() == SEC_PLAYER )
 186         _player->LeaveLFGChannel();
 187 }
 188
 189 void WorldSession::HandleLfmClearOpcode( WorldPacket & /*recv_data */)
 190 {
 191     // empty packet
 192     sLog.outDebug("CMSG_CLEAR_LOOKING_FOR_MORE");
 193
 194     _player->m_lookingForGroup.more.Clear();
 195 }
 196
 197 void WorldSession::HandleSetLfmOpcode( WorldPacket & recv_data )
 198 {
 199     CHECK_PACKET_SIZE(recv_data,4);
 200
 201     sLog.outDebug("CMSG_SET_LOOKING_FOR_MORE");
 202     //recv_data.hexlike();
 203     uint32 temp, entry, type;
 204
 205     recv_data >> temp;
 206
 207     entry = ( temp & 0xFFFF);
 208     type = ( (temp >> 24) & 0xFFFF);
 209
 210     _player->m_lookingForGroup.more.Set(entry,type);
 211     sLog.outDebug("LFM set: temp %u, zone %u, type %u", temp, entry, type);
 212
 213     if(LookingForGroup_auto_add)
 214         AttemptAddMore(_player);
 215
 216     SendLfgResult(type, entry, 1);
 217 }
 218
 219 void WorldSession::HandleSetLfgCommentOpcode( WorldPacket & recv_data )
 220 {
 221     CHECK_PACKET_SIZE(recv_data, 1);
 222
 223     sLog.outDebug("CMSG_SET_LFG_COMMENT");
 224     //recv_data.hexlike();
 225
 226     std::string comment;
 227     recv_data >> comment;
 228     sLog.outDebug("LFG comment %s", comment.c_str());
 229
 230     _player->m_lookingForGroup.comment = comment;
 231 }
 232
 233 void WorldSession::HandleLookingForGroup(WorldPacket& recv_data)
 234 {
 235     CHECK_PACKET_SIZE(recv_data, 4+4+4);
 236
 237     sLog.outDebug("MSG_LOOKING_FOR_GROUP");
 238     //recv_data.hexlike();
 239     uint32 type, entry, unk;
 240
 241     recv_data >> type >> entry >> unk;
 242     sLog.outDebug("MSG_LOOKING_FOR_GROUP: type %u, entry %u, unk %u", type, entry, unk);
 243
 244     if(LookingForGroup_auto_add)
 245         AttemptAddMore(_player);
 246
 247     if(LookingForGroup_auto_join)
 248         AttemptJoin(_player);
 249
 250     SendLfgResult(type, entry, 0);
 251 }
 252
 253 void WorldSession::SendLfgResult(uint32 type, uint32 entry, uint8 lfg_type)
 254 {
 255     uint32 number = 0;
 256
 257     // start prepare packet;
 258     WorldPacket data(MSG_LOOKING_FOR_GROUP);
 259     data << uint32(type);                                   // type
 260     data << uint32(entry);                                  // entry from LFGDungeons.dbc
 261     data << uint32(0);                                      // count, placeholder
 262     data << uint32(0);                                      // count again, strange, placeholder
 263
 264     //TODO: Guard Player map
 265     HashMapHolder<Player>::MapType const& players = ObjectAccessor::Instance().GetPlayers();
 266     for(HashMapHolder<Player>::MapType::const_iterator iter = players.begin(); iter != players.end(); ++iter)
 267     {
 268         Player *plr = iter->second;
 269
 270         if(!plr || plr->GetTeam() != _player->GetTeam())
 271             continue;
 272
 273         if(!plr->m_lookingForGroup.HaveInSlot(entry,type))
 274             continue;
 275
 276         ++number;
 277
 278         data.append(plr->GetPackGUID());                    // packed guid
 279         data << plr->getLevel();                            // level
 280         data << plr->GetZoneId();                           // current zone
 281         data << lfg_type;                                   // 0x00 - LFG, 0x01 - LFM
 282
 283         for(uint8 j = 0; j < MAX_LOOKING_FOR_GROUP_SLOT; ++j)
 284         {
 285             data << uint32( plr->m_lookingForGroup.slots[j].entry | (plr->m_lookingForGroup.slots[j].type << 24) );
 286         }
 287         data << plr->m_lookingForGroup.comment;
 288
 289         Group *group = plr->GetGroup();
 290         if(group)
 291         {
 292             data << group->GetMembersCount()-1;             // count of group members without group leader
 293             for(GroupReference *itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
 294             {
 295                 Player *member = itr->getSource();
 296                 if(member && member->GetGUID() != plr->GetGUID())
 297                 {
 298                     data.append(member->GetPackGUID());     // packed guid
 299                     data << member->getLevel();             // player level
 300                 }
 301             }
 302         }
 303         else
 304         {
 305             data << uint32(0x00);
 306         }
 307     }
 308
 309     // fill count placeholders
 310     data.put<uint32>(4+4,  number);
 311     data.put<uint32>(4+4+4,number);
 312
 313     SendPacket(&data);
 314 }
 315
 316 void WorldSession::HandleSetLfgOpcode( WorldPacket & recv_data )
 317 {
 318     CHECK_PACKET_SIZE(recv_data,4+4);
 319
 320     sLog.outDebug("CMSG_SET_LOOKING_FOR_GROUP");
 321     //recv_data.hexlike();
 322     uint32 slot, temp, entry, type;
 323
 324     recv_data >> slot >> temp;
 325
 326     entry = ( temp & 0xFFFF);
 327     type = ( (temp >> 24) & 0xFFFF);
 328
 329     if(slot >= MAX_LOOKING_FOR_GROUP_SLOT)
 330         return;
 331
 332     _player->m_lookingForGroup.slots[slot].Set(entry,type);
 333     sLog.outDebug("LFG set: looknumber %u, temp %X, type %u, entry %u", slot, temp, type, entry);
 334
 335     if(LookingForGroup_auto_join)
 336         AttemptJoin(_player);
 337
 338     SendLfgResult(type, entry, 0);
 339 }