Inventory.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once

 
#include <array>
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "Core/Rpg/Ability.h"
#include "Core/Rpg/Dice.h"
#include "Core/Rpg/Equipment.h"
#include "Core/Rpg/RpgEnums.h"
 
namespace core {
 
struct CharacterSheet;
struct CharacterCreationRules;

struct Item {
    std::string id;
    std::string name;
    std::string source;
    std::string category;
    int price = 0;
    int weightGrams = 0;
    bool stackable = false;
    std::string rarity;
    bool requiresAttunement = false;
    std::string text;
};

struct ItemCatalog {
    std::vector<Item> items;
    std::vector<std::string> errors;
 
    [[nodiscard]] const Item* find(std::string_view id) const;
};

[[nodiscard]] ItemCatalog loadItems(const std::filesystem::path& itemsDir);

struct EncumbranceRules {
    int carryingCapacityGramsPerStrength = 0;
    int encumberedGramsPerStrength = 0;
    int heavilyEncumberedGramsPerStrength = 0;
    float encumberedSpeedPenaltyMeters = 0.0F;
    float heavilyEncumberedSpeedPenaltyMeters = 0.0F;

    [[nodiscard]] bool isLoaded() const noexcept {
        return carryingCapacityGramsPerStrength > 0;
    }
};

[[nodiscard]] EncumbranceRules loadEncumbranceRules(const std::filesystem::path& rulesFile);

enum class EncumbranceLevel {
    Unencumbered,       
    Encumbered,         
    HeavilyEncumbered,  
    OverCapacity,       
};

enum class EquipmentSlot {
    Head,
    Neck,
    Cloak,
    Torso,
    Belt,
    Hands,
    RingLeft,
    RingRight,
    MainHand,
    OffHand,
    Ranged,
    Ammunition,
    Feet,
    Bracers,
    Pouch,
    Trinket,
};

inline constexpr std::size_t EQUIPMENT_SLOT_COUNT = 16;

[[nodiscard]] std::string_view equipmentSlotName(EquipmentSlot slot);
[[nodiscard]] std::optional<EquipmentSlot> parseEquipmentSlot(std::string_view name);

struct InventoryStack {
    std::string itemId;
    int quantity = 1;
};

struct Inventory {
    std::array<std::string, EQUIPMENT_SLOT_COUNT> equipped{};
    std::vector<InventoryStack> backpack;
    int purseCopper = 0;

    [[nodiscard]] const std::string& at(EquipmentSlot slot) const {
        return equipped[static_cast<std::size_t>(slot)];
    }

    [[nodiscard]] bool isEquipped(EquipmentSlot slot) const {
        return !at(slot).empty();
    }
};

std::string equip(Inventory& inventory, EquipmentSlot slot, std::string itemId);

std::string unequip(Inventory& inventory, EquipmentSlot slot);

void addToBackpack(Inventory& inventory, const std::string& itemId, int quantity = 1);

int removeFromBackpack(Inventory& inventory, const std::string& itemId, int quantity = 1);

struct ItemLookup {
    const ItemCatalog* items = nullptr;
    const EquipmentCatalog* equipment = nullptr;

    [[nodiscard]] int weightGramsOf(std::string_view id) const;
};

[[nodiscard]] int carriedWeightGrams(const Inventory& inventory, const ItemLookup& lookup);

[[nodiscard]] std::vector<std::string> unknownIds(const Inventory& inventory,
                                                  const ItemLookup& lookup);

struct DerivedStats {
    int armorClass = 0;
    std::optional<Dice> damage;
    std::optional<DamageType> damageType;
    Ability attackAbility = Ability::Strength;
    int carriedWeightGrams = 0;
    int carryingCapacityGrams = 0;
    EncumbranceLevel encumbrance = EncumbranceLevel::Unencumbered;
    float speedMeters = 0.0F;
};

[[nodiscard]] DerivedStats derivedStatsFor(const CharacterSheet& sheet, const Inventory& inventory,
                                           const ItemLookup& lookup,
                                           const CharacterCreationRules& creation,
                                           const EncumbranceRules& carrying);
 
}  // namespace core