Horizon::Zone::Assets::Inventory Class Reference

#include <Inventory.hpp>

Public Member Functions
	Inventory (std::shared_ptr< Horizon::Zone::Units::Player > player, uint32_t max_storage)
virtual	~Inventory ()
int16_t	get_free_index ()
std::shared_ptr< Horizon::Zone::Units::Player >	player ()
inventory_addition_result_type	add_item (std::shared_ptr< Horizon::Zone::Units::Item > floor_item)
inventory_addition_result_type	add_item (uint32_t item_id, uint16_t amount, bool is_identified=false)
inventory_addition_result_type	add_item (std::shared_ptr< item_entry_data > item, int amount)
std::shared_ptr< item_entry_data >	get_item (uint32_t inventory_index)
inventory_removal_result_type	remove_item (int16_t inventory_index, int amount, item_deletion_reason_type reason=ITEM_DEL_NORMAL)
void	drop_item (uint32_t inventory_index, uint16_t amount)
void	initialize ()
	Inventory initialization for player, called after Status is computed and notified. More...
bool	use_item (uint32_t inventory_index, uint32_t guid)
bool	can_equip (uint32_t inventory_index)
item_equip_result_type	equip_item (uint32_t inventory_index, uint16_t equip_location_mask)
item_unequip_result_type	unequip_item (uint32_t inventory_index)
EquipmentListType &	equipments ()
void	add_to_equipment_list (std::shared_ptr< item_entry_data > item)
void	remove_from_equipment_list (std::shared_ptr< item_entry_data > item)
void	notify_all ()
void	notify_without_equipments ()
void	notify_only_equipments ()
void	notify_add (std::shared_ptr< item_entry_data > const &item, uint16_t amount, inventory_addition_result_type fail)
void	notify_deletion (uint16_t idx, uint16_t amount, inventory_deletion_reason_type reason)
void	notify_drop (uint16_t idx, uint16_t amount)
void	notify_move_fail (uint16_t idx, bool silent)
int32_t	save ()
int32_t	load ()
void	set_max_storage (uint32_t max_storage)
uint32_t	max_storage ()
void	print_inventory ()

Protected Member Functions
uint32_t	calculate_current_equip_location_mask (std::shared_ptr< const item_config_data > item)

Private Types
typedef std::vector< std::shared_ptr< item_entry_data > >	storage_type

Private Attributes
int32_t	_max_storage
std::weak_ptr< Horizon::Zone::Units::Player >	_player
EquipmentListType	_equipments
storage_type	_inventory_items
storage_type	_saved_inventory_items

Member Typedef Documentation

storage_type

typedef std::vector<std::shared_ptr<item_entry_data> > Horizon::Zone::Assets::Inventory::storage_type

private

Constructor & Destructor Documentation

Inventory()

Inventory::Inventory	(	std::shared_ptr< Horizon::Zone::Units::Player >	player,
		uint32_t	max_storage
	)

: _player(player), _max_storage(max_storage)
{
    _equipments[IT_EQPI_ACC_L].first = IT_EQPM_ACC_L;
    _equipments[IT_EQPI_ACC_R].first = IT_EQPM_ACC_R;
    _equipments[IT_EQPI_SHOES].first = IT_EQPM_SHOES;
    _equipments[IT_EQPI_GARMENT].first = IT_EQPM_GARMENT;
    _equipments[IT_EQPI_HEAD_LOW].first = IT_EQPM_HEAD_LOW;
    _equipments[IT_EQPI_HEAD_MID].first = IT_EQPM_HEAD_MID;
    _equipments[IT_EQPI_HEAD_TOP].first = IT_EQPM_HEAD_TOP;
    _equipments[IT_EQPI_ARMOR].first = IT_EQPM_ARMOR;
    _equipments[IT_EQPI_HAND_L].first = IT_EQPM_HAND_L;
    _equipments[IT_EQPI_HAND_R].first = IT_EQPM_HAND_R;
    _equipments[IT_EQPI_COSTUME_TOP].first = IT_EQPM_COSTUME_HEAD_TOP;
    _equipments[IT_EQPI_COSTUME_MID].first = IT_EQPM_COSTUME_HEAD_MID;
    _equipments[IT_EQPI_COSTUME_LOW].first = IT_EQPM_COSTUME_HEAD_LOW;
    _equipments[IT_EQPI_COSTUME_GARMENT].first = IT_EQPM_COSTUME_GARMENT;
    _equipments[IT_EQPI_AMMO].first = IT_EQPM_AMMO;
    _equipments[IT_EQPI_SHADOW_ARMOR].first = IT_EQPM_SHADOW_ARMOR;
    _equipments[IT_EQPI_SHADOW_WEAPON].first = IT_EQPM_SHADOW_WEAPON;
    _equipments[IT_EQPI_SHADOW_SHIELD].first = IT_EQPM_SHADOW_SHIELD;
    _equipments[IT_EQPI_SHADOW_SHOES].first = IT_EQPM_SHADOW_SHOES;
    _equipments[IT_EQPI_SHADOW_ACC_R].first = IT_EQPM_SHADOW_ACC_R;
    _equipments[IT_EQPI_SHADOW_ACC_L].first = IT_EQPM_SHADOW_ACC_L;
}

