Horizon::Zone::Assets::Storage Class Reference

#include <Storage.hpp>

Public Member Functions
	Storage (std::shared_ptr< Horizon::Zone::Units::Player > player, int32_t storage_id, std::string name, uint32_t max_storage)
virtual	~Storage ()
int32_t	load ()
int32_t	save ()
int16_t	get_free_index ()
int32_t	get_storage_id ()
std::string	name ()
int32_t	max_storage ()
std::shared_ptr< Horizon::Zone::Units::Player >	player ()
storage_add_item_result_type	add_item (std::shared_ptr< item_entry_data > item, int amount)
storage_remove_item_result_type	remove_item (int32_t index, int amount)
std::shared_ptr< item_entry_data >	get_item (int32_t storage_index)
storage_add_item_result_type	add_item_from_inventory (int16_t inventory_index, int amount)
storage_to_inventory_result_type	add_item_to_inventory (int storage_index, int amount)
void	notify_all ()
void	notify_normal ()
void	notify_equips ()

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

Private Attributes
int32_t	_storage_id { 0 }
std::string	_name {""}
int32_t	_max_storage { 0 }
std::weak_ptr< Horizon::Zone::Units::Player >	_player
storage_type	_storage_items
storage_type	_saved_storage_items

Member Typedef Documentation

storage_type

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

private

Constructor & Destructor Documentation

Storage()

Storage::Storage	(	std::shared_ptr< Horizon::Zone::Units::Player >	player,
		int32_t	storage_id,
		std::string	name,
		uint32_t	max_storage
	)

: _player(player), _storage_id(storage_id), _name(name), _max_storage(max_storage)
{
}

~Storage()

Storage::~Storage ( )

virtual

{
}

Member Function Documentation

add_item()

Horizon::Zone::storage_add_item_result_type Storage::add_item	(	std::shared_ptr< item_entry_data >	item,
		int	amount
	)

{
    if (amount == 0)
        return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_INVALID;
 
    // Check if item is stackable
    if (item->is_stackable()) {
        // Check if item exists in inventory.
        auto storitem = std::find_if(_storage_items.begin(), _storage_items.end(), 
            [&item] (std::shared_ptr<item_entry_data> storeit) {
                if (storeit == nullptr)
                    return false;
                return (storeit->amount < MAX_STORAGE_STACK_LIMIT && *storeit == *item); 
            }
        );
        // If item was found in inventory...
        if (storitem != _storage_items.end()) {
            std::shared_ptr<item_entry_data> store_item = *storitem;
            // Check if amount exeeds stack size.
            if (store_item->amount + amount > MAX_STORAGE_STACK_LIMIT) {
                // Add appropriately
                int left_amt = store_item->amount - MAX_STORAGE_STACK_LIMIT;
                store_item->amount += left_amt;
                item->amount -= left_amt;
                if (amount - left_amt > 0)
                    add_item_from_inventory(item->index.inventory, amount - left_amt);
                return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_SUCCESS;
            } else {
                store_item->amount += amount;
            }
            player()->get_session()->clif()->notify_storage_add_item(store_item, amount);
        } else {
            int16_t 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_STORAGE;
            item_new_stack->index.storage = index + 1;
            _storage_items[index] = item_new_stack;
            player()->get_session()->clif()->notify_storage_add_item(item_new_stack, amount);
        }
    } else {
        int16_t index = get_free_index();
 
        item->amount = 1;
        item->storage_type = ITEM_STORE_STORAGE;
        item->index.storage = index + 1;
        _storage_items[index] = item;
        player()->get_session()->clif()->notify_storage_add_item(item, 1);
    }
 
    return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_SUCCESS;
}

References _storage_items, add_item_from_inventory(), get_free_index(), ITEM_STORE_STORAGE, MAX_STORAGE_STACK_LIMIT, player(), Horizon::Zone::STORAGE_ADD_INVALID, and Horizon::Zone::STORAGE_ADD_SUCCESS.

Referenced by add_item_from_inventory().

Here is the call graph for this function:

Here is the caller graph for this function:

add_item_from_inventory()

Horizon::Zone::storage_add_item_result_type Storage::add_item_from_inventory	(	int16_t	inventory_index,
		int	amount
	)

{
    std::shared_ptr<item_entry_data> item = player()->inventory()->get_item(inventory_index);
 
    if (item == nullptr)
        return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_INVALID;
 
    if (amount == 0)
        return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_INVALID;
 
    if (_storage_items.size() >= _max_storage)
        return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_OVER_QUANTITY;
 
    if (item->amount > MAX_STORAGE_STACK_LIMIT)
        return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_OVER_STACK_LIMIT;
    
    if (add_item(item, amount) == Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_SUCCESS)
        player()->inventory()->remove_item(inventory_index, amount, item_deletion_reason_type::ITEM_DEL_TOSTORAGE);
 
    return Horizon::Zone::storage_add_item_result_type::STORAGE_ADD_SUCCESS;
}

