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