References _equipments, IT_EQPI_ACC_L, IT_EQPI_ACC_R, IT_EQPI_AMMO, IT_EQPI_ARMOR, IT_EQPI_COSTUME_GARMENT, IT_EQPI_COSTUME_LOW, IT_EQPI_COSTUME_MID, IT_EQPI_COSTUME_TOP, IT_EQPI_GARMENT, IT_EQPI_HAND_L, IT_EQPI_HAND_R, IT_EQPI_HEAD_LOW, IT_EQPI_HEAD_MID, IT_EQPI_HEAD_TOP, IT_EQPI_SHADOW_ACC_L, IT_EQPI_SHADOW_ACC_R, IT_EQPI_SHADOW_ARMOR, IT_EQPI_SHADOW_SHIELD, IT_EQPI_SHADOW_SHOES, IT_EQPI_SHADOW_WEAPON, IT_EQPI_SHOES, IT_EQPM_ACC_L, IT_EQPM_ACC_R, IT_EQPM_AMMO, IT_EQPM_ARMOR, IT_EQPM_COSTUME_GARMENT, IT_EQPM_COSTUME_HEAD_LOW, IT_EQPM_COSTUME_HEAD_MID, IT_EQPM_COSTUME_HEAD_TOP, IT_EQPM_GARMENT, IT_EQPM_HAND_L, IT_EQPM_HAND_R, IT_EQPM_HEAD_LOW, IT_EQPM_HEAD_MID, IT_EQPM_HEAD_TOP, IT_EQPM_SHADOW_ACC_L, IT_EQPM_SHADOW_ACC_R, IT_EQPM_SHADOW_ARMOR, IT_EQPM_SHADOW_SHIELD, IT_EQPM_SHADOW_SHOES, IT_EQPM_SHADOW_WEAPON, and IT_EQPM_SHOES.

~Inventory()

Inventory::~Inventory ( )

virtual

{
    //
}

Member Function Documentation

add_item() [1/3]

inventory_addition_result_type Inventory::add_item

(

std::shared_ptr< Horizon::Zone::Units::Item >

floor_item

)

{
    if (floor_item->entry() == nullptr)
        return add_item(floor_item->config()->item_id, floor_item->amount(), floor_item->is_identified());
 
    return add_item(floor_item->entry(), floor_item->amount());
}

References add_item().

Referenced by add_item(), and Horizon::Zone::PlayerComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

add_item() [2/3]

inventory_addition_result_type Inventory::add_item	(	std::shared_ptr< item_entry_data >	item,
		int	amount
	)

{
    if (item == nullptr)
        return INVENTORY_ADD_INVALID;
 
    if (item->config == nullptr)
        return INVENTORY_ADD_INVALID;
 
    std::shared_ptr<Horizon::Zone::Traits::CurrentWeight> current_weight = player()->status()->current_weight();
    std::shared_ptr<Horizon::Zone::Traits::MaxWeight> max_weight = player()->status()->max_weight();
 
    if (amount <= 0)
        return INVENTORY_ADD_INVALID;
 
    if (*current_weight + (amount * item->config->weight) > max_weight->total()) {
        notify_add(item, item->amount, INVENTORY_ADD_OVER_WEIGHT);
        return INVENTORY_ADD_OVER_WEIGHT;
    }
 
    if (item->config->stack.inventory > 0 && (amount > item->config->stack.inventory)) {
        notify_add(item, amount, INVENTORY_ADD_OVER_STACK_LIMIT);
        return INVENTORY_ADD_OVER_STACK_LIMIT;
    }
 
    if (amount > MAX_INVENTORY_STACK_LIMIT) {
        notify_add(item, amount, INVENTORY_ADD_OVER_QUANTITY);
        return INVENTORY_ADD_OVER_QUANTITY;
    }
 
    if (_inventory_items.size() >= max_storage()) {
        notify_add(item, amount, INVENTORY_ADD_NO_INV_SPACE);
        return INVENTORY_ADD_NO_INV_SPACE;
    }
 
    // Check if item is stackable
    if (item->is_stackable()) {
        // Check if item exists in inventory.
        auto invitem = std::find_if(_inventory_items.begin(), _inventory_items.end(), 
            [&item] (std::shared_ptr<item_entry_data> invit) { 
                if (invit == nullptr)
                    return false;
                return (invit->amount < MAX_INVENTORY_STACK_LIMIT && *invit == *item); 
            }
        );
        // If item was found in inventory...
        if (invitem != _inventory_items.end()) {
            std::shared_ptr<item_entry_data> it_entry = *invitem;
            // Check if amount exeeds stack size.
            if (it_entry->amount + amount > MAX_INVENTORY_STACK_LIMIT) {
                // Add appropriately
                int left_amt = it_entry->amount - MAX_INVENTORY_STACK_LIMIT;
                it_entry->amount += left_amt;
                item->amount -= left_amt;
                add_item(item->item_id, amount, item->info.is_identified);
            } else {
                it_entry->amount += amount;
                notify_add(it_entry, amount, INVENTORY_ADD_SUCCESS);
 
                current_weight->add_base(item->config->weight * amount);
            }
        } else {
            int index = get_free_index();
            std::shared_ptr<item_entry_data> item_new_stack = std::make_shared<item_entry_data>(*item);
            item_new_stack->amount = amount;
            item_new_stack->storage_type = ITEM_STORE_INVENTORY;
            item_new_stack->index.inventory = index + 2;
            _inventory_items[index] = item_new_stack;
            notify_add(item_new_stack, amount, INVENTORY_ADD_SUCCESS);
 
            current_weight->add_base(item_new_stack->config->weight * amount);
        }
    } else {
        int index = get_free_index();
        std::shared_ptr<item_entry_data> it_entry = std::make_shared<item_entry_data>(*item);
        it_entry->unique_id = player()->new_unique_id();
        it_entry->amount = 1;
        it_entry->storage_type = ITEM_STORE_INVENTORY;
        it_entry->index.inventory = index + 2;
        _inventory_items[index] = it_entry;
        notify_add(it_entry, it_entry->amount, INVENTORY_ADD_SUCCESS);
        current_weight->add_base(item->config->weight);
        if (--amount)
            add_item(item, amount);
    }
 
    return INVENTORY_ADD_SUCCESS;
}

