rearranged core files
--HG-- branch : trunk
This commit is contained in:
Rat
@@ -0,0 +1,549 @@
|
||||
/*
|
||||
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
||||
*
|
||||
* Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include "Common.h"
|
||||
#include "WorldPacket.h"
|
||||
#include "Log.h"
|
||||
#include "Corpse.h"
|
||||
#include "GameObject.h"
|
||||
#include "Player.h"
|
||||
#include "ObjectAccessor.h"
|
||||
#include "WorldSession.h"
|
||||
#include "LootMgr.h"
|
||||
#include "Object.h"
|
||||
#include "Group.h"
|
||||
#include "World.h"
|
||||
#include "Util.h"
|
||||
|
||||
void WorldSession::HandleAutostoreLootItemOpcode(WorldPacket & recv_data)
|
||||
{
|
||||
sLog.outDebug("WORLD: CMSG_AUTOSTORE_LOOT_ITEM");
|
||||
Player *player = GetPlayer();
|
||||
uint64 lguid = player->GetLootGUID();
|
||||
Loot *loot;
|
||||
uint8 lootSlot;
|
||||
|
||||
recv_data >> lootSlot;
|
||||
|
||||
if (IS_GAMEOBJECT_GUID(lguid))
|
||||
{
|
||||
GameObject *go = player->GetMap()->GetGameObject(lguid);
|
||||
|
||||
// not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
|
||||
if (!go || ((go->GetOwnerGUID() != _player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(_player,INTERACTION_DISTANCE)))
|
||||
{
|
||||
player->SendLootRelease(lguid);
|
||||
return;
|
||||
}
|
||||
|
||||
loot = &go->loot;
|
||||
}
|
||||
else if (IS_ITEM_GUID(lguid))
|
||||
{
|
||||
Item *pItem = player->GetItemByGuid(lguid);
|
||||
|
||||
if (!pItem)
|
||||
{
|
||||
player->SendLootRelease(lguid);
|
||||
return;
|
||||
}
|
||||
|
||||
loot = &pItem->loot;
|
||||
}
|
||||
else if (IS_CORPSE_GUID(lguid))
|
||||
{
|
||||
Corpse *bones = ObjectAccessor::GetCorpse(*player, lguid);
|
||||
if (!bones)
|
||||
{
|
||||
player->SendLootRelease(lguid);
|
||||
return;
|
||||
}
|
||||
loot = &bones->loot;
|
||||
}
|
||||
else
|
||||
{
|
||||
Creature* pCreature = GetPlayer()->GetMap()->GetCreature(lguid);
|
||||
|
||||
bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass() == CLASS_ROGUE && pCreature->lootForPickPocketed);
|
||||
|
||||
if (!ok_loot || !pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
|
||||
{
|
||||
player->SendLootRelease(lguid);
|
||||
return;
|
||||
}
|
||||
|
||||
loot = &pCreature->loot;
|
||||
}
|
||||
|
||||
QuestItem *qitem = NULL;
|
||||
QuestItem *ffaitem = NULL;
|
||||
QuestItem *conditem = NULL;
|
||||
|
||||
LootItem *item = loot->LootItemInSlot(lootSlot,player,&qitem,&ffaitem,&conditem);
|
||||
|
||||
if (!item)
|
||||
{
|
||||
player->SendEquipError(EQUIP_ERR_ALREADY_LOOTED, NULL, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
// questitems use the blocked field for other purposes
|
||||
if (!qitem && item->is_blocked)
|
||||
{
|
||||
player->SendLootRelease(lguid);
|
||||
return;
|
||||
}
|
||||
|
||||
ItemPosCountVec dest;
|
||||
uint8 msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, item->itemid, item->count);
|
||||
if (msg == EQUIP_ERR_OK)
|
||||
{
|
||||
Item * newitem = player->StoreNewItem(dest, item->itemid, true, item->randomPropertyId);
|
||||
|
||||
if (qitem)
|
||||
{
|
||||
qitem->is_looted = true;
|
||||
//freeforall is 1 if everyone's supposed to get the quest item.
|
||||
if (item->freeforall || loot->GetPlayerQuestItems().size() == 1)
|
||||
player->SendNotifyLootItemRemoved(lootSlot);
|
||||
else
|
||||
loot->NotifyQuestItemRemoved(qitem->index);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ffaitem)
|
||||
{
|
||||
//freeforall case, notify only one player of the removal
|
||||
ffaitem->is_looted=true;
|
||||
player->SendNotifyLootItemRemoved(lootSlot);
|
||||
}
|
||||
else
|
||||
{
|
||||
//not freeforall, notify everyone
|
||||
if (conditem)
|
||||
conditem->is_looted=true;
|
||||
loot->NotifyItemRemoved(lootSlot);
|
||||
}
|
||||
}
|
||||
|
||||
//if only one person is supposed to loot the item, then set it to looted
|
||||
if (!item->freeforall)
|
||||
item->is_looted = true;
|
||||
|
||||
--loot->unlootedCount;
|
||||
|
||||
player->SendNewItem(newitem, uint32(item->count), false, false, true);
|
||||
player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, item->itemid, item->count);
|
||||
player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, loot->loot_type, item->count);
|
||||
player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM, item->itemid, item->count);
|
||||
}
|
||||
else
|
||||
player->SendEquipError(msg, NULL, NULL);
|
||||
}
|
||||
|
||||
void WorldSession::HandleLootMoneyOpcode(WorldPacket & /*recv_data*/)
|
||||
{
|
||||
sLog.outDebug("WORLD: CMSG_LOOT_MONEY");
|
||||
|
||||
Player *player = GetPlayer();
|
||||
uint64 guid = player->GetLootGUID();
|
||||
if (!guid)
|
||||
return;
|
||||
|
||||
Loot *pLoot = NULL;
|
||||
|
||||
switch(GUID_HIPART(guid))
|
||||
{
|
||||
case HIGHGUID_GAMEOBJECT:
|
||||
{
|
||||
GameObject *pGameObject = GetPlayer()->GetMap()->GetGameObject(guid);
|
||||
|
||||
// not check distance for GO in case owned GO (fishing bobber case, for example)
|
||||
if (pGameObject && ((pGameObject->GetOwnerGUID() == _player->GetGUID() || pGameObject->IsWithinDistInMap(_player,INTERACTION_DISTANCE))))
|
||||
pLoot = &pGameObject->loot;
|
||||
|
||||
break;
|
||||
}
|
||||
case HIGHGUID_CORPSE: // remove insignia ONLY in BG
|
||||
{
|
||||
Corpse *bones = ObjectAccessor::GetCorpse(*GetPlayer(), guid);
|
||||
|
||||
if (bones && bones->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
|
||||
pLoot = &bones->loot;
|
||||
|
||||
break;
|
||||
}
|
||||
case HIGHGUID_ITEM:
|
||||
{
|
||||
if (Item *item = GetPlayer()->GetItemByGuid(guid))
|
||||
pLoot = &item->loot;
|
||||
break;
|
||||
}
|
||||
case HIGHGUID_UNIT:
|
||||
{
|
||||
Creature* pCreature = GetPlayer()->GetMap()->GetCreature(guid);
|
||||
|
||||
bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass() == CLASS_ROGUE && pCreature->lootForPickPocketed);
|
||||
|
||||
if (ok_loot && pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
|
||||
pLoot = &pCreature->loot ;
|
||||
|
||||
break;
|
||||
}
|
||||
default:
|
||||
return; // unlootable type
|
||||
}
|
||||
|
||||
if (pLoot)
|
||||
{
|
||||
if (!IS_ITEM_GUID(guid) && player->GetGroup()) //item can be looted only single player
|
||||
{
|
||||
Group *group = player->GetGroup();
|
||||
|
||||
std::vector<Player*> playersNear;
|
||||
for (GroupReference *itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
|
||||
{
|
||||
Player* playerGroup = itr->getSource();
|
||||
if (!playerGroup)
|
||||
continue;
|
||||
if (player->IsWithinDistInMap(playerGroup,sWorld.getConfig(CONFIG_GROUP_XP_DISTANCE),false))
|
||||
playersNear.push_back(playerGroup);
|
||||
}
|
||||
|
||||
uint32 money_per_player = uint32((pLoot->gold)/(playersNear.size()));
|
||||
|
||||
for (std::vector<Player*>::const_iterator i = playersNear.begin(); i != playersNear.end(); ++i)
|
||||
{
|
||||
(*i)->ModifyMoney(money_per_player);
|
||||
(*i)->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY, money_per_player);
|
||||
//Offset surely incorrect, but works
|
||||
WorldPacket data(SMSG_LOOT_MONEY_NOTIFY, 4);
|
||||
data << uint32(money_per_player);
|
||||
(*i)->GetSession()->SendPacket(&data);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
player->ModifyMoney(pLoot->gold);
|
||||
player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY, pLoot->gold);
|
||||
}
|
||||
pLoot->gold = 0;
|
||||
pLoot->NotifyMoneyRemoved();
|
||||
}
|
||||
}
|
||||
|
||||
void WorldSession::HandleLootOpcode(WorldPacket & recv_data)
|
||||
{
|
||||
sLog.outDebug("WORLD: CMSG_LOOT");
|
||||
|
||||
uint64 guid;
|
||||
recv_data >> guid;
|
||||
|
||||
// Check possible cheat
|
||||
if (!_player->isAlive())
|
||||
return;
|
||||
|
||||
GetPlayer()->SendLoot(guid, LOOT_CORPSE);
|
||||
}
|
||||
|
||||
void WorldSession::HandleLootReleaseOpcode(WorldPacket & recv_data)
|
||||
{
|
||||
sLog.outDebug("WORLD: CMSG_LOOT_RELEASE");
|
||||
|
||||
// cheaters can modify lguid to prevent correct apply loot release code and re-loot
|
||||
// use internal stored guid
|
||||
recv_data.read_skip<uint64>(); // guid;
|
||||
|
||||
if (uint64 lguid = GetPlayer()->GetLootGUID())
|
||||
DoLootRelease(lguid);
|
||||
}
|
||||
|
||||
void WorldSession::DoLootRelease(uint64 lguid)
|
||||
{
|
||||
Player *player = GetPlayer();
|
||||
Loot *loot;
|
||||
|
||||
player->SetLootGUID(0);
|
||||
player->SendLootRelease(lguid);
|
||||
|
||||
player->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_LOOTING);
|
||||
|
||||
if (!player->IsInWorld())
|
||||
return;
|
||||
|
||||
if (IS_GAMEOBJECT_GUID(lguid))
|
||||
{
|
||||
GameObject *go = GetPlayer()->GetMap()->GetGameObject(lguid);
|
||||
|
||||
// not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
|
||||
if (!go || ((go->GetOwnerGUID() != _player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(_player,INTERACTION_DISTANCE)))
|
||||
return;
|
||||
|
||||
loot = &go->loot;
|
||||
|
||||
if (go->GetGoType() == GAMEOBJECT_TYPE_DOOR)
|
||||
{
|
||||
// locked doors are opened with spelleffect openlock, prevent remove its as looted
|
||||
go->UseDoorOrButton();
|
||||
}
|
||||
else if (loot->isLooted() || go->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE)
|
||||
{
|
||||
// GO is mineral vein? so it is not removed after its looted
|
||||
if (go->GetGoType() == GAMEOBJECT_TYPE_CHEST)
|
||||
{
|
||||
uint32 go_min = go->GetGOInfo()->chest.minSuccessOpens;
|
||||
uint32 go_max = go->GetGOInfo()->chest.maxSuccessOpens;
|
||||
|
||||
// only vein pass this check
|
||||
if (go_min != 0 && go_max > go_min)
|
||||
{
|
||||
float amount_rate = sWorld.getRate(RATE_MINING_AMOUNT);
|
||||
float min_amount = go_min*amount_rate;
|
||||
float max_amount = go_max*amount_rate;
|
||||
|
||||
go->AddUse();
|
||||
float uses = float(go->GetUseCount());
|
||||
|
||||
if (uses < max_amount)
|
||||
{
|
||||
if (uses >= min_amount)
|
||||
{
|
||||
float chance_rate = sWorld.getRate(RATE_MINING_NEXT);
|
||||
|
||||
int32 ReqValue = 175;
|
||||
LockEntry const *lockInfo = sLockStore.LookupEntry(go->GetGOInfo()->chest.lockId);
|
||||
if (lockInfo)
|
||||
ReqValue = lockInfo->Skill[0];
|
||||
float skill = float(player->GetSkillValue(SKILL_MINING))/(ReqValue+25);
|
||||
double chance = pow(0.8*chance_rate,4*(1/double(max_amount))*double(uses));
|
||||
if (roll_chance_f(100*chance+skill))
|
||||
{
|
||||
go->SetLootState(GO_READY);
|
||||
}
|
||||
else // not have more uses
|
||||
go->SetLootState(GO_JUST_DEACTIVATED);
|
||||
}
|
||||
else // 100% chance until min uses
|
||||
go->SetLootState(GO_READY);
|
||||
}
|
||||
else // max uses already
|
||||
go->SetLootState(GO_JUST_DEACTIVATED);
|
||||
}
|
||||
else // not vein
|
||||
go->SetLootState(GO_JUST_DEACTIVATED);
|
||||
}
|
||||
else if (go->GetGoType() == GAMEOBJECT_TYPE_FISHINGHOLE)
|
||||
{ // The fishing hole used once more
|
||||
go->AddUse(); // if the max usage is reached, will be despawned in next tick
|
||||
if (go->GetUseCount() >= irand(go->GetGOInfo()->fishinghole.minSuccessOpens,go->GetGOInfo()->fishinghole.maxSuccessOpens))
|
||||
{
|
||||
go->SetLootState(GO_JUST_DEACTIVATED);
|
||||
}
|
||||
else
|
||||
go->SetLootState(GO_READY);
|
||||
}
|
||||
else // not chest (or vein/herb/etc)
|
||||
go->SetLootState(GO_JUST_DEACTIVATED);
|
||||
|
||||
loot->clear();
|
||||
}
|
||||
else
|
||||
{
|
||||
// not fully looted object
|
||||
go->SetLootState(GO_ACTIVATED);
|
||||
|
||||
// if the round robin player release, reset it.
|
||||
if (player->GetGUID() == loot->roundRobinPlayer)
|
||||
{
|
||||
if (Group* pGroup = player->GetGroup())
|
||||
{
|
||||
if (pGroup->GetLootMethod() != MASTER_LOOT)
|
||||
{
|
||||
loot->roundRobinPlayer = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
loot->roundRobinPlayer = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (IS_CORPSE_GUID(lguid)) // ONLY remove insignia at BG
|
||||
{
|
||||
Corpse *corpse = ObjectAccessor::GetCorpse(*player, lguid);
|
||||
if (!corpse || !corpse->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
|
||||
return;
|
||||
|
||||
loot = &corpse->loot;
|
||||
|
||||
if (loot->isLooted())
|
||||
{
|
||||
loot->clear();
|
||||
corpse->RemoveFlag(CORPSE_FIELD_DYNAMIC_FLAGS, CORPSE_DYNFLAG_LOOTABLE);
|
||||
}
|
||||
}
|
||||
else if (IS_ITEM_GUID(lguid))
|
||||
{
|
||||
Item *pItem = player->GetItemByGuid(lguid);
|
||||
if (!pItem)
|
||||
return;
|
||||
|
||||
ItemPrototype const* proto = pItem->GetProto();
|
||||
|
||||
// destroy only 5 items from stack in case prospecting and milling
|
||||
if ((proto->BagFamily & (BAG_FAMILY_MASK_MINING_SUPP|BAG_FAMILY_MASK_HERBS)) &&
|
||||
proto->Class == ITEM_CLASS_TRADE_GOODS)
|
||||
{
|
||||
pItem->m_lootGenerated = false;
|
||||
pItem->loot.clear();
|
||||
|
||||
uint32 count = pItem->GetCount();
|
||||
|
||||
// >=5 checked in spell code, but will work for cheating cases also with removing from another stacks.
|
||||
if (count > 5)
|
||||
count = 5;
|
||||
|
||||
player->DestroyItemCount(pItem, count, true);
|
||||
}
|
||||
else
|
||||
// FIXME: item must not be deleted in case not fully looted state. But this pre-request implement loot saving in DB at item save. Or cheating possible.
|
||||
player->DestroyItem(pItem->GetBagSlot(),pItem->GetSlot(), true);
|
||||
return; // item can be looted only single player
|
||||
}
|
||||
else
|
||||
{
|
||||
Creature* pCreature = GetPlayer()->GetMap()->GetCreature(lguid);
|
||||
|
||||
bool ok_loot = pCreature && pCreature->isAlive() == (player->getClass() == CLASS_ROGUE && pCreature->lootForPickPocketed);
|
||||
if (!ok_loot || !pCreature->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
|
||||
return;
|
||||
|
||||
loot = &pCreature->loot;
|
||||
if (loot->isLooted())
|
||||
{
|
||||
// skip pickpocketing loot for speed, skinning timer redunction is no-op in fact
|
||||
if (!pCreature->isAlive())
|
||||
pCreature->AllLootRemovedFromCorpse();
|
||||
|
||||
pCreature->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
|
||||
pCreature->SetLootRecipient(NULL);
|
||||
loot->clear();
|
||||
}
|
||||
else
|
||||
{
|
||||
// if the round robin player release, reset it.
|
||||
if (player->GetGUID() == loot->roundRobinPlayer)
|
||||
{
|
||||
if (Group* pGroup = player->GetGroup())
|
||||
{
|
||||
if (pGroup->GetLootMethod() != MASTER_LOOT)
|
||||
{
|
||||
loot->roundRobinPlayer = 0;
|
||||
pGroup->SendLooter(pCreature, NULL);
|
||||
|
||||
// force update of dynamic flags, otherwise other group's players still not able to loot.
|
||||
pCreature->ForceValuesUpdateAtIndex(UNIT_DYNAMIC_FLAGS);
|
||||
}
|
||||
}
|
||||
else
|
||||
loot->roundRobinPlayer = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Player is not looking at loot list, he doesn't need to see updates on the loot list
|
||||
loot->RemoveLooter(player->GetGUID());
|
||||
}
|
||||
|
||||
void WorldSession::HandleLootMasterGiveOpcode(WorldPacket & recv_data)
|
||||
{
|
||||
uint8 slotid;
|
||||
uint64 lootguid, target_playerguid;
|
||||
|
||||
recv_data >> lootguid >> slotid >> target_playerguid;
|
||||
|
||||
if (!_player->GetGroup() || _player->GetGroup()->GetLooterGuid() != _player->GetGUID())
|
||||
{
|
||||
_player->SendLootRelease(GetPlayer()->GetLootGUID());
|
||||
return;
|
||||
}
|
||||
|
||||
Player *target = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(target_playerguid, 0, HIGHGUID_PLAYER));
|
||||
if (!target)
|
||||
return;
|
||||
|
||||
sLog.outDebug("WorldSession::HandleLootMasterGiveOpcode (CMSG_LOOT_MASTER_GIVE, 0x02A3) Target = [%s].", target->GetName());
|
||||
|
||||
if (_player->GetLootGUID() != lootguid)
|
||||
return;
|
||||
|
||||
Loot *pLoot = NULL;
|
||||
|
||||
if (IS_CRE_OR_VEH_GUID(GetPlayer()->GetLootGUID()))
|
||||
{
|
||||
Creature *pCreature = GetPlayer()->GetMap()->GetCreature(lootguid);
|
||||
if (!pCreature)
|
||||
return;
|
||||
|
||||
pLoot = &pCreature->loot;
|
||||
}
|
||||
else if (IS_GAMEOBJECT_GUID(GetPlayer()->GetLootGUID()))
|
||||
{
|
||||
GameObject *pGO = GetPlayer()->GetMap()->GetGameObject(lootguid);
|
||||
if (!pGO)
|
||||
return;
|
||||
|
||||
pLoot = &pGO->loot;
|
||||
}
|
||||
|
||||
if (!pLoot)
|
||||
return;
|
||||
|
||||
if (slotid > pLoot->items.size())
|
||||
{
|
||||
sLog.outDebug("AutoLootItem: Player %s might be using a hack! (slot %d, size %lu)",GetPlayer()->GetName(), slotid, (unsigned long)pLoot->items.size());
|
||||
return;
|
||||
}
|
||||
|
||||
LootItem& item = pLoot->items[slotid];
|
||||
|
||||
ItemPosCountVec dest;
|
||||
uint8 msg = target->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, item.itemid, item.count);
|
||||
if (msg != EQUIP_ERR_OK)
|
||||
{
|
||||
target->SendEquipError(msg, NULL, NULL);
|
||||
_player->SendEquipError(msg, NULL, NULL); // send duplicate of error massage to master looter
|
||||
return;
|
||||
}
|
||||
|
||||
// not move item from loot to target inventory
|
||||
Item * newitem = target->StoreNewItem(dest, item.itemid, true, item.randomPropertyId);
|
||||
target->SendNewItem(newitem, uint32(item.count), false, false, true);
|
||||
target->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, item.itemid, item.count);
|
||||
target->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, pLoot->loot_type, item.count);
|
||||
target->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM, item.itemid, item.count);
|
||||
|
||||
// mark as looted
|
||||
item.count=0;
|
||||
item.is_looted=true;
|
||||
|
||||
pLoot->NotifyItemRemoved(slotid);
|
||||
--pLoot->unlootedCount;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,403 @@
|
||||
/*
|
||||
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
||||
*
|
||||
* Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef TRINITY_LOOTMGR_H
|
||||
#define TRINITY_LOOTMGR_H
|
||||
|
||||
#include "ItemEnchantmentMgr.h"
|
||||
#include "ByteBuffer.h"
|
||||
#include "Utilities/LinkedReference/RefManager.h"
|
||||
#include "SharedDefines.h"
|
||||
#include "ConditionMgr.h"
|
||||
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
enum RollType
|
||||
{
|
||||
ROLL_PASS = 0,
|
||||
ROLL_NEED = 1,
|
||||
ROLL_GREED = 2,
|
||||
ROLL_DISENCHANT = 3,
|
||||
MAX_ROLL_TYPE = 4
|
||||
};
|
||||
|
||||
enum RollMask
|
||||
{
|
||||
ROLL_FLAG_TYPE_PASS = 0x01,
|
||||
ROLL_FLAG_TYPE_NEED = 0x02,
|
||||
ROLL_FLAG_TYPE_GREED = 0x04,
|
||||
ROLL_FLAG_TYPE_DISENCHANT = 0x08,
|
||||
|
||||
ROLL_ALL_TYPE_NO_DISENCHANT = 0x07,
|
||||
ROLL_ALL_TYPE_MASK = 0x0F
|
||||
};
|
||||
|
||||
#define MAX_NR_LOOT_ITEMS 16
|
||||
// note: the client cannot show more than 16 items total
|
||||
#define MAX_NR_QUEST_ITEMS 32
|
||||
// unrelated to the number of quest items shown, just for reserve
|
||||
|
||||
enum LootMethod
|
||||
{
|
||||
FREE_FOR_ALL = 0,
|
||||
ROUND_ROBIN = 1,
|
||||
MASTER_LOOT = 2,
|
||||
GROUP_LOOT = 3,
|
||||
NEED_BEFORE_GREED = 4
|
||||
};
|
||||
|
||||
enum PermissionTypes
|
||||
{
|
||||
ALL_PERMISSION = 0,
|
||||
GROUP_PERMISSION = 1,
|
||||
MASTER_PERMISSION = 2,
|
||||
ROUND_ROBIN_PERMISSION = 3,
|
||||
NONE_PERMISSION = 4,
|
||||
};
|
||||
|
||||
enum LootType
|
||||
{
|
||||
LOOT_CORPSE = 1,
|
||||
LOOT_PICKPOCKETING = 2,
|
||||
LOOT_FISHING = 3,
|
||||
LOOT_DISENCHANTING = 4,
|
||||
// ignored always by client
|
||||
LOOT_SKINNING = 6,
|
||||
LOOT_PROSPECTING = 7,
|
||||
LOOT_MILLING = 8,
|
||||
|
||||
LOOT_FISHINGHOLE = 20, // unsupported by client, sending LOOT_FISHING instead
|
||||
LOOT_INSIGNIA = 21 // unsupported by client, sending LOOT_CORPSE instead
|
||||
};
|
||||
|
||||
// type of Loot Item in Loot View
|
||||
enum LootSlotType
|
||||
{
|
||||
LOOT_SLOT_TYPE_ALLOW_LOOT = 0, // player can loot the item.
|
||||
LOOT_SLOT_TYPE_ROLL_ONGOING = 1, // roll is ongoing. player cannot loot.
|
||||
LOOT_SLOT_TYPE_MASTER = 2, // item can only be distributed by group loot master.
|
||||
LOOT_SLOT_TYPE_LOCKED = 3, // item is shown in red. player cannot loot.
|
||||
};
|
||||
|
||||
class Player;
|
||||
class LootStore;
|
||||
class ConditionMgr;
|
||||
|
||||
struct LootStoreItem
|
||||
{
|
||||
uint32 itemid; // id of the item
|
||||
float chance; // always positive, chance to drop for both quest and non-quest items, chance to be used for refs
|
||||
int32 mincountOrRef; // mincount for drop items (positive) or minus referenced TemplateleId (negative)
|
||||
uint16 lootmode;
|
||||
uint8 group :7;
|
||||
bool needs_quest :1; // quest drop (negative ChanceOrQuestChance in DB)
|
||||
uint8 maxcount :8; // max drop count for the item (mincountOrRef positive) or Ref multiplicator (mincountOrRef negative)
|
||||
ConditionList conditions; // additional loot condition
|
||||
|
||||
// Constructor, converting ChanceOrQuestChance -> (chance, needs_quest)
|
||||
// displayid is filled in IsValid() which must be called after
|
||||
LootStoreItem(uint32 _itemid, float _chanceOrQuestChance, uint16 _lootmode, uint8 _group, int32 _mincountOrRef, uint8 _maxcount)
|
||||
: itemid(_itemid), chance(fabs(_chanceOrQuestChance)), mincountOrRef(_mincountOrRef), lootmode(_lootmode),
|
||||
group(_group), needs_quest(_chanceOrQuestChance < 0), maxcount(_maxcount)
|
||||
{}
|
||||
|
||||
bool Roll(bool rate) const; // Checks if the entry takes it's chance (at loot generation)
|
||||
bool IsValid(LootStore const& store, uint32 entry) const;
|
||||
// Checks correctness of values
|
||||
};
|
||||
|
||||
struct LootItem
|
||||
{
|
||||
uint32 itemid;
|
||||
uint32 randomSuffix;
|
||||
int32 randomPropertyId;
|
||||
ConditionList conditions; // additional loot condition
|
||||
uint8 count : 8;
|
||||
bool is_looted : 1;
|
||||
bool is_blocked : 1;
|
||||
bool freeforall : 1; // free for all
|
||||
bool is_underthreshold : 1;
|
||||
bool is_counted : 1;
|
||||
bool needs_quest : 1; // quest drop
|
||||
|
||||
// Constructor, copies most fields from LootStoreItem, generates random count and random suffixes/properties
|
||||
// Should be called for non-reference LootStoreItem entries only (mincountOrRef > 0)
|
||||
explicit LootItem(LootStoreItem const& li);
|
||||
|
||||
// Basic checks for player/item compatibility - if false no chance to see the item in the loot
|
||||
bool AllowedForPlayer(Player const * player) const;
|
||||
};
|
||||
|
||||
struct QuestItem
|
||||
{
|
||||
uint8 index; // position in quest_items;
|
||||
bool is_looted;
|
||||
|
||||
QuestItem()
|
||||
: index(0), is_looted(false) {}
|
||||
|
||||
QuestItem(uint8 _index, bool _islooted = false)
|
||||
: index(_index), is_looted(_islooted) {}
|
||||
};
|
||||
|
||||
struct Loot;
|
||||
class LootTemplate;
|
||||
|
||||
typedef std::vector<QuestItem> QuestItemList;
|
||||
typedef std::vector<LootItem> LootItemList;
|
||||
typedef std::map<uint32, QuestItemList *> QuestItemMap;
|
||||
typedef std::vector<LootStoreItem> LootStoreItemList;
|
||||
typedef UNORDERED_MAP<uint32, LootTemplate*> LootTemplateMap;
|
||||
|
||||
typedef std::set<uint32> LootIdSet;
|
||||
|
||||
class LootStore
|
||||
{
|
||||
public:
|
||||
explicit LootStore(char const* name, char const* entryName, bool ratesAllowed)
|
||||
: m_name(name), m_entryName(entryName), m_ratesAllowed(ratesAllowed) {}
|
||||
virtual ~LootStore() { Clear(); }
|
||||
|
||||
void Verify() const;
|
||||
|
||||
void LoadAndCollectLootIds(LootIdSet& ids_set);
|
||||
void CheckLootRefs(LootIdSet* ref_set = NULL) const; // check existence reference and remove it from ref_set
|
||||
void ReportUnusedIds(LootIdSet const& ids_set) const;
|
||||
void ReportNotExistedId(uint32 id) const;
|
||||
|
||||
bool HaveLootFor(uint32 loot_id) const { return m_LootTemplates.find(loot_id) != m_LootTemplates.end(); }
|
||||
bool HaveQuestLootFor(uint32 loot_id) const;
|
||||
bool HaveQuestLootForPlayer(uint32 loot_id,Player* player) const;
|
||||
|
||||
LootTemplate const* GetLootFor(uint32 loot_id) const;
|
||||
void ResetConditions();
|
||||
LootTemplate* GetLootForConditionFill(uint32 loot_id);
|
||||
|
||||
char const* GetName() const { return m_name; }
|
||||
char const* GetEntryName() const { return m_entryName; }
|
||||
bool IsRatesAllowed() const { return m_ratesAllowed; }
|
||||
protected:
|
||||
void LoadLootTable();
|
||||
void Clear();
|
||||
private:
|
||||
LootTemplateMap m_LootTemplates;
|
||||
char const* m_name;
|
||||
char const* m_entryName;
|
||||
bool m_ratesAllowed;
|
||||
};
|
||||
|
||||
class LootTemplate
|
||||
{
|
||||
class LootGroup; // A set of loot definitions for items (refs are not allowed inside)
|
||||
typedef std::vector<LootGroup> LootGroups;
|
||||
|
||||
public:
|
||||
// Adds an entry to the group (at loading stage)
|
||||
void AddEntry(LootStoreItem& item);
|
||||
// Rolls for every item in the template and adds the rolled items the the loot
|
||||
void Process(Loot& loot, LootStore const& store, bool rate, uint16 lootMode, uint8 groupId = 0) const;
|
||||
void CopyConditions(ConditionList conditions);
|
||||
|
||||
// True if template includes at least 1 quest drop entry
|
||||
bool HasQuestDrop(LootTemplateMap const& store, uint8 groupId = 0) const;
|
||||
// True if template includes at least 1 quest drop for an active quest of the player
|
||||
bool HasQuestDropForPlayer(LootTemplateMap const& store, Player const * player, uint8 groupId = 0) const;
|
||||
|
||||
// Checks integrity of the template
|
||||
void Verify(LootStore const& store, uint32 Id) const;
|
||||
void CheckLootRefs(LootTemplateMap const& store, LootIdSet* ref_set) const;
|
||||
bool addConditionItem(Condition* cond);
|
||||
bool isReference(uint32 id);
|
||||
|
||||
private:
|
||||
LootStoreItemList Entries; // not grouped only
|
||||
LootGroups Groups; // groups have own (optimised) processing, grouped entries go there
|
||||
};
|
||||
|
||||
//=====================================================
|
||||
|
||||
class LootValidatorRef : public Reference<Loot, LootValidatorRef>
|
||||
{
|
||||
public:
|
||||
LootValidatorRef() {}
|
||||
void targetObjectDestroyLink() {}
|
||||
void sourceObjectDestroyLink() {}
|
||||
};
|
||||
|
||||
//=====================================================
|
||||
|
||||
class LootValidatorRefManager : public RefManager<Loot, LootValidatorRef>
|
||||
{
|
||||
public:
|
||||
typedef LinkedListHead::Iterator< LootValidatorRef > iterator;
|
||||
|
||||
LootValidatorRef* getFirst() { return (LootValidatorRef*)RefManager<Loot, LootValidatorRef>::getFirst(); }
|
||||
LootValidatorRef* getLast() { return (LootValidatorRef*)RefManager<Loot, LootValidatorRef>::getLast(); }
|
||||
|
||||
iterator begin() { return iterator(getFirst()); }
|
||||
iterator end() { return iterator(NULL); }
|
||||
iterator rbegin() { return iterator(getLast()); }
|
||||
iterator rend() { return iterator(NULL); }
|
||||
};
|
||||
|
||||
//=====================================================
|
||||
struct LootView;
|
||||
|
||||
ByteBuffer& operator<<(ByteBuffer& b, LootItem const& li);
|
||||
ByteBuffer& operator<<(ByteBuffer& b, LootView const& lv);
|
||||
|
||||
struct Loot
|
||||
{
|
||||
friend ByteBuffer& operator<<(ByteBuffer& b, LootView const& lv);
|
||||
|
||||
QuestItemMap const& GetPlayerQuestItems() const { return PlayerQuestItems; }
|
||||
QuestItemMap const& GetPlayerFFAItems() const { return PlayerFFAItems; }
|
||||
QuestItemMap const& GetPlayerNonQuestNonFFAConditionalItems() const { return PlayerNonQuestNonFFAConditionalItems; }
|
||||
|
||||
std::vector<LootItem> items;
|
||||
uint32 gold;
|
||||
uint8 unlootedCount;
|
||||
uint64 roundRobinPlayer; // GUID of the player having the Round-Robin ownership for the loot. If 0, round robin owner has released.
|
||||
LootType loot_type; // required for achievement system
|
||||
|
||||
Loot(uint32 _gold = 0) : gold(_gold), unlootedCount(0), loot_type(LOOT_CORPSE) {}
|
||||
~Loot() { clear(); }
|
||||
|
||||
// if loot becomes invalid this reference is used to inform the listener
|
||||
void addLootValidatorRef(LootValidatorRef* pLootValidatorRef)
|
||||
{
|
||||
i_LootValidatorRefManager.insertFirst(pLootValidatorRef);
|
||||
}
|
||||
|
||||
// void clear();
|
||||
void clear()
|
||||
{
|
||||
for (QuestItemMap::const_iterator itr = PlayerQuestItems.begin(); itr != PlayerQuestItems.end(); ++itr)
|
||||
delete itr->second;
|
||||
PlayerQuestItems.clear();
|
||||
|
||||
for (QuestItemMap::const_iterator itr = PlayerFFAItems.begin(); itr != PlayerFFAItems.end(); ++itr)
|
||||
delete itr->second;
|
||||
PlayerFFAItems.clear();
|
||||
|
||||
for (QuestItemMap::const_iterator itr = PlayerNonQuestNonFFAConditionalItems.begin(); itr != PlayerNonQuestNonFFAConditionalItems.end(); ++itr)
|
||||
delete itr->second;
|
||||
PlayerNonQuestNonFFAConditionalItems.clear();
|
||||
|
||||
PlayersLooting.clear();
|
||||
items.clear();
|
||||
quest_items.clear();
|
||||
gold = 0;
|
||||
unlootedCount = 0;
|
||||
roundRobinPlayer = 0;
|
||||
i_LootValidatorRefManager.clearReferences();
|
||||
}
|
||||
|
||||
bool empty() const { return items.empty() && gold == 0; }
|
||||
bool isLooted() const { return gold == 0 && unlootedCount == 0; }
|
||||
|
||||
void NotifyItemRemoved(uint8 lootIndex);
|
||||
void NotifyQuestItemRemoved(uint8 questIndex);
|
||||
void NotifyMoneyRemoved();
|
||||
void AddLooter(uint64 GUID) { PlayersLooting.insert(GUID); }
|
||||
void RemoveLooter(uint64 GUID) { PlayersLooting.erase(GUID); }
|
||||
|
||||
void generateMoneyLoot(uint32 minAmount, uint32 maxAmount);
|
||||
bool FillLoot(uint32 loot_id, LootStore const& store, Player* loot_owner, bool personal, bool noEmptyError = false, uint16 lootMode = LOOT_MODE_DEFAULT);
|
||||
|
||||
// Inserts the item into the loot (called by LootTemplate processors)
|
||||
void AddItem(LootStoreItem const & item);
|
||||
|
||||
LootItem* LootItemInSlot(uint32 lootslot, Player* player, QuestItem** qitem = NULL, QuestItem** ffaitem = NULL, QuestItem** conditem = NULL);
|
||||
uint32 GetMaxSlotInLootFor(Player* player) const;
|
||||
bool hasItemFor(Player* player) const;
|
||||
bool hasOverThresholdItem() const;
|
||||
|
||||
private:
|
||||
void FillNotNormalLootFor(Player* player);
|
||||
QuestItemList* FillFFALoot(Player* player);
|
||||
QuestItemList* FillQuestLoot(Player* player);
|
||||
QuestItemList* FillNonQuestNonFFAConditionalLoot(Player* player);
|
||||
|
||||
std::vector<LootItem> quest_items;
|
||||
std::set<uint64> PlayersLooting;
|
||||
QuestItemMap PlayerQuestItems;
|
||||
QuestItemMap PlayerFFAItems;
|
||||
QuestItemMap PlayerNonQuestNonFFAConditionalItems;
|
||||
|
||||
// All rolls are registered here. They need to know, when the loot is not valid anymore
|
||||
LootValidatorRefManager i_LootValidatorRefManager;
|
||||
};
|
||||
|
||||
struct LootView
|
||||
{
|
||||
Loot &loot;
|
||||
Player *viewer;
|
||||
PermissionTypes permission;
|
||||
LootView(Loot &_loot, Player *_viewer,PermissionTypes _permission = ALL_PERMISSION)
|
||||
: loot(_loot), viewer(_viewer), permission(_permission) {}
|
||||
};
|
||||
|
||||
extern LootStore LootTemplates_Creature;
|
||||
extern LootStore LootTemplates_Fishing;
|
||||
extern LootStore LootTemplates_Gameobject;
|
||||
extern LootStore LootTemplates_Item;
|
||||
extern LootStore LootTemplates_Mail;
|
||||
extern LootStore LootTemplates_Milling;
|
||||
extern LootStore LootTemplates_Pickpocketing;
|
||||
extern LootStore LootTemplates_Reference;
|
||||
extern LootStore LootTemplates_Skinning;
|
||||
extern LootStore LootTemplates_Disenchant;
|
||||
extern LootStore LootTemplates_Prospecting;
|
||||
extern LootStore LootTemplates_Spell;
|
||||
|
||||
void LoadLootTemplates_Creature();
|
||||
void LoadLootTemplates_Fishing();
|
||||
void LoadLootTemplates_Gameobject();
|
||||
void LoadLootTemplates_Item();
|
||||
void LoadLootTemplates_Mail();
|
||||
void LoadLootTemplates_Milling();
|
||||
void LoadLootTemplates_Pickpocketing();
|
||||
void LoadLootTemplates_Skinning();
|
||||
void LoadLootTemplates_Disenchant();
|
||||
void LoadLootTemplates_Prospecting();
|
||||
|
||||
void LoadLootTemplates_Spell();
|
||||
void LoadLootTemplates_Reference();
|
||||
|
||||
inline void LoadLootTables()
|
||||
{
|
||||
LoadLootTemplates_Creature();
|
||||
LoadLootTemplates_Fishing();
|
||||
LoadLootTemplates_Gameobject();
|
||||
LoadLootTemplates_Item();
|
||||
LoadLootTemplates_Mail();
|
||||
LoadLootTemplates_Milling();
|
||||
LoadLootTemplates_Pickpocketing();
|
||||
LoadLootTemplates_Skinning();
|
||||
LoadLootTemplates_Disenchant();
|
||||
LoadLootTemplates_Prospecting();
|
||||
LoadLootTemplates_Spell();
|
||||
|
||||
LoadLootTemplates_Reference();
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user