References _max_storage, _storage_items, add_item(), ITEM_DEL_TOSTORAGE, MAX_STORAGE_STACK_LIMIT, player(), Horizon::Zone::STORAGE_ADD_INVALID, Horizon::Zone::STORAGE_ADD_OVER_QUANTITY, Horizon::Zone::STORAGE_ADD_OVER_STACK_LIMIT, and Horizon::Zone::STORAGE_ADD_SUCCESS.

Referenced by add_item().

Here is the call graph for this function:

Here is the caller graph for this function:

add_item_to_inventory()

Horizon::Zone::storage_to_inventory_result_type Storage::add_item_to_inventory	(	int	storage_index,
		int	amount
	)

{
    std::shared_ptr<item_entry_data> item = get_item(storage_index);
 
    if (item == nullptr)
        return Horizon::Zone::storage_to_inventory_result_type::STORAGE_TO_INVENTORY_INVALID;
 
    if (amount > MAX_STORAGE_STACK_LIMIT)
        return Horizon::Zone::storage_to_inventory_result_type::STORAGE_TO_INVENTORY_OVER_STACK_LIMIT;
 
    if (remove_item(storage_index, amount) == Horizon::Zone::storage_remove_item_result_type::STORAGE_REMOVE_SUCCESS)
        player()->get_session()->clif()->notify_storage_remove_item(storage_index, amount);
    else
        return Horizon::Zone::storage_to_inventory_result_type::STORAGE_TO_INVENTORY_INVALID;
    
    player()->inventory()->add_item(item, amount);
 
    return Horizon::Zone::storage_to_inventory_result_type::STORAGE_TO_INVENTORY_SUCCESS;
}

References get_item(), MAX_STORAGE_STACK_LIMIT, player(), remove_item(), Horizon::Zone::STORAGE_REMOVE_SUCCESS, Horizon::Zone::STORAGE_TO_INVENTORY_INVALID, Horizon::Zone::STORAGE_TO_INVENTORY_OVER_STACK_LIMIT, and Horizon::Zone::STORAGE_TO_INVENTORY_SUCCESS.

Here is the call graph for this function:

get_free_index()

int16_t Storage::get_free_index

(

)

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

References _storage_items.

Referenced by add_item().

Here is the caller graph for this function:

get_item()

std::shared_ptr< item_entry_data > Storage::get_item

(

int32_t

storage_index

)

{
    if (storage_index - 1 < 0)
        return nullptr;
 
    if (_storage_items.size() - 1 < storage_index - 1) {
        HLog(error) << "Storage::get_item: Attempted to get item from storage index " << storage_index << " but storage size is " << _storage_items.size();
        return nullptr;
    }
 
    return _storage_items[storage_index - 1];
}

References _storage_items, and HLog.

Referenced by add_item_to_inventory(), and remove_item().

Here is the caller graph for this function:

get_storage_id()

int32_t Horizon::Zone::Assets::Storage::get_storage_id ( )

inline

{ return _storage_id; }

References _storage_id.

load()

int32_t Storage::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 `storage` WHERE `account_id` = ? AND `storage_id` = ?");
        auto b1 = stmt.bind(player()->account()._account_id, _storage_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        if (_storage_items.size() != 0) {
            HLog(warning) << "Attempt to synchronize the saved storage, which should be empty at the time of load or re-load, size: " << _storage_items.size();
            return 0;
        }
 
        int storage_index = 1;
        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_STORAGE;
            i.index.storage = storage_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_storage_items.push_back(item);
            _storage_items.push_back(item);
        }
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << "Storage::load:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Storage::load:" << error.what();
        return false;
    }
    
    HLog(info) << "Loaded Storage (" << _name << ") for (Account ID: " << player()->account()._account_id << ") with " << _storage_items.size() << " items.";
 
    return _storage_items.size();
}

References _name, _saved_storage_items, _storage_id, _storage_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::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_STORAGE, 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, 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()

int32_t Horizon::Zone::Assets::Storage::max_storage ( )

inline

{ return _max_storage; }

References _max_storage.

name()

std::string Horizon::Zone::Assets::Storage::name ( )

inline

{ return _name; }

References _name.

notify_all()

void Storage::notify_all

(

)