References _inventory_items, add_item(), get_free_index(), Horizon::Zone::Assets::INVENTORY_ADD_INVALID, Horizon::Zone::Assets::INVENTORY_ADD_NO_INV_SPACE, Horizon::Zone::Assets::INVENTORY_ADD_OVER_QUANTITY, Horizon::Zone::Assets::INVENTORY_ADD_OVER_STACK_LIMIT, Horizon::Zone::Assets::INVENTORY_ADD_OVER_WEIGHT, Horizon::Zone::Assets::INVENTORY_ADD_SUCCESS, ITEM_STORE_INVENTORY, MAX_INVENTORY_STACK_LIMIT, max_storage(), notify_add(), and player().

Here is the call graph for this function:

add_item() [3/3]

inventory_addition_result_type Inventory::add_item	(	uint32_t	item_id,
		uint16_t	amount,
		bool	is_identified = false
	)

{
    item_entry_data data;
 
    std::shared_ptr<const item_config_data> item_d = ItemDB->get_item_by_id(item_id);
    std::shared_ptr<const job_config_data> job = JobDB->get_job_by_id(player()->job_id());
 
    if (item_d == nullptr)
        return INVENTORY_ADD_INVALID;
 
    // Copy item properties from static db entry.
    data.item_id = item_id;
    data.type = item_d->type;
    data.actual_equip_location_mask = item_d->equip_location_mask;
    data.bind_type = IT_BIND_NONE;
    data.info.is_identified = is_identified;
    data.info.is_favorite = 0;
    data.config = item_d;
 
    std::shared_ptr<item_entry_data> inv_item = std::make_shared<item_entry_data>(data);
 
    return add_item(inv_item, amount);
}

References item_entry_data::actual_equip_location_mask, add_item(), item_entry_data::bind_type, item_entry_data::config, item_entry_data::info, Horizon::Zone::Assets::INVENTORY_ADD_INVALID, item_entry_data::item_entry_info::is_favorite, item_entry_data::item_entry_info::is_identified, IT_BIND_NONE, item_entry_data::item_id, ItemDB, JobDB, player(), and item_entry_data::type.

Here is the call graph for this function:

add_to_equipment_list()

void Inventory::add_to_equipment_list

(

std::shared_ptr< item_entry_data >

item

)

{
    for (int i = 0; i < (item_equip_location_index) IT_EQPI_MAX; i++) {
        auto &equip = equipments()[i];
        std::shared_ptr<item_entry_data> id = equip.second.lock();
 
        // Unequip the existing item and wear the new item.
        if ((item->current_equip_location_mask & equip.first)) {
            if (!equip.second.expired() && unequip_item(id->index.inventory) == IT_UNEQUIP_FAIL)
                return;
            equip.second = item;
        }
    }
}

References equipments(), IT_EQPI_MAX, IT_UNEQUIP_FAIL, and unequip_item().

Referenced by equip_item().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_current_equip_location_mask()

uint32_t Inventory::calculate_current_equip_location_mask ( std::shared_ptr< const item_config_data >  item )

protected

{
    job_class_mask job_mask = JobDB->job_id_to_mask((job_class_type) player()->job_id());
    uint32_t current_equip_location_mask = item->equip_location_mask;
 
    if (item->type == IT_TYPE_WEAPON) {
        if (item->sub_type.weapon_t == IT_WT_DAGGER ||
            item->sub_type.weapon_t == IT_WT_1HSWORD ||
            item->sub_type.weapon_t == IT_WT_1HAXE) {
            if ((job_mask & JMASK_ASSASSIN) == JMASK_ASSASSIN
                 || (job_mask & JMASK_KAGEROUOBORO) == JMASK_KAGEROUOBORO) {
                if (item->equip_location_mask == IT_EQPM_HAND_R)
                    current_equip_location_mask = IT_EQPM_ARMS;
                if (item->equip_location_mask == IT_EQPM_SHADOW_WEAPON)
                    current_equip_location_mask = IT_EQPM_SHADOW_ARMS;
            }
        }
    }
 
    if (current_equip_location_mask == IT_EQPM_ACC)
        current_equip_location_mask = equipments()[IT_EQPI_ACC_L].second.expired() ? IT_EQPM_ACC_L : IT_EQPM_ACC_R;
    else if (current_equip_location_mask == IT_EQPM_ARMS && item->equip_location_mask == IT_EQPM_WEAPON)
        current_equip_location_mask = equipments()[IT_EQPI_HAND_L].second.expired() ? IT_EQPM_HAND_L : IT_EQPM_HAND_R;
    else if (current_equip_location_mask == IT_EQPM_SHADOW_ACC)
        current_equip_location_mask = equipments()[IT_EQPI_SHADOW_ACC_L].second.expired() ? IT_EQPM_SHADOW_ACC_L : IT_EQPM_SHADOW_ACC_R;
    else if (current_equip_location_mask == IT_EQPM_SHADOW_ARMS && item->equip_location_mask == IT_EQPM_SHADOW_WEAPON)
        current_equip_location_mask = equipments()[IT_EQPI_SHADOW_WEAPON].second.expired() ? IT_EQPM_SHADOW_WEAPON : IT_EQPM_SHADOW_SHIELD;
 
    return current_equip_location_mask;
}

