Bag.cpp

浏览该文件的文档.

#include "inventory/Bag.h"
#include "inventory/InventorySystem.h"
 
#include <algorithm>
 
namespace eve::inventory {
 
Bag::Bag(int slotCount) {
    if (slotCount < 0) slotCount = 0;
    slots_.assign(size_t(slotCount), ItemStack{});
}
 
void Bag::destroy() { delete this; }
 
void Bag::setSlotCount(int slotCount) {
    if (slotCount < 0) slotCount = 0;
    slots_.resize(size_t(slotCount));
}
 
void Bag::clearAcceptTags() { acceptTags_.clear(); }
 
void Bag::addAcceptTag(const std::string &tag) {
    if (tag.empty()) return;
    if (std::find(acceptTags_.begin(), acceptTags_.end(), tag) == acceptTags_.end())
        acceptTags_.push_back(tag);
}
 
int Bag::getAcceptTagCount() const { return int(acceptTags_.size()); }
 
std::string Bag::getAcceptTag(int index) const {
    if (index < 0 || index >= int(acceptTags_.size())) return {};
    return acceptTags_[size_t(index)];
}
 
void Bag::clearRejectTags() { rejectTags_.clear(); }
 
void Bag::addRejectTag(const std::string &tag) {
    if (tag.empty()) return;
    if (std::find(rejectTags_.begin(), rejectTags_.end(), tag) == rejectTags_.end())
        rejectTags_.push_back(tag);
}
 
int Bag::getRejectTagCount() const { return int(rejectTags_.size()); }
 
std::string Bag::getRejectTag(int index) const {
    if (index < 0 || index >= int(rejectTags_.size())) return {};
    return rejectTags_[size_t(index)];
}
 
void Bag::setExtra(const std::string &key, const std::string &value) { extra_[key] = value; }
 
std::string Bag::getExtra(const std::string &key, const std::string &fallback) const {
    auto it = extra_.find(key);
    return it == extra_.end() ? fallback : it->second;
}
 
bool Bag::canAddItem(const std::string &itemId, int quantity) {
    return InventorySystem::canAdd(this, itemId, quantity, nullptr);
}
 
std::string Bag::canAddItemReason(const std::string &itemId, int quantity) {
    std::string reason;
    InventorySystem::canAdd(this, itemId, quantity, &reason);
    return reason;
}
 
int Bag::addItem(const std::string &itemId, int quantity) {
    return InventorySystem::addItem(this, itemId, quantity);
}
 
int Bag::removeItem(const std::string &itemId, int quantity) {
    return InventorySystem::removeItem(this, itemId, quantity);
}
 
int Bag::removeAt(int slot, int quantity) { return InventorySystem::removeAt(this, slot, quantity); }
 
bool Bag::swapSlots(int slotA, int slotB) { return InventorySystem::swapSlots(this, slotA, slotB); }
 
bool Bag::moveSlot(int fromSlot, int toSlot) {
    return InventorySystem::moveSlot(this, fromSlot, toSlot);
}
 
bool Bag::splitStack(int slot, int quantity, int toSlot) {
    return InventorySystem::splitStack(this, slot, quantity, toSlot);
}
 
int Bag::countItem(const std::string &itemId) const {
    return InventorySystem::countItem(this, itemId);
}
 
int Bag::findItem(const std::string &itemId) const {
    return InventorySystem::findItem(this, itemId);
}
 
int Bag::findItemByTag(const std::string &tag) const {
    return InventorySystem::findItemByTag(this, tag);
}
 
float Bag::getUsedWeight() const { return InventorySystem::usedWeight(this); }
 
float Bag::getUsedVolume() const { return InventorySystem::usedVolume(this); }
 
int Bag::getUsedSlotCount() const { return InventorySystem::usedSlotCount(this); }
 
void Bag::clear() { InventorySystem::clearBag(this); }
 
bool Bag::isSlotEmpty(int slot) const {
    if (slot < 0 || slot >= getSlotCount()) return true;
    return slots_[size_t(slot)].empty();
}
 
std::string Bag::getSlotItemId(int slot) const {
    if (slot < 0 || slot >= getSlotCount()) return {};
    return slots_[size_t(slot)].itemId;
}
 
int Bag::getSlotQuantity(int slot) const {
    if (slot < 0 || slot >= getSlotCount()) return 0;
    return slots_[size_t(slot)].quantity;
}
 
int Bag::getSlotInstanceId(int slot) const {
    if (slot < 0 || slot >= getSlotCount()) return 0;
    return slots_[size_t(slot)].instanceId;
}
 
float Bag::getSlotDurability(int slot) const {
    if (slot < 0 || slot >= getSlotCount()) return -1.f;
    return slots_[size_t(slot)].durability;
}
 
void Bag::setSlotDurability(int slot, float durability) {
    if (slot < 0 || slot >= getSlotCount()) return;
    if (!slots_[size_t(slot)].empty()) slots_[size_t(slot)].durability = durability;
}
 
std::string Bag::getSlotProp(int slot, const std::string &key, const std::string &fallback) const {
    if (slot < 0 || slot >= getSlotCount()) return fallback;
    return slots_[size_t(slot)].getProp(key, fallback);
}
 
void Bag::setSlotProp(int slot, const std::string &key, const std::string &value) {
    if (slot < 0 || slot >= getSlotCount()) return;
    if (!slots_[size_t(slot)].empty()) slots_[size_t(slot)].setProp(key, value);
}
 
bool Bag::slotHasTag(int slot, const std::string &tag) const {
    if (slot < 0 || slot >= getSlotCount()) return false;
    return slots_[size_t(slot)].hasTag(tag);
}
 
void Bag::addSlotTag(int slot, const std::string &tag) {
    if (slot < 0 || slot >= getSlotCount() || tag.empty()) return;
    auto &s = slots_[size_t(slot)];
    if (s.empty()) return;
    if (!s.hasTag(tag)) s.tags.push_back(tag);
}
 
}  // namespace eve::inventory