RoT2_PRC8/_module/nss/nui_c_storage.nss

/// ----------------------------------------------------------------------------
/// @file   nui_c_storage.nss
/// @author Ed Burke (tinygiant98) <af.hog.pilot@gmail.com>
/// @brief  Persistent Storage formfile configuration settings
/// ----------------------------------------------------------------------------

/// @note Most of the following global/default settings can be overriden on a
///     per-container basis by setting a local variable on the container
///     object as noted in the setting descriptions below.  Constants, such as
///     PS_TRUE, PS_NONE, etc. should be used in this configuration file, however,
///     actual values must be used when setting local overrides.  Those values
///     are provided below.

/// @warning This system uses player character UUIDs.  This can cause issues in
///     single-player modules if the player-character is not exported and the
///     UUID is not saved to the .bic file.

/// @brief By default, containers will be saved to a database table referenced
///     by the container object's tag.  The saved item data includes the UUID
///     and CD Key of the PC that deposited the item so the same container can
///     be used for multiple PCs.  To set a specific (unique) name to use as the
///     table name instead, set a local string called `PS_UNIQUE_ID` on the
///     container object and set it to any unique string.

/// @brief Determines usage of the `Search` button.
///     Configuration File:
///         PS_TRUE to force players to click the `Search` button
///             before an inventory search will commence.  This is a good idea
///             for containers that you expect will have large inventories.
///         PS_FALSE to allow real-time searching as the player types
///             characters into the `Search` textbox.
///     Local Override (int): PS_FORCE_SEARCH_BUTTON
///          1 = PS_TRUE
///         -1 = PS_FALSE
const int PS_FORCE_SEARCH_BUTTON_DEFAULT = PS_FALSE;

/// @brief Determines whether item object state is saved to the database. The
///     object state includes variables and effects.
///     Configuration File:
///         PS_TRUE saves the object state
///         PS_FALSE does not save the object state
///     Local Override (int): PS_FORCE_OBJECT_STATE
///          1 = PS_TRUE
///         -1 = PS_FALSE
const int PS_FORCE_OBJECT_STATE_DEFAULT = PS_TRUE;

/// @brief Sets the item storage limit.
///     Configuration File:
///         PS_UNLIMITED to allow unlimited item storage.
///         Set to any positive integer to limit item storage to that amount.
///     Local Override (int): PS_STORAGE_LIMIT
///         -1 = PS_UNLIMITED
///         Set to any positive integer to limit item storage to that amount.
const int PS_STORAGE_LIMIT_DEFAULT = 500;

/// @brief Set the maximum distance (meters) a PC can travel from the container
///     before the form will auto-close.
///     Configuration File:
///         PS_UNLIMITED_DISTANCE to never auto-close the form
///         Set to any positive float to limit distance to that amount.
///     Local Override (float): PS_DISTANCE
///         -1.0 = PS_UNLIMITED_DISTANCE
///         Set to any positive float to limit distance to that amount.
const float PS_DISTANCE_DEFAULT = 2.0;

/// @brief Set the container access type.  Container inventories can be accessed
///     by two methods:  exclusive and contentious.
///     - Exclusive:  Multiple players may open the same container, but each
///         player will only see items they've previously deposited.  Players
///         may only withdraw items they've previously deposited.
///     - Contentious:  Multiple players may open the same container.  All
///         players will see all items deposited by any player.  Any player
///         can remove any item, regardless of who originally deposited the
///         item.
///
///     Configuration File:
///         PS_ACCESS_EXCLUSIVE for exclusive access
///         PS_ACCESS_CONTENTIOUS for contentious access
///     Local Override (int): PS_ACCESS_TYPE
///         1 = PS_ACCESS_EXCLUSIVE
///         2 = PS_ACCESS_CONTENTIOUS
const int PS_ACCESS_TYPE_DEFAULT = PS_ACCESS_EXCLUSIVE;

/// @brief Set the container type. Containers can be of multiple types:
///     - Public:  Any player can open, deposit and withdraw items from this
///         container.  Whether they are limited to specific items is dependant
///         on the container's access setting.
///     - Character:  Creates a 'portable' storage container for any player
///         character.  Any container of this type will hold the same inventory
///         for any specific player.
///     - CD Key:  Creates a 'portable' storage container for any characters
///         owned by cd-key associated with the player character.  Any container
///         of this type will hold the inventory desposited by any character
///         sharing the player's cd key.
///
///     Configuration File:
///         PS_CONTAINER_PUBLIC for public.
///         PS_CONTAINER_CHARACTER for per-character.
///         PS_CONTAINER_CD_KEY for per-cdkey.
///     Local Override (int): PS_CONTAINER_TYPE
///         1 = PS_CONTAINER_PUBLIC
///         2 = PS_CONTAINER_CHARACTER
///         3 = PS_CONTAINER_CDKEY
const int PS_CONTAINER_TYPE_DEFAULT = PS_CONTAINER_CDKEY;