References equipments(), IT_EQPI_ACC_L, IT_EQPI_HAND_L, IT_EQPI_SHADOW_ACC_L, IT_EQPI_SHADOW_WEAPON, IT_EQPM_ACC, IT_EQPM_ACC_L, IT_EQPM_ACC_R, IT_EQPM_ARMS, IT_EQPM_HAND_L, IT_EQPM_HAND_R, IT_EQPM_SHADOW_ACC, IT_EQPM_SHADOW_ACC_L, IT_EQPM_SHADOW_ACC_R, IT_EQPM_SHADOW_ARMS, IT_EQPM_SHADOW_SHIELD, IT_EQPM_SHADOW_WEAPON, IT_EQPM_WEAPON, IT_TYPE_WEAPON, IT_WT_1HAXE, IT_WT_1HSWORD, IT_WT_DAGGER, JMASK_ASSASSIN, JMASK_KAGEROUOBORO, JobDB, and player().

Referenced by equip_item().

Here is the call graph for this function:

Here is the caller graph for this function:

can_equip()

bool Horizon::Zone::Assets::Inventory::can_equip

(

uint32_t

inventory_index

)

drop_item()

void Inventory::drop_item	(	uint32_t	inventory_index,
		uint16_t	amount
	)

{
    std::shared_ptr<item_entry_data> inv_item = get_item(inventory_index);
 
    if (inv_item == nullptr)
        return;
 
    if (inv_item->config == nullptr)
        return;
 
    if (inv_item->amount < amount)
        return;
 
    player()->status()->current_weight()->sub_base(inv_item->config->weight * amount);
 
    if (inv_item->amount == amount) {
        inv_item = nullptr;
        notify_drop(inventory_index, amount);
    } else {
        inv_item->amount -= amount;
        notify_drop(inventory_index, amount);
    }
}

References get_item(), notify_drop(), and player().

Here is the call graph for this function:

equip_item()

item_equip_result_type Inventory::equip_item	(	uint32_t	inventory_index,
		uint16_t	equip_location_mask
	)

{
    uint32_t job_id = player()->job_id();
    std::shared_ptr<item_entry_data> inv_item = _inventory_items.at(inventory_index - 2);
 
    if (inv_item == nullptr) {
        HLog(debug) << "Inventory::equip_item: Could not wear item at inventory index " << inventory_index << " - Inventory data not found.";
        return IT_EQUIP_FAIL;
    }
 
    if (inv_item->config == nullptr) {
        player()->get_session()->clif()->notify_equip_item(inv_item, IT_EQUIP_FAIL);
        return IT_EQUIP_FAIL;
    }
 
    if (inv_item->current_equip_location_mask != 0 || inv_item->config->equip_location_mask != equip_location_mask) {
        player()->get_session()->clif()->notify_equip_item(inv_item, IT_EQUIP_FAIL);
        return IT_EQUIP_FAIL;
    }
 
    auto req_job_it = std::find_if(inv_item->config->requirements.job_ids.begin(), inv_item->config->requirements.job_ids.end(),
        [job_id](uint32_t id) {
            return job_id == id;
        });
    if (req_job_it == inv_item->config->requirements.job_ids.end()) {
        player()->get_session()->clif()->notify_equip_item(inv_item, IT_EQUIP_FAIL);
        return IT_EQUIP_FAIL;
    }
 
    if (inv_item->config->config.bind_on_equip != 0 && inv_item->bind_type == IT_BIND_NONE) {
        inv_item->bind_type = IT_BIND_CHARACTER;
        player()->get_session()->clif()->notify_bind_on_equip(inv_item->index.inventory);
    }
 
    inv_item->current_equip_location_mask = calculate_current_equip_location_mask(inv_item->config);
 
    add_to_equipment_list(inv_item);
 
    if (inv_item->type == IT_TYPE_AMMO) {
        player()->get_session()->clif()->notify_equip_arrow(inv_item);
        player()->get_session()->clif()->notify_action_failure(3);
    } else {
        HLog(debug) << "Inventory Item " << inv_item->index.inventory << " - " << inv_item->item_id << "worn.";
        
        player()->get_session()->clif()->notify_equip_item(inv_item, IT_EQUIP_SUCCESS);
        
        player()->on_item_equip(inv_item);
        
        print_inventory();
    }
 
    return IT_EQUIP_SUCCESS;
}

