src/game/LootHandler.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 "Log.h"
  22 #include "Corpse.h"
  23 #include "GameObject.h"
  24 #include "Player.h"
  25 #include "ObjectAccessor.h"
  26 #include "WorldSession.h"
  27 #include "LootMgr.h"
  28 #include "Object.h"
  29 #include "Group.h"
  30 #include "World.h"
  31 #include "Util.h"
  32
  33 void WorldSession::HandleAutostoreLootItemOpcode( WorldPacket & recv_data )
  34 {
  35     CHECK_PACKET_SIZE(recv_data,1);
  36
  37     sLog.outDebug("WORLD: CMSG_AUTOSTORE_LOOT_ITEM");
  38     Player  *player =   GetPlayer();
  39     uint64   lguid =    player->GetLootGUID();
  40     Loot    *loot;
  41     uint8    lootSlot;
  42
  43     recv_data >> lootSlot;
  44
  45     if (IS_GAMEOBJECT_GUID(lguid))
  46     {
  47         GameObject *go =
  48             ObjectAccessor::GetGameObject(*player, lguid);
  49
  50         // not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
  51         if (!go || (go->GetOwnerGUID() != _player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
  52         {
  53             player->SendLootRelease(lguid);
  54             return;
  55         }
  56
  57         loot = &go->loot;
  58     }
  59     else if (IS_ITEM_GUID(lguid))
  60     {
  61         Item *pItem = player->GetItemByGuid( lguid );
  62
  63         if (!pItem)
  64         {
  65             player->SendLootRelease(lguid);
  66             return;
  67         }
  68
  69         loot = &pItem->loot;
  70     }
  71     else
  72     {
  73         Creature* pCreature =
  74             ObjectAccessor::GetCreature(*player, lguid);
  75
  76         bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass()==CLASS_ROGUE && pCreature->lootForPickPocketed);
  77
  78         if( !ok_loot || !pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE) )
  79         {
  80             player->SendLootRelease(lguid);
  81             return;
  82         }
  83
  84         loot = &pCreature->loot;
  85     }
  86
  87     QuestItem *qitem = NULL;
  88     QuestItem *ffaitem = NULL;
  89     QuestItem *conditem = NULL;
  90
  91     LootItem *item = loot->LootItemInSlot(lootSlot,player,&qitem,&ffaitem,&conditem);
  92
  93     if(!item)
  94     {
  95         player->SendEquipError( EQUIP_ERR_ALREADY_LOOTED, NULL, NULL );
  96         return;
  97     }
  98
  99     // questitems use the blocked field for other purposes
 100     if (!qitem && item->is_blocked)
 101     {
 102         player->SendLootRelease(lguid);
 103         return;
 104     }
 105
 106     ItemPosCountVec dest;
 107     uint8 msg = player->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, item->itemid, item->count );
 108     if ( msg == EQUIP_ERR_OK )
 109     {
 110         Item * newitem = player->StoreNewItem( dest, item->itemid, true, item->randomPropertyId);
 111
 112         if (qitem)
 113         {
 114             qitem->is_looted = true;
 115             //freeforall is 1 if everyone's supposed to get the quest item.
 116             if (item->freeforall || loot->GetPlayerQuestItems().size() == 1)
 117                 player->SendNotifyLootItemRemoved(lootSlot);
 118             else
 119                 loot->NotifyQuestItemRemoved(qitem->index);
 120         }
 121         else
 122         {
 123             if (ffaitem)
 124             {
 125                 //freeforall case, notify only one player of the removal
 126                 ffaitem->is_looted=true;
 127                 player->SendNotifyLootItemRemoved(lootSlot);
 128             }
 129             else
 130             {
 131                 //not freeforall, notify everyone
 132                 if(conditem)
 133                     conditem->is_looted=true;
 134                 loot->NotifyItemRemoved(lootSlot);
 135             }
 136         }
 137
 138         //if only one person is supposed to loot the item, then set it to looted
 139         if (!item->freeforall)
 140             item->is_looted = true;
 141
 142         --loot->unlootedCount;
 143
 144         player->SendNewItem(newitem, uint32(item->count), false, false, true);
 145         player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, item->itemid, item->count);
 146     }
 147     else
 148         player->SendEquipError( msg, NULL, NULL );
 149 }
 150
 151 void WorldSession::HandleLootMoneyOpcode( WorldPacket & /*recv_data*/ )
 152 {
 153     sLog.outDebug("WORLD: CMSG_LOOT_MONEY");
 154
 155     Player *player = GetPlayer();
 156     uint64 guid = player->GetLootGUID();
 157     if(!guid)
 158         return;
 159
 160     Loot *pLoot = NULL;
 161
 162     switch(GUID_HIPART(guid))
 163     {
 164         case HIGHGUID_GAMEOBJECT:
 165         {
 166             GameObject *pGameObject = ObjectAccessor::GetGameObject(*GetPlayer(), guid);
 167
 168             // not check distance for GO in case owned GO (fishing bobber case, for example)
 169             if( pGameObject && (pGameObject->GetOwnerGUID()==_player->GetGUID() || pGameObject->IsWithinDistInMap(_player,INTERACTION_DISTANCE)) )
 170                 pLoot = &pGameObject->loot;
 171
 172             break;
 173         }
 174         case HIGHGUID_CORPSE:                               // remove insignia ONLY in BG
 175         {
 176             Corpse *bones = ObjectAccessor::GetCorpse(*GetPlayer(), guid);
 177
 178             if (bones && bones->IsWithinDistInMap(_player,INTERACTION_DISTANCE) )
 179                 pLoot = &bones->loot;
 180
 181             break;
 182         }
 183         case HIGHGUID_ITEM:
 184         {
 185             if(Item *item = GetPlayer()->GetItemByGuid(guid))
 186                 pLoot = &item->loot;
 187             break;
 188         }
 189         case HIGHGUID_UNIT:
 190         {
 191             Creature* pCreature = ObjectAccessor::GetCreature(*GetPlayer(), guid);
 192
 193             bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass()==CLASS_ROGUE && pCreature->lootForPickPocketed);
 194
 195             if ( ok_loot && pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE) )
 196                 pLoot = &pCreature->loot ;
 197
 198             break;
 199         }
 200         default:
 201             return;                                         // unlootable type
 202     }
 203
 204     if( pLoot )
 205     {
 206         if (!IS_ITEM_GUID(guid) && player->GetGroup())      //item can be looted only single player
 207         {
 208             Group *group = player->GetGroup();
 209
 210             std::vector<Player*> playersNear;
 211             for(GroupReference *itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
 212             {
 213                 Player* playerGroup = itr->getSource();
 214                 if(!playerGroup)
 215                     continue;
 216                 if (player->GetDistance2d(playerGroup) < sWorld.getConfig(CONFIG_GROUP_XP_DISTANCE))
 217                     playersNear.push_back(playerGroup);
 218             }
 219
 220             uint32 money_per_player = uint32((pLoot->gold)/(playersNear.size()));
 221
 222             for (std::vector<Player*>::iterator i = playersNear.begin(); i != playersNear.end(); ++i)
 223             {
 224                 (*i)->ModifyMoney( money_per_player );
 225                 //Offset surely incorrect, but works
 226                 WorldPacket data( SMSG_LOOT_MONEY_NOTIFY, 4 );
 227                 data << uint32(money_per_player);
 228                 (*i)->GetSession()->SendPacket( &data );
 229             }
 230         }
 231         else
 232             player->ModifyMoney( pLoot->gold );
 233         pLoot->gold = 0;
 234         pLoot->NotifyMoneyRemoved();
 235     }
 236 }
 237
 238 void WorldSession::HandleLootOpcode( WorldPacket & recv_data )
 239 {
 240     CHECK_PACKET_SIZE(recv_data,8);
 241
 242     sLog.outDebug("WORLD: CMSG_LOOT");
 243
 244     uint64 guid;
 245     recv_data >> guid;
 246
 247     GetPlayer()->SendLoot(guid, LOOT_CORPSE);
 248 }
 249
 250 void WorldSession::HandleLootReleaseOpcode( WorldPacket & recv_data )
 251 {
 252     CHECK_PACKET_SIZE(recv_data,8);
 253
 254     sLog.outDebug("WORLD: CMSG_LOOT_RELEASE");
 255
 256     // cheaters can modify lguid to prevent correct apply loot release code and re-loot
 257     // use internal stored guid
 258     //uint64   lguid;
 259     //recv_data >> lguid;
 260
 261     if(uint64 lguid = GetPlayer()->GetLootGUID())
 262         DoLootRelease(lguid);
 263 }
 264
 265 void WorldSession::DoLootRelease( uint64 lguid )
 266 {
 267     Player  *player = GetPlayer();
 268     Loot    *loot;
 269
 270     player->SetLootGUID(0);
 271     player->SendLootRelease(lguid);
 272
 273     player->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_LOOTING);
 274
 275     if (IS_GAMEOBJECT_GUID(lguid))
 276     {
 277         GameObject *go =
 278             ObjectAccessor::GetGameObject(*player, lguid);
 279
 280         // not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
 281         if (!go || (go->GetOwnerGUID() != _player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
 282             return;
 283
 284         loot = &go->loot;
 285
 286         if (go->GetGoType() == GAMEOBJECT_TYPE_DOOR)
 287         {
 288             // locked doors are opened with spelleffect openlock, prevent remove its as looted
 289             go->UseDoorOrButton();
 290         }
 291         else if (loot->isLooted() || go->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE)
 292         {
 293             // GO is mineral vein? so it is not removed after its looted
 294             if(go->GetGoType() == GAMEOBJECT_TYPE_CHEST)
 295             {
 296                 uint32 go_min = go->GetGOInfo()->chest.minSuccessOpens;
 297                 uint32 go_max = go->GetGOInfo()->chest.maxSuccessOpens;
 298
 299                 // only vein pass this check
 300                 if(go_min != 0 && go_max > go_min)
 301                 {
 302                     float amount_rate = sWorld.getRate(RATE_MINING_AMOUNT);
 303                     float min_amount = go_min*amount_rate;
 304                     float max_amount = go_max*amount_rate;
 305
 306                     go->AddUse();
 307                     float uses = float(go->GetUseCount());
 308
 309                     if(uses < max_amount)
 310                     {
 311                         if(uses >= min_amount)
 312                         {
 313                             float chance_rate = sWorld.getRate(RATE_MINING_NEXT);
 314
 315                             int32 ReqValue = 175;
 316                             LockEntry const *lockInfo = sLockStore.LookupEntry(go->GetGOInfo()->chest.lockId);
 317                             if(lockInfo)
 318                                 ReqValue = lockInfo->Skill[0];
 319                             float skill = float(player->GetSkillValue(SKILL_MINING))/(ReqValue+25);
 320                             double chance = pow(0.8*chance_rate,4*(1/double(max_amount))*double(uses));
 321                             if(roll_chance_f(100*chance+skill))
 322                             {
 323                                 go->SetLootState(GO_READY);
 324                             }
 325                             else                            // not have more uses
 326                                 go->SetLootState(GO_JUST_DEACTIVATED);
 327                         }
 328                         else                                // 100% chance until min uses
 329                             go->SetLootState(GO_READY);
 330                     }
 331                     else                                    // max uses already
 332                         go->SetLootState(GO_JUST_DEACTIVATED);
 333                 }
 334                 else                                        // not vein
 335                     go->SetLootState(GO_JUST_DEACTIVATED);
 336             }
 337             else if (go->GetGoType() == GAMEOBJECT_TYPE_FISHINGHOLE)
 338             {                                               // The fishing hole used once more
 339                 go->AddUse();                               // if the max usage is reached, will be despawned in next tick
 340                 if (go->GetUseCount()>=irand(go->GetGOInfo()->fishinghole.minSuccessOpens,go->GetGOInfo()->fishinghole.maxSuccessOpens))
 341                 {
 342                     go->SetLootState(GO_JUST_DEACTIVATED);
 343                 }
 344                 else
 345                     go->SetLootState(GO_READY);
 346             }
 347             else // not chest (or vein/herb/etc)
 348                 go->SetLootState(GO_JUST_DEACTIVATED);
 349
 350             loot->clear();
 351         }
 352         else
 353             // not fully looted object
 354             go->SetLootState(GO_ACTIVATED);
 355     }
 356     else if (IS_CORPSE_GUID(lguid))        // ONLY remove insignia at BG
 357     {
 358         Corpse *corpse = ObjectAccessor::GetCorpse(*player, lguid);
 359         if (!corpse || !corpse->IsWithinDistInMap(_player,INTERACTION_DISTANCE) )
 360             return;
 361
 362         loot = &corpse->loot;
 363
 364         if (loot->isLooted())
 365         {
 366             loot->clear();
 367             corpse->RemoveFlag(CORPSE_FIELD_DYNAMIC_FLAGS, CORPSE_DYNFLAG_LOOTABLE);
 368         }
 369     }
 370     else if (IS_ITEM_GUID(lguid))
 371     {
 372         Item *pItem = player->GetItemByGuid(lguid );
 373         if(!pItem)
 374             return;
 375
 376         ItemPrototype const* proto = pItem->GetProto();
 377
 378         // destroy only 5 items from stack in case prospecting and milling
 379         if( (proto->BagFamily & (BAG_FAMILY_MASK_MINING_SUPP|BAG_FAMILY_MASK_HERBS)) &&
 380             proto->Class == ITEM_CLASS_TRADE_GOODS)
 381         {
 382             pItem->m_lootGenerated = false;
 383             pItem->loot.clear();
 384
 385             uint32 count = pItem->GetCount();
 386
 387             // >=5 checked in spell code, but will work for cheating cases also with removing from another stacks.
 388             if(count > 5)
 389                 count = 5;
 390
 391             player->DestroyItemCount(pItem, count, true);
 392         }
 393         else
 394             // FIXME: item don't must be deleted in case not fully looted state. But this pre-request implement loot saving in DB at item save. Or checting possible.
 395             player->DestroyItem( pItem->GetBagSlot(),pItem->GetSlot(), true);
 396         return;                                             // item can be looted only single player
 397     }
 398     else
 399     {
 400         Creature* pCreature = ObjectAccessor::GetCreature(*player, lguid);
 401
 402         bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass()==CLASS_ROGUE && pCreature->lootForPickPocketed);
 403         if ( !ok_loot || !pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE) )
 404             return;
 405
 406         loot = &pCreature->loot;
 407
 408         // update next looter
 409         if(Player *recipient = pCreature->GetLootRecipient())
 410             if(Group* group = recipient->GetGroup())
 411                 if (group->GetLooterGuid() == player->GetGUID())
 412                     group->UpdateLooterGuid(pCreature);
 413
 414         if (loot->isLooted())
 415         {
 416             // skip pickpocketing loot for speed, skinning timer redunction is no-op in fact
 417             if(!pCreature->isAlive())
 418                 pCreature->AllLootRemovedFromCorpse();
 419
 420             pCreature->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 421             loot->clear();
 422         }
 423     }
 424
 425     //Player is not looking at loot list, he doesn't need to see updates on the loot list
 426     loot->RemoveLooter(player->GetGUID());
 427 }
 428
 429 void WorldSession::HandleLootMasterGiveOpcode( WorldPacket & recv_data )
 430 {
 431     CHECK_PACKET_SIZE(recv_data,8+1+8);
 432
 433     uint8 slotid;
 434     uint64 lootguid, target_playerguid;
 435
 436     recv_data >> lootguid >> slotid >> target_playerguid;
 437
 438     if(!_player->GetGroup() || _player->GetGroup()->GetLooterGuid() != _player->GetGUID())
 439     {
 440         _player->SendLootRelease(GetPlayer()->GetLootGUID());
 441         return;
 442     }
 443
 444     Player *target = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(target_playerguid, 0, HIGHGUID_PLAYER));
 445     if(!target)
 446         return;
 447
 448     sLog.outDebug("WorldSession::HandleLootMasterGiveOpcode (CMSG_LOOT_MASTER_GIVE, 0x02A3) Target = [%s].", target->GetName());
 449
 450     if(_player->GetLootGUID() != lootguid)
 451         return;
 452
 453     Loot *pLoot = NULL;
 454
 455     if(IS_CREATURE_GUID(GetPlayer()->GetLootGUID()))
 456     {
 457         Creature *pCreature = ObjectAccessor::GetCreature(*GetPlayer(), lootguid);
 458         if(!pCreature)
 459             return;
 460
 461         pLoot = &pCreature->loot;
 462     }
 463     else if(IS_GAMEOBJECT_GUID(GetPlayer()->GetLootGUID()))
 464     {
 465         GameObject *pGO = ObjectAccessor::GetGameObject(*GetPlayer(), lootguid);
 466         if(!pGO)
 467             return;
 468
 469         pLoot = &pGO->loot;
 470     }
 471
 472     if(!pLoot)
 473         return;
 474
 475     if (slotid > pLoot->items.size())
 476     {
 477         sLog.outDebug("AutoLootItem: Player %s might be using a hack! (slot %d, size %d)",GetPlayer()->GetName(), slotid, pLoot->items.size());
 478         return;
 479     }
 480
 481     LootItem& item = pLoot->items[slotid];
 482
 483     ItemPosCountVec dest;
 484     uint8 msg = target->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, item.itemid, item.count );
 485     if ( msg != EQUIP_ERR_OK )
 486     {
 487         target->SendEquipError( msg, NULL, NULL );
 488         _player->SendEquipError( msg, NULL, NULL );         // send duplicate of error massage to master looter
 489         return;
 490     }
 491
 492     // not move item from loot to target inventory
 493     Item * newitem = target->StoreNewItem( dest, item.itemid, true, item.randomPropertyId );
 494     target->SendNewItem(newitem, uint32(item.count), false, false, true );
 495     target->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, item.itemid, item.count);
 496
 497     // mark as looted
 498     item.count=0;
 499     item.is_looted=true;
 500
 501
 502     pLoot->NotifyItemRemoved(slotid);
 503     --pLoot->unlootedCount;
 504 }