/// @brief Set the default container type, if the container is an item.  Containers
///     can be of multiple types:
///     - Public:  Any player can open, deposit and withdraw items from this
///         container.  Whether they are limited to specific items is dependant
///         on the container's access setting.
///     - Character:  Creates a 'portable' storage container for any player
///         character.  Any container of this type will hold the same inventory
///         for any specific player.
///     - CD Key:  Creates a 'portable' storage container for any characters
///         owned by cd-key associated with the player character.  Any container
///         of this type will hold the inventory desposited by any character
///         sharing the player's cd key.
///
///     Configuration File:
///         PS_CONTAINER_PUBLIC for public.
///         PS_CONTAINER_CHARACTER for per-character.
///         PS_CONTAINER_CD_KEY for per-cdkey.
///     Local Override (int): PS_CONTAINER_TYPE
///         1 = PS_CONTAINER_PUBLIC
///         2 = PS_CONTAINER_CHARACTER
///         3 = PS_CONTAINER_CDKEY
const int PS_CONTAINER_ITEM_TYPE_DEFAULT = PS_CONTAINER_CDKEY;

/// @brief Determines whether the player's inventory window will be opened
///     when a container is opened.
///     Configuration File:
///         PS_TRUE to open the inventory window.
///         PS_FALSE to prevent the window from opening.  If the inventory
///             window is already open, this will not close it.
///     Local Override (int): PS_OPEN_INVENTORY
///          1 = PS_TRUE
///         -1 = PS_FALSE
const int PS_OPEN_INVENTORY_DEFAULT = PS_TRUE;

/// @brief Determines the maximum amount of gold a container can store.
///     If the container is set to store no gold, the form controls that
///     manipulate gold storage will not be visible on the form.
///     Configuration File:
///         PS_UNLIMITED to allow unlimited gold storage.
///         PS_NONE to prevent gold storage.
///         Set to any positive integer to limit gold to that amount.
///     Local Override (int): PS_MAX_GOLD
///         -1 = PS_UNLIMITED
///         -2 = PS_NONE
///         Set to any positive integer to limit gold to that amount.
const int PS_MAX_GOLD_DEFAULT = 2000000000;

/// @note Reference these terms for the following option:
///     Container: A persistent storage object in the game, such as a chest.
///     Container Item: An item which:
///                         Can have its own inventory
///                         Can be carried in a player's inventory

/// @brief Determines handling for container objects.  Containers can optionally
///     store container items.
///     Configuration File:
///         PS_UNLIMITED to allow storage of an unlimited number of container items.
///         PS_NONE to prevent storage of any container items.
///         Set to any positive integer to limit storage to that number of container
///             items.
///     Local Override (int): PS_MAX_CONTAINER_TIMES
///         -1 = PS_UNLIMITED
///         -2 = PS_NONE
///         Set to any positive integer to limit storage to that number of container
///             items.
const int PS_MAX_CONTAINER_ITEMS_DEFAULT = 10;

/// @brief Determines how many items can be stored in stored container items.
///     Configuration File:
///         PS_UNLIMITED to allow storage of any number of items within a container
///             item's inventory.  This will be naturally limited by the size of
///             the container item's inventory.
///         PS_NONE to prevent any items from being stored in a container item.  If
///             container item storage is allow and PS_NONE is used, only empty
///             container items can be stored.
///         Set to any positive integer to limit the number of items stored in
///             the inventory of a container item.
///     Local Override (int): PS_MAX_CONTAINER_ITEMS_INVENTORY
///         -1 = PS_UNLIMITED
///         -2 = PS_NONE
///         Set to any positive integer to limit the number of items stored in
///             the inventory of a container item.
///
/// @note This configuration option has no effect if PS_MAX_CONTAINER_ITEMS_DEFAULT
///     is set to PS_NONE or its local override is set to -1.
/// @warning Items that fail check involved with container item limitations do
///     not have default messages reported to the player.  The item will simply fail
///     to be stored.
const int PS_MAX_CONTAINER_ITEMS_INVENTORY_DEFAULT = 100;

/// @brief Creates the form's title.
/// @param oContainer The container object being used.
/// @param oPC The player using oContainer.
/// @note A local string called `PS_TITLE` may be set on the object for easy
///     reference in this function.  The function below is an example and may
///     be modified in any way.  The returned value will be displayed as the
///     form's title.
string ps_GetFormTitle(object oContainer, object oPC, int nAccess, int nType)
{
    string sTitle;
    if ((sTitle = GetLocalString(oContainer, PS_TITLE)) != "")
        return sTitle;
    else
    {
        switch (nType)
        {
            case PS_CONTAINER_PUBLIC:
                return GetTag(oContainer);
            case PS_CONTAINER_CDKEY:
                return GetName(oPC) + "'s Player-Specific Storage";
            case PS_CONTAINER_CHARACTER:
                return GetName(oPC) + "'s Character-Specific Storage";
        }

        if (GetIsPC(OBJECT_SELF))
            return GetName(OBJECT_SELF) + "'s Storage";
    }

    return "Persistent Storage";
}