References _inventory_items, add_to_equipment_list(), calculate_current_equip_location_mask(), HLog, IT_BIND_CHARACTER, IT_BIND_NONE, IT_EQUIP_FAIL, IT_EQUIP_SUCCESS, IT_TYPE_AMMO, player(), and print_inventory().

Here is the call graph for this function:

equipments()

EquipmentListType & Horizon::Zone::Assets::Inventory::equipments ( )

inline

{ return _equipments; }

References _equipments.

Referenced by add_to_equipment_list(), calculate_current_equip_location_mask(), notify_only_equipments(), print_inventory(), and remove_from_equipment_list().

Here is the caller graph for this function:

get_free_index()

int16_t Inventory::get_free_index

(

)

{
    for (auto i = _inventory_items.begin(); i != _inventory_items.end(); i++) {
        if (*i == nullptr)
            return std::distance(_inventory_items.begin(), i);
    }
 
    _inventory_items.resize(_inventory_items.size() + 1);
    return _inventory_items.size() - 1;
}

References _inventory_items.

Referenced by add_item().

Here is the caller graph for this function:

get_item()

std::shared_ptr< item_entry_data > Inventory::get_item

(

uint32_t

inventory_index

)

{
    return _inventory_items.at(inventory_index - 2);
}

References _inventory_items.

Referenced by drop_item(), and remove_item().

Here is the caller graph for this function:

initialize()

void Inventory::initialize

(

)

Inventory initialization for player, called after Status is computed and notified.

{
    for (auto item : _inventory_items) {
        player()->status()->current_weight()->add_base(item->config->weight * item->amount);
    }
}

References _inventory_items, and player().

Here is the call graph for this function:

load()

int32_t Inventory::load

(

)

