pscharinventory.h

Go to the documentation of this file.

/*
 * pscharinventory.h  by Keith Fulton <[email protected]>
 *
 * Copyright (C) 2007 Atomic Blue ([email protected], http://www.atomicblue.org)
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef __PSCHARINV_H__
#define __PSCHARINV_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/sysfunc.h>
#include <csutil/weakref.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "util/poolallocator.h"
#include "util/psconst.h"

#include "../icachedobject.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "psitemstats.h"
#include "psstdint.h"
#include "psitem.h"
#include "psinventorycachesvr.h"
#include "psspell.h"

struct iDocumentNode;

class MsgEntry;
class psItemStats;
class psItem;
class gemContainer;
struct psRaceInfo;
class gemActor;


#define PSCHARACTER_EQUIPMENTFLAG_AUTOATTACK       0x00000001

#define PSCHARACTER_EQUIPMENTFLAG_SINGLEATTACK     0x00000002

#define PSCHARACTER_EQUIPMENTFLAG_ATTACKIFEMPTY    0x00000004


//-----------------------------------------------------------------------------

struct glyphSlotInfo
{
    psItemStats* glyphType;
    int purifyStatus;   
};


//-----------------------------------------------------------------------------

class psCharacterInventory
{
public:
    psCharacter* owner;

    class psCharacterInventoryItem
    {
        friend class psCharacterInventory;
        psItem* item;               
    public:
        psCharacterInventoryItem(psItem* it)
        {
            item = it;
            exchangeOfferSlot  = -1;
            exchangeStackCount = 0;
        }
        int    exchangeOfferSlot;   
        int    exchangeStackCount;  
        psItem* GetItem()
        {
            return item;    
        }
    };

protected:

    csArray<psCharacterInventoryItem> inventory;

    csArray<psItem*> storageInventory;

    struct psEquipInfo
    {
        unsigned int EquipmentFlags;
        int          eventId;
        size_t       itemIndexEquipped;
        psItem*      default_if_empty;
    };

    psEquipInfo equipment[PSCHARACTER_SLOT_BULK1]; // bulk1 is the first slot above equipment

    bool doRestrictions;

    bool loaded;

    float maxWeight;

    float maxSize;

    bool inExchangeMode;

    uint32 version;

public:

    psCharacterInventory(psCharacter* owner);
    ~psCharacterInventory();

    bool Load();

    bool Load(PID id);

    bool QuickLoad(PID id);

    bool HasEnoughUnusedSpace(float desiredSpace);
    int GetCurrentTotalSpace();
    int GetCurrentMaxSpace();

    void AddStorageItem(psItem* &item);

    bool HasEnoughUnusedWeight(float requiredWeight);
    float GetCurrentTotalWeight();

    size_t HowManyCanFit(psItem* item);


    float MaxWeight()
    {
        return maxWeight;
    }


    // float Weight() { return 0; }

    float GetTotalSizeOfItemsInContainer(psItem* container=NULL);

    uint32 GetInventoryVersion() const
    {
        return version;
    }

    void IncreaseInventoryVersion()
    {
        version++;
    }

    bool Add(psItem* &item, bool test = false, bool stack = true,
             INVENTORY_SLOT_NUMBER slot = PSCHARACTER_SLOT_NONE, gemContainer* container = NULL, bool precise = true, bool skip_requirements = false);

    psItem* AddStacked(psItem* &item, int &added);

    bool AddOrDrop(psItem* &item, bool stack = true);

    psItem* GetItem(psItem* container, INVENTORY_SLOT_NUMBER slot);

    bool hasItemsWithName(csString &itemname, bool includeEquipment, bool includeBulk, int amountMin = 1, int amountMax = -1, float qualityMin = 0, float qualityMax = 0);

    psItem* GetInventoryItem(INVENTORY_SLOT_NUMBER slot);

    void RestoreAllInventoryQuality();

    psItem* GetItemHeld();

    psCharacterInventoryItem* GetCharInventoryItem(INVENTORY_SLOT_NUMBER slot);

    INVENTORY_SLOT_NUMBER FindSlotHoldingItem(psItem* item);

    size_t FindItemStatIndex(psItemStats* itemstats,size_t startAt=1);

    psItem* RemoveItem(psItem* container, INVENTORY_SLOT_NUMBER bulkslot, int count = -1);

    psItem* RemoveItemID(uint32 itemID,int count = -1, bool storage = false);

    psItem* RemoveInventoryItem(INVENTORY_SLOT_NUMBER slot, int count = -1);


    unsigned int TotalStackOfItem(psItemStats* item);

    psItem* FindItemID(uint32 itemID, bool storage = false);

    void SetExchangeOfferSlot(psItem* Container,INVENTORY_SLOT_NUMBER slot,int toSlot,int stackCount);
    int  GetOfferedStackCount(psItem* item);
    psCharacterInventoryItem* FindExchangeSlotOffered(int slotID);
    void PurgeOffered();

    bool HaveKeyForLock(uint32 lock);

    bool CanItemAttack(INVENTORY_SLOT_NUMBER slot);

    bool IsItemAutoAttack(INVENTORY_SLOT_NUMBER slot);

    psEquipInfo &GetEquipmentObject(INVENTORY_SLOT_NUMBER idx);

    psItem* GetEffectiveWeaponInSlot(INVENTORY_SLOT_NUMBER slot, bool includeShield = false);

    psItem* GetEffectiveArmorInSlot(INVENTORY_SLOT_NUMBER slot);

    bool hasItemCategory(psItemCategory* category, bool includeEquipment, bool includeBulk, bool includeStorage = false);

    bool hasItemCategory(csString &categoryname, bool includeEquipment, bool includeBulk, bool includeStorage = false, int amountMin = 1, int amountMax = -1 , float qualityMin = 0, float qualityMax = 0);

    csArray<psItem*> GetItemsInCategory(psItemCategory* category, bool storage = false);

    psItem* StackNumberItems(const csString &itemname, int count, bool container);


    size_t GetContainedItemCount(psItem* container);
    float GetContainedWeight(psItem* container);
    float GetContainedSize(psItem* container);

    void CalculateLimits();

    void RunEquipScripts();

    csString lastError;

    void SetDoRestrictions(bool v);

    bool GetDoRestrictions()
    {
        return doRestrictions;
    }

    psInventoryCacheServer* GetInventoryCacheServer(void)
    {
        return &inventoryCacheServer;
    }

    bool HasPurifiedGlyphs(const glyphList_t glyphsToCheck);

    void CreateGlyphList(csArray <glyphSlotInfo> &slots);

    bool AddLoadedItem(uint32 parentID, INVENTORY_SLOT_NUMBER slot, psItem* item);

    void Equip(psItem* item);
    void Unequip(psItem* item);
    bool CheckSlotRequirements(psItem* item, INVENTORY_SLOT_NUMBER proposedSlot, unsigned short stackCount = 0);

    bool EquipItem(psItem* newItem, INVENTORY_SLOT_NUMBER slotID);

    INVENTORY_SLOT_NUMBER FindFreeEquipSlot(psItem* itemToPlace);

    size_t GetInventoryIndexCount()
    {
        return inventory.GetSize();
    }

    psItem* GetInventoryIndexItem(size_t which)
    {
        return inventory[which].item;
    }

    psCharacterInventoryItem* GetIndexCharInventoryItem(size_t index)
    {
        return &inventory[index];
    }

    void WriteAllInventory(iDocumentNode* npcRoot);

    psItem* RemoveItemIndex(size_t index,int count=-1, bool storage = false);

    bool BeginExchange();

    void CommitExchange();

    void RollbackExchange();

    void UpdateEncumbrance();

    void SetBasicArmor(psRaceInfo* race = NULL);

    void SetBasicWeapon(psRaceInfo* race = NULL);

    static psItem* GetItemFactory(psItemStats* stats);

private:
    void WriteItem(csRef<iDocumentNode> equipmentNode, psItem* item, int bulk, INVENTORY_SLOT_NUMBER slot);

    size_t GetItemIndex(psItem* item);

    size_t FindSlotIndex(psItem* container,INVENTORY_SLOT_NUMBER slot);

    int FindFirstOpenSlot(psItem* container);

    size_t FindCompatibleStackedItem(psItem* item, bool checkStackCount = true);

    csArray<size_t> FindCompatibleStackedItems(psItem* item, bool checkStackCount = true, bool precise = true);

    psInventoryCacheServer inventoryCacheServer;    

};

class InventoryTransaction
{
public:
    InventoryTransaction(psCharacterInventory* what)
    {
        myInv    = what;
        committed = false;
        myInv->BeginExchange();
    }
    ~InventoryTransaction()
    {
        if(!committed && myInv)
            myInv->RollbackExchange();
    }
    void Commit()
    {
        myInv->CommitExchange();
        committed = true;
    }
    void Cancel()
    {
        myInv = NULL; // character deleted or somesuch
    }

protected:
    psCharacterInventory* myInv;
    bool committed;
};

#endif