{
    player()->get_session()->clif()->notify_inventory_start(INVTYPE_STORAGE, _name);
    if (_storage_items.size()) {
        notify_normal();
        notify_equips();
    }
    player()->get_session()->clif()->notify_storage_size(_storage_items.size(), _max_storage);
    player()->get_session()->clif()->notify_inventory_end(INVTYPE_STORAGE);
    player()->set_current_storage_id(_storage_id);
}

References _max_storage, _name, _storage_id, _storage_items, INVTYPE_STORAGE, notify_equips(), notify_normal(), and player().

Referenced by Horizon::Zone::PlayerComponent::sync_data_types().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_equips()

void Storage::notify_equips

(

)

{
    std::vector<std::shared_ptr<const item_entry_data>> equipments;
 
    for (auto eit = _storage_items.begin(); eit != _storage_items.end(); eit++) {
        if ((*eit) == nullptr)
            continue;
        if ((*eit)->is_equipment())
            equipments.push_back(*eit);
    }
 
    player()->get_session()->clif()->notify_storage_equip_items(_name, equipments);
}

References _name, _storage_items, and player().

Referenced by notify_all().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_normal()

void Storage::notify_normal

(

)

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

References _name, _storage_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::Storage::player ( )

inline

{ return _player.lock(); }

References _player.

Referenced by add_item(), add_item_from_inventory(), add_item_to_inventory(), load(), notify_all(), notify_equips(), notify_normal(), and save().

Here is the caller graph for this function:

remove_item()

Horizon::Zone::storage_remove_item_result_type Storage::remove_item	(	int32_t	index,
		int	amount
	)

{
    std::shared_ptr<item_entry_data> item = get_item(storage_index);
 
    if (item == nullptr)
        return Horizon::Zone::storage_remove_item_result_type::STORAGE_REMOVE_INVALID;
 
    if (item->amount < amount)
        return Horizon::Zone::storage_remove_item_result_type::STORAGE_REMOVE_INVALID;
 
    if (amount > item->amount)
        return Horizon::Zone::storage_remove_item_result_type::STORAGE_REMOVE_INVALID;
 
    item->amount -= amount;
 
    if (item->amount == 0)
        _storage_items[storage_index - 1] = nullptr;
 
    return Horizon::Zone::storage_remove_item_result_type::STORAGE_REMOVE_SUCCESS;
}

References _storage_items, get_item(), Horizon::Zone::STORAGE_REMOVE_INVALID, and Horizon::Zone::STORAGE_REMOVE_SUCCESS.

Referenced by add_item_to_inventory().

Here is the call graph for this function:

Here is the caller graph for this function:

save()

int32_t Storage::save

(

)

{
    int32_t changes = 0;
 
    _saved_storage_items.clear();
 
    std::copy(_storage_items.begin(), _storage_items.end(), std::inserter(_saved_storage_items, _saved_storage_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 `storage` WHERE `account_id` = ? AND `storage_id` = ?");
        auto b1 = stmt.bind(player()->account()._account_id, _storage_id);
        boost::mysql::results results;
        conn->execute(b1, results);
 
        boost::format fmt_ctx = boost::format("INSERT INTO `storage` (`account_id`, `storage_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_storage_items.begin(); mit_i != _saved_storage_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%, %27%)")
                % player()->account()._account_id
                % (int)_storage_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) << "Storage::save:" << error.what();
        return false;
    }
    catch (std::exception& error) {
        HLog(error) << "Storage::save:" << error.what();
        return false;
    }
 
    HLog(info) << "Saved Storage (" << _name << ") for (Account ID: " << player()->account()._account_id << ") with " << changes << " changes.";
 
    return changes;
}

References _name, _saved_storage_items, _storage_id, _storage_items, GridTypeListIterator::count(), HLog, player(), and sZone.

Here is the call graph for this function:

Member Data Documentation

_max_storage

int32_t Horizon::Zone::Assets::Storage::_max_storage { 0 }

private

Referenced by add_item_from_inventory(), max_storage(), and notify_all().

_name

std::string Horizon::Zone::Assets::Storage::_name {""}

private

Referenced by load(), name(), notify_all(), notify_equips(), notify_normal(), and save().

_player

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

private

Referenced by player().

_saved_storage_items

storage_type Horizon::Zone::Assets::Storage::_saved_storage_items

private

Referenced by load(), and save().

_storage_id

int32_t Horizon::Zone::Assets::Storage::_storage_id { 0 }

private

Referenced by get_storage_id(), load(), notify_all(), and save().

_storage_items

storage_type Horizon::Zone::Assets::Storage::_storage_items

private

Referenced by add_item(), add_item_from_inventory(), get_free_index(), get_item(), load(), notify_all(), notify_equips(), notify_normal(), remove_item(), and save().

---

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

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