{   
 
    std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sZone->get_database_connection();
    
    try {
        boost::mysql::statement stmt = conn->prepare_statement("SELECT `item_id`, `amount`, `equip_location_mask`, `refine_level`, `slot_item_id_0`,"
            "`slot_item_id_1`, `slot_item_id_2`, `slot_item_id_3`, `hire_expire_date`, `element_type`, `opt_idx0`, `opt_val0`, `opt_idx1`, `opt_val1`,"
            "`opt_idx2`, `opt_val2`, `opt_idx3`, `opt_val3`, `opt_idx4`, `opt_val4`, `is_identified`, `is_broken`, `is_favorite`, `bind_type`, `unique_id`"
            " FROM `character_inventory` WHERE `char_id` = ?");
        auto b1 = stmt.bind(player()->character()._character_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        if (_inventory_items.size() != 0) {
            HLog(warning) << "Attempt to synchronize the saved inventory, which should be empty at the time of load or re-load, size: " << _inventory_items.size();
            return 0;
        }
 
        int inventory_index = 2;
        for (auto r : results.rows()) {
            item_entry_data i;
 
            std::shared_ptr<const item_config_data> d = ItemDB->get_item_by_id(r[0].as_uint64());
 
            i.storage_type = ITEM_STORE_INVENTORY;
            i.index.inventory = inventory_index;
            i.item_id = r[0].as_uint64();
            i.type = d->type;
            i.amount = r[1].as_uint64();
            i.current_equip_location_mask = r[2].as_uint64();
            i.actual_equip_location_mask = d->equip_location_mask;
            i.refine_level = r[3].as_uint64();
            i.config = d;
 
            i.slot_item_id[0] = r[4].as_int64();
            i.slot_item_id[1] = r[5].as_int64();
            i.slot_item_id[2] = r[6].as_int64();
            i.slot_item_id[3] = r[7].as_int64();
 
            i.hire_expire_date = r[8].as_uint64();
            i.sprite_id = d->sprite_id;
 
            i.ele_type = (element_type)(int)r[9].as_uint64();
 
            if (r[10].as_uint64()) {
                i.option_data[0].set_index(r[10].as_uint64());
                i.option_data[0].set_value(r[11].as_int64());
                i.option_count = 1;
            }
 
            if (r[12].as_uint64()) {
                i.option_data[1].set_index(r[12].as_uint64());
                i.option_data[1].set_value(r[13].as_int64());
                i.option_count = 2;
            }
 
            if (r[14].as_uint64()) {
                i.option_data[2].set_index(r[14].as_uint64());
                i.option_data[2].set_value(r[15].as_int64());
                i.option_count = 3;
            }
 
            if (r[16].as_uint64()) {
                i.option_data[3].set_index(r[16].as_uint64());
                i.option_data[3].set_value(r[17].as_int64());
                i.option_count = 4;
            }
 
            if (r[18].as_uint64()) {
                i.option_data[4].set_index(r[18].as_uint64());
                i.option_data[4].set_value(r[19].as_int64());
                i.option_count = 5;
            }
 
            i.info.is_identified = r[20].as_int64();
            i.info.is_broken = r[21].as_uint64();
            i.info.is_favorite = r[22].as_uint64();
 
            i.bind_type = (item_bind_type)(int)r[23].as_uint64(); // int16_t
            i.unique_id = r[24].as_uint64();
 
            std::shared_ptr<item_entry_data> item = std::make_shared<item_entry_data>(i);
 
            _saved_inventory_items.resize(inventory_index - 2 + 1);
            _inventory_items.resize(inventory_index - 2 + 1);
            _saved_inventory_items[inventory_index - 2] = item;
            _inventory_items[inventory_index - 2] = item;
            inventory_index++;
        }
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << "Inventory::load:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Inventory::load:" << error.what();
        return false;
    }
    
    HLog(info) << "Loaded inventory for (Character ID: " << player()->account()._account_id << ") with " << _inventory_items.size() << " items.";
 
    return _inventory_items.size();
}

References _character_id, _inventory_items, _saved_inventory_items, item_entry_data::actual_equip_location_mask, item_entry_data::amount, item_entry_data::bind_type, item_entry_data::config, item_entry_data::current_equip_location_mask, item_entry_data::ele_type, item_entry_data::hire_expire_date, HLog, item_entry_data::index, item_entry_data::info, item_entry_data::inventory, item_entry_data::item_entry_info::is_broken, item_entry_data::item_entry_info::is_favorite, item_entry_data::item_entry_info::is_identified, item_entry_data::item_id, ITEM_STORE_INVENTORY, ItemDB, item_entry_data::option_count, item_entry_data::option_data, player(), item_entry_data::refine_level, item_entry_data::options::set_index(), item_entry_data::options::set_value(), item_entry_data::slot_item_id, item_entry_data::sprite_id, item_entry_data::storage_type, sZone, item_entry_data::type, and item_entry_data::unique_id.

Here is the call graph for this function:

max_storage()

uint32_t Horizon::Zone::Assets::Inventory::max_storage ( )

inline

{ return _max_storage; }

References _max_storage.

Referenced by add_item(), and set_max_storage().

Here is the caller graph for this function:

notify_add()

void Inventory::notify_add	(	std::shared_ptr< item_entry_data > const &	item,
		uint16_t	amount,
		inventory_addition_result_type	fail
	)

{
    item_inventory_addition_notif_type notif_type;
 
    switch (result)
    {
    case INVENTORY_ADD_SUCCESS: notif_type = ITEM_INV_ADD_SUCCESS; break;
    case INVENTORY_ADD_INVALID: notif_type = ITEM_INV_ADD_INVALID; break;
    case INVENTORY_ADD_OVER_WEIGHT: notif_type = ITEM_INV_ADD_OVER_WEIGHT; break;
    case INVENTORY_ADD_NO_INV_SPACE: notif_type = ITEM_INV_ADD_NO_INV_SPACE; break;
    case INVENTORY_ADD_OVER_QUANTITY: notif_type = ITEM_INV_ADD_OVER_QUANTITY; break;
    case INVENTORY_ADD_OVER_STACK_LIMIT: notif_type = ITEM_INV_ADD_OVER_STACK_LIMIT; break;
    }
 
    player()->get_session()->clif()->notify_pickup_item(item, amount, notif_type);
}

References Horizon::Zone::Assets::INVENTORY_ADD_INVALID, Horizon::Zone::Assets::INVENTORY_ADD_NO_INV_SPACE, Horizon::Zone::Assets::INVENTORY_ADD_OVER_QUANTITY, Horizon::Zone::Assets::INVENTORY_ADD_OVER_STACK_LIMIT, Horizon::Zone::Assets::INVENTORY_ADD_OVER_WEIGHT, Horizon::Zone::Assets::INVENTORY_ADD_SUCCESS, ITEM_INV_ADD_INVALID, ITEM_INV_ADD_NO_INV_SPACE, ITEM_INV_ADD_OVER_QUANTITY, ITEM_INV_ADD_OVER_STACK_LIMIT, ITEM_INV_ADD_OVER_WEIGHT, ITEM_INV_ADD_SUCCESS, and player().

Referenced by add_item().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_all()

void Inventory::notify_all

(

)

{
    player()->get_session()->clif()->notify_inventory_start(INVTYPE_INVENTORY, "Inventory");
    notify_only_equipments();
    notify_without_equipments();
    player()->get_session()->clif()->notify_inventory_end(INVTYPE_INVENTORY);
}

References INVTYPE_INVENTORY, notify_only_equipments(), notify_without_equipments(), and player().

Here is the call graph for this function:

notify_deletion()

void Inventory::notify_deletion	(	uint16_t	idx,
		uint16_t	amount,
		inventory_deletion_reason_type	reason
	)

{
 
}

notify_drop()

void Inventory::notify_drop	(	uint16_t	idx,
		uint16_t	amount
	)

{
    player()->get_session()->clif()->notify_throw_item(idx, amount);
}

References player().

Referenced by drop_item().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_move_fail()

void Inventory::notify_move_fail	(	uint16_t	idx,
		bool	silent
	)

{
 
}

notify_only_equipments()

void Inventory::notify_only_equipments

(

)

{
    std::vector<std::shared_ptr<const item_entry_data>> equipments;
 
    for (auto eit = _inventory_items.begin(); eit != _inventory_items.end(); eit++) {
        if ((*eit)->is_equipment())
            equipments.push_back(*eit);
    }
 
    player()->get_session()->clif()->notify_equipment_item_list(equipments);
}

References _inventory_items, equipments(), and player().

Referenced by notify_all().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_without_equipments()

void Inventory::notify_without_equipments

(

)

{
    std::vector<std::shared_ptr<const item_entry_data>> normal_items;
 
    for (auto nit = _inventory_items.begin(); nit != _inventory_items.end(); nit++) {
        if ((*nit)->is_equipment() == false)
            normal_items.push_back(*nit);
    }
 
    player()->get_session()->clif()->notify_normal_item_list(normal_items);
 
}

References _inventory_items, and player().

Referenced by notify_all().

Here is the call graph for this function:

Here is the caller graph for this function:

player()

std::shared_ptr< Horizon::Zone::Units::Player > Horizon::Zone::Assets::Inventory::player ( )

inline

{ return _player.lock(); }

References _player.

Referenced by add_item(), calculate_current_equip_location_mask(), drop_item(), equip_item(), initialize(), load(), notify_add(), notify_all(), notify_drop(), notify_only_equipments(), notify_without_equipments(), remove_item(), save(), unequip_item(), and use_item().

Here is the caller graph for this function:

print_inventory()

void Inventory::print_inventory

(

)

{
    HLog(debug) << " -- Inventory List --";
    for (auto i : _inventory_items)
        HLog(debug) << "Idx: " << i->index.inventory << " ItemID: " << i->item_id << " Amount: " << i->amount;
 
 
    HLog(debug) << " -- Equipments List --";
    for (int i = 0; i < IT_EQPI_MAX; i++) {
        auto &equip = equipments()[i];
        std::shared_ptr<const item_entry_data> id = equip.second.lock();
        if (id != nullptr)
            HLog(debug) << "Loc:" << std::hex << id->current_equip_location_mask << " Loc2: " << id->actual_equip_location_mask << " Idx: " << std::dec << id->index.inventory << " ItemID: " << id->item_id << " Amount: " << id->amount;
    }
}

References _inventory_items, equipments(), HLog, and IT_EQPI_MAX.

Referenced by equip_item(), and unequip_item().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_from_equipment_list()

void Inventory::remove_from_equipment_list

(

std::shared_ptr< item_entry_data >

item

)

{
    for (int i = 0; i < (item_equip_location_index)  IT_EQPI_MAX; i++) {
        auto &equip = equipments()[i];
        std::shared_ptr<const item_entry_data> id = equip.second.lock();
 
        if ((item->current_equip_location_mask & equip.first)) {
            item->current_equip_location_mask &= ~equip.first;
            equip.second.reset();
        }
    }
}

References equipments(), and IT_EQPI_MAX.

Referenced by unequip_item().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_item()

inventory_removal_result_type Inventory::remove_item	(	int16_t	inventory_index,
		int	amount,
		item_deletion_reason_type	reason = ITEM_DEL_NORMAL
	)

{
    std::shared_ptr<item_entry_data> inv_item = get_item(inventory_index);
    
    std::shared_ptr<Horizon::Zone::Traits::CurrentWeight> current_weight = player()->status()->current_weight();
 
    if (inv_item->amount - amount < 0)
        return INVENTORY_REMOVE_INVALID;
 
    if (amount > inv_item->amount || amount > MAX_INVENTORY_STACK_LIMIT)
        return INVENTORY_REMOVE_INVALID;
    
    if (inv_item->amount - amount == 0)
        _inventory_items[inventory_index - 2] = nullptr;
    else
        inv_item->amount -= amount;
    
    player()->get_session()->clif()->notify_delete_item(inventory_index, amount, reason);
    current_weight->sub_base(inv_item->config->weight * amount);
 
    return INVENTORY_REMOVE_SUCCESS;
}

References _inventory_items, get_item(), Horizon::Zone::Assets::INVENTORY_REMOVE_INVALID, Horizon::Zone::Assets::INVENTORY_REMOVE_SUCCESS, MAX_INVENTORY_STACK_LIMIT, and player().

Here is the call graph for this function:

save()

int32_t Inventory::save

(

)

{
    int32_t changes = 0;
 
    // Erase saved vector and copy the current inventory.
    _saved_inventory_items.clear();
    std::copy(_inventory_items.begin(), _inventory_items.end(), std::inserter(_saved_inventory_items, _saved_inventory_items.end()));
    
    std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sZone->get_database_connection();
 
    try {
        boost::mysql::statement stmt = conn->prepare_statement("DELETE FROM `character_inventory` WHERE `char_id` = ?");
        auto b1 = stmt.bind(player()->character()._character_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        boost::format fmt_ctx = boost::format("INSERT INTO `character_inventory` (`char_id`, `item_id`, `amount`, `equip_location_mask`,"
            "`is_identified`, `refine_level`, `element_type`, `slot_item_id_0`, `slot_item_id_1`, `slot_item_id_2`, `slot_item_id_3`, `opt_idx0`, `opt_val0`,"
            "`opt_idx1`, `opt_val1`, `opt_idx2`, `opt_val2`, `opt_idx3`, `opt_val3`, `opt_idx4`, `opt_val4`, `hire_expire_date`, `is_favorite`, `is_broken`, `bind_type`, `unique_id`"
            "VALUES ");
            
        int count = 0;
        for (auto mit_i = _saved_inventory_items.begin(); mit_i != _saved_inventory_items.end(); mit_i++) {
            std::shared_ptr<const item_entry_data> mit = *mit_i;
 
            if (mit == nullptr)
                continue;
 
            if (count != 0) {
                std::string str = fmt_ctx.str();
                fmt_ctx = boost::format(str.append(", "));
            }
 
            boost::format new_fmt = boost::format("(%1%, %2%, %3%, %4%, %5%, %6%, %7%, %8%, %9%, %10%, %11%, %12%, %13%, %14%, %15%, %16%, %17%, %18%, %19%, %20%, %21%, %22%, %23%, %24%, %25%, %26%)")
                % player()->character()._character_id
                % (int)mit->item_id
                % (int)mit->amount
                % (int)mit->current_equip_location_mask
                % (int)mit->info.is_identified
                % (int)mit->refine_level
                % (int)mit->ele_type
                % (int)mit->slot_item_id[0]
                % (int)mit->slot_item_id[1]
                % (int)mit->slot_item_id[2]
                % (int)mit->slot_item_id[3]
                % (int)mit->option_data[0].get_index()
                % (int)mit->option_data[0].get_value()
                % (int)mit->option_data[1].get_index()
                % (int)mit->option_data[1].get_value()
                % (int)mit->option_data[2].get_index()
                % (int)mit->option_data[2].get_value()
                % (int)mit->option_data[3].get_index()
                % (int)mit->option_data[3].get_value()
                % (int)mit->option_data[4].get_index()
                % (int)mit->option_data[4].get_value()
                % (int)mit->hire_expire_date
                % (int)mit->info.is_favorite
                % (int)mit->info.is_broken
                % (int)mit->bind_type
                % (int64_t)mit->unique_id;
 
            std::string str_str = fmt_ctx.str() + new_fmt.str();
            fmt_ctx = boost::format(str_str);
            count++;
        }
 
        if (count) {
            boost::mysql::results results;
            conn->execute(fmt_ctx.str(), results);
        }
 
        changes = count;
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << "Inventory::save:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Inventory::save:" << error.what();
        return false;
    }
 
    HLog(info) << "Saved inventory for (Character ID: " << player()->account()._account_id << ") with " << changes << " changes.";
    return changes;
}

References _character_id, _inventory_items, _saved_inventory_items, GridTypeListIterator::count(), HLog, player(), and sZone.

Here is the call graph for this function:

set_max_storage()

void Horizon::Zone::Assets::Inventory::set_max_storage ( uint32_t  max_storage )

inline

{ _max_storage = max_storage; }

References _max_storage, and max_storage().

Here is the call graph for this function:

unequip_item()

item_unequip_result_type Inventory::unequip_item

(

uint32_t

inventory_index

)

{
    std::shared_ptr<item_entry_data> inv_item = _inventory_items.at(inventory_index - 2);
 
    if (inv_item == nullptr) {
        player()->get_session()->clif()->notify_unequip_item(inv_item, IT_UNEQUIP_FAIL);
        return IT_UNEQUIP_FAIL;
    }
 
    if (inv_item->config == nullptr) {
        player()->get_session()->clif()->notify_unequip_item(inv_item, IT_UNEQUIP_FAIL);
        return IT_UNEQUIP_FAIL;
    }
 
    player()->get_session()->clif()->notify_unequip_item(inv_item, IT_UNEQUIP_SUCCESS);
 
    remove_from_equipment_list(inv_item);
 
    player()->on_item_unequip(inv_item);
 
    print_inventory();
 
    return IT_UNEQUIP_SUCCESS;
}

References _inventory_items, IT_UNEQUIP_FAIL, IT_UNEQUIP_SUCCESS, player(), print_inventory(), and remove_from_equipment_list().

Referenced by add_to_equipment_list().

Here is the call graph for this function:

Here is the caller graph for this function:

use_item()

bool Inventory::use_item	(	uint32_t	inventory_index,
		uint32_t	guid
	)

{
    std::shared_ptr<item_entry_data> inv_item = _inventory_items.at(inventory_index - 2);
 
    if (inv_item == nullptr)
        return false;
 
    if (inv_item->config == nullptr) {
        player()->get_session()->clif()->notify_use_item(inv_item, false);
        return false;
    }
 
    player()->get_session()->clif()->notify_use_item(inv_item, true);
    return true;
}

References _inventory_items, and player().

Here is the call graph for this function:

Member Data Documentation

_equipments

EquipmentListType Horizon::Zone::Assets::Inventory::_equipments

private

Referenced by equipments(), and Inventory().

_inventory_items

storage_type Horizon::Zone::Assets::Inventory::_inventory_items

private

Referenced by add_item(), equip_item(), get_free_index(), get_item(), initialize(), load(), notify_only_equipments(), notify_without_equipments(), print_inventory(), remove_item(), save(), unequip_item(), and use_item().

_max_storage

int32_t Horizon::Zone::Assets::Inventory::_max_storage

private

Referenced by max_storage(), and set_max_storage().

_player

std::weak_ptr<Horizon::Zone::Units::Player> Horizon::Zone::Assets::Inventory::_player

private

Referenced by player().

_saved_inventory_items

storage_type Horizon::Zone::Assets::Inventory::_saved_inventory_items

private

Referenced by load(), and save().

---

The documentation for this class was generated from the following files:

• src/Server/Zone/Game/Units/Player/Assets/Inventory.hpp
• src/Server/Zone/Game/Units/Player/Assets/Inventory.cpp