src/game/LootHandler.cpp

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