pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-04-03 00:52:25 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
eqemu-server/zone/inventory.cpp
Knightly 7ab909ee47 Standardize Licensing 
- License was intended to be GPLv3 per earlier commit of GPLv3 LICENSE FILE
- This is confirmed by the inclusion of libraries that are incompatible with GPLv2
- This is also confirmed by KLS and the agreement of KLS's predecessors
- Added GPLv3 license headers to the compilable source files
- Removed Folly licensing in strings.h since the string functions do not match the Folly functions and are standard functions - this must have been left over from previous implementations
- Removed individual contributor license headers since the project has been under the "developer" mantle for many years
- Removed comments on files that were previously automatically generated since they've been manually modified multiple times and there are no automatic scripts referencing them (removed in 2023)
2026-04-01 17:09:57 -07:00

4733 lines
151 KiB
C++
Raw Blame History

/* EQEmu: EQEmulator
Copyright (C) 2001-2026 EQEmu Development Team
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "client.h"
#include "common/eqemu_logsys.h"
#include "common/events/player_event_logs.h"
#include "common/evolving_items.h"
#include "common/repositories/character_corpse_items_repository.h"
#include "common/strings.h"
#include "zone/bot.h"
#include "zone/queryserv.h"
#include "zone/quest_parser_collection.h"
#include "zone/worldserver.h"
#include "zone/zonedb.h"
extern WorldServer worldserver;
extern QueryServ *QServ;
// @merth: this needs to be touched up
uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
if (itemnum == 0)
return 0;
uint32 x = 0;
EQ::ItemInstance *cur = nullptr;
int i;
if(where_to_check & invWhereWorn) {
for (i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) != 0));
}
}
}
if(where_to_check & invWhereCursor) {
if (GetItemIDAt(EQ::invslot::slotCursor) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(EQ::invslot::slotCursor) != INVALID_ID)) {
cur = m_inv.GetItem(EQ::invslot::slotCursor);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(EQ::invslot::slotCursor, 0, true);
}
for (i = EQ::invbag::CURSOR_BAG_BEGIN; i <= EQ::invbag::CURSOR_BAG_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, true);
}
}
}
if(where_to_check & invWherePersonal) {
for (i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) != 0));
}
}
for (i = EQ::invbag::GENERAL_BAGS_BEGIN; i <= EQ::invbag::GENERAL_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, ((((uint64)1 << (EQ::invslot::GENERAL_BEGIN + ((i - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT))) & GetInv().GetLookup()->PossessionsBitmask) != 0));
}
}
}
if(where_to_check & invWhereBank) {
for (i = EQ::invslot::BANK_BEGIN; i <= EQ::invslot::BANK_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, ((i - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank));
}
}
for (i = EQ::invbag::BANK_BAGS_BEGIN; i <= EQ::invbag::BANK_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, (((i - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT) >= GetInv().GetLookup()->InventoryTypeSize.Bank));
}
}
}
if(where_to_check & invWhereSharedBank) {
for (i = EQ::invslot::SHARED_BANK_BEGIN; i <= EQ::invslot::SHARED_BANK_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, true);
}
}
for (i = EQ::invbag::SHARED_BANK_BAGS_BEGIN; i <= EQ::invbag::SHARED_BANK_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges();
} else {
x++;
}
DeleteItemInInventory(i, 0, true);
}
}
}
return x;
}
bool Client::CheckLoreConflict(const EQ::ItemData* item)
{
if (!item) { return false; }
if (!item->LoreFlag) { return false; }
if (item->LoreGroup == 0) { return false; }
if (item->LoreGroup == -1) // Standard lore items; look everywhere except the shared bank, return the result
return (m_inv.HasItem(item->ID, 0, ~invWhereSharedBank) != INVALID_INDEX);
// If the item has a lore group, we check for other items with the same group and return the result
return (m_inv.HasItemByLoreGroup(item->LoreGroup, ~invWhereSharedBank) != INVALID_INDEX);
}
bool Client::SummonItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, bool attuned, uint16 to_slot, uint32 ornament_icon, uint32 ornament_idfile, uint32 ornament_hero_model) {
const EQ::ItemData* item = database.GetItem(item_id);
// make sure the item exists
if(item == nullptr) {
Message(
Chat::Red,
fmt::format(
"Item {} does not exist.",
item_id
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to create an item with an invalid id.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item_id,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// check that there is not a lore conflict between base item and existing inventory
else if(CheckLoreConflict(item)) {
// DuplicateLoreMessage(item_id);
Message(
Chat::Red,
fmt::format(
"You already have a lore {} ({}) in your inventory.",
database.CreateItemLink(item_id),
item_id
).c_str()
);
return false;
}
// check to make sure we are augmenting an augmentable item
else if (((!item->IsClassCommon()) || (item->AugType > 0)) && (aug1 | aug2 | aug3 | aug4 | aug5 | aug6)) {
Message(Chat::Red, "You can not augment an augment or a non-common class item.");
LogInventory(
"Player [{}] on account [{}] attempted to augment an augment or a non-common class item.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug5: [{}])\n",
GetName(),
account_name,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// This code is ready to implement once the item load code is changed to process the 'minstatus' field.
// Checking #iteminfo in-game verfies that item->MinStatus is set to '0' regardless of field value.
// An optional sql script will also need to be added, once this goes live, to allow changing of the min status.
// check to make sure we are a GM if the item is GM-only
/*
else if(item->MinStatus && ((Admin() < item->MinStatus) || (Admin() < RuleI(GM, MinStatusToSummonItem)))) {
Message(Chat::Red, "You are not a GM or do not have the status to summon this item.");
LogInventory("Player [{}] on account [{}] attempted to create a GM-only item with a status of [{}].\n"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}], MinStatus: [{}])\n",
GetName(), account_name, Admin(), item->ID, aug1, aug2, aug3, aug4, aug5, aug6, item->MinStatus);
return false;
}
*/
uint32 augments[EQ::invaug::SOCKET_COUNT] = { aug1, aug2, aug3, aug4, aug5, aug6 };
uint32 classes = item->Classes;
uint32 races = item->Races;
uint32 slots = item->Slots;
bool enforce_wearable = RuleB(Inventory, EnforceAugmentWear);
bool enforce_restrictions = RuleB(Inventory, EnforceAugmentRestriction);
bool enforce_usable = RuleB(Inventory, EnforceAugmentUsability);
for (int iter = EQ::invaug::SOCKET_BEGIN; iter <= EQ::invaug::SOCKET_END; ++iter) {
int augment_slot = iter + 1;
const EQ::ItemData* augtest = database.GetItem(augments[iter]);
if(augtest == nullptr) {
if(augments[iter]) {
Message(
Chat::Red,
fmt::format(
"Augment {} in Augment Slot {} does not exist.",
augments[iter],
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to create an augment (Aug[{}]) with an invalid id.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
augment_slot,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
}
else {
// check that there is not a lore conflict between augment and existing inventory
if(CheckLoreConflict(augtest)) {
// DuplicateLoreMessage(augtest->ID);
Message(
Chat::Red,
fmt::format(
"You already have a lore {} ({}) in your inventory.",
database.CreateItemLink(augtest->ID),
augtest->ID
).c_str()
);
return false;
}
// check that augment is an actual augment
else if(augtest->AugType == 0) {
Message(
Chat::Red,
fmt::format(
"{} ({}) in Augment Slot {} is not an actual augment.",
database.CreateItemLink(augtest->ID),
augtest->ID,
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to use a non-augment item (Augment Slot [{}]) as an augment.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item->ID,
augment_slot,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// Same as GM check above
// check to make sure we are a GM if the augment is GM-only
/*
else if(augtest->MinStatus && ((Admin() < augtest->MinStatus) || (Admin() < RuleI(GM, MinStatusToSummonItem)))) {
Message(Chat::Red, "You are not a GM or do not have the status to summon this augment.");
LogInventory("Player [{}] on account [{}] attempted to create a GM-only augment (Aug[{}]) with a status of [{}].\n(Item: [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], MinStatus: [{}])\n",
GetName(), account_name, augment_slot, Admin(), item->ID, aug1, aug2, aug3, aug4, aug5, aug6, item->MinStatus);
return false;
}
*/
// check for augment type allowance
if(enforce_wearable) {
if ((item->AugSlotType[iter] == EQ::item::AugTypeNone) || !(((uint32)1 << (item->AugSlotType[iter] - 1)) & augtest->AugType)) {
Message(
Chat::Red,
fmt::format(
"Augment {} ({}) in Augment Slot {} is not capable of being socketed in to {} ({}).",
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot,
database.CreateItemLink(item->ID),
item->ID
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to augment an item with an unacceptable augment type (Aug[{}]).\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
augment_slot,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
if (!RuleB(Items, SummonItemAllowInvisibleAugments) && item->AugSlotVisible[iter] == 0) {
Message(
Chat::Red,
fmt::format(
"{} ({}) has not evolved enough to accept {} ({}) in Augment Slot {}.",
database.CreateItemLink(item->ID),
item->ID,
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to augment an unevolved item with augment type (Aug[{}]).\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
augment_slot,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
}
// check for augment to item restriction
if (enforce_restrictions) {
bool is_restricted = IsAugmentRestricted(item->ItemType, augtest->AugRestrict);
if (is_restricted) {
Message(
Chat::Red,
fmt::format(
"{} ({}) in Augment Slot {} is restricted from being augmented in to {} ({}).",
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot,
database.CreateItemLink(item->ID),
item->ID
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to augment an item with a restricted augment (Aug[{}]).\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
augment_slot,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
}
if(enforce_usable) {
// check for class usability
if(item->Classes && !(classes &= augtest->Classes)) {
Message(
Chat::Red,
fmt::format(
"{} ({}) in Augment Slot {} will result in an item unusable by any class.",
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to create an item unusable by any class.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// check for race usability
if(item->Races && !(races &= augtest->Races)) {
Message(
Chat::Red,
fmt::format(
"{} ({}) in Augment Slot {} will result in an item unusable by any race.",
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to create an item unusable by any race.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// check for slot usability
if(item->Slots && !(slots &= augtest->Slots)) {
Message(
Chat::Red,
fmt::format(
"{} ({}) in Augment Slot {} will result in an item unusable in any slot.",
database.CreateItemLink(augments[iter]),
augments[iter],
augment_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to create an item unusable in any slot.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
}
}
}
// validation passed..so, set the charges and create the actual item
// if the item is stackable and the charge amount is -1 or 0 then set to 1 charge.
// removed && item->MaxCharges == 0 if -1 or 0 was passed max charges is irrelevant
if(charges <= 0 && item->Stackable) {
charges = 1;
} else if(charges == -1) { // if the charges is -1, then no charge value was passed in set to max charges
charges = item->MaxCharges;
}
// in any other situation just use charges as passed
EQ::ItemInstance* inst = database.CreateItem(item, charges);
auto timestamps = database.GetItemRecastTimestamps(CharacterID());
if (inst) {
const auto* d = inst->GetItem();
if (d->RecastDelay) {
if (d->RecastType != RECAST_TYPE_UNLINKED_ITEM) {
inst->SetRecastTimestamp(timestamps.count(d->RecastType) ? timestamps.at(d->RecastType) : 0);
}
else {
inst->SetRecastTimestamp(timestamps.count(d->ID) ? timestamps.at(d->ID) : 0);
}
}
}
if(inst == nullptr) {
Message(Chat::Red, "An unknown server error has occurred and your item was not created.");
// this goes to logfile since this is a major error
LogError(
"Player [{}] on account [{}] encountered an unknown item creation error.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
return false;
}
// add any validated augments
for (int iter = EQ::invaug::SOCKET_BEGIN; iter <= EQ::invaug::SOCKET_END; ++iter) {
if(augments[iter]) {
inst->PutAugment(&database, iter, augments[iter]);
}
}
// attune item
if(attuned && inst->GetItem()->Attuneable) {
inst->SetAttuned(true);
}
inst->SetOrnamentIcon(ornament_icon);
inst->SetOrnamentationIDFile(ornament_idfile);
inst->SetOrnamentHeroModel(ornament_hero_model);
// check to see if item is usable in requested slot
if (enforce_usable && (to_slot >= EQ::invslot::EQUIPMENT_BEGIN && to_slot <= EQ::invslot::EQUIPMENT_END)) {
uint32 slottest = to_slot;
if(!(slots & ((uint32)1 << slottest))) {
Message(
Chat::White,
fmt::format(
"{} ({}) cannot be equipped in {} ({}), moving to cursor.",
database.CreateItemLink(item->ID),
item->ID,
EQ::invslot::GetInvPossessionsSlotName(to_slot),
to_slot
).c_str()
);
LogInventory(
"Player [{}] on account [{}] attempted to equip an item unusable in slot [{}] - moved to cursor.\n"
"Item [{}], Aug1: [{}], Aug2: [{}], Aug3: [{}], Aug4: [{}], Aug5: [{}], Aug6: [{}])\n",
GetName(),
account_name,
to_slot,
item->ID,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6
);
to_slot = EQ::invslot::slotCursor;
}
}
if (PlayerEventLogs::Instance()->IsEventEnabled(PlayerEvent::ITEM_CREATION)) {
auto e = PlayerEvent::ItemCreationEvent{};
e.item_id = item->ID;
e.item_name = item->Name;
e.to_slot = to_slot;
e.charges = charges;
e.augment_1_id = aug1;
e.augment_2_id = aug2;
e.augment_3_id = aug3;
e.augment_4_id = aug4;
e.augment_5_id = aug5;
e.augment_6_id = aug6;
e.attuned = attuned;
RecordPlayerEventLog(PlayerEvent::ITEM_CREATION, e);
}
// put item into inventory
if (to_slot == EQ::invslot::slotCursor) {
PushItemOnCursor(*inst);
SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketLimbo);
} else {
PutItemInInventory(to_slot, *inst, true);
}
m_external_handin_items_returned.emplace_back(inst->GetItem()->ID);
safe_delete(inst);
// discover item and any augments
if (
RuleB(Character, EnableDiscoveredItems) &&
!GetGM() &&
!IsDiscovered(item_id)
) {
DiscoverItem(item_id);
}
return true;
}
// Drop item from inventory to ground (generally only dropped from SLOT_CURSOR)
void Client::DropItem(int16 slot_id, bool recurse)
{
LogInventory(
"[{}] (char_id: [{}]) Attempting to drop item from slot [{}] on the ground",
GetCleanName(),
CharacterID(),
slot_id
);
if (GetInv().CheckNoDrop(slot_id, recurse) && !CanTradeFVNoDropItem()) {
auto invalid_drop = m_inv.GetItem(slot_id);
if (!invalid_drop) {
LogInventory("Error in InventoryProfile::CheckNoDrop() - returned 'true' for empty slot");
}
else {
if (EQEmuLogSys::Instance()->log_settings[Logs::Inventory].is_category_enabled) {
LogInventory("DropItem() Hack detected - full item parse:");
LogInventory("depth: 0, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(invalid_drop->GetItem() ? invalid_drop->GetItem()->Name : "null data"), invalid_drop->GetID(), (invalid_drop->IsDroppable(false) ? "true" : "false"));
for (auto iter1 : *invalid_drop->GetContents()) { // depth 1
LogInventory("-depth: 1, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(iter1.second->GetItem() ? iter1.second->GetItem()->Name : "null data"), iter1.second->GetID(), (iter1.second->IsDroppable(false) ? "true" : "false"));
for (auto iter2 : *iter1.second->GetContents()) { // depth 2
LogInventory("--depth: 2, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(iter2.second->GetItem() ? iter2.second->GetItem()->Name : "null data"), iter2.second->GetID(), (iter2.second->IsDroppable(false) ? "true" : "false"));
}
}
}
}
std::string message = fmt::format(
"Tried to drop an item on the ground that was no-drop! item_name [{}] item_id ({})",
invalid_drop->GetItem()->Name,
invalid_drop->GetItem()->ID
);
invalid_drop = nullptr;
RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = message});
GetInv().DeleteItem(slot_id);
return;
}
// Take control of item in client inventory
auto* inst = m_inv.PopItem(slot_id);
if (inst) {
if (EQEmuLogSys::Instance()->log_settings[Logs::Inventory].is_category_enabled) {
LogInventory("DropItem() Processing - full item parse:");
LogInventory(
"depth: 0, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(inst->GetItem() ? inst->GetItem()->Name : "null data"),
inst->GetID(),
(inst->IsDroppable(false) ? "true" : "false")
);
if (!inst->IsDroppable(false)) {
LogError("Non-droppable item being processed for drop by [{}]", GetCleanName());
}
for (auto iter1 : *inst->GetContents()) { // depth 1
LogInventory(
"-depth: 1, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(iter1.second->GetItem() ? iter1.second->GetItem()->Name : "null data"),
iter1.second->GetID(),
(iter1.second->IsDroppable(false) ? "true" : "false")
);
if (!iter1.second->IsDroppable(false)) {
LogError("Non-droppable item being processed for drop by [{}]", GetCleanName());
}
for (auto iter2 : *iter1.second->GetContents()) { // depth 2
LogInventory(
"--depth: 2, Item: [{}] (id: [{}]), IsDroppable: [{}]",
(iter2.second->GetItem() ? iter2.second->GetItem()->Name : "null data"),
iter2.second->GetID(),
(iter2.second->IsDroppable(false) ? "true" : "false")
);
if (!iter2.second->IsDroppable(false)) {
LogError("Non-droppable item being processed for drop by [{}]", GetCleanName());
}
}
}
}
int i = 0;
if (inst && PlayerEventLogs::Instance()->IsEventEnabled(PlayerEvent::DROPPED_ITEM)) {
auto e = PlayerEvent::DroppedItemEvent{
.item_id = inst->GetID(),
.augment_1_id = inst->GetAugmentItemID(0),
.augment_2_id = inst->GetAugmentItemID(1),
.augment_3_id = inst->GetAugmentItemID(2),
.augment_4_id = inst->GetAugmentItemID(3),
.augment_5_id = inst->GetAugmentItemID(4),
.augment_6_id = inst->GetAugmentItemID(5),
.item_name = inst->GetItem()->Name,
.slot_id = slot_id,
.charges = (uint32) inst->GetCharges()
};
RecordPlayerEventLog(PlayerEvent::DROPPED_ITEM, e);
}
if (parse->ItemHasQuestSub(inst, EVENT_DROP_ITEM)) {
parse->EventItem(EVENT_DROP_ITEM, this, inst, nullptr, "", slot_id);
if (i != 0) {
LogInventory("Item drop handled by [EVENT_DROP_ITEM]");
safe_delete(inst);
}
}
if (parse->PlayerHasQuestSub(EVENT_DROP_ITEM_CLIENT)) {
std::vector<std::any> args = { inst };
i = parse->EventPlayer(EVENT_DROP_ITEM_CLIENT, this, "", slot_id, &args);
if (i != 0) {
LogInventory("Item drop handled by [EVENT_DROP_ITEM_CLIENT]");
safe_delete(inst);
}
}
} else {
// Item doesn't exist in inventory!
LogInventory("DropItem() - No item found in slot [{}]", slot_id);
Message(
Chat::Red,
fmt::format(
"Error: Item not found in slot {}.",
slot_id
).c_str()
);
return;
}
// Save client inventory change to database
if (slot_id == EQ::invslot::slotCursor) {
SendCursorBuffer();
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
} else {
database.SaveInventory(CharacterID(), nullptr, slot_id);
}
if (!inst) {
return;
}
// Package as zone object
auto object = new Object(this, inst);
entity_list.AddObject(object, true);
object->StartDecay();
LogInventory("[{}] dropped [{}] from slot [{}]", GetCleanName(), inst->GetItem()->Name, slot_id);
safe_delete(inst);
}
// Drop inst
void Client::DropInst(const EQ::ItemInstance* inst)
{
if (!inst) {
// Item doesn't exist in inventory!
Message(Chat::Red, "Error: Item not found");
return;
}
if (inst->GetItem()->NoDrop == 0)
{
Message(Chat::Red, "This item is NODROP. Deleting.");
return;
}
// Package as zone object
auto object = new Object(this, inst);
entity_list.AddObject(object, true);
object->StartDecay();
}
// Returns a slot's item ID (returns INVALID_ID if not found)
int32 Client::GetItemIDAt(int16 slot_id) {
if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0)
return INVALID_ID;
}
else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0)
return INVALID_ID;
}
else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank)
return INVALID_ID;
}
else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank)
return INVALID_ID;
}
const EQ::ItemInstance* inst = m_inv[slot_id];
if (inst)
return inst->GetItem()->ID;
// None found
return INVALID_ID;
}
// Returns an augment's ID that's in an item (returns INVALID_ID if not found)
// Pass in the slot ID of the item and which augslot you want to check (0-5)
int32 Client::GetAugmentIDAt(int16 slot_id, uint8 augslot) {
if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0)
return INVALID_ID;
}
else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0)
return INVALID_ID;
}
else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank)
return INVALID_ID;
}
else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank)
return INVALID_ID;
}
const EQ::ItemInstance* inst = m_inv[slot_id];
if (inst && inst->GetAugmentItemID(augslot)) {
return inst->GetAugmentItemID(augslot);
}
// None found
return INVALID_ID;
}
void Client::SendCursorBuffer()
{
// Temporary work-around for the RoF+ Client Buffer
// Instead of dealing with client moving items in cursor buffer,
// we can just send the next item in the cursor buffer to the cursor.
if (ClientVersion() < EQ::versions::ClientVersion::RoF) { return; }
if (GetInv().CursorEmpty()) { return; }
auto test_inst = GetInv().GetCursorItem();
if (test_inst == nullptr) { return; }
auto test_item = test_inst->GetItem();
if (test_item == nullptr) { return; }
bool lore_pass = true;
if (test_item->LoreGroup == -1) {
lore_pass = (m_inv.HasItem(test_item->ID, 0, ~(invWhereSharedBank | invWhereCursor)) == INVALID_INDEX);
}
else if (test_item->LoreGroup != 0) {
lore_pass = (m_inv.HasItemByLoreGroup(test_item->LoreGroup, ~(invWhereSharedBank | invWhereCursor)) == INVALID_INDEX);
}
if (!lore_pass) {
LogInventory("([{}]) Duplicate lore items are not allowed - destroying item [{}](id:[{}]) on cursor",
GetName(), test_item->Name, test_item->ID);
MessageString(Chat::Loot, 290);
if (parse->ItemHasQuestSub(test_inst, EVENT_DESTROY_ITEM)) {
parse->EventItem(EVENT_DESTROY_ITEM, this, test_inst, nullptr, "", 0);
}
if (parse->PlayerHasQuestSub(EVENT_DESTROY_ITEM_CLIENT)) {
std::vector<std::any> args = { test_inst };
parse->EventPlayer(EVENT_DESTROY_ITEM_CLIENT, this, "", 0, &args);
}
DeleteItemInInventory(EQ::invslot::slotCursor);
SendCursorBuffer();
}
else {
SendItemPacket(EQ::invslot::slotCursor, test_inst, ItemPacketLimbo);
}
}
// Remove item from inventory
void Client::DeleteItemInInventory(int16 slot_id, int16 quantity, bool client_update, bool update_db) {
#if (EQDEBUG >= 5)
LogDebug("DeleteItemInInventory([{}], [{}], [{}])", slot_id, quantity, (client_update) ? "true":"false");
#endif
// Added 'IsSlotValid(slot_id)' check to both segments of client packet processing.
// - cursor queue slots were slipping through and crashing client
if(!m_inv[slot_id]) {
// Make sure the client deletes anything in this slot to match the server.
if(client_update && IsValidSlot(slot_id)) {
EQApplicationPacket* outapp;
outapp = new EQApplicationPacket(OP_DeleteItem, sizeof(DeleteItem_Struct));
DeleteItem_Struct* delitem = (DeleteItem_Struct*)outapp->pBuffer;
delitem->from_slot = slot_id;
delitem->to_slot = 0xFFFFFFFF;
delitem->number_in_stack = 0xFFFFFFFF;
QueuePacket(outapp);
safe_delete(outapp);
}
return;
}
uint64 evolve_id = m_inv[slot_id]->GetEvolveUniqueID();
bool isDeleted = m_inv.DeleteItem(slot_id, quantity);
if (isDeleted && evolve_id && (slot_id > EQ::invslot::TRADE_END || slot_id < EQ::invslot::TRADE_BEGIN)) {
CharacterEvolvingItemsRepository::SoftDelete(database, evolve_id);
}
const EQ::ItemInstance* inst = nullptr;
if (slot_id == EQ::invslot::slotCursor) {
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
if(update_db)
database.SaveCursor(character_id, s, e);
}
else {
// Save change to database
inst = m_inv[slot_id];
if(update_db)
database.SaveInventory(character_id, inst, slot_id);
}
if(client_update && IsValidSlot(slot_id)) {
EQApplicationPacket* outapp = nullptr;
if(inst) {
if (!inst->IsStackable() && !isDeleted) {
// Non stackable item with charges = Item with clicky spell effect ? Delete a charge.
outapp = new EQApplicationPacket(OP_DeleteCharge, sizeof(MoveItem_Struct));
}
else {
// Stackable, arrows, etc ? Delete one from the stack
outapp = new EQApplicationPacket(OP_DeleteItem, sizeof(MoveItem_Struct));
}
DeleteItem_Struct* delitem = (DeleteItem_Struct*)outapp->pBuffer;
delitem->from_slot = slot_id;
delitem->to_slot = 0xFFFFFFFF;
delitem->number_in_stack = 0xFFFFFFFF;
for(int loop=0;loop<quantity;loop++)
QueuePacket(outapp);
safe_delete(outapp);
}
else {
outapp = new EQApplicationPacket(OP_MoveItem, sizeof(MoveItem_Struct));
MoveItem_Struct* delitem = (MoveItem_Struct*)outapp->pBuffer;
delitem->from_slot = slot_id;
delitem->to_slot = 0xFFFFFFFF;
delitem->number_in_stack = 0xFFFFFFFF;
QueuePacket(outapp);
safe_delete(outapp);
}
}
}
bool Client::PushItemOnCursor(const EQ::ItemInstance& inst, bool client_update)
{
LogInventory("Putting item [{}] ([{}]) on the cursor", inst.GetItem()->Name, inst.GetItem()->ID);
EvolvingItemsManager::Instance()->DoLootChecks(CharacterID(), EQ::invslot::slotCursor, inst);
m_inv.PushCursor(inst);
if (client_update) {
SendItemPacket(EQ::invslot::slotCursor, &inst, ItemPacketLimbo);
}
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
return database.SaveCursor(CharacterID(), s, e);
}
// Puts an item into the person's inventory
// Any items already there will be removed from user's inventory
// (Also saves changes back to the database: this may be optimized in the future)
// client_update: Sends packet to client
bool Client::PutItemInInventory(int16 slot_id, const EQ::ItemInstance& inst, bool client_update) {
LogInventory("Putting item [{}] ([{}]) into slot [{}]", inst.GetItem()->Name, inst.GetItem()->ID, slot_id);
if (slot_id == EQ::invslot::slotCursor) { // don't trust macros before conditional statements...
return PushItemOnCursor(inst, client_update);
}
EvolvingItemsManager::Instance()->DoLootChecks(CharacterID(), slot_id, inst);
m_inv.PutItem(slot_id, inst);
if (client_update)
{
SendItemPacket(slot_id, &inst, ((slot_id == EQ::invslot::slotCursor) ? ItemPacketLimbo : ItemPacketTrade));
//SendWearChange(EQ::InventoryProfile::CalcMaterialFromSlot(slot_id));
}
CalcBonuses();
if (slot_id == EQ::invslot::slotCursor) {
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
return database.SaveCursor(CharacterID(), s, e);
}
return database.SaveInventory(CharacterID(), &inst, slot_id);
//CalcBonuses(); // this never fires??
// a lot of wasted checks and calls coded above...
}
void Client::PutLootInInventory(int16 slot_id, const EQ::ItemInstance &inst, LootItem** bag_item_data)
{
LogInventory("Putting loot item [{}] ([{}]) into slot [{}]", inst.GetItem()->Name, inst.GetItem()->ID, slot_id);
bool cursor_empty = m_inv.CursorEmpty();
EvolvingItemsManager::Instance()->DoLootChecks(CharacterID(), slot_id, inst);
if (slot_id == EQ::invslot::slotCursor) {
m_inv.PushCursor(inst);
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
}
else {
m_inv.PutItem(slot_id, inst);
database.SaveInventory(CharacterID(), &inst, slot_id);
}
// Subordinate items in cursor buffer must be sent via ItemPacketSummonItem or we just overwrite the visible cursor and desync the client
if (slot_id == EQ::invslot::slotCursor && !cursor_empty) {
// RoF+ currently has a specialized cursor handler
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendItemPacket(slot_id, &inst, ItemPacketLimbo);
}
else {
SendLootItemInPacket(&inst, slot_id);
}
if (bag_item_data) {
for (int index = EQ::invbag::SLOT_BEGIN; index <= EQ::invbag::SLOT_END; ++index) {
if (bag_item_data[index] == nullptr)
continue;
const EQ::ItemInstance *bagitem = database.CreateItem(
bag_item_data[index]->item_id,
bag_item_data[index]->charges,
bag_item_data[index]->aug_1,
bag_item_data[index]->aug_2,
bag_item_data[index]->aug_3,
bag_item_data[index]->aug_4,
bag_item_data[index]->aug_5,
bag_item_data[index]->aug_6,
bag_item_data[index]->attuned,
bag_item_data[index]->custom_data,
bag_item_data[index]->ornamenticon,
bag_item_data[index]->ornamentidfile,
bag_item_data[index]->ornament_hero_model
);
// Dump bag contents to cursor in the event that owning bag is not the first cursor item
// (This assumes that the data passed is correctly associated..no safety checks are implemented)
if (slot_id == EQ::invslot::slotCursor && !cursor_empty) {
LogInventory("Putting bag loot item [{}] ([{}]) into slot [{}] (non-empty cursor override)",
inst.GetItem()->Name, inst.GetItem()->ID, EQ::invslot::slotCursor);
PutLootInInventory(EQ::invslot::slotCursor, *bagitem);
}
else {
auto bag_slot = EQ::InventoryProfile::CalcSlotId(slot_id, index);
LogInventory("Putting bag loot item [{}] ([{}]) into slot [{}] (bag slot [{}])",
inst.GetItem()->Name, inst.GetItem()->ID, bag_slot, index);
PutLootInInventory(bag_slot, *bagitem);
}
safe_delete(bagitem);
}
}
CalcBonuses();
}
bool Client::TryStacking(EQ::ItemInstance* item, uint8 type, bool try_worn, bool try_cursor) {
if(!item || !item->IsStackable() || item->GetCharges()>=item->GetItem()->StackSize)
return false;
int16 i;
uint32 item_id = item->GetItem()->ID;
for (i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
if ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
EQ::ItemInstance* tmp_inst = m_inv.GetItem(i);
if(tmp_inst && tmp_inst->GetItem()->ID == item_id && tmp_inst->GetCharges() < tmp_inst->GetItem()->StackSize){
MoveItemCharges(*item, i, type);
CalcBonuses();
if (item->GetCharges()) { // we didn't get them all
return AutoPutLootInInventory(*item, try_worn, try_cursor, 0);
}
return true;
}
}
for (i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
if ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
for (uint8 j = EQ::invbag::SLOT_BEGIN; j <= EQ::invbag::SLOT_END; j++) {
uint16 slotid = EQ::InventoryProfile::CalcSlotId(i, j);
EQ::ItemInstance* tmp_inst = m_inv.GetItem(slotid);
if(tmp_inst && tmp_inst->GetItem()->ID == item_id && tmp_inst->GetCharges() < tmp_inst->GetItem()->StackSize) {
MoveItemCharges(*item, slotid, type);
CalcBonuses();
if (item->GetCharges()) { // we didn't get them all
return AutoPutLootInInventory(*item, try_worn, try_cursor, 0);
}
return true;
}
}
}
return false;
}
// Locate an available space in inventory to place an item
// and then put the item there
// The change will be saved to the database
bool Client::AutoPutLootInInventory(EQ::ItemInstance& inst, bool try_worn, bool try_cursor, LootItem** bag_item_data)
{
// #1: Try to auto equip
if (try_worn && inst.IsEquipable(GetBaseRace(), GetClass()) && inst.GetItem()->ReqLevel <= level && (!inst.GetItem()->Attuneable || inst.IsAttuned()) && inst.GetItem()->ItemType != EQ::item::ItemTypeAugmentation) {
for (int16 i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; i++) {
if ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
if (!m_inv[i]) {
if (i == EQ::invslot::slotPrimary && inst.IsWeapon()) { // If item is primary slot weapon
if (inst.GetItem()->IsType2HWeapon()) { // and uses 2hs \ 2hb \ 2hp
if (m_inv[EQ::invslot::slotSecondary]) { // and if secondary slot is not empty
continue; // Can't auto-equip
}
}
}
if( i == EQ::invslot::slotPrimary && m_inv[EQ::invslot::slotSecondary] ) {
uint8 instrument = m_inv[EQ::invslot::slotSecondary]->GetItem()->ItemType;
if(
instrument == EQ::item::ItemTypeWindInstrument ||
instrument == EQ::item::ItemTypeStringedInstrument ||
instrument == EQ::item::ItemTypeBrassInstrument ||
instrument == EQ::item::ItemTypePercussionInstrument
) {
LogInventory("Cannot equip a primary item with [{}] already in the secondary.", m_inv[EQ::invslot::slotSecondary]->GetItem()->Name);
continue; // Do not auto-equip Primary when instrument is in Secondary
}
}
if (i == EQ::invslot::slotSecondary && m_inv[EQ::invslot::slotPrimary]) { // check to see if primary slot is a two hander
uint8 instrument = inst.GetItem()->ItemType;
if(
instrument == EQ::item::ItemTypeWindInstrument ||
instrument == EQ::item::ItemTypeStringedInstrument ||
instrument == EQ::item::ItemTypeBrassInstrument ||
instrument == EQ::item::ItemTypePercussionInstrument
) {
LogInventory("Cannot equip a secondary instrument with [{}] already in the primary.", m_inv[EQ::invslot::slotPrimary]->GetItem()->Name);
continue; // Do not auto-equip instrument in Secondary when Primary is equipped.
}
uint8 use = m_inv[EQ::invslot::slotPrimary]->GetItem()->ItemType;
if(use == EQ::item::ItemType2HSlash || use == EQ::item::ItemType2HBlunt || use == EQ::item::ItemType2HPiercing) {
continue;
}
}
if (i == EQ::invslot::slotSecondary && inst.IsWeapon() && !CanThisClassDualWield()) {
continue;
}
if (inst.IsEquipable(i)) { // Equippable at this slot?
//send worn to everyone...
PutLootInInventory(i, inst);
uint8 worn_slot_material = EQ::InventoryProfile::CalcMaterialFromSlot(i);
if (worn_slot_material != EQ::textures::materialInvalid) {
SendWearChange(worn_slot_material);
}
if (parse->ItemHasQuestSub(&inst, EVENT_EQUIP_ITEM)) {
parse->EventItem(EVENT_EQUIP_ITEM, this, &inst, nullptr, "", i);
}
return true;
}
}
}
}
// #2: Stackable item?
if (inst.IsStackable()) {
if (TryStacking(&inst, ItemPacketTrade, try_worn, try_cursor))
return true;
}
// #3: put it in inventory
bool is_arrow = (inst.GetItem()->ItemType == EQ::item::ItemTypeArrow) ? true : false;
int16 slot_id = m_inv.FindFreeSlot(inst.IsClassBag(), try_cursor, inst.GetItem()->Size, is_arrow);
if (slot_id != INVALID_INDEX) {
PutLootInInventory(slot_id, inst, bag_item_data);
return true;
}
return false;
}
// helper function for AutoPutLootInInventory
void Client::MoveItemCharges(EQ::ItemInstance &from, int16 to_slot, uint8 type)
{
EQ::ItemInstance *tmp_inst = m_inv.GetItem(to_slot);
if(tmp_inst && tmp_inst->GetCharges() < tmp_inst->GetItem()->StackSize) {
// this is how much room is left on the item we're stacking onto
int charge_slots_left = tmp_inst->GetItem()->StackSize - tmp_inst->GetCharges();
// this is how many charges we can move from the looted item to
// the item in the inventory
int charges_to_move = (from.GetCharges() < charge_slots_left) ? from.GetCharges() : charge_slots_left;
tmp_inst->SetCharges(tmp_inst->GetCharges() + charges_to_move);
from.SetCharges(from.GetCharges() - charges_to_move);
SendLootItemInPacket(tmp_inst, to_slot);
if (to_slot == EQ::invslot::slotCursor) {
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
}
else {
database.SaveInventory(CharacterID(), tmp_inst, to_slot);
}
}
}
#if 0
// TODO: needs clean-up to save references
bool MakeItemLink(char* &ret_link, const ItemData *item, uint32 aug0, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint8 evolving, uint8 evolvedlevel) {
//we're sending back the entire "link", minus the null characters & item name
//that way, we can use it for regular links & Task links
//note: initiator needs to pass us ret_link
/*
--- Usage ---
Chat: "%c" "%s" "%s" "%c", 0x12, ret_link, inst->GetItem()->name, 0x12
Task: "<a WndNotify=\"27," "%s" "\">" "%s" "</a>", ret_link, inst->GetItem()->name
<a WndNotify="27,00960F000000000000000000000000000000000000000">Master's Book of Wood Elven Culture</a>
http://eqitems.13th-floor.org/phpBB2/viewtopic.php?p=510#510
*/
if (!item) //have to have an item to make the link
return false;
//format:
//0 itemid aug1 aug2 aug3 aug4 aug5 evolving? loregroup evolved level hash
//0 00000 00000 00000 00000 00000 00000 0 0000 0 00000000
//length:
//1 5 5 5 5 5 5 1 4 1 8 = 45
//evolving item info: http://eqitems.13th-floor.org/phpBB2/viewtopic.php?t=145#558
//int hash = GetItemLinkHash(inst); //eventually this will work (currently crashes zone), but for now we'll skip the extra overhead
int hash = NOT_USED;
// Tested with UF and RoF..there appears to be a problem with using non-augment arguments below...
// Currently, enabling them causes misalignments in what the client expects. I haven't looked
// into it further to determine the cause..but, the function is setup to accept the parameters.
// Note: some links appear with '00000' in front of the name..so, it's likely we need to send
// some additional information when certain parameters are true
//switch (GetClientVersion()) {
switch (0) {
case EQClientRoF2:
// This operator contains 14 parameter masks..but, only 13 parameter values.
// Even so, the client link appears ok... Need to figure out the discrepancy
MakeAnyLenString(&ret_link, "%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%1X" "%04X" "%1X" "%05X" "%08X",
0,
item->ID,
aug0,
aug1,
aug2,
aug3,
aug4,
aug5,
0,//evolving,
0,//item->LoreGroup,
0,//evolvedlevel,
0,
hash
);
return true;
case EQClientRoF:
MakeAnyLenString(&ret_link, "%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%04X" "%1X" "%05X" "%08X",
0,
item->ID,
aug0,
aug1,
aug2,
aug3,
aug4,
aug5,
0,//evolving,
0,//item->LoreGroup,
0,//evolvedlevel,
0,
hash
);
return true;
case EQClientUnderfoot:
case EQClientSoD:
case EQClientSoF:
MakeAnyLenString(&ret_link, "%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%04X" "%1X" "%05X" "%08X",
0,
item->ID,
aug0,
aug1,
aug2,
aug3,
aug4,
0,//evolving,
0,//item->LoreGroup,
0,//evolvedlevel,
0,
hash
);
return true;
case EQClientTitanium:
MakeAnyLenString(&ret_link, "%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%04X" "%1X" "%08X",
0,
item->ID,
aug0,
aug1,
aug2,
aug3,
aug4,
0,//evolving,
0,//item->LoreGroup,
0,//evolvedlevel,
hash
);
return true;
case EQClient62:
default:
return false;
}
}
#endif
int Client::GetItemLinkHash(const EQ::ItemInstance* inst) {
#if 0
//pre-Titanium: http://eqitems.13th-floor.org/phpBB2/viewtopic.php?t=70&postdays=0&postorder=asc
//Titanium: http://eqitems.13th-floor.org/phpBB2/viewtopic.php?t=145
if (!inst) //have to have an item to make the hash
return 0;
const EQ::ItemData* item = inst->GetItem();
char* hash_str = 0;
/*register */int hash = 0;
//now the fun part, since different types of items use different hashes...
if (item->ItemClass == 0 && item->CharmFileID) { //charm
MakeAnyLenString(&hash_str, "%d%s-1-1-1-1-1%d %d %d %d %d %d %d %d %d",
item->ID,
item->Name,
item->Light,
item->Icon,
item->Price,
item->Size,
item->Weight,
item->ItemClass,
item->ItemType,
item->Favor,
item->GuildFavor);
} else if (item->ItemClass == 2) { //book
MakeAnyLenString(&hash_str, "%d%s%d%d%09X",
item->ID,
item->Name,
item->Weight,
item->BookType,
item->Price);
} else if (item->ItemClass == 1) { //bag
MakeAnyLenString(&hash_str, "%d%s%x%d%09X%d",
item->ID,
item->Name,
item->BagSlots,
item->BagWR,
item->Price,
item->Weight);
} else { //everything else
MakeAnyLenString(&hash_str, "%d%s-1-1-1-1-1%d %d %d %d %d %d %d %d %d %d %d %d %d",
item->ID,
item->Name,
item->Mana,
item->HP,
item->Favor,
item->Light,
item->Icon,
item->Price,
item->Weight,
item->ReqLevel,
item->Size,
item->ItemClass,
item->ItemType,
item->AC,
item->GuildFavor);
}
//this currently crashes zone, so someone feel free to fix this so we can work with hashes:
//*** glibc detected *** double free or corruption (out): 0xb2403470 ***
/*
while (*hash_str != '\0') {
register int c = toupper(*hash_str);
asm volatile("\
imul $31, %1, %1;\
movzx %%ax, %%edx;\
addl %%edx, %1;\
movl %1, %0;\
"
:"=r"(hash)
:"D"(hash), "a"(c)
:"%edx"
);
// This is what the inline asm is doing:
// hash *= 0x1f;
// hash += (int)c;
hash_str++;
}
*/
safe_delete_array(hash_str);
return hash;
#endif
return 0;
}
// This appears to still be in use... The core of this should be incorporated into class EQ::SayLinkEngine
void Client::SendItemLink(const EQ::ItemInstance* inst, bool send_to_all)
{
/*
this stuff is old, live dosent do this anymore. they send a much smaller
packet with the item number in it, but I cant seem to find it right now
*/
if (!inst)
return;
const EQ::ItemData* item = inst->GetItem();
const char* name2 = &item->Name[0];
auto outapp = new EQApplicationPacket(OP_ItemLinkText, strlen(name2) + 68);
char buffer2[135] = {0};
char itemlink[135] = {0};
sprintf(itemlink,"%c0%06u0%05u-%05u-%05u-%05u-%05u00000000%c",
0x12,
item->ID,
inst->GetAugmentItemID(0),
inst->GetAugmentItemID(1),
inst->GetAugmentItemID(2),
inst->GetAugmentItemID(3),
inst->GetAugmentItemID(4),
0x12);
sprintf(buffer2,"%c%c%c%c%c%c%c%c%c%c%c%c%s",0x00,0x00,0x00,0x00,0xD3,0x01,0x00,0x00,0x1E,0x01,0x00,0x00,itemlink);
memcpy(outapp->pBuffer,buffer2,outapp->size);
QueuePacket(outapp);
safe_delete(outapp);
if (send_to_all==false)
return;
const char* charname = GetName();
outapp = new EQApplicationPacket(OP_ItemLinkText,strlen(itemlink)+14+strlen(charname));
char buffer3[150] = {0};
sprintf(buffer3,"%c%c%c%c%c%c%c%c%c%c%c%c%6s%c%s",0x00,0x00,0x00,0x00,0xD2,0x01,0x00,0x00,0x00,0x00,0x00,0x00,charname,0x00,itemlink);
memcpy(outapp->pBuffer,buffer3,outapp->size);
entity_list.QueueCloseClients(CastToMob(),outapp,true,200,0,false);
safe_delete(outapp);
}
void Client::SendLootItemInPacket(const EQ::ItemInstance* inst, int16 slot_id)
{
SendItemPacket(slot_id,inst, ItemPacketTrade);
}
bool Client::IsValidSlot(uint32 slot) {
if (slot <= EQ::invslot::POSSESSIONS_END && slot >= EQ::invslot::POSSESSIONS_BEGIN) {
return ((((uint64)1 << slot) & GetInv().GetLookup()->PossessionsBitmask) != 0);
}
else if (slot <= EQ::invbag::GENERAL_BAGS_END && slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
return ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) != 0);
}
else if (slot <= EQ::invslot::BANK_END && slot >= EQ::invslot::BANK_BEGIN) {
return ((slot - EQ::invslot::BANK_BEGIN) < GetInv().GetLookup()->InventoryTypeSize.Bank);
}
else if (slot <= EQ::invbag::BANK_BAGS_END && slot >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
return (temp_slot < GetInv().GetLookup()->InventoryTypeSize.Bank);
}
else if (
(slot == (uint32)INVALID_INDEX) ||
(slot == (uint32)EQ::invslot::slotCursor) ||
(slot <= EQ::invbag::CURSOR_BAG_END && slot >= EQ::invbag::CURSOR_BAG_BEGIN) ||
(slot <= EQ::invslot::TRIBUTE_END && slot >= EQ::invslot::TRIBUTE_BEGIN) ||
(slot <= EQ::invslot::GUILD_TRIBUTE_END && slot >= EQ::invslot::GUILD_TRIBUTE_BEGIN) ||
(slot <= EQ::invslot::SHARED_BANK_END && slot >= EQ::invslot::SHARED_BANK_BEGIN) ||
(slot <= EQ::invbag::SHARED_BANK_BAGS_END && slot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN) ||
(slot <= EQ::invslot::TRADE_END && slot >= EQ::invslot::TRADE_BEGIN) ||
(slot <= EQ::invslot::WORLD_END && slot >= EQ::invslot::WORLD_BEGIN)
) {
return true;
}
return false;
}
bool Client::IsBankSlot(uint32 slot)
{
if ((slot >= EQ::invslot::BANK_BEGIN && slot <= EQ::invslot::BANK_END) ||
(slot >= EQ::invbag::BANK_BAGS_BEGIN && slot <= EQ::invbag::BANK_BAGS_END) ||
(slot >= EQ::invslot::SHARED_BANK_BEGIN && slot <= EQ::invslot::SHARED_BANK_END) ||
(slot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN && slot <= EQ::invbag::SHARED_BANK_BAGS_END))
{
return true;
}
return false;
}
// Moves items around both internally and in the database
// In the future, this can be optimized by pushing all changes through one database REPLACE call
bool Client::SwapItem(MoveItem_Struct* move_in) {
uint32 src_slot_check = move_in->from_slot;
uint32 dst_slot_check = move_in->to_slot;
uint32 stack_count_check = move_in->number_in_stack;
if(!IsValidSlot(src_slot_check)){
// SoF+ sends a Unix timestamp (should be int32) for src and dst slots every 10 minutes for some reason.
if(src_slot_check < 2147483647)
Message(Chat::Red, "Warning: Invalid slot move from slot %u to slot %u with %u charges!", src_slot_check, dst_slot_check, stack_count_check);
LogInventory("Invalid slot move from slot [{}] to slot [{}] with [{}] charges!", src_slot_check, dst_slot_check, stack_count_check);
return false;
}
if(!IsValidSlot(dst_slot_check)) {
// SoF+ sends a Unix timestamp (should be int32) for src and dst slots every 10 minutes for some reason.
if(src_slot_check < 2147483647)
Message(Chat::Red, "Warning: Invalid slot move from slot %u to slot %u with %u charges!", src_slot_check, dst_slot_check, stack_count_check);
LogInventory("Invalid slot move from slot [{}] to slot [{}] with [{}] charges!", src_slot_check, dst_slot_check, stack_count_check);
return false;
}
if (move_in->from_slot == move_in->to_slot) { // Item summon, no further processing needed
if (ClientVersion() >= EQ::versions::ClientVersion::RoF) { return true; } // Can't do RoF+
if (move_in->to_slot == EQ::invslot::slotCursor) {
auto test_inst = m_inv.GetItem(EQ::invslot::slotCursor);
if (test_inst == nullptr) { return true; }
auto test_item = test_inst->GetItem();
if (test_item == nullptr) { return true; }
if (!test_item->LoreFlag) { return true; }
bool lore_pass = true;
if (test_item->LoreGroup == -1) {
lore_pass = (m_inv.HasItem(test_item->ID, 0, ~(invWhereSharedBank | invWhereCursor)) == INVALID_INDEX);
}
else if (test_item->LoreGroup != 0) {
lore_pass = (m_inv.HasItemByLoreGroup(test_item->LoreGroup, ~(invWhereSharedBank | invWhereCursor)) == INVALID_INDEX);
}
if (!lore_pass) {
LogInventory("([{}]) Duplicate lore items are not allowed - destroying item [{}](id:[{}]) on cursor",
GetName(), test_item->Name, test_item->ID);
MessageString(Chat::Loot, 290);
if (parse->ItemHasQuestSub(test_inst, EVENT_DESTROY_ITEM)) {
parse->EventItem(EVENT_DESTROY_ITEM, this, test_inst, nullptr, "", 0);
}
if (parse->PlayerHasQuestSub(EVENT_DESTROY_ITEM_CLIENT)) {
std::vector<std::any> args = { test_inst };
parse->EventPlayer(EVENT_DESTROY_ITEM_CLIENT, this, "", 0, &args);
}
DeleteItemInInventory(EQ::invslot::slotCursor, 0, true);
if (test_inst && PlayerEventLogs::Instance()->IsEventEnabled(PlayerEvent::ITEM_DESTROY)) {
auto e = PlayerEvent::DestroyItemEvent{
.item_id = test_inst->GetItem()->ID,
.item_name = test_inst->GetItem()->Name,
.charges = test_inst->GetCharges(),
.augment_1_id = test_inst->GetAugmentItemID(0),
.augment_2_id = test_inst->GetAugmentItemID(1),
.augment_3_id = test_inst->GetAugmentItemID(2),
.augment_4_id = test_inst->GetAugmentItemID(3),
.augment_5_id = test_inst->GetAugmentItemID(4),
.augment_6_id = test_inst->GetAugmentItemID(5),
.attuned = test_inst->IsAttuned(),
.reason = "Duplicate lore item"
};
RecordPlayerEventLog(PlayerEvent::ITEM_DESTROY, e);
}
}
}
return true;
}
if (move_in->to_slot == (uint32)INVALID_INDEX) {
if (move_in->from_slot == (uint32)EQ::invslot::slotCursor) {
LogInventory("Client destroyed item from cursor slot [{}]", move_in->from_slot);
EQ::ItemInstance *inst = m_inv.GetItem(EQ::invslot::slotCursor);
if (inst) {
if (PlayerEventLogs::Instance()->IsEventEnabled(PlayerEvent::ITEM_DESTROY)) {
auto e = PlayerEvent::DestroyItemEvent{
.item_id = inst->GetItem()->ID,
.item_name = inst->GetItem()->Name,
.charges = inst->GetCharges(),
.augment_1_id = inst->GetAugmentItemID(0),
.augment_2_id = inst->GetAugmentItemID(1),
.augment_3_id = inst->GetAugmentItemID(2),
.augment_4_id = inst->GetAugmentItemID(3),
.augment_5_id = inst->GetAugmentItemID(4),
.augment_6_id = inst->GetAugmentItemID(5),
.attuned = inst->IsAttuned(),
.reason = "Client destroy cursor"
};
RecordPlayerEventLog(PlayerEvent::ITEM_DESTROY, e);
}
if (parse->ItemHasQuestSub(inst, EVENT_DESTROY_ITEM)) {
parse->EventItem(EVENT_DESTROY_ITEM, this, inst, nullptr, "", 0);
}
if (parse->PlayerHasQuestSub(EVENT_DESTROY_ITEM_CLIENT)) {
std::vector<std::any> args = { inst };
parse->EventPlayer(EVENT_DESTROY_ITEM_CLIENT, this, "", 0, &args);
}
}
DeleteItemInInventory(move_in->from_slot);
SendCursorBuffer();
return true; // Item destroyed by client
}
else {
LogInventory("Deleted item from slot [{}] as a result of an inventory container tradeskill combine", move_in->from_slot);
DeleteItemInInventory(move_in->from_slot);
return true; // Item deletion
}
}
if (auto_attack) {
if (move_in->from_slot == EQ::invslot::slotPrimary || move_in->from_slot == EQ::invslot::slotSecondary || move_in->from_slot == EQ::invslot::slotRange)
SetAttackTimer();
else if (move_in->to_slot == EQ::invslot::slotPrimary || move_in->to_slot == EQ::invslot::slotSecondary || move_in->to_slot == EQ::invslot::slotRange)
SetAttackTimer();
}
// Step 1: Variables
int16 src_slot_id = (int16)move_in->from_slot;
int16 dst_slot_id = (int16)move_in->to_slot;
if(IsBankSlot(src_slot_id) || IsBankSlot(dst_slot_id) || IsBankSlot(src_slot_check) || IsBankSlot(dst_slot_check)) {
uint32 distance = 0;
NPC *banker = entity_list.GetClosestBanker(this, distance);
if(!banker || distance > USE_NPC_RANGE2)
{
auto message = fmt::format(
"Player tried to make use of a banker (items) but banker [{}] is "
"non-existent or too far away [{}] units",
banker ? banker->GetName() : "UNKNOWN NPC", distance
);
RecordPlayerEventLog(PlayerEvent::POSSIBLE_HACK, PlayerEvent::PossibleHackEvent{.message = message});
Kick("Inventory desync"); // Kicking player to avoid item loss do to client and server inventories not being sync'd
return false;
}
}
//Setup
uint32 srcitemid = 0;
uint32 dstitemid = 0;
EQ::ItemInstance* src_inst = m_inv.GetItem(src_slot_id);
EQ::ItemInstance* dst_inst = m_inv.GetItem(dst_slot_id);
if (src_inst){
LogInventory("Src slot [{}] has item [{}] ([{}]) with [{}] charges in it", src_slot_id, src_inst->GetItem()->Name, src_inst->GetItem()->ID, src_inst->GetCharges());
srcitemid = src_inst->GetItem()->ID;
//SetTint(dst_slot_id,src_inst->GetColor());
if (src_inst->GetCharges() > 0 && (src_inst->GetCharges() < (int16)move_in->number_in_stack || move_in->number_in_stack > src_inst->GetItem()->StackSize))
{
Message(Chat::Red,"Error: Insufficient number in stack.");
return false;
}
}
if (dst_inst) {
LogInventory("Dest slot [{}] has item [{}] ([{}]) with [{}] charges in it", dst_slot_id, dst_inst->GetItem()->Name, dst_inst->GetItem()->ID, dst_inst->GetCharges());
dstitemid = dst_inst->GetItem()->ID;
}
if (IsBuyer() && srcitemid > 0) {
CheckIfMovedItemIsPartOfBuyLines(srcitemid);
}
if (IsTrader() && srcitemid>0){
EQ::ItemInstance* srcbag;
EQ::ItemInstance* dstbag;
uint32 srcbagid =0;
uint32 dstbagid = 0;
if (src_slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN && src_slot_id <= EQ::invbag::GENERAL_BAGS_END) {
srcbag = m_inv.GetItem(EQ::InventoryProfile::CalcSlotId(src_slot_id));
if (srcbag)
srcbagid = srcbag->GetItem()->ID;
}
if (dst_slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN && dst_slot_id <= EQ::invbag::GENERAL_BAGS_END) {
dstbag = m_inv.GetItem(EQ::InventoryProfile::CalcSlotId(dst_slot_id));
if (dstbag)
dstbagid = dstbag->GetItem()->ID;
}
if ((srcbagid && srcbag->GetItem()->BagType == EQ::item::BagTypeTradersSatchel) ||
(dstbagid && dstbag->GetItem()->BagType == EQ::item::BagTypeTradersSatchel) ||
(srcitemid && src_inst && src_inst->GetItem()->BagType == EQ::item::BagTypeTradersSatchel) ||
(dstitemid && dst_inst && dst_inst->GetItem()->BagType == EQ::item::BagTypeTradersSatchel)) {
TraderEndTrader();
Message(Chat::Red,"You cannot move your Trader Satchels, or items inside them, while Trading.");
}
}
// Step 2: Validate item in from_slot
// After this, we can assume src_inst is a valid ptr
if (!src_inst && (src_slot_id < EQ::invslot::WORLD_BEGIN || src_slot_id > EQ::invslot::WORLD_END)) {
if (dst_inst) {
// If there is no source item, but there is a destination item,
// move the slots around before deleting the invalid source slot item,
// which is now in the destination slot.
move_in->from_slot = dst_slot_check;
move_in->to_slot = src_slot_check;
move_in->number_in_stack = dst_inst->GetCharges();
if(!SwapItem(move_in)) { LogInventory("Recursive SwapItem call failed due to non-existent destination item (charid: [{}], fromslot: [{}], toslot: [{}])", CharacterID(), src_slot_id, dst_slot_id); }
}
return false;
}
//verify shared bank transactions in the database
if (
src_inst &&
(
EQ::ValueWithin(src_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
EQ::ValueWithin(src_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
)
) {
if(!database.VerifyInventory(account_id, src_slot_id, src_inst)) {
LogError("Player [{}] on account [{}] was found exploiting the shared bank.\n", GetName(), account_name);
DeleteItemInInventory(dst_slot_id,0,true);
return(false);
}
if (EQ::ValueWithin(src_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) && src_inst->IsClassBag()){
for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx <= EQ::invbag::SLOT_END; idx++) {
const EQ::ItemInstance* baginst = src_inst->GetItem(idx);
if (baginst && !database.VerifyInventory(account_id, EQ::InventoryProfile::CalcSlotId(src_slot_id, idx), baginst)){
DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(src_slot_id, idx), 0, false);
}
}
}
}
if (
dst_inst &&
(
EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
EQ::ValueWithin(dst_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
)
) {
if(!database.VerifyInventory(account_id, dst_slot_id, dst_inst)) {
LogError("Player [{}] on account [{}] was found exploting the shared bank.\n", GetName(), account_name);
DeleteItemInInventory(src_slot_id,0,true);
return(false);
}
if (EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) && dst_inst->IsClassBag()){
for (uint8 idx = EQ::invbag::SLOT_BEGIN; idx <= EQ::invbag::SLOT_END; idx++) {
const EQ::ItemInstance* baginst = dst_inst->GetItem(idx);
if (baginst && !database.VerifyInventory(account_id, EQ::InventoryProfile::CalcSlotId(dst_slot_id, idx), baginst)){
DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(dst_slot_id, idx), 0, false);
}
}
}
}
// Check for No Drop Hacks
Mob* with = trade->With();
if (
(
(
with &&
with->IsClient() &&
!with->CastToClient()->IsBecomeNPC() &&
EQ::ValueWithin(dst_slot_id, EQ::invslot::TRADE_BEGIN, EQ::invslot::TRADE_END)
) ||
EQ::ValueWithin(dst_slot_id, EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END) ||
EQ::ValueWithin(dst_slot_id, EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END)
) &&
GetInv().CheckNoDrop(src_slot_id) &&
!CanTradeFVNoDropItem()
) {
auto ndh_inst = m_inv[src_slot_id];
std::string ndh_item_data;
if (ndh_inst == nullptr) {
ndh_item_data.append("[nullptr on EQ::ItemInstance*]");
}
else {
auto ndh_item = ndh_inst->GetItem();
if (ndh_item == nullptr) {
ndh_item_data.append("[nullptr on ItemData*]");
}
else {
ndh_item_data.append(StringFormat("name=%s", ndh_item->Name));
ndh_item_data.append(StringFormat(", id=%u", ndh_item->ID));
ndh_item_data.append(StringFormat(", nodrop=%s(%u)", (ndh_item->NoDrop == 0 ? "true" : "false"), ndh_item->NoDrop));
}
}
LogError("WorldKick() of Player [{}](id:[{}], acct:[{}]) due to 'NoDrop Hack' detection >> SlotID:[{}], ItemData:[{}]",
GetName(), CharacterID(), AccountID(), src_slot_id, ndh_item_data.c_str());
ndh_inst = nullptr;
DeleteItemInInventory(src_slot_id);
WorldKick();
return false;
}
// Step 3: Check for interaction with World Container (tradeskills)
if(m_tradeskill_object != nullptr) {
if (src_slot_id >= EQ::invslot::WORLD_BEGIN && src_slot_id <= EQ::invslot::WORLD_END) {
// Picking up item from world container
EQ::ItemInstance* inst = m_tradeskill_object->PopItem(EQ::InventoryProfile::CalcBagIdx(src_slot_id));
if (inst) {
PutItemInInventory(dst_slot_id, *inst, false);
safe_delete(inst);
}
return true;
}
else if (dst_slot_id >= EQ::invslot::WORLD_BEGIN && dst_slot_id <= EQ::invslot::WORLD_END) {
// Putting item into world container, which may swap (or pile onto) with existing item
uint8 world_idx = EQ::InventoryProfile::CalcBagIdx(dst_slot_id);
EQ::ItemInstance* world_inst = m_tradeskill_object->PopItem(world_idx);
// Case 1: No item in container, unidirectional "Put"
if (world_inst == nullptr) {
m_tradeskill_object->PutItem(world_idx, src_inst);
m_inv.DeleteItem(src_slot_id);
}
else {
const EQ::ItemData* world_item = world_inst->GetItem();
const EQ::ItemData* src_item = src_inst->GetItem();
if (world_item && src_item) {
// Case 2: Same item on cursor, stacks, transfer of charges needed
if ((world_item->ID == src_item->ID) && src_inst->IsStackable()) {
int16 world_charges = world_inst->GetCharges();
int16 src_charges = src_inst->GetCharges();
// Fill up destination stack as much as possible
world_charges += src_charges;
if (world_charges > world_inst->GetItem()->StackSize) {
src_charges = world_charges - world_inst->GetItem()->StackSize;
world_charges = world_inst->GetItem()->StackSize;
}
else {
src_charges = 0;
}
world_inst->SetCharges(world_charges);
m_tradeskill_object->PutItem(world_idx, world_inst);
m_tradeskill_object->Save();
if (src_charges == 0) {
m_inv.DeleteItem(src_slot_id); // DB remove will occur below
}
else {
src_inst->SetCharges(src_charges);
}
}
else {
// Case 3: Swap the item on user with item in world container
// World containers don't follow normal rules for swapping
EQ::ItemInstance* inv_inst = m_inv.PopItem(src_slot_id);
m_tradeskill_object->PutItem(world_idx, inv_inst);
m_inv.PutItem(src_slot_id, *world_inst);
safe_delete(inv_inst);
}
}
}
safe_delete(world_inst);
if (src_slot_id == EQ::invslot::slotCursor)
{
if (dstitemid == 0)
{
SendCursorBuffer();
}
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(character_id, s, e);
}
else
{
database.SaveInventory(character_id, m_inv[src_slot_id], src_slot_id);
}
return true;
}
}
// Step 4: Check for entity trade
if (dst_slot_id >= EQ::invslot::TRADE_BEGIN && dst_slot_id <= EQ::invslot::TRADE_END) {
if (src_slot_id != EQ::invslot::slotCursor) {
Kick("Trade with non-cursor item");
return false;
}
if (with) {
LogInventory("Trade item move from slot [{}] to slot [{}] (trade with [{}])", src_slot_id, dst_slot_id, with->GetName());
// Fill Trade list with items from cursor
if (!m_inv[EQ::invslot::slotCursor]) {
Message(Chat::Red, "Error: Cursor item not located on server!");
return false;
}
trade->AddEntity(dst_slot_id, move_in->number_in_stack);
if (dstitemid == 0)
{
SendCursorBuffer();
}
return true;
} else {
SummonItem(src_inst->GetID(), src_inst->GetCharges());
DeleteItemInInventory(EQ::invslot::slotCursor);
return true;
}
}
bool all_to_stack = false;
// Step 5: Swap (or stack) items
if (move_in->number_in_stack > 0) {
// Determine if charged items can stack
if(src_inst && !src_inst->IsStackable()) {
LogInventory("Move from [{}] to [{}] with stack size [{}]. [{}] is not a stackable item. (charname: [{}])", src_slot_id, dst_slot_id, move_in->number_in_stack, src_inst->GetItem()->Name, GetName());
return false;
}
if (dst_inst) {
if(src_inst->GetID() != dst_inst->GetID()) {
LogInventory("Move from [{}] to [{}] with stack size [{}]. Incompatible item types: [{}] != [{}]", src_slot_id, dst_slot_id, move_in->number_in_stack, src_inst->GetID(), dst_inst->GetID());
return(false);
}
if(dst_inst->GetCharges() < dst_inst->GetItem()->StackSize) {
//we have a chance of stacking.
LogInventory("Move from [{}] to [{}] with stack size [{}]. dest has [{}]/[{}] charges", src_slot_id, dst_slot_id, move_in->number_in_stack, dst_inst->GetCharges(), dst_inst->GetItem()->StackSize);
// Charges can be emptied into dst
uint16 usedcharges = dst_inst->GetItem()->StackSize - dst_inst->GetCharges();
if (usedcharges > move_in->number_in_stack)
usedcharges = move_in->number_in_stack;
dst_inst->SetCharges(dst_inst->GetCharges() + usedcharges);
src_inst->SetCharges(src_inst->GetCharges() - usedcharges);
// Depleted all charges?
if (src_inst->GetCharges() < 1)
{
LogInventory("Dest ([{}]) now has [{}] charges, source ([{}]) was entirely consumed. ([{}] moved)", dst_slot_id, dst_inst->GetCharges(), src_slot_id, usedcharges);
database.SaveInventory(CharacterID(),nullptr,src_slot_id);
m_inv.DeleteItem(src_slot_id);
all_to_stack = true;
} else {
LogInventory("Dest ([{}]) now has [{}] charges, source ([{}]) has [{}] ([{}] moved)", dst_slot_id, dst_inst->GetCharges(), src_slot_id, src_inst->GetCharges(), usedcharges);
}
} else {
LogInventory("Move from [{}] to [{}] with stack size [{}]. Exceeds dest maximum stack size: [{}]/[{}]", src_slot_id, dst_slot_id, move_in->number_in_stack, (src_inst->GetCharges()+dst_inst->GetCharges()), dst_inst->GetItem()->StackSize);
return false;
}
}
else {
// Nothing in destination slot: split stack into two
if ((int16)move_in->number_in_stack >= src_inst->GetCharges()) {
// Move entire stack
EQ::InventoryProfile::SwapItemFailState fail_state = EQ::InventoryProfile::swapInvalid;
if (!m_inv.SwapItem(src_slot_id, dst_slot_id, fail_state)) { return false; }
LogInventory("Move entire stack from [{}] to [{}] with stack size [{}]. Dest empty", src_slot_id, dst_slot_id, move_in->number_in_stack);
}
else {
// Split into two
src_inst->SetCharges(src_inst->GetCharges() - move_in->number_in_stack);
LogInventory("Split stack of [{}] ([{}]) from slot [{}] to [{}] with stack size [{}]. Src keeps [{}]", src_inst->GetItem()->Name, src_inst->GetItem()->ID, src_slot_id, dst_slot_id, move_in->number_in_stack, src_inst->GetCharges());
EQ::ItemInstance* inst = database.CreateItem(src_inst->GetItem(), move_in->number_in_stack);
m_inv.PutItem(dst_slot_id, *inst);
safe_delete(inst);
}
}
}
else {
// Not dealing with charges - just do direct swap
if (src_inst && (dst_slot_id <= EQ::invslot::EQUIPMENT_END) && dst_slot_id >= EQ::invslot::EQUIPMENT_BEGIN) {
if (src_inst->GetItem()->Attuneable) {
src_inst->SetAttuned(true);
}
if (src_inst->IsAugmented()) {
for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
if (src_inst->GetAugment(i)) {
if (src_inst->GetAugment(i)->GetItem()->Attuneable) {
src_inst->GetAugment(i)->SetAttuned(true);
}
}
}
}
SetMaterial(dst_slot_id,src_inst->GetItem()->ID);
}
EQ::InventoryProfile::SwapItemFailState fail_state = EQ::InventoryProfile::swapInvalid;
if (!m_inv.SwapItem(src_slot_id, dst_slot_id, fail_state, GetBaseRace(), GetBaseClass(), GetDeity(), GetLevel())) {
const char* fail_message = "The selected slot was invalid.";
if (fail_state == EQ::InventoryProfile::swapRaceClass || fail_state == EQ::InventoryProfile::swapDeity)
fail_message = "Your class, deity and/or race may not equip that item.";
else if (fail_state == EQ::InventoryProfile::swapLevel)
fail_message = "You are not sufficient level to use this item.";
if (fail_message)
Message(Chat::Red, "%s", fail_message);
return false;
}
LogInventory("Moving entire item from slot [{}] to slot [{}]", src_slot_id, dst_slot_id);
if (src_inst->IsStackable() &&
dst_slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN &&
dst_slot_id <= EQ::invbag::GENERAL_BAGS_END
) {
EQ::ItemInstance *bag = nullptr;
bag = m_inv.GetItem(EQ::InventoryProfile::CalcSlotId(dst_slot_id));
if (bag) {
if (bag->GetItem()->BagType == EQ::item::BagTypeTradersSatchel) {
PutItemInInventory(dst_slot_id, *src_inst, true);
//This resets the UF client to recognize the new serial item of the placed item
//if it came from a stack without having to close the trader window and re-open.
//It is not required for the RoF2 client.
if (ClientVersion() < EQ::versions::ClientVersion::RoF2) {
auto outapp = new EQApplicationPacket(OP_Trader, sizeof(TraderBuy_Struct));
auto data = (TraderBuy_Struct *) outapp->pBuffer;
data->action = BazaarBuyItem;
FastQueuePacket(&outapp);
}
}
}
}
if (src_slot_id <= EQ::invslot::EQUIPMENT_END) {
if(src_inst) {
if (parse->ItemHasQuestSub(src_inst, EVENT_UNEQUIP_ITEM)) {
parse->EventItem(EVENT_UNEQUIP_ITEM, this, src_inst, nullptr, "", src_slot_id);
}
if (parse->PlayerHasQuestSub(EVENT_UNEQUIP_ITEM_CLIENT)) {
const auto& export_string = fmt::format(
"{} {}",
src_inst->IsStackable() ? src_inst->GetCharges() : 1,
src_slot_id
);
parse->EventPlayer(EVENT_UNEQUIP_ITEM_CLIENT, this, export_string, src_inst->GetItem()->ID);
}
}
if (dst_inst) {
if (parse->ItemHasQuestSub(dst_inst, EVENT_EQUIP_ITEM)) {
parse->EventItem(EVENT_EQUIP_ITEM, this, dst_inst, nullptr, "", src_slot_id);
}
if (parse->PlayerHasQuestSub(EVENT_EQUIP_ITEM_CLIENT)) {
const auto& export_string = fmt::format(
"{} {}",
dst_inst->IsStackable() ? dst_inst->GetCharges() : 1,
src_slot_id
);
parse->EventPlayer(EVENT_EQUIP_ITEM_CLIENT, this, export_string, dst_inst->GetItem()->ID);
}
}
}
if (dst_slot_id <= EQ::invslot::EQUIPMENT_END) {
if (dst_inst) {
if (parse->ItemHasQuestSub(dst_inst, EVENT_UNEQUIP_ITEM)) {
parse->EventItem(EVENT_UNEQUIP_ITEM, this, dst_inst, nullptr, "", dst_slot_id);
}
if (parse->PlayerHasQuestSub(EVENT_UNEQUIP_ITEM_CLIENT)) {
const auto& export_string = fmt::format(
"{} {}",
dst_inst->IsStackable() ? dst_inst->GetCharges() : 1,
dst_slot_id
);
std::vector<std::any> args = { dst_inst };
parse->EventPlayer(EVENT_UNEQUIP_ITEM_CLIENT, this, export_string, dst_inst->GetItem()->ID, &args);
}
}
if (src_inst) {
if (parse->ItemHasQuestSub(src_inst, EVENT_EQUIP_ITEM)) {
parse->EventItem(EVENT_EQUIP_ITEM, this, src_inst, nullptr, "", dst_slot_id);
}
if (parse->PlayerHasQuestSub(EVENT_EQUIP_ITEM_CLIENT)) {
const auto& export_string = fmt::format(
"{} {}",
src_inst->IsStackable() ? src_inst->GetCharges() : 1,
dst_slot_id
);
std::vector<std::any> args = { src_inst };
parse->EventPlayer(EVENT_EQUIP_ITEM_CLIENT, this, export_string, src_inst->GetItem()->ID, &args);
}
}
}
}
int matslot = SlotConvert2(dst_slot_id);
if (dst_slot_id <= EQ::invslot::EQUIPMENT_END) {// on Titanium and ROF2 /showhelm works even if sending helm slot
SendWearChange(matslot);
}
// Step 7: Save change to the database
if (src_slot_id == EQ::invslot::slotCursor) {
// If not swapping another item to cursor and stacking items were depleted
if (dstitemid == 0 || all_to_stack == true)
{
SendCursorBuffer();
}
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(character_id, s, e);
}
else {
database.SaveInventory(character_id, m_inv.GetItem(src_slot_id), src_slot_id);
}
if (dst_slot_id == EQ::invslot::slotCursor) {
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(character_id, s, e);
}
else {
database.SaveInventory(character_id, m_inv.GetItem(dst_slot_id), dst_slot_id);
}
// Step 8: Re-calc stats
CalcBonuses();
ApplyWeaponsStance();
return true;
}
void Client::SwapItemResync(MoveItem_Struct* move_slots) {
// wow..this thing created a helluva memory leak...
// with any luck..this won't be needed in the future
// resync the 'from' and 'to' slots on an as-needed basis
// Not as effective as the full process, but less intrusive to gameplay
LogInventory("Inventory desyncronization. (charname: [{}], source: [{}], destination: [{}])", GetName(), move_slots->from_slot, move_slots->to_slot);
Message(Chat::Yellow, "Inventory Desyncronization detected: Resending slot data...");
if (move_slots->from_slot >= EQ::invslot::EQUIPMENT_BEGIN && move_slots->from_slot <= EQ::invbag::CURSOR_BAG_END) {
int16 resync_slot = (EQ::InventoryProfile::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : EQ::InventoryProfile::CalcSlotId(move_slots->from_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
// This prevents the client from crashing when closing any 'phantom' bags
const EQ::ItemData* token_struct = database.GetItem(22292); // 'Copper Coin'
EQ::ItemInstance* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
if(m_inv[resync_slot]) { SendItemPacket(resync_slot, m_inv[resync_slot], ItemPacketTrade); }
else {
auto outapp = new EQApplicationPacket(OP_DeleteItem, sizeof(DeleteItem_Struct));
DeleteItem_Struct* delete_slot = (DeleteItem_Struct*)outapp->pBuffer;
delete_slot->from_slot = resync_slot;
delete_slot->to_slot = 0xFFFFFFFF;
delete_slot->number_in_stack = 0xFFFFFFFF;
QueuePacket(outapp);
safe_delete(outapp);
}
safe_delete(token_inst);
Message(Chat::Lime, "Source slot %i resyncronized.", move_slots->from_slot);
}
else { Message(Chat::Red, "Could not resyncronize source slot %i.", move_slots->from_slot); }
}
else {
int16 resync_slot = (EQ::InventoryProfile::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : EQ::InventoryProfile::CalcSlotId(move_slots->from_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
if(m_inv[resync_slot]) {
const EQ::ItemData* token_struct = database.GetItem(22292); // 'Copper Coin'
EQ::ItemInstance* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
SendItemPacket(resync_slot, m_inv[resync_slot], ItemPacketTrade);
safe_delete(token_inst);
Message(Chat::Lime, "Source slot %i resyncronized.", move_slots->from_slot);
}
else { Message(Chat::Red, "Could not resyncronize source slot %i.", move_slots->from_slot); }
}
else { Message(Chat::Red, "Could not resyncronize source slot %i.", move_slots->from_slot); }
}
if (move_slots->to_slot >= EQ::invslot::EQUIPMENT_BEGIN && move_slots->to_slot <= EQ::invbag::CURSOR_BAG_END) {
int16 resync_slot = (EQ::InventoryProfile::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : EQ::InventoryProfile::CalcSlotId(move_slots->to_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
const EQ::ItemData* token_struct = database.GetItem(22292); // 'Copper Coin'
EQ::ItemInstance* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
if(m_inv[resync_slot]) { SendItemPacket(resync_slot, m_inv[resync_slot], ItemPacketTrade); }
else {
auto outapp = new EQApplicationPacket(OP_DeleteItem, sizeof(DeleteItem_Struct));
DeleteItem_Struct* delete_slot = (DeleteItem_Struct*)outapp->pBuffer;
delete_slot->from_slot = resync_slot;
delete_slot->to_slot = 0xFFFFFFFF;
delete_slot->number_in_stack = 0xFFFFFFFF;
QueuePacket(outapp);
safe_delete(outapp);
}
safe_delete(token_inst);
Message(Chat::Lime, "Destination slot %i resyncronized.", move_slots->to_slot);
}
else { Message(Chat::Red, "Could not resyncronize destination slot %i.", move_slots->to_slot); }
}
else {
int16 resync_slot = (EQ::InventoryProfile::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : EQ::InventoryProfile::CalcSlotId(move_slots->to_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
if(m_inv[resync_slot]) {
const EQ::ItemData* token_struct = database.GetItem(22292); // 'Copper Coin'
EQ::ItemInstance* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
SendItemPacket(resync_slot, m_inv[resync_slot], ItemPacketTrade);
safe_delete(token_inst);
Message(Chat::Lime, "Destination slot %i resyncronized.", move_slots->to_slot);
}
else { Message(Chat::Red, "Could not resyncronize destination slot %i.", move_slots->to_slot); }
}
else { Message(Chat::Red, "Could not resyncronize destination slot %i.", move_slots->to_slot); }
}
}
void Client::DyeArmor(EQ::TintProfile* dye){
int16 slot=0;
for (int i = EQ::textures::textureBegin; i <= EQ::textures::LastTintableTexture; i++) {
if ((m_pp.item_tint.Slot[i].Color & 0x00FFFFFF) != (dye->Slot[i].Color & 0x00FFFFFF)) {
slot = m_inv.HasItem(32557, 1, invWherePersonal);
if (slot != INVALID_INDEX){
DeleteItemInInventory(slot,1,true);
uint8 slot2=SlotConvert(i);
EQ::ItemInstance* inst = m_inv.GetItem(slot2);
if(inst){
uint32 armor_color = ((uint32)dye->Slot[i].Red << 16) | ((uint32)dye->Slot[i].Green << 8) | ((uint32)dye->Slot[i].Blue);
inst->SetColor(armor_color);
database.SaveCharacterMaterialColor(CharacterID(), i, armor_color);
database.SaveInventory(CharacterID(),inst,slot2);
if(dye->Slot[i].UseTint)
m_pp.item_tint.Slot[i].UseTint = 0xFF;
else
m_pp.item_tint.Slot[i].UseTint=0x00;
}
m_pp.item_tint.Slot[i].Blue=dye->Slot[i].Blue;
m_pp.item_tint.Slot[i].Red=dye->Slot[i].Red;
m_pp.item_tint.Slot[i].Green=dye->Slot[i].Green;
SendWearChange(i);
}
else{
Message(Chat::Red,"Could not locate A Vial of Prismatic Dye.");
return;
}
}
}
auto outapp = new EQApplicationPacket(OP_Dye, 0);
QueuePacket(outapp);
safe_delete(outapp);
}
void Client::DyeArmorBySlot(uint8 slot, uint8 red, uint8 green, uint8 blue, uint8 use_tint) {
uint8 item_slot = SlotConvert(slot);
EQ::ItemInstance* item_instance = m_inv.GetItem(item_slot);
if (item_instance) {
uint32 armor_color = ((uint32)red << 16) | ((uint32)green << 8) | ((uint32)blue);
item_instance->SetColor(armor_color);
database.SaveCharacterMaterialColor(CharacterID(), slot, armor_color);
database.SaveInventory(CharacterID(), item_instance, item_slot);
m_pp.item_tint.Slot[slot].UseTint = (use_tint ? 0xFF : 0x00);
}
m_pp.item_tint.Slot[slot].Red = red;
m_pp.item_tint.Slot[slot].Green = green;
m_pp.item_tint.Slot[slot].Blue = blue;
SendWearChange(slot);
}
bool Client::DecreaseByID(uint32 type, int16 quantity) {
const EQ::ItemData* TempItem = nullptr;
EQ::ItemInstance* ins = nullptr;
int x;
int num = 0;
for (x = EQ::invslot::POSSESSIONS_BEGIN; x <= EQ::invslot::POSSESSIONS_END; ++x) {
if (num >= quantity)
break;
if ((((uint64)1 << x) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID == type)
num += ins->GetCharges();
}
for (x = EQ::invbag::GENERAL_BAGS_BEGIN; x <= EQ::invbag::GENERAL_BAGS_END; ++x) {
if (num >= quantity)
break;
if ((((uint64)1 << (EQ::invslot::GENERAL_BEGIN + ((x - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT))) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID == type)
num += ins->GetCharges();
}
for (x = EQ::invbag::CURSOR_BAG_BEGIN; x <= EQ::invbag::CURSOR_BAG_END; ++x) {
if (num >= quantity)
break;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID == type)
num += ins->GetCharges();
}
if (num < quantity)
return false;
for (x = EQ::invslot::POSSESSIONS_BEGIN; x <= EQ::invslot::POSSESSIONS_END; ++x) {
if (quantity < 1)
break;
if ((((uint64)1 << x) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID != type)
continue;
if (ins->GetCharges() < quantity) {
quantity -= ins->GetCharges();
DeleteItemInInventory(x, quantity, true);
}
else {
DeleteItemInInventory(x, quantity, true);
quantity = 0;
}
}
for (x = EQ::invbag::GENERAL_BAGS_BEGIN; x <= EQ::invbag::GENERAL_BAGS_END; ++x) {
if (quantity < 1)
break;
if ((((uint64)1 << (EQ::invslot::GENERAL_BEGIN + ((x - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT))) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID != type)
continue;
if (ins->GetCharges() < quantity) {
quantity -= ins->GetCharges();
DeleteItemInInventory(x, quantity, true);
}
else {
DeleteItemInInventory(x, quantity, true);
quantity = 0;
}
}
for (x = EQ::invbag::CURSOR_BAG_BEGIN; x <= EQ::invbag::CURSOR_BAG_END; ++x) {
if (quantity < 1)
break;
TempItem = nullptr;
ins = GetInv().GetItem(x);
if (ins)
TempItem = ins->GetItem();
if (TempItem && TempItem->ID != type)
continue;
if (ins->GetCharges() < quantity) {
quantity -= ins->GetCharges();
DeleteItemInInventory(x, quantity, true);
}
else {
DeleteItemInInventory(x, quantity, true);
quantity = 0;
}
}
return true;
}
static bool IsSummonedBagID(uint32 item_id)
{
switch (item_id) {
case 17147: // "Spiritual Prismatic Pack"
case 17303: // "Spirit Pouch"
case 17304: // "Dimensional Pocket"
case 17305: // "Dimensional Hole"
case 17306: // "Glowing Backpack"
case 17307: // "Quiver of Marr"
case 17308: // "Bandoleer of Luclin"
case 17309: // "Pouch of Quellious"
case 17310: // "Phantom Satchel"
case 17510: // "Glowing Chest"
case 17900: // "Grandmaster's Satchel"
case 57260: // "Glowing Backpack"
case 57261: // "Pouch of Quellious"
case 57262: // "Phantom Satchel"
case 60224: // "Faded-Glyph Tablet"
case 95199: // "Beginner Artisan Satchel"
case 95200: // "Apprentice Artisan Satchel"
case 95201: // "Freshman Artisan Satchel"
case 95202: // "Journeyman Artisan Satchel"
case 95203: // "Expert Artisan Satchel"
case 95204: // "Master Artisan Satchel"
//case 96960: // "Artisan Satchel" - no 12-slot disenchanted bags
return true;
default:
return false;
}
}
static uint32 GetDisenchantedBagID(uint8 bag_slots)
{
switch (bag_slots) {
case 4:
return 77772; // "Small Disenchanted Backpack"
case 6:
return 77774; // "Disenchanted Backpack"
case 8:
return 77776; // "Large Disenchanted Backpack"
case 10:
return 77778; // "Huge Disenchanted Backpack"
default:
return 0; // no suitable conversions
}
}
static bool CopyBagContents(EQ::ItemInstance* new_bag, const EQ::ItemInstance* old_bag)
{
if (!new_bag || !old_bag) { return false; }
if (new_bag->GetItem()->BagSlots < old_bag->GetItem()->BagSlots) { return false; }
// pre-check for size comparisons
for (auto bag_slot = 0; bag_slot < old_bag->GetItem()->BagSlots; ++bag_slot) {
if (!old_bag->GetItem(bag_slot)) { continue; }
if (old_bag->GetItem(bag_slot)->GetItem()->Size > new_bag->GetItem()->BagSize) {
LogInventory("Copy Bag Contents: Failure due to [{}] is larger than size capacity of [{}] ([{}] > [{}])",
old_bag->GetItem(bag_slot)->GetItem()->Name, new_bag->GetItem()->Name, old_bag->GetItem(bag_slot)->GetItem()->Size, new_bag->GetItem()->BagSize);
return false;
}
}
for (auto bag_slot = 0; bag_slot < old_bag->GetItem()->BagSlots; ++bag_slot) {
if (!old_bag->GetItem(bag_slot)) { continue; }
new_bag->PutItem(bag_slot, *(old_bag->GetItem(bag_slot)));
}
return true;
}
void Client::DisenchantSummonedBags(bool client_update)
{
for (auto slot_id = EQ::invslot::GENERAL_BEGIN; slot_id <= EQ::invslot::GENERAL_END; ++slot_id) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue; // not usable this session - will be disenchanted once player logs in on client that doesn't exclude affected slots
auto inst = m_inv[slot_id];
if (!inst) { continue; }
if (!IsSummonedBagID(inst->GetItem()->ID)) { continue; }
if (!inst->GetItem()->IsClassBag()) { continue; }
if (inst->GetTotalItemCount() == 1) { continue; }
auto new_id = GetDisenchantedBagID(inst->GetItem()->BagSlots);
if (!new_id) { continue; }
auto new_item = database.GetItem(new_id);
if (!new_item) { continue; }
auto new_inst = database.CreateBaseItem(new_item);
if (!new_inst) { continue; }
if (CopyBagContents(new_inst, inst)) {
LogInventory("Disenchant Summoned Bags: Replacing [{}] with [{}] in slot [{}]", inst->GetItem()->Name, new_inst->GetItem()->Name, slot_id);
PutItemInInventory(slot_id, *new_inst, client_update);
}
safe_delete(new_inst);
}
for (auto slot_id = EQ::invslot::BANK_BEGIN; slot_id <= EQ::invslot::BANK_END; ++slot_id) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank)
continue;
auto inst = m_inv[slot_id];
if (!inst) { continue; }
if (!IsSummonedBagID(inst->GetItem()->ID)) { continue; }
if (!inst->GetItem()->IsClassBag()) { continue; }
if (inst->GetTotalItemCount() == 1) { continue; }
auto new_id = GetDisenchantedBagID(inst->GetItem()->BagSlots);
if (!new_id) { continue; }
auto new_item = database.GetItem(new_id);
if (!new_item) { continue; }
auto new_inst = database.CreateBaseItem(new_item);
if (!new_inst) { continue; }
if (CopyBagContents(new_inst, inst)) {
LogInventory("Disenchant Summoned Bags: Replacing [{}] with [{}] in slot [{}]", inst->GetItem()->Name, new_inst->GetItem()->Name, slot_id);
PutItemInInventory(slot_id, *new_inst, client_update);
}
safe_delete(new_inst);
}
for (auto slot_id = EQ::invslot::SHARED_BANK_BEGIN; slot_id <= EQ::invslot::SHARED_BANK_END; ++slot_id) {
auto inst = m_inv[slot_id];
if (!inst) { continue; }
if (!IsSummonedBagID(inst->GetItem()->ID)) { continue; }
if (!inst->GetItem()->IsClassBag()) { continue; }
if (inst->GetTotalItemCount() == 1) { continue; }
auto new_id = GetDisenchantedBagID(inst->GetItem()->BagSlots);
if (!new_id) { continue; }
auto new_item = database.GetItem(new_id);
if (!new_item) { continue; }
auto new_inst = database.CreateBaseItem(new_item);
if (!new_inst) { continue; }
if (CopyBagContents(new_inst, inst)) {
LogInventory("Disenchant Summoned Bags: Replacing [{}] with [{}] in slot [{}]", inst->GetItem()->Name, new_inst->GetItem()->Name, slot_id);
PutItemInInventory(slot_id, *new_inst, client_update);
}
safe_delete(new_inst);
}
while (!m_inv.CursorEmpty()) {
auto inst = m_inv[EQ::invslot::slotCursor];
if (!inst) { break; }
if (!IsSummonedBagID(inst->GetItem()->ID)) { break; }
if (!inst->GetItem()->IsClassBag()) { break; }
if (inst->GetTotalItemCount() == 1) { break; }
auto new_id = GetDisenchantedBagID(inst->GetItem()->BagSlots);
if (!new_id) { break; }
auto new_item = database.GetItem(new_id);
if (!new_item) { break; }
auto new_inst = database.CreateBaseItem(new_item);
if (!new_inst) { break; }
if (CopyBagContents(new_inst, inst)) {
LogInventory("Disenchant Summoned Bags: Replacing [{}] with [{}] in slot [{}]", inst->GetItem()->Name, new_inst->GetItem()->Name, EQ::invslot::slotCursor);
std::list<EQ::ItemInstance*> local;
local.push_front(new_inst);
m_inv.PopItem(EQ::invslot::slotCursor);
safe_delete(inst);
while (!m_inv.CursorEmpty()) {
auto limbo_inst = m_inv.PopItem(EQ::invslot::slotCursor);
if (limbo_inst == nullptr) { continue; }
local.push_back(limbo_inst);
}
for (auto iter = local.begin(); iter != local.end(); ++iter) {
auto cur_inst = *iter;
if (cur_inst == nullptr) { continue; }
m_inv.PushCursor(*cur_inst);
safe_delete(cur_inst);
}
local.clear();
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
}
else {
safe_delete(new_inst); // deletes disenchanted bag if not used
}
break;
}
}
void Client::RemoveNoRent(bool client_update)
{
for (auto slot_id = EQ::invslot::EQUIPMENT_BEGIN; slot_id <= EQ::invslot::EQUIPMENT_END; ++slot_id) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id, 0, client_update);
}
}
for (auto slot_id = EQ::invslot::GENERAL_BEGIN; slot_id <= EQ::invslot::GENERAL_END; ++slot_id) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
auto inst = m_inv[slot_id];
if (inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id, 0, client_update);
}
}
for (auto slot_id = EQ::invbag::GENERAL_BAGS_BEGIN; slot_id <= EQ::invbag::CURSOR_BAG_END; ++slot_id) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id, 0, client_update);
}
}
for (auto slot_id = EQ::invslot::BANK_BEGIN; slot_id <= EQ::invslot::BANK_END; ++slot_id) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank)
continue;
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id); // Can't delete from client Bank slots
}
}
for (auto slot_id = EQ::invbag::BANK_BAGS_BEGIN; slot_id <= EQ::invbag::BANK_BAGS_END; ++slot_id) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank)
continue;
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id); // Can't delete from client Bank Container slots
}
}
for (auto slot_id = EQ::invslot::SHARED_BANK_BEGIN; slot_id <= EQ::invslot::SHARED_BANK_END; ++slot_id) {
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id); // Can't delete from client Shared Bank slots
}
}
for (auto slot_id = EQ::invbag::SHARED_BANK_BAGS_BEGIN; slot_id <= EQ::invbag::SHARED_BANK_BAGS_END; ++slot_id) {
auto inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from slot [{}]", inst->GetItem()->Name, slot_id);
DeleteItemInInventory(slot_id); // Can't delete from client Shared Bank Container slots
}
}
if (!m_inv.CursorEmpty()) {
std::list<EQ::ItemInstance*> local;
while (!m_inv.CursorEmpty()) {
auto inst = m_inv.PopItem(EQ::invslot::slotCursor);
if (inst == nullptr) { continue; }
local.push_back(inst);
}
for (auto iter = local.begin(); iter != local.end(); ++iter) {
auto inst = *iter;
if (inst == nullptr) { continue; }
if (!inst->GetItem()->NoRent) {
LogInventory("NoRent Timer Lapse: Deleting [{}] from `Limbo`", inst->GetItem()->Name);
}
else {
m_inv.PushCursor(*inst);
}
safe_delete(inst);
}
local.clear();
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
}
}
// Two new methods to alleviate perpetual login desyncs
void Client::RemoveDuplicateLore()
{
for (auto slot_id : GetInventorySlots()) {
if ((((uint64) 1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
continue;
}
// ignore shared bank slots
if (slot_id >= EQ::invslot::SHARED_BANK_BEGIN && slot_id <= EQ::invslot::SHARED_BANK_END) {
continue;
}
if (slot_id >= EQ::invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= EQ::invbag::SHARED_BANK_BAGS_END) {
continue;
}
// slot gets handled in a queue
if (slot_id == EQ::invslot::slotCursor) {
continue;
}
// temporarily move the item off of the slot
auto inst = m_inv.PopItem(slot_id);
if (!inst) {
continue;
}
if (CheckLoreConflict(inst->GetItem())) {
LogError(
"Lore Duplication Error | Deleting [{}] ({}) from slot [{}] client [{}]",
inst->GetItem()->Name,
inst->GetItem()->ID,
slot_id,
GetCleanName()
);
database.SaveInventory(character_id, nullptr, slot_id);
safe_delete(inst);
}
// if no lore conflict, put the item back in the slot
m_inv.PushItem(slot_id, inst);
}
if (!m_inv.CursorEmpty()) {
std::list<EQ::ItemInstance*> local_1;
std::list<EQ::ItemInstance*> local_2;
while (!m_inv.CursorEmpty()) {
auto inst = m_inv.PopItem(EQ::invslot::slotCursor);
if (!inst) {
continue;
}
local_1.push_back(inst);
}
for (auto inst: local_1) {
if (!inst) {
continue;
}
if (CheckLoreConflict(inst->GetItem())) {
LogError(
"Lore Duplication Error | Deleting [{}] ({}) from `Limbo` client [{}]",
inst->GetItem()->Name,
inst->GetItem()->ID,
GetCleanName()
);
safe_delete(inst);
}
else {
local_2.push_back(inst);
}
}
local_1.clear();
for (auto inst: local_2) {
if (!inst) {
continue;
}
if (!inst->GetItem()->LoreFlag ||
((inst->GetItem()->LoreGroup == -1) &&
(m_inv.HasItem(inst->GetID(), 0, invWhereCursor) == INVALID_INDEX)) ||
(inst->GetItem()->LoreGroup && (~inst->GetItem()->LoreGroup) &&
(m_inv.HasItemByLoreGroup(inst->GetItem()->LoreGroup, invWhereCursor) == INVALID_INDEX))
) {
m_inv.PushCursor(*inst);
}
else {
LogError(
"Lore Duplication Error | Deleting [{}] ({}) from `Limbo` client [{}]",
inst->GetItem()->Name,
inst->GetItem()->ID,
GetCleanName()
);
}
safe_delete(inst);
}
local_2.clear();
auto s = m_inv.cursor_cbegin(), e = m_inv.cursor_cend();
database.SaveCursor(CharacterID(), s, e);
}
}
void Client::MoveSlotNotAllowed(bool client_update)
{
for (auto slot_id = EQ::invslot::EQUIPMENT_BEGIN; slot_id <= EQ::invslot::EQUIPMENT_END; ++slot_id) {
if(m_inv[slot_id] && !m_inv[slot_id]->IsSlotAllowed(slot_id)) {
auto inst = m_inv.PopItem(slot_id);
bool is_arrow = (inst->GetItem()->ItemType == EQ::item::ItemTypeArrow) ? true : false;
int16 free_slot_id = m_inv.FindFreeSlot(inst->IsClassBag(), true, inst->GetItem()->Size, is_arrow);
LogInventory("Slot Assignment Error: Moving [{}] from slot [{}] to [{}]", inst->GetItem()->Name, slot_id, free_slot_id);
PutItemInInventory(free_slot_id, *inst, client_update);
database.SaveInventory(character_id, nullptr, slot_id);
safe_delete(inst);
}
}
// added this check to move any client-based excluded slots
//for (auto slot_id = EQ::invslot::POSSESSIONS_BEGIN; slot_id <= EQ::invslot::POSSESSIONS_END; ++slot_id) {
// if (((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask != 0)
// continue;
// if (m_inv[slot_id]) { // this is currently dangerous for bag-based movements since limbo does not save bag slots
// auto inst = m_inv.PopItem(slot_id);
// bool is_arrow = (inst->GetItem()->ItemType == EQ::item::ItemTypeArrow) ? true : false;
// int16 free_slot_id = m_inv.FindFreeSlot(inst->IsClassBag(), true, inst->GetItem()->Size, is_arrow);
// LogInventory("Slot Assignment Error: Moving [{}] from slot [{}] to [{}]", inst->GetItem()->Name, slot_id, free_slot_id);
// PutItemInInventory(free_slot_id, *inst, client_update);
// database.SaveInventory(character_id, nullptr, slot_id);
// safe_delete(inst);
// }
//}
// No need to check inventory, cursor, bank or shared bank since they allow max item size and containers
// Code can be added to check item size vs. container size, but it is left to attrition for now.
}
// these functions operate with a material slot, which is from 0 to 8
uint32 Client::GetEquippedItemFromTextureSlot(uint8 material_slot) const
{
int16 inventory_slot;
const EQ::ItemInstance *item;
if (material_slot > EQ::textures::LastTexture) {
return 0;
}
inventory_slot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (inventory_slot == INVALID_INDEX) {
return 0;
}
item = m_inv.GetItem(inventory_slot);
if (item && item->GetItem()) {
return item->GetItem()->ID;
}
return 0;
}
uint32 Client::GetEquipmentColor(uint8 material_slot) const
{
if (material_slot > EQ::textures::LastTexture)
return 0;
const EQ::ItemData *item = database.GetItem(GetEquippedItemFromTextureSlot(material_slot));
if(item != nullptr)
return ((m_pp.item_tint.Slot[material_slot].UseTint) ? m_pp.item_tint.Slot[material_slot].Color : item->Color);
return 0;
}
// Send an item packet (including all subitems of the item)
void Client::SendItemPacket(int16 slot_id, const EQ::ItemInstance* inst, ItemPacketType packet_type)
{
if (!inst) {
return;
}
if (!eqs) {
return;
}
if (packet_type != ItemPacketMerchant) {
if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
LogError("Item not sent to merchant : slot [{}]", slot_id);
return;
}
}
else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
LogError("Item not sent to merchant2 : slot [{}]", slot_id);
return;
}
}
else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
LogError("Item not sent to merchant3 : slot [{}]", slot_id);
return;
}
}
else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
LogError("Item not sent to merchant4 : slot [{}]", slot_id);
return;
}
}
}
// Serialize item into |-delimited string (Titanium- uses '|' delimiter .. newer clients use pure data serialization)
std::string packet = inst->Serialize(slot_id);
EmuOpcode opcode = OP_Unknown;
EQApplicationPacket* outapp = nullptr;
ItemPacket_Struct* itempacket = nullptr;
// Construct packet
opcode = (packet_type==ItemPacketViewLink) ? OP_ItemLinkResponse : OP_ItemPacket;
outapp = new EQApplicationPacket(opcode, packet.length()+sizeof(ItemPacket_Struct));
itempacket = (ItemPacket_Struct*)outapp->pBuffer;
memcpy(itempacket->SerializedItem, packet.c_str(), packet.length());
itempacket->PacketType = packet_type;
#if EQDEBUG >= 9
DumpPacket(outapp);
#endif
FastQueuePacket(&outapp);
}
static int16 BandolierSlotToWeaponSlot(int BandolierSlot)
{
switch (BandolierSlot)
{
case bandolierPrimary:
return EQ::invslot::slotPrimary;
case bandolierSecondary:
return EQ::invslot::slotSecondary;
case bandolierRange:
return EQ::invslot::slotRange;
default:
return EQ::invslot::slotAmmo;
}
}
void Client::CreateBandolier(const EQApplicationPacket *app)
{
// Store bandolier set with the number and name passed by the client, along with the items that are currently
// in the players weapon slots.
BandolierCreate_Struct *bs = (BandolierCreate_Struct*)app->pBuffer;
LogInventory("Char: [{}] Creating Bandolier Set [{}], Set Name: [{}]", GetName(), bs->Number, bs->Name);
strcpy(m_pp.bandoliers[bs->Number].Name, bs->Name);
const EQ::ItemInstance* InvItem = nullptr;
const EQ::ItemData *BaseItem = nullptr;
int16 WeaponSlot = 0;
database.DeleteCharacterBandolier(CharacterID(), bs->Number);
for(int BandolierSlot = bandolierPrimary; BandolierSlot <= bandolierAmmo; BandolierSlot++) {
WeaponSlot = BandolierSlotToWeaponSlot(BandolierSlot);
InvItem = GetInv()[WeaponSlot];
if(InvItem) {
BaseItem = InvItem->GetItem();
LogInventory("Char: [{}] adding item [{}] to slot [{}]", GetName(),BaseItem->Name, WeaponSlot);
m_pp.bandoliers[bs->Number].Items[BandolierSlot].ID = BaseItem->ID;
m_pp.bandoliers[bs->Number].Items[BandolierSlot].Icon = BaseItem->Icon;
strncpy(m_pp.bandoliers[bs->Number].Items[BandolierSlot].Name, BaseItem->Name, sizeof(m_pp.bandoliers[bs->Number].Items[BandolierSlot].Name));
database.SaveCharacterBandolier(CharacterID(), bs->Number, BandolierSlot, m_pp.bandoliers[bs->Number].Items[BandolierSlot].ID, m_pp.bandoliers[bs->Number].Items[BandolierSlot].Icon, bs->Name);
}
else {
LogInventory("Char: [{}] no item in slot [{}]", GetName(), WeaponSlot);
m_pp.bandoliers[bs->Number].Items[BandolierSlot].ID = 0;
m_pp.bandoliers[bs->Number].Items[BandolierSlot].Icon = 0;
m_pp.bandoliers[bs->Number].Items[BandolierSlot].Name[0] = '\0';
}
}
}
void Client::RemoveBandolier(const EQApplicationPacket *app)
{
BandolierDelete_Struct *bds = (BandolierDelete_Struct*)app->pBuffer;
LogInventory("Char: [{}] removing set", GetName(), bds->Number);
memset(m_pp.bandoliers[bds->Number].Name, 0, 32);
for(int i = bandolierPrimary; i <= bandolierAmmo; i++) {
m_pp.bandoliers[bds->Number].Items[i].ID = 0;
m_pp.bandoliers[bds->Number].Items[i].Icon = 0;
}
database.DeleteCharacterBandolier(CharacterID(), bds->Number);
}
void Client::SetBandolier(const EQApplicationPacket *app)
{
// Swap the weapons in the given bandolier set into the character's weapon slots and return
// any items currently in the weapon slots to inventory.
BandolierSet_Struct *bss = (BandolierSet_Struct*)app->pBuffer;
LogInventory("Char: [{}] activating set [{}]", GetName(), bss->Number);
int16 slot = 0;
int16 WeaponSlot = 0;
EQ::ItemInstance *BandolierItems[4]; // Temporary holding area for the weapons we pull out of their inventory
// First we pull the items for this bandolier set out of their inventory, this makes space to put the
// currently equipped items back.
for(int BandolierSlot = bandolierPrimary; BandolierSlot <= bandolierAmmo; BandolierSlot++) {
// If this bandolier set has an item in this position
if(m_pp.bandoliers[bss->Number].Items[BandolierSlot].ID) {
WeaponSlot = BandolierSlotToWeaponSlot(BandolierSlot);
// Check if the player has the item specified in the bandolier set on them.
//
slot = m_inv.HasItem(m_pp.bandoliers[bss->Number].Items[BandolierSlot].ID, 1,
invWhereWorn|invWherePersonal);
// removed 'invWhereCursor' argument from above and implemented slots 30, 331-340 checks here
if (slot == INVALID_INDEX) {
if (m_inv.GetItem(EQ::invslot::slotCursor)) {
// Below used to check charges but for some reason
// m_inv.GetItem(EQ::invslot::slotCursor)->GetCharges()
// is returning 0. We know it exists, so removed check.
// TODO: Why is 0 being returned for slotCursor.
if (m_inv.GetItem(EQ::invslot::slotCursor)->GetItem()->ID == m_pp.bandoliers[bss->Number].Items[BandolierSlot].ID) {
slot = EQ::invslot::slotCursor;
}
else if (m_inv.GetItem(EQ::invslot::slotCursor)->GetItem()->ItemClass == 1) {
for(int16 CursorBagSlot = EQ::invbag::CURSOR_BAG_BEGIN; CursorBagSlot <= EQ::invbag::CURSOR_BAG_END; CursorBagSlot++) {
if (m_inv.GetItem(CursorBagSlot)) {
if (m_inv.GetItem(CursorBagSlot)->GetItem()->ID == m_pp.bandoliers[bss->Number].Items[BandolierSlot].ID &&
m_inv.GetItem(CursorBagSlot)->GetCharges() >= 1) { // ditto
slot = CursorBagSlot;
break;
}
}
}
}
}
}
// if the player has this item in their inventory,
if (slot != INVALID_INDEX) {
// Pull the item out of the inventory
BandolierItems[BandolierSlot] = m_inv.PopItem(slot);
// If ammo with charges, only take one charge out to put in the range slot, that is what
// the client does.
if(((BandolierSlot == bandolierAmmo) || (BandolierSlot == bandolierRange)) &&
BandolierItems[BandolierSlot] && BandolierItems[BandolierSlot]->IsStackable()){
int Charges = BandolierItems[BandolierSlot]->GetCharges();
// If there is more than one charge
if(Charges > 1) {
BandolierItems[BandolierSlot]->SetCharges(Charges-1);
// Take one charge out and put the rest back
m_inv.PutItem(slot, *BandolierItems[BandolierSlot]);
database.SaveInventory(character_id, BandolierItems[BandolierSlot], slot);
BandolierItems[BandolierSlot]->SetCharges(1);
}
else { // Remove the item from the inventory
database.SaveInventory(character_id, 0, slot);
}
}
else { // Remove the item from the inventory
database.SaveInventory(character_id, 0, slot);
}
}
else { // The player doesn't have the required weapon with them.
BandolierItems[BandolierSlot] = 0;
if (slot == INVALID_INDEX) {
LogInventory("Character does not have required bandolier item for slot [{}]", WeaponSlot);
EQ::ItemInstance *InvItem = m_inv.PopItem(WeaponSlot);
if(InvItem) {
// If there was an item in that weapon slot, put it in the inventory
LogInventory("returning item [{}] in weapon slot [{}] to inventory",
InvItem->GetItem()->Name, WeaponSlot);
LogInventory("returning item [{}] in weapon slot [{}] to inventory", InvItem->GetItem()->Name, WeaponSlot);
if (MoveItemToInventory(InvItem)) {
database.SaveInventory(character_id, 0, WeaponSlot);
LogError("returning item [{}] in weapon slot [{}] to inventory", InvItem->GetItem()->Name, WeaponSlot);
}
else {
LogError("Char: [{}], ERROR returning [{}] to inventory", GetName(), InvItem->GetItem()->Name);
}
safe_delete(InvItem);
}
}
}
}
}
// Now we move the required weapons into the character weapon slots, and return any items we are replacing
// back to inventory.
//
for(int BandolierSlot = bandolierPrimary; BandolierSlot <= bandolierAmmo; BandolierSlot++) {
// Find the inventory slot corresponding to this bandolier slot
WeaponSlot = BandolierSlotToWeaponSlot(BandolierSlot);
// if there is an item in this Bandolier slot ?
if(m_pp.bandoliers[bss->Number].Items[BandolierSlot].ID) {
// if the player has this item in their inventory, and it is not already where it needs to be
if(BandolierItems[BandolierSlot]) {
// Pull the item that we are going to replace
EQ::ItemInstance *InvItem = m_inv.PopItem(WeaponSlot);
// Put the item specified in the bandolier where it needs to be
m_inv.PutItem(WeaponSlot, *BandolierItems[BandolierSlot]);
safe_delete(BandolierItems[BandolierSlot]);
// Update the database, save the item now in the weapon slot
database.SaveInventory(character_id, m_inv.GetItem(WeaponSlot), WeaponSlot);
if(InvItem) {
// If there was already an item in that weapon slot that we replaced, find a place to put it
if (!MoveItemToInventory(InvItem)) {
LogError("Char: [{}], ERROR returning [{}] to inventory", GetName(), InvItem->GetItem()->Name);
}
safe_delete(InvItem);
}
}
}
else {
// This bandolier set has no item for this slot, so take whatever is in the weapon slot and
// put it in the player's inventory.
EQ::ItemInstance *InvItem = m_inv.PopItem(WeaponSlot);
if(InvItem) {
LogInventory("Bandolier has no item for slot [{}], returning item [{}] to inventory", WeaponSlot, InvItem->GetItem()->Name);
// If there was an item in that weapon slot, put it in the inventory
if (MoveItemToInventory(InvItem)) {
database.SaveInventory(character_id, 0, WeaponSlot);
}
else {
LogError("Char: [{}], ERROR returning [{}] to inventory", GetName(), InvItem->GetItem()->Name);
}
safe_delete(InvItem);
}
}
}
if (RuleI(Character, BandolierSwapDelay) > 0) {
bandolier_throttle_timer.Start(RuleI(Character, BandolierSwapDelay));
}
// finally, recalculate any stat bonuses from the item change
CalcBonuses();
}
bool Client::MoveItemToInventory(EQ::ItemInstance *ItemToReturn, bool UpdateClient) {
// This is a support function for Client::SetBandolier, however it can be used anywhere it's functionality is required.
//
// When the client moves items around as Bandolier sets are activated, it does not send details to the
// server of what item it has moved to which slot. It assumes the server knows what it will do.
//
// The standard EQEmu auto inventory routines do not behave as the client does when manipulating bandoliers.
// The client will look in each main inventory slot. If it finds a bag in a slot, it will then look inside
// the bag for a free slot.
//
// This differs from the standard EQEmu method of looking in all 8 inventory slots first to find an empty slot, and
// then going back and looking in bags. There are also other differences related to how it moves stackable items back
// to inventory.
//
// Rather than alter the current auto inventory behaviour, just in case something
// depends on current behaviour, this routine operates the same as the client when moving items back to inventory when
// swapping bandolier sets.
if (!ItemToReturn) {
return false;
}
LogInventory("Char: [{}] Returning [{}] to inventory", GetName(), ItemToReturn->GetItem()->Name);
uint32 ItemID = ItemToReturn->GetItem()->ID;
// If the item is stackable (ammo in range slot), try stacking it with other items of the same type
//
if(ItemToReturn->IsStackable()) {
for (int16 i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::slotCursor; i++) { // changed slot max to 30 from 29. client will stack into slot 30 (bags too) before moving.
if ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
EQ::ItemInstance* InvItem = m_inv.GetItem(i);
if(InvItem && (InvItem->GetItem()->ID == ItemID) && (InvItem->GetCharges() < InvItem->GetItem()->StackSize)) {
int ChargeSlotsLeft = InvItem->GetItem()->StackSize - InvItem->GetCharges();
int ChargesToMove = ItemToReturn->GetCharges() < ChargeSlotsLeft ? ItemToReturn->GetCharges() : ChargeSlotsLeft;
InvItem->SetCharges(InvItem->GetCharges() + ChargesToMove);
if(UpdateClient)
SendItemPacket(i, InvItem, ItemPacketTrade);
database.SaveInventory(character_id, m_inv.GetItem(i), i);
ItemToReturn->SetCharges(ItemToReturn->GetCharges() - ChargesToMove);
if(!ItemToReturn->GetCharges())
return true;
}
// If there is a bag in this slot, look inside it.
//
if (InvItem && InvItem->IsClassBag()) {
int16 BaseSlotID = EQ::InventoryProfile::CalcSlotId(i, EQ::invbag::SLOT_BEGIN);
uint8 BagSize=InvItem->GetItem()->BagSlots;
uint8 BagSlot;
for (BagSlot = EQ::invbag::SLOT_BEGIN; BagSlot < BagSize; BagSlot++) {
InvItem = m_inv.GetItem(BaseSlotID + BagSlot);
if (InvItem && (InvItem->GetItem()->ID == ItemID) &&
(InvItem->GetCharges() < InvItem->GetItem()->StackSize)) {
int ChargeSlotsLeft = InvItem->GetItem()->StackSize - InvItem->GetCharges();
int ChargesToMove = ItemToReturn->GetCharges() < ChargeSlotsLeft ? ItemToReturn->GetCharges() : ChargeSlotsLeft;
InvItem->SetCharges(InvItem->GetCharges() + ChargesToMove);
if(UpdateClient)
SendItemPacket(BaseSlotID + BagSlot, m_inv.GetItem(BaseSlotID + BagSlot), ItemPacketTrade);
database.SaveInventory(character_id, m_inv.GetItem(BaseSlotID + BagSlot), BaseSlotID + BagSlot);
ItemToReturn->SetCharges(ItemToReturn->GetCharges() - ChargesToMove);
if(!ItemToReturn->GetCharges())
return true;
}
}
}
}
}
// We have tried stacking items, now just try and find an empty slot.
for (int16 i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::slotCursor; i++) { // changed slot max to 30 from 29. client will move into slot 30 (bags too) before pushing onto cursor.
if ((((uint64)1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0)
continue;
EQ::ItemInstance* InvItem = m_inv.GetItem(i);
if (!InvItem) {
// Found available slot in personal inventory
m_inv.PutItem(i, *ItemToReturn);
if(UpdateClient)
SendItemPacket(i, ItemToReturn, ItemPacketTrade);
database.SaveInventory(character_id, m_inv.GetItem(i), i);
LogInventory("Char: [{}] Storing in main inventory slot [{}]", GetName(), i);
return true;
}
if (InvItem->IsClassBag() && EQ::InventoryProfile::CanItemFitInContainer(ItemToReturn->GetItem(), InvItem->GetItem())) {
int16 BaseSlotID = EQ::InventoryProfile::CalcSlotId(i, EQ::invbag::SLOT_BEGIN);
uint8 BagSize=InvItem->GetItem()->BagSlots;
for (uint8 BagSlot = EQ::invbag::SLOT_BEGIN; BagSlot < BagSize; BagSlot++) {
InvItem = m_inv.GetItem(BaseSlotID + BagSlot);
if (!InvItem) {
// Found available slot within bag
m_inv.PutItem(BaseSlotID + BagSlot, *ItemToReturn);
if(UpdateClient)
SendItemPacket(BaseSlotID + BagSlot, ItemToReturn, ItemPacketTrade);
database.SaveInventory(character_id, m_inv.GetItem(BaseSlotID + BagSlot), BaseSlotID + BagSlot);
LogInventory("Char: [{}] Storing in bag slot [{}]", GetName(), BaseSlotID + BagSlot);
return true;
}
}
}
}
// Store on the cursor
//
LogInventory("Char: [{}] No space, putting on the cursor", GetName());
PushItemOnCursor(*ItemToReturn, UpdateClient);
return true;
}
bool Client::InterrogateInventory(Client* requester, bool log, bool silent, bool allowtrip, bool& error, bool autolog)
{
if (!requester)
return false;
std::map<int16, const EQ::ItemInstance*> instmap;
// build reference map
for (int16 index = EQ::invslot::POSSESSIONS_BEGIN; index <= EQ::invslot::POSSESSIONS_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
for (int16 index = EQ::invslot::TRIBUTE_BEGIN; index <= EQ::invslot::TRIBUTE_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
for (int16 index = EQ::invslot::GUILD_TRIBUTE_BEGIN; index <= EQ::invslot::GUILD_TRIBUTE_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
for (int16 index = EQ::invslot::BANK_BEGIN; index <= EQ::invslot::BANK_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
for (int16 index = EQ::invslot::SHARED_BANK_BEGIN; index <= EQ::invslot::SHARED_BANK_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
for (int16 index = EQ::invslot::TRADE_BEGIN; index <= EQ::invslot::TRADE_END; ++index) {
auto inst = m_inv[index];
if (inst == nullptr) { continue; }
instmap[index] = inst;
}
auto tsobject = GetTradeskillObject();
if (tsobject != nullptr) {
for (int16 index = EQ::invslot::SLOT_BEGIN; index < EQ::invtype::WORLD_SIZE; ++index) {
auto inst = tsobject->GetItem(index);
if (inst == nullptr) { continue; }
instmap[EQ::invslot::WORLD_BEGIN + index] = inst;
}
}
int limbo = 0;
for (auto cursor_itr = m_inv.cursor_cbegin(); cursor_itr != m_inv.cursor_cend(); ++cursor_itr, ++limbo) {
// m_inv.cursor_begin() is referenced as SlotCursor in MapPossessions above
if (cursor_itr == m_inv.cursor_cbegin())
continue;
instmap[EQ::invbag::CURSOR_BAG_BEGIN + limbo] = *cursor_itr;
}
// call InterrogateInventory_ for error check
for (auto instmap_itr = instmap.begin(); (instmap_itr != instmap.end()) && (!error); ++instmap_itr) {
InterrogateInventory_(true, requester, instmap_itr->first, INVALID_INDEX, instmap_itr->second, nullptr, log, silent, error, 0);
}
if (autolog && error && (!log))
log = true;
if (log) {
LogError("Client::InterrogateInventory() called for [{}] by [{}] with an error state of [{}]", GetName(), requester->GetName(), (error ? "TRUE" : "FALSE"));
}
if (!silent) {
requester->Message(Chat::Default, "--- Inventory Interrogation Report for %s (requested by: %s, error state: %s) ---", GetName(), requester->GetName(), (error ? "TRUE" : "FALSE"));
}
// call InterrogateInventory_ for report
for (auto instmap_itr = instmap.begin(); (instmap_itr != instmap.end()); ++instmap_itr) {
InterrogateInventory_(false, requester, instmap_itr->first, INVALID_INDEX, instmap_itr->second, nullptr, log, silent, error, 0);
}
if (error) {
Message(Chat::Red, "An error has been discovered in your inventory!");
Message(Chat::Red, "Do not log out, zone or re-arrange items until this");
Message(Chat::Red, "issue has been resolved or item loss may occur!");
if (allowtrip)
TripInterrogateInvState();
}
if (log) {
LogError("Target interrogate inventory flag: [{}]", (GetInterrogateInvState() ? "TRUE" : "FALSE"));
}
if (!silent) {
requester->Message(Chat::Default, "Target interrogation flag: %s", (GetInterrogateInvState() ? "TRUE" : "FALSE"));
requester->Message(Chat::Default, "--- End of Interrogation Report ---");
}
instmap.clear();
return true;
}
void Client::InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const EQ::ItemInstance* inst, const EQ::ItemInstance* parent, bool log, bool silent, bool &error, int depth)
{
if (depth >= 10) {
LogDebug("[CLIENT] Client::InterrogateInventory_() - Recursion count has exceeded the maximum allowable (You have a REALLY BIG PROBLEM!!)");
return;
}
if (errorcheck) {
if (InterrogateInventory_error(head, index, inst, parent, depth)) {
error = true;
}
else {
if (inst) {
for (int16 sub = EQ::invbag::SLOT_BEGIN; (sub <= EQ::invbag::SLOT_END) && (!error); ++sub) { // treat any EQ::ItemInstance as having the max internal slots available
if (inst->GetItem(sub))
InterrogateInventory_(true, requester, head, sub, inst->GetItem(sub), inst, log, silent, error, depth + 1);
}
}
}
}
else {
bool localerror = InterrogateInventory_error(head, index, inst, parent, depth);
std::string i;
std::string p;
std::string e;
if (inst) { i = StringFormat("%s (id: %u, cls: %u, aug_t: %u)", inst->GetItem()->Name, inst->GetItem()->ID, inst->GetItem()->ItemClass, inst->GetItem()->AugType); }
else { i = "NONE"; }
if (parent) { p = StringFormat("%s (id: %u, cls: %u, aug_t: %u), index: %i", parent->GetItem()->Name, parent->GetItem()->ID, parent->GetItem()->ItemClass, parent->GetItem()->AugType, index); }
else { p = "NONE"; }
if (localerror) { e = " [ERROR]"; }
else { e = ""; }
if (log) {
LogError("Head: [{}], Depth: [{}], Instance: [{}], Parent: [{}][{}]",
head, depth, i.c_str(), p.c_str(), e.c_str());
}
if (!silent) {
requester->Message(Chat::Gray, "%i:%i - inst: %s - parent: %s%s",
head, depth, i.c_str(), p.c_str(), e.c_str());
}
if (inst) {
for (int16 sub = EQ::invbag::SLOT_BEGIN; (sub <= EQ::invbag::SLOT_END); ++sub) {
if (inst->GetItem(sub))
InterrogateInventory_(false, requester, head, sub, inst->GetItem(sub), inst, log, silent, error, depth + 1);
}
}
}
return;
}
bool Client::InterrogateInventory_error(int16 head, int16 index, const EQ::ItemInstance* inst, const EQ::ItemInstance* parent, int depth)
{
// very basic error checking - can be elaborated upon if more in-depth testing is needed...
if (
EQ::ValueWithin(head, EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END) ||
EQ::ValueWithin(head, EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END) ||
EQ::ValueWithin(head, EQ::invslot::GUILD_TRIBUTE_BEGIN, EQ::invslot::GUILD_TRIBUTE_END) ||
EQ::ValueWithin(head, EQ::invslot::WORLD_BEGIN, EQ::invslot::WORLD_END) ||
EQ::ValueWithin(head, EQ::invbag::CURSOR_BAG_BEGIN, EQ::invbag::CURSOR_BAG_END)
) {
switch (depth)
{
case 0: // requirement: inst is extant
if (!inst)
return true;
break;
case 1: // requirement: parent is common and inst is augment
if ((!parent) || (!inst))
return true;
if (!parent->IsType(EQ::item::ItemClassCommon))
return true;
if (index > EQ::invaug::SOCKET_END)
return true;
break;
default: // requirement: none (something bad happened...)
return true;
}
}
else if (
(head >= EQ::invslot::GENERAL_BEGIN && head <= EQ::invslot::GENERAL_END) ||
(head == EQ::invslot::slotCursor) ||
(head >= EQ::invslot::BANK_BEGIN && head <= EQ::invslot::BANK_END) ||
(head >= EQ::invslot::SHARED_BANK_BEGIN && head <= EQ::invslot::SHARED_BANK_END) ||
(head >= EQ::invslot::TRADE_BEGIN && head <= EQ::invslot::TRADE_END)) {
switch (depth)
{
case 0: // requirement: inst is extant
if (!inst)
return true;
break;
case 1: // requirement: parent is common and inst is augment ..or.. parent is container and inst is extant
if ((!parent) || (!inst))
return true;
if (parent->IsType(EQ::item::ItemClassBag))
break;
if (parent->IsClassBook())
return true;
if (parent->IsClassCommon()) {
if (!(inst->GetItem()->AugType > 0))
return true;
if (index > EQ::invaug::SOCKET_END)
return true;
}
break;
case 2: // requirement: parent is common and inst is augment
if ((!parent) || (!inst))
return true;
if (parent->IsType(EQ::item::ItemClassBag))
return true;
if (parent->IsClassBook())
return true;
if (parent->IsClassCommon()) {
if (!(inst->GetItem()->AugType > 0))
return true;
if (index > EQ::invaug::SOCKET_END)
return true;
}
break;
default: // requirement: none (something bad happened again...)
return true;
}
}
else {
return true;
}
return false;
}
void EQ::InventoryProfile::SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, const std::string &value) {
EQ::ItemInstance *inst = GetItem(slot_id);
if(inst) {
inst->SetCustomData(identifier, value);
database.SaveInventory(character_id, inst, slot_id);
}
}
void EQ::InventoryProfile::SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, int value) {
EQ::ItemInstance *inst = GetItem(slot_id);
if(inst) {
inst->SetCustomData(identifier, value);
database.SaveInventory(character_id, inst, slot_id);
}
}
void EQ::InventoryProfile::SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, float value) {
EQ::ItemInstance *inst = GetItem(slot_id);
if(inst) {
inst->SetCustomData(identifier, value);
database.SaveInventory(character_id, inst, slot_id);
}
}
void EQ::InventoryProfile::SetCustomItemData(uint32 character_id, int16 slot_id, const std::string &identifier, bool value) {
EQ::ItemInstance *inst = GetItem(slot_id);
if(inst) {
inst->SetCustomData(identifier, value);
database.SaveInventory(character_id, inst, slot_id);
}
}
std::string EQ::InventoryProfile::GetCustomItemData(int16 slot_id, const std::string &identifier) {
EQ::ItemInstance *inst = GetItem(slot_id);
if(inst) {
return inst->GetCustomData(identifier);
}
return "";
}
const int EQ::InventoryProfile::GetItemStatValue(uint32 item_id, const std::string &identifier) {
if (identifier.empty()) {
return 0;
}
const auto* inst = database.CreateItem(item_id);
if (!inst) {
return 0;
}
const auto* item = inst->GetItem();
if (!item) {
return 0;
}
int stat = 0;
if (Strings::EqualFold(identifier, "itemclass")) {
stat = static_cast<int>(item->ItemClass);
}
if (Strings::EqualFold(identifier, "id")) {
stat = static_cast<int>(item->ID);
}
if (Strings::EqualFold(identifier, "idfile")) {
stat = Strings::IsNumber(&item->IDFile[2]) ? Strings::ToInt(&item->IDFile[2]) : 0;
}
if (Strings::EqualFold(identifier, "weight")) {
stat = static_cast<int>(item->Weight);
}
if (Strings::EqualFold(identifier, "norent")) {
stat = static_cast<int>(item->NoRent);
}
if (Strings::EqualFold(identifier, "nodrop")) {
stat = static_cast<int>(item->NoDrop);
}
if (Strings::EqualFold(identifier, "size")) {
stat = static_cast<int>(item->Size);
}
if (Strings::EqualFold(identifier, "slots")) {
stat = static_cast<int>(item->Slots);
}
if (Strings::EqualFold(identifier, "price")) {
stat = static_cast<int>(item->Price);
}
if (Strings::EqualFold(identifier, "icon")) {
stat = static_cast<int>(item->Icon);
}
if (Strings::EqualFold(identifier, "loregroup")) {
stat = static_cast<int>(item->LoreGroup);
}
if (Strings::EqualFold(identifier, "loreflag")) {
stat = static_cast<int>(item->LoreFlag);
}
if (Strings::EqualFold(identifier, "pendingloreflag")) {
stat = static_cast<int>(item->PendingLoreFlag);
}
if (Strings::EqualFold(identifier, "artifactflag")) {
stat = static_cast<int>(item->ArtifactFlag);
}
if (Strings::EqualFold(identifier, "summonedflag")) {
stat = static_cast<int>(item->SummonedFlag);
}
if (Strings::EqualFold(identifier, "fvnodrop")) {
stat = static_cast<int>(item->FVNoDrop);
}
if (Strings::EqualFold(identifier, "favor")) {
stat = static_cast<int>(item->Favor);
}
if (Strings::EqualFold(identifier, "guildfavor")) {
stat = static_cast<int>(item->GuildFavor);
}
if (Strings::EqualFold(identifier, "pointtype")) {
stat = static_cast<int>(item->PointType);
}
if (Strings::EqualFold(identifier, "bagtype")) {
stat = static_cast<int>(item->BagType);
}
if (Strings::EqualFold(identifier, "bagslots")) {
stat = static_cast<int>(item->BagSlots);
}
if (Strings::EqualFold(identifier, "bagsize")) {
stat = static_cast<int>(item->BagSize);
}
if (Strings::EqualFold(identifier, "bagwr")) {
stat = static_cast<int>(item->BagWR);
}
if (Strings::EqualFold(identifier, "benefitflag")) {
stat = static_cast<int>(item->BenefitFlag);
}
if (Strings::EqualFold(identifier, "tradeskills")) {
stat = static_cast<int>(item->Tradeskills);
}
if (Strings::EqualFold(identifier, "cr")) {
stat = static_cast<int>(item->CR);
}
if (Strings::EqualFold(identifier, "dr")) {
stat = static_cast<int>(item->DR);
}
if (Strings::EqualFold(identifier, "pr")) {
stat = static_cast<int>(item->PR);
}
if (Strings::EqualFold(identifier, "mr")) {
stat = static_cast<int>(item->MR);
}
if (Strings::EqualFold(identifier, "fr")) {
stat = static_cast<int>(item->FR);
}
if (Strings::EqualFold(identifier, "astr")) {
stat = static_cast<int>(item->AStr);
}
if (Strings::EqualFold(identifier, "asta")) {
stat = static_cast<int>(item->ASta);
}
if (Strings::EqualFold(identifier, "aagi")) {
stat = static_cast<int>(item->AAgi);
}
if (Strings::EqualFold(identifier, "adex")) {
stat = static_cast<int>(item->ADex);
}
if (Strings::EqualFold(identifier, "acha")) {
stat = static_cast<int>(item->ACha);
}
if (Strings::EqualFold(identifier, "aint")) {
stat = static_cast<int>(item->AInt);
}
if (Strings::EqualFold(identifier, "awis")) {
stat = static_cast<int>(item->AWis);
}
if (Strings::EqualFold(identifier, "hp")) {
stat = static_cast<int>(item->HP);
}
if (Strings::EqualFold(identifier, "mana")) {
stat = static_cast<int>(item->Mana);
}
if (Strings::EqualFold(identifier, "ac")) {
stat = static_cast<int>(item->AC);
}
if (Strings::EqualFold(identifier, "deity")) {
stat = static_cast<int>(item->Deity);
}
if (Strings::EqualFold(identifier, "skillmodvalue")) {
stat = static_cast<int>(item->SkillModValue);
}
if (Strings::EqualFold(identifier, "skillmodtype")) {
stat = static_cast<int>(item->SkillModType);
}
if (Strings::EqualFold(identifier, "banedmgrace")) {
stat = static_cast<int>(item->BaneDmgRace);
}
if (Strings::EqualFold(identifier, "banedmgamt")) {
stat = static_cast<int>(item->BaneDmgAmt);
}
if (Strings::EqualFold(identifier, "banedmgbody")) {
stat = static_cast<int>(item->BaneDmgBody);
}
if (Strings::EqualFold(identifier, "magic")) {
stat = static_cast<int>(item->Magic);
}
if (Strings::EqualFold(identifier, "casttime_")) {
stat = static_cast<int>(item->CastTime_);
}
if (Strings::EqualFold(identifier, "reqlevel")) {
stat = static_cast<int>(item->ReqLevel);
}
if (Strings::EqualFold(identifier, "bardtype")) {
stat = static_cast<int>(item->BardType);
}
if (Strings::EqualFold(identifier, "bardvalue")) {
stat = static_cast<int>(item->BardValue);
}
if (Strings::EqualFold(identifier, "light")) {
stat = static_cast<int>(item->Light);
}
if (Strings::EqualFold(identifier, "delay")) {
stat = static_cast<int>(item->Delay);
}
if (Strings::EqualFold(identifier, "reclevel")) {
stat = static_cast<int>(item->RecLevel);
}
if (Strings::EqualFold(identifier, "recskill")) {
stat = static_cast<int>(item->RecSkill);
}
if (Strings::EqualFold(identifier, "elemdmgtype")) {
stat = static_cast<int>(item->ElemDmgType);
}
if (Strings::EqualFold(identifier, "elemdmgamt")) {
stat = static_cast<int>(item->ElemDmgAmt);
}
if (Strings::EqualFold(identifier, "range")) {
stat = static_cast<int>(item->Range);
}
if (Strings::EqualFold(identifier, "damage")) {
stat = static_cast<int>(item->Damage);
}
if (Strings::EqualFold(identifier, "color")) {
stat = static_cast<int>(item->Color);
}
if (Strings::EqualFold(identifier, "classes")) {
stat = static_cast<int>(item->Classes);
}
if (Strings::EqualFold(identifier, "races")) {
stat = static_cast<int>(item->Races);
}
if (Strings::EqualFold(identifier, "maxcharges")) {
stat = static_cast<int>(item->MaxCharges);
}
if (Strings::EqualFold(identifier, "itemtype")) {
stat = static_cast<int>(item->ItemType);
}
if (Strings::EqualFold(identifier, "material")) {
stat = static_cast<int>(item->Material);
}
if (Strings::EqualFold(identifier, "casttime")) {
stat = static_cast<int>(item->CastTime);
}
if (Strings::EqualFold(identifier, "elitematerial")) {
stat = static_cast<int>(item->EliteMaterial);
}
if (Strings::EqualFold(identifier, "herosforgemodel")) {
stat = static_cast<int>(item->HerosForgeModel);
}
if (Strings::EqualFold(identifier, "procrate")) {
stat = static_cast<int>(item->ProcRate);
}
if (Strings::EqualFold(identifier, "combateffects")) {
stat = static_cast<int>(item->CombatEffects);
}
if (Strings::EqualFold(identifier, "shielding")) {
stat = static_cast<int>(item->Shielding);
}
if (Strings::EqualFold(identifier, "stunresist")) {
stat = static_cast<int>(item->StunResist);
}
if (Strings::EqualFold(identifier, "strikethrough")) {
stat = static_cast<int>(item->StrikeThrough);
}
if (Strings::EqualFold(identifier, "extradmgskill")) {
stat = static_cast<int>(item->ExtraDmgSkill);
}
if (Strings::EqualFold(identifier, "extradmgamt")) {
stat = static_cast<int>(item->ExtraDmgAmt);
}
if (Strings::EqualFold(identifier, "spellshield")) {
stat = static_cast<int>(item->SpellShield);
}
if (Strings::EqualFold(identifier, "avoidance")) {
stat = static_cast<int>(item->Avoidance);
}
if (Strings::EqualFold(identifier, "accuracy")) {
stat = static_cast<int>(item->Accuracy);
}
if (Strings::EqualFold(identifier, "charmfileid")) {
stat = static_cast<int>(item->CharmFileID);
}
if (Strings::EqualFold(identifier, "factionmod1")) {
stat = static_cast<int>(item->FactionMod1);
}
if (Strings::EqualFold(identifier, "factionmod2")) {
stat = static_cast<int>(item->FactionMod2);
}
if (Strings::EqualFold(identifier, "factionmod3")) {
stat = static_cast<int>(item->FactionMod3);
}
if (Strings::EqualFold(identifier, "factionmod4")) {
stat = static_cast<int>(item->FactionMod4);
}
if (Strings::EqualFold(identifier, "factionamt1")) {
stat = static_cast<int>(item->FactionAmt1);
}
if (Strings::EqualFold(identifier, "factionamt2")) {
stat = static_cast<int>(item->FactionAmt2);
}
if (Strings::EqualFold(identifier, "factionamt3")) {
stat = static_cast<int>(item->FactionAmt3);
}
if (Strings::EqualFold(identifier, "factionamt4")) {
stat = static_cast<int>(item->FactionAmt4);
}
if (Strings::EqualFold(identifier, "augtype")) {
stat = static_cast<int>(item->AugType);
}
if (Strings::EqualFold(identifier, "ldontheme")) {
stat = static_cast<int>(item->LDoNTheme);
}
if (Strings::EqualFold(identifier, "ldonprice")) {
stat = static_cast<int>(item->LDoNPrice);
}
if (Strings::EqualFold(identifier, "ldonsold")) {
stat = static_cast<int>(item->LDoNSold);
}
if (Strings::EqualFold(identifier, "banedmgraceamt")) {
stat = static_cast<int>(item->BaneDmgRaceAmt);
}
if (Strings::EqualFold(identifier, "augrestrict")) {
stat = static_cast<int>(item->AugRestrict);
}
if (Strings::EqualFold(identifier, "endur")) {
stat = static_cast<int>(item->Endur);
}
if (Strings::EqualFold(identifier, "dotshielding")) {
stat = static_cast<int>(item->DotShielding);
}
if (Strings::EqualFold(identifier, "attack")) {
stat = static_cast<int>(item->Attack);
}
if (Strings::EqualFold(identifier, "regen")) {
stat = static_cast<int>(item->Regen);
}
if (Strings::EqualFold(identifier, "manaregen")) {
stat = static_cast<int>(item->ManaRegen);
}
if (Strings::EqualFold(identifier, "enduranceregen")) {
stat = static_cast<int>(item->EnduranceRegen);
}
if (Strings::EqualFold(identifier, "haste")) {
stat = static_cast<int>(item->Haste);
}
if (Strings::EqualFold(identifier, "damageshield")) {
stat = static_cast<int>(item->DamageShield);
}
if (Strings::EqualFold(identifier, "recastdelay")) {
stat = static_cast<int>(item->RecastDelay);
}
if (Strings::EqualFold(identifier, "recasttype")) {
stat = static_cast<int>(item->RecastType);
}
if (Strings::EqualFold(identifier, "augdistiller")) {
stat = static_cast<int>(item->AugDistiller);
}
if (Strings::EqualFold(identifier, "attuneable")) {
stat = static_cast<int>(item->Attuneable);
}
if (Strings::EqualFold(identifier, "nopet")) {
stat = static_cast<int>(item->NoPet);
}
if (Strings::EqualFold(identifier, "potionbelt")) {
stat = static_cast<int>(item->PotionBelt);
}
if (Strings::EqualFold(identifier, "stackable")) {
stat = static_cast<int>(item->Stackable);
}
if (Strings::EqualFold(identifier, "notransfer")) {
stat = static_cast<int>(item->NoTransfer);
}
if (Strings::EqualFold(identifier, "questitemflag")) {
stat = static_cast<int>(item->QuestItemFlag);
}
if (Strings::EqualFold(identifier, "stacksize")) {
stat = static_cast<int>(item->StackSize);
}
if (Strings::EqualFold(identifier, "potionbeltslots")) {
stat = static_cast<int>(item->PotionBeltSlots);
}
if (Strings::EqualFold(identifier, "book")) {
stat = static_cast<int>(item->Book);
}
if (Strings::EqualFold(identifier, "booktype")) {
stat = static_cast<int>(item->BookType);
}
if (Strings::EqualFold(identifier, "svcorruption")) {
stat = static_cast<int>(item->SVCorruption);
}
if (Strings::EqualFold(identifier, "purity")) {
stat = static_cast<int>(item->Purity);
}
if (Strings::EqualFold(identifier, "backstabdmg")) {
stat = static_cast<int>(item->BackstabDmg);
}
if (Strings::EqualFold(identifier, "dsmitigation")) {
stat = static_cast<int>(item->DSMitigation);
}
if (Strings::EqualFold(identifier, "heroicstr")) {
stat = static_cast<int>(item->HeroicStr);
}
if (Strings::EqualFold(identifier, "heroicint")) {
stat = static_cast<int>(item->HeroicInt);
}
if (Strings::EqualFold(identifier, "heroicwis")) {
stat = static_cast<int>(item->HeroicWis);
}
if (Strings::EqualFold(identifier, "heroicagi")) {
stat = static_cast<int>(item->HeroicAgi);
}
if (Strings::EqualFold(identifier, "heroicdex")) {
stat = static_cast<int>(item->HeroicDex);
}
if (Strings::EqualFold(identifier, "heroicsta")) {
stat = static_cast<int>(item->HeroicSta);
}
if (Strings::EqualFold(identifier, "heroiccha")) {
stat = static_cast<int>(item->HeroicCha);
}
if (Strings::EqualFold(identifier, "heroicmr")) {
stat = static_cast<int>(item->HeroicMR);
}
if (Strings::EqualFold(identifier, "heroicfr")) {
stat = static_cast<int>(item->HeroicFR);
}
if (Strings::EqualFold(identifier, "heroiccr")) {
stat = static_cast<int>(item->HeroicCR);
}
if (Strings::EqualFold(identifier, "heroicdr")) {
stat = static_cast<int>(item->HeroicDR);
}
if (Strings::EqualFold(identifier, "heroicpr")) {
stat = static_cast<int>(item->HeroicPR);
}
if (Strings::EqualFold(identifier, "heroicsvcorrup")) {
stat = static_cast<int>(item->HeroicSVCorrup);
}
if (Strings::EqualFold(identifier, "healamt")) {
stat = static_cast<int>(item->HealAmt);
}
if (Strings::EqualFold(identifier, "spelldmg")) {
stat = static_cast<int>(item->SpellDmg);
}
if (Strings::EqualFold(identifier, "ldonsellbackrate")) {
stat = static_cast<int>(item->LDoNSellBackRate);
}
if (Strings::EqualFold(identifier, "scriptfileid")) {
stat = static_cast<int>(item->ScriptFileID);
}
if (Strings::EqualFold(identifier, "expendablearrow")) {
stat = static_cast<int>(item->ExpendableArrow);
}
if (Strings::EqualFold(identifier, "clairvoyance")) {
stat = static_cast<int>(item->Clairvoyance);
}
if (Strings::EqualFold(identifier, "clickeffect")) {
stat = static_cast<int>(item->Click.Effect);
}
if (Strings::EqualFold(identifier, "clicktype")) {
stat = static_cast<int>(item->Click.Type);
}
if (Strings::EqualFold(identifier, "clicklevel")) {
stat = static_cast<int>(item->Click.Level);
}
if (Strings::EqualFold(identifier, "clicklevel2")) {
stat = static_cast<int>(item->Click.Level2);
}
if (Strings::EqualFold(identifier, "proceffect")) {
stat = static_cast<int>(item->Proc.Effect);
}
if (Strings::EqualFold(identifier, "proctype")) {
stat = static_cast<int>(item->Proc.Type);
}
if (Strings::EqualFold(identifier, "proclevel")) {
stat = static_cast<int>(item->Proc.Level);
}
if (Strings::EqualFold(identifier, "proclevel2")) {
stat = static_cast<int>(item->Proc.Level2);
}
if (Strings::EqualFold(identifier, "worneffect")) {
stat = static_cast<int>(item->Worn.Effect);
}
if (Strings::EqualFold(identifier, "worntype")) {
stat = static_cast<int>(item->Worn.Type);
}
if (Strings::EqualFold(identifier, "wornlevel")) {
stat = static_cast<int>(item->Worn.Level);
}
if (Strings::EqualFold(identifier, "wornlevel2")) {
stat = static_cast<int>(item->Worn.Level2);
}
if (Strings::EqualFold(identifier, "focuseffect")) {
stat = static_cast<int>(item->Focus.Effect);
}
if (Strings::EqualFold(identifier, "focustype")) {
stat = static_cast<int>(item->Focus.Type);
}
if (Strings::EqualFold(identifier, "focuslevel")) {
stat = static_cast<int>(item->Focus.Level);
}
if (Strings::EqualFold(identifier, "focuslevel2")) {
stat = static_cast<int>(item->Focus.Level2);
}
if (Strings::EqualFold(identifier, "scrolleffect")) {
stat = static_cast<int>(item->Scroll.Effect);
}
if (Strings::EqualFold(identifier, "scrolltype")) {
stat = static_cast<int>(item->Scroll.Type);
}
if (Strings::EqualFold(identifier, "scrolllevel")) {
stat = static_cast<int>(item->Scroll.Level);
}
if (Strings::EqualFold(identifier, "scrolllevel2")) {
stat = static_cast<int>(item->Scroll.Level2);
}
if (Strings::EqualFold(identifier, "augslot1type")) {
stat = static_cast<int>(item->AugSlotType[0]);
}
if (Strings::EqualFold(identifier, "augslot2type")) {
stat = static_cast<int>(item->AugSlotType[1]);
}
if (Strings::EqualFold(identifier, "augslot3type")) {
stat = static_cast<int>(item->AugSlotType[2]);
}
if (Strings::EqualFold(identifier, "augslot4type")) {
stat = static_cast<int>(item->AugSlotType[3]);
}
if (Strings::EqualFold(identifier, "augslot5type")) {
stat = static_cast<int>(item->AugSlotType[4]);
}
if (Strings::EqualFold(identifier, "augslot6type")) {
stat = static_cast<int>(item->AugSlotType[5]);
}
if (Strings::EqualFold(identifier, "augslot1visible")) {
stat = static_cast<int>(item->AugSlotVisible[0]);
}
if (Strings::EqualFold(identifier, "augslot2visible")) {
stat = static_cast<int>(item->AugSlotVisible[1]);
}
if (Strings::EqualFold(identifier, "augslot3visible")) {
stat = static_cast<int>(item->AugSlotVisible[2]);
}
if (Strings::EqualFold(identifier, "augslot4visible")) {
stat = static_cast<int>(item->AugSlotVisible[3]);
}
if (Strings::EqualFold(identifier, "augslot5visible")) {
stat = static_cast<int>(item->AugSlotVisible[4]);
}
if (Strings::EqualFold(identifier, "augslot6visible")) {
stat = static_cast<int>(item->AugSlotVisible[5]);
}
safe_delete(inst);
return stat;
}
// Returns a slot's item ID (returns INVALID_ID if not found)
int32 Bot::GetItemIDAt(int16 slot_id) {
if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
return INVALID_ID;
}
}
const EQ::ItemInstance* inst = m_inv[slot_id];
if (inst)
return inst->GetItem()->ID;
// None found
return INVALID_ID;
}
// Returns an augment's ID that's in an item (returns INVALID_ID if not found)
// Pass in the slot ID of the item and which augslot you want to check (0-5)
int32 Bot::GetAugmentIDAt(int16 slot_id, uint8 augslot) {
if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
if ((((uint64)1 << slot_id) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
if ((((uint64)1 << temp_slot) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
if ((slot_id - EQ::invslot::BANK_BEGIN) >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
return INVALID_ID;
}
}
else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
if (temp_slot >= GetInv().GetLookup()->InventoryTypeSize.Bank) {
return INVALID_ID;
}
}
const EQ::ItemInstance* inst = m_inv[slot_id];
if (inst && inst->GetAugmentItemID(augslot)) {
return inst->GetAugmentItemID(augslot);
}
// None found
return INVALID_ID;
}
bool Client::IsAugmentRestricted(uint8 item_type, uint32 augment_restriction)
{
switch (augment_restriction) {
case EQ::item::AugRestrictionAny:
break;
case EQ::item::AugRestrictionArmor:
switch (item_type) {
case EQ::item::ItemTypeArmor:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionWeapons:
switch (item_type) {
case EQ::item::ItemType1HSlash:
case EQ::item::ItemType1HBlunt:
case EQ::item::ItemType1HPiercing:
case EQ::item::ItemTypeMartial:
case EQ::item::ItemType2HSlash:
case EQ::item::ItemType2HBlunt:
case EQ::item::ItemType2HPiercing:
case EQ::item::ItemTypeBow:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction1HWeapons:
switch (item_type) {
case EQ::item::ItemType1HSlash:
case EQ::item::ItemType1HBlunt:
case EQ::item::ItemType1HPiercing:
case EQ::item::ItemTypeMartial:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction2HWeapons:
switch (item_type) {
case EQ::item::ItemType2HSlash:
case EQ::item::ItemType2HBlunt:
case EQ::item::ItemType2HPiercing:
case EQ::item::ItemTypeBow:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction1HSlash:
switch (item_type) {
case EQ::item::ItemType1HSlash:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction1HBlunt:
switch (item_type) {
case EQ::item::ItemType1HBlunt:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionPiercing:
switch (item_type) {
case EQ::item::ItemType1HPiercing:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionHandToHand:
switch (item_type) {
case EQ::item::ItemTypeMartial:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction2HSlash:
switch (item_type) {
case EQ::item::ItemType2HSlash:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction2HBlunt:
switch (item_type) {
case EQ::item::ItemType2HBlunt:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction2HPierce:
switch (item_type) {
case EQ::item::ItemType2HPiercing:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionBows:
switch (item_type) {
case EQ::item::ItemTypeBow:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionShields:
switch (item_type) {
case EQ::item::ItemTypeShield:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction1HSlash1HBluntOrHandToHand:
switch (item_type) {
case EQ::item::ItemType1HSlash:
case EQ::item::ItemType1HBlunt:
case EQ::item::ItemTypeMartial:
break;
default:
return true;
}
break;
case EQ::item::AugRestriction1HBluntOrHandToHand:
switch (item_type) {
case EQ::item::ItemType1HBlunt:
case EQ::item::ItemTypeMartial:
break;
default:
return true;
}
break;
case EQ::item::AugRestrictionUnknown1:
case EQ::item::AugRestrictionUnknown2:
case EQ::item::AugRestrictionUnknown3:
default:
return true;
}
return false;
}
void Client::SummonItemIntoInventory(
uint32 item_id,
int16 charges,
uint32 aug1,
uint32 aug2,
uint32 aug3,
uint32 aug4,
uint32 aug5,
uint32 aug6,
bool is_attuned
)
{
auto *inst = database.CreateItem(
item_id,
charges,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6,
is_attuned
);
if (!inst) {
return;
}
// Try stacking first if the item is stackable, then fall back to finding a free slot
if (!PutItemInInventoryWithStacking(inst)) {
// PutItemInInventoryWithStacking failed, fall back to original behavior
const bool is_arrow = inst->GetItem()->ItemType == EQ::item::ItemTypeArrow;
const int16 slot_id = m_inv.FindFreeSlot(
inst->IsClassBag(),
true,
inst->GetItem()->Size,
is_arrow
);
SummonItem(
item_id,
charges,
aug1,
aug2,
aug3,
aug4,
aug5,
aug6,
is_attuned,
slot_id
);
}
safe_delete(inst);
}
bool Client::HasItemOnCorpse(uint32 item_id)
{
auto corpses = CharacterCorpsesRepository::GetWhere(database, fmt::format("charid = {}", CharacterID()));
if (corpses.empty()) {
return false;
}
std::vector<uint32> corpse_ids;
corpse_ids.reserve(corpses.size());
for (auto &corpse : corpses) {
corpse_ids.push_back(corpse.id);
}
auto items = CharacterCorpseItemsRepository::GetWhere(
database,
fmt::format(
"corpse_id IN ({})",
Strings::Join(corpse_ids, ",")
)
);
for (auto &item : items) {
if (item.item_id == item_id) {
return true;
}
if (item.aug_1 == item_id || item.aug_2 == item_id ||
item.aug_3 == item_id || item.aug_4 == item_id ||
item.aug_5 == item_id || item.aug_6 == item_id) {
return true;
}
}
return false;
}
bool Client::PutItemInInventoryWithStacking(EQ::ItemInstance *inst)
{
auto free_id = GetInv().FindFirstFreeSlotThatFitsItem(inst->GetItem());
if (inst->IsStackable()) {
if (TryStacking(inst, ItemPacketTrade, true, false)) {
return true;
}
}
// Protect equipment slots (0-22) from being overwritten
if (free_id != INVALID_INDEX && !EQ::ValueWithin(free_id, EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END)) {
if (PutItemInInventory(free_id, *inst, true)) {
return true;
}
}
return false;
};
bool Client::FindNumberOfFreeInventorySlotsWithSizeCheck(std::vector<BuyerLineTradeItems_Struct> items)
{
uint32 count = 0;
for (int16 i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
if ((((uint64) 1 << i) & GetInv().GetLookup()->PossessionsBitmask) == 0) {
continue;
}
EQ::ItemInstance *inv_item = GetInv().GetItem(i);
if (!inv_item) {
// Found available slot in personal inventory. Fits all sizes
count++;
}
if (count >= items.size()) {
return true;
}
if (inv_item->IsClassBag()) {
for (auto const& item:items) {
auto item_tmp = database.GetItem(item.item_id);
if (EQ::InventoryProfile::CanItemFitInContainer(item_tmp, inv_item->GetItem())) {
int16 base_slot_id = EQ::InventoryProfile::CalcSlotId(i, EQ::invbag::SLOT_BEGIN);
uint8 bag_size = inv_item->GetItem()->BagSlots;
for (uint8 bag_slot = EQ::invbag::SLOT_BEGIN; bag_slot < bag_size; bag_slot++) {
auto bag_item = GetInv().GetItem(base_slot_id + bag_slot);
if (!bag_item) {
// Found a bag slot that fits the item
count++;
}
}
if (count >= items.size()) {
return true;
}
}
}
}
}
return false;
};
Reference in New Issue View Git Blame Copy Permalink