psitem.h

Go to the documentation of this file.

/*
 * psitem.h
 *
 * Copyright (C) 2003 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 __PSITEM_H__
#define __PSITEM_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/array.h>
#include <csgeom/vector3.h>
#include <csutil/weakreferenced.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "util/psconst.h"
#include "util/scriptvar.h"
#include "util/gameevent.h"
#include "util/slots.h"

#include <idal.h>

#include "util/poolallocator.h"

#include "net/messages.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "psskills.h"
#include "psitemstats.h"
#include "deleteobjcallback.h"
#include "psactionlocationinfo.h"
#include "lootrandomizer.h"


class Client;
class gemActor;

// Note: The following 2 options require a clean rebuild when changed.

#define SAVE_DEBUG 0

#define SAVE_TRACER 0


#define REMOVAL_INTERVAL_RANGE     300
#define REMOVAL_INTERVAL_MINIMUM  2419200

#define  ID_DONT_SAVE_ITEM 0xffffffff

#define PSITEM_FLAG_CRAFTER_ID_IS_VALID 0x00000001

#define PSITEM_FLAG_GUILD_ID_IS_VALID   0x00000002

#define PSITEM_FLAG_UNIQUE_ITEM         0x00000004

#define PSITEM_FLAG_USES_BASIC_ITEM     0x00000008

#define PSITEM_FLAG_PURIFIED            0x00000010
#define PSITEM_FLAG_PURIFYING           0x00000020

#define PSITEM_FLAG_LOCKED              0x00000040

#define PSITEM_FLAG_LOCKABLE            0x00000080

#define PSITEM_FLAG_NOPICKUP            0x00000100

#define PSITEM_FLAG_KEY                 0x00000200

#define PSITEM_FLAG_TRANSIENT           0x00000400

#define PSITEM_FLAG_UNPICKABLE          0x00000800

#define PSITEM_FLAG_SECURITYLOCK        0x00001000

#define PSITEM_FLAG_NPCOWNED            0x00002000

#define PSITEM_FLAG_MASTERKEY           0x00004000

#define PSITEM_FLAG_USE_CD              0x00008000

#define PSITEM_FLAG_ACTIVE              0x00010000

#define PSITEM_FLAG_UNSTACKABLE         0x00020000

#define PSITEM_FLAG_STACKABLE           0x00040000

#define PSITEM_FLAG_SETTINGITEM         0x00080000

#define PSITEM_FLAG_NOPICKUPWEAK        0x00100000

#define PSITEM_FLAG_IDENTIFIABLE        0x00200000

#define KEY_SKELETON      ((unsigned int)-2)

#define MAX_STACK_COUNT        65  // This is the most items a player can have in a stack

typedef unsigned int PSITEM_FLAGS;

#define PSITEM_MAX_MODIFIERS    10

class ActiveSpell;
class psItem;
class psCharacter;
class gemItem;
class psSectorInfo;
struct psItemCategory;
class psScheduledItem;
class psWorkGameEvent;

class RandomizedOverlay
{
public:
    RandomizedOverlay(); 
    ~RandomizedOverlay(); 
    bool active; 
    csString name; 
    float weight; 
    float latency; 
    float damageStats[PSITEMSTATS_DAMAGETYPE_COUNT]; 
    ApplicativeScript* equip_script; 
    psMoney price; 
    csArray<ItemRequirement> reqs; 
    csString mesh; 
    csString icon; 
};

class psItem : public iScriptableVar, public iDeleteObjectCallback
{
public:

    psItem();

    virtual ~psItem();

    virtual const char* GetItemType()
    {
        return "Item";
    }

    gemItem* GetGemObject()
    {
        return gItem;
    }
    void SetGemObject(gemItem* object);

    psWorkGameEvent* GetTransformationEvent()
    {
        return transformationEvent;
    }
    void SetTransformationEvent(psWorkGameEvent* t)
    {
        transformationEvent = t;
    }

    virtual void DeleteObjectCallback(iDeleteNotificationObject* object);

    void UpdateView(Client* fromClient, EID eid, bool clear);

    bool SendItemDescription(Client* client);

    bool SendContainerContents(Client* client, int containerID = CONTAINER_INVENTORY_BULK);

    void ViewItem(Client* client, int containerID, INVENTORY_SLOT_NUMBER slotID);

    bool SendActionContents(Client* client, psActionLocation* action);

private:


    void FillContainerMsg(Client* client, psViewContainerDescription &outgoing);

    void SendCraftTransInfo(Client* client);

    void GetComboInfoString(psCharacter* character, uint32 designID, csString &comboString);

    void GetTransInfoString(psCharacter* character, uint32 designID, csString &transString);

    bool SendBookText(Client* client, int containerID, int slotID);

    void SendSketchDefinition(Client* client);

    void SendMusicalSheet(Client* client);

    uint32 uid;

    bool item_in_use;

    psWorkGameEvent* transformationEvent;

    struct
    {
        psSectorInfo* loc_sectorinfo;
        float loc_x,loc_y,loc_z;
        float loc_xrot,loc_yrot,loc_zrot;
        InstanceID worldInstance;
    } location;

    float decay_resistance; // percent 3.2


    float item_quality;                     
    float crafted_quality;                  


    float item_quality_original;

    unsigned short stack_count;

    int charges;

    bool useNat;


protected:
    PSITEM_FLAGS flags;
private:
    PID crafter_id;
    unsigned int guild_id;

    /* Container Hierarchy Data
     *
     *  The following field allows objects-within-objects (containers) to be described.
     *
     */
    InstanceID parent_item_InstanceID;


    INVENTORY_SLOT_NUMBER loc_in_parent;


    psCharacter* owning_character;

    PID owningCharacterID;
    PID guardingCharacterID;

    psItemStats* base_stats;
    psItemStats* current_stats;
    psItemStats* modifiers[PSITEM_MAX_MODIFIERS];

    // Lock stuff
    unsigned int lockStrength;
    PSSKILL lockpickSkill;

    // A key can open multiple locks
    csArray<unsigned int> openableLocks;

    psScheduledItem* schedule;

    void Commit(bool children = false);

    void UpdateItemQuality(uint32 id, float qual);

    friend class psDelaySave;

    csString item_name;

    csString item_description;

    ActiveSpell* equipActiveSpell;

    psItemCreativeStats creativeStats;

    RandomizedOverlay* itemModifiers;

    csArray<uint32_t> modifierIds;

public:
    virtual bool Load(iResultRow &row);

    void Save(bool children);

    void ForceSaveIfNew();

    void SetLoaded()
    {
        loaded = true;
    }

    bool CheckRequirements(psCharacter* character, csString &resp);

    uint32 GetUID()
    {
        return uid;
    }

    void SetUID(uint32 v);

    bool GetIsCrafterIDValid();
    void SetIsCrafterIDValid(bool v);

    bool GetIsGuildIDValid();
    void SetIsGuildIDValid(bool v);

    PID GetCrafterID() const
    {
        return crafter_id;
    }
    void SetCrafterID(PID v);

    unsigned int GetGuildID() const
    {
        return guild_id;
    }
    void SetGuildID(unsigned int v);

    float GetMaxItemQuality() const;
    void SetMaxItemQuality(float v);

    float GetItemQuality() const;
    void SetItemQuality(float v);
    const char* GetQualityString();

    PSITEM_FLAGS ParseItemFlags(csString flagstr);

    int GetRequiredRepairTool();
    bool GetRequiredRepairToolConsumed();

    int GetIdentifySkill();
    int GetIdentifyMinSkill();

    void SetDecayResistance(float v);
    void SetItemDecayRate(float v);
    float GetItemDecayRate()
    {
        return base_stats->GetDecayRate();
    }
    float AddDecay(float severityFactor);

    bool IsInUse()
    {
        return item_in_use;
    }
    void SetInUse(bool flag)
    {
        item_in_use = flag;
    }

    bool GetIsUnique() const;

    bool HasModifier(psItemStats* modifier);

    bool AddModifier(psItemStats* modifier);

    psItemStats* GetModifier(int index);

    virtual psItem* CreateNew()
    {
        return new psItem();
    }

    virtual psItem* Copy(unsigned short newstackcount);

    virtual void Copy(psItem* target);

    psItem* SplitStack(unsigned short newstackcount);


    void CombineStack(psItem* &stackme);


    int GetAttackAnimID(psCharacter* pschar);

    float GetDecay();
    void SetDecay(float v);

    unsigned short GetStackCount() const
    {
        return stack_count;
    }
    void SetStackCount(unsigned short v);


    psCharacter* GetOwningCharacter()
    {
        return owning_character;
    }
    PID GetOwningCharacterID() const
    {
        return owningCharacterID;
    }

    virtual void SetOwningCharacter(psCharacter* owner);

    PID  GetGuardingCharacterID() const
    {
        return guardingCharacterID;
    }
    void SetGuardingCharacterID(PID guardian)
    {
        guardingCharacterID = guardian;
    }

    uint32 GetContainerID() const
    {
        return parent_item_InstanceID;
    }
    void SetContainerID(uint32 parentId)
    {
        parent_item_InstanceID = parentId;
    }


    INVENTORY_SLOT_NUMBER GetLocInParent(bool adjustSlot=false);

    void SetLocInParent(INVENTORY_SLOT_NUMBER location);

    void SetUniqueStats(psItemStats* statptr);

    void SetBaseStats(psItemStats* statptr);

    psItemStats* GetBaseStats() const
    {
        return base_stats;
    }

    void SetCurrentStats(psItemStats* statptr);

    psItemStats* GetCurrentStats() const
    {
        return current_stats;
    }

    void RecalcCurrentStats();

    PSITEM_FLAGS GetFlags()
    {
        return flags;
    }

    void SetFlags(int f)
    {
        flags = f;
    }

    virtual int GetPurifyStatus() const
    {
        return 0;
    }

    // Interface to itemstats

    /*  The following functions mostly call into the current stats to return the requested values.
     *  In the future additional logic about value modification may be added to these functions.
     *  For this reason these functions should ALWAYS be used rather than calling GetCurrentStats()->Get*()
     *   unless you REALLY know what you're doing and REALLY mean to bypass the intended value of the item instance.
     */

    bool GetIsMeleeWeapon();
    bool GetIsBothHandsWeapon();
    bool GetIsRangeWeapon();
    bool GetIsAmmo();
    bool GetIsArmor();
    bool GetIsShield();
    bool GetIsContainer();
    bool GetIsAutoTransformContainer();
    bool GetIsTrap();
    bool GetIsConstructible();
    bool GetCanTransform();
    bool GetUsesAmmo();
    bool GetIsStackable() const;
    bool GetIsEquipStackable() const;
    PSITEMSTATS_CREATIVETYPE GetCreative();
    bool SetCreation(PSITEMSTATS_CREATIVETYPE, const csString &, csString);
    PID GetCreator(PSITEMSTATS_CREATORSTATUS &creatorStatus);
    void SetCreator(PID, PSITEMSTATS_CREATORSTATUS);

    bool IsThisTheCreator(PID pid);
    bool GetBuyPersonalise();
    const char* GetName() const;
    const char* GetDescription() const;
    void SetName(const char* newName);
    void SetDescription(const char* newDescription);
    const char* GetStandardName();
    const char* GetStandardDescription();

    void AddLootModifier(uint32_t id, int pos = -1);

    void UpdateModifiers();

    float GetRange() const
    {
        return current_stats->GetRange();
    }
    bool UsesAmmoType(uint32_t id) const
    {
        return current_stats->UsesAmmoType(id);
    }

    psWeaponType *GetWeaponType();
    PSSKILL GetWeaponSkill(PSITEMSTATS_WEAPONSKILL_INDEX index);
    float GetLatency();
    float GetDamage(PSITEMSTATS_DAMAGETYPE dmgtype);
    PSITEMSTATS_AMMOTYPE GetAmmoType();

    float GetPenetration();
    float GetUntargetedBlockValue();
    float GetTargetedBlockValue();
    float GetCounterBlockValue();
    PSITEMSTATS_ARMORTYPE GetArmorType();
    float GetDamageProtection(PSITEMSTATS_DAMAGETYPE dmgtype);
    float GetHardness();
    float GetWeaponAttributeBonus(PSITEMSTATS_STAT stat);
    PSITEMSTATS_STAT GetWeaponAttributeBonusType(int index);
    float GetWeaponAttributeBonusMax(int index);

    float GetWeight();
    float GetItemSize();
    float GetTotalStackSize()
    {
        return GetItemSize()*stack_count;
    }

    unsigned short GetContainerMaxSize();

    int GetContainerMaxSlots();
    PSITEMSTATS_SLOTLIST GetValidSlots();
    bool FitsInSlots(PSITEMSTATS_SLOTLIST slotmask);
    bool FitsInSlot(INVENTORY_SLOT_NUMBER slot);

    csString GetSlotRemovedMesh(int slot, csString meshName = "")
    {
        return GetBaseStats()->GetSlotRemovedMesh(slot, meshName);
    }
    float GetDecayResistance();
    psMoney GetPrice();
    psMoney GetSellPrice();    
    psItemCategory* GetCategory();


    float GetVisibleDistance();

    void GetLocationInWorld(InstanceID &instance,psSectorInfo** sectorinfo,float &loc_x,float &loc_y,float &loc_z,float &loc_yrot) const;
    void SetLocationInWorld(InstanceID instance,psSectorInfo* sectorinfo,float loc_x,float loc_y,float loc_z,float loc_yrot);

    void GetXZRotationInWorld(float &loc_xrot, float &loc_zrot);

    void SetXZRotationInWorld(float loc_xrot, float loc_zrot);

    void GetRotationInWorld(float &loc_xrot, float &loc_yrot, float &loc_zrot);

    void SetRotationInWorld(float loc_xrot, float loc_yrot, float loc_zrot);

    psSectorInfo* GetSector() const
    {
        return location.loc_sectorinfo;
    }

    const char* GetMeshName();

    const char* GetTextureName();

    const char* GetPartName();

    const char* GetPartMeshName();

    const char* GetImageName();

    csString GetQuantityName(); // returns the quantity and plural name in a string
    static csString GetQuantityName(const char* namePtr, int stack_count, PSITEMSTATS_CREATIVETYPE creativeType, bool giveDetail = false);

    // For future use, see notes for mesh_index variables, etc.
    /*
    unsigned int GetMeshIndex();
    unsigned int GetTextureIndex();
    unsigned int GetTexturePartIndex();
    unsigned int GetImageIndex();
    */

    void UpdateInventoryStatus(psCharacter* owner,uint32 parent_id, INVENTORY_SLOT_NUMBER slot);

    bool IsEquipped() const;
    // an item can be equipped, but not active. This happens when its equip requirements
    // fail to be met while the item is still equipped.
    //   IsActive = true means the progression script for this item is active
    //   IsActive = false means the progression script for this item is inactive
    bool IsActive() const;
    void SetActive(bool state);

    void RunEquipScript(gemActor* actor);
    void CancelEquipScript();

    const char* GetModifiersDescription();

    bool CheckStackableWith(const psItem* otheritem, bool precise, bool checkStackCount = true, bool checkWorld = true) const;

    const char* GetSound();

    double GetProperty(MathEnvironment* env, const char* ptr);
    double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);
    const char* ToString()
    {
        return item_name.GetDataSafe();
    }

    bool GetIsLocked()
    {
        return ((flags & PSITEM_FLAG_LOCKED)? true : false);
    }
    void SetIsLocked(bool v);

    bool GetIsLockable()
    {
        return ((flags & PSITEM_FLAG_LOCKABLE)? true : false);
    }
    void SetIsLockable(bool v);

    bool GetIsSecurityLocked()
    {
        return ((flags & PSITEM_FLAG_SECURITYLOCK)? true : false);
    }
    void SetIsSecurityLocked(bool v);

    bool GetIsUnpickable()
    {
        return ((flags & PSITEM_FLAG_UNPICKABLE)? true : false);
    }
    void SetIsUnpickable(bool v);

    bool GetIsNoPickup()
    {
        return (GetIsNoPickupStrong() || GetIsNoPickupWeak());
    }

    bool GetIsNoPickupStrong()
    {
        return ((flags & PSITEM_FLAG_NOPICKUP)? true : false);
    }

    bool GetIsNoPickupWeak()
    {
        return ((flags & PSITEM_FLAG_NOPICKUPWEAK)? true : false);
    }

    bool GetIsCD() const
    {
        return ((flags & PSITEM_FLAG_USE_CD)? true : false);
    }
    void SetIsCD(bool v);

    bool GetIsNpcOwned() const
    {
        return (flags & PSITEM_FLAG_NPCOWNED) != 0;
    }
    void SetIsNpcOwned(bool v);

    bool GetIsKey() const
    {
        return ((flags & PSITEM_FLAG_KEY)? true : false);
    }
    void SetIsKey(bool v);

    bool GetIsMasterKey() const
    {
        return ((flags & PSITEM_FLAG_MASTERKEY)? true : false);
    }
    void SetIsMasterKey(bool v);

    bool IsTransient()
    {
        return ((flags & PSITEM_FLAG_TRANSIENT) ? true : false);
    }
    void SetIsTransient(bool v);

    void SetIsPickupable(bool v);

    void SetIsPickupableWeak(bool v);

    void SetIsItemStackable(bool v);
    void ResetItemStackable();

    bool GetIsSettingItem() const
    {
        return ((flags & PSITEM_FLAG_SETTINGITEM)? true : false);
    }
    void SetIsSettingItem(bool v);

    PSSKILL GetLockpickSkill()
    {
        return lockpickSkill;
    }
    void SetLockpickSkill(PSSKILL v);

    unsigned int GetLockStrength()
    {
        return lockStrength;
    }
    void SetLockStrength(unsigned int v);

    bool CompareOpenableLocks(const psItem* key) const;
    bool CanOpenLock(uint32 id, bool includeSkel) const;
    void AddOpenableLock(uint32 v);
    void RemoveOpenableLock(uint32 v);
    void ClearOpenableLocks();
    void CopyOpenableLock(psItem* origKey);
    void MakeSkeleton(bool b);
    bool GetIsSkeleton();
    csString GetOpenableLockNames();

    psScheduledItem* GetScheduledItem()
    {
        return schedule;
    }
    void SetScheduledItem(psScheduledItem* item)
    {
        schedule = item;
    }
    void ScheduleRespawn();

    float GetArmorVSWeaponResistance(psItemStats* armor);

    csString GetBookText()
    {
        return GetLiteratureText();
    }
    bool SetBookText(const csString &newText);
    bool SetSketch(const csString &newSketchData);
    bool SetMusicalSheet(const csString &newMusicalSheet);

    bool HasCharges() const;
    bool IsRechargeable() const;
    void SetCharges(int charges);
    int GetCharges() const;
    int GetMaxCharges() const;

    csString GetItemCommand()
    {
        return GetBaseStats()->GetItemCommand();
    }

    bool Destroy();

    void ScheduleRemoval();

    bool DeleteFromDatabase();

    /*  Objects of this class utilize a pool allocator.  The pool allocator can be found in poolallocator.h in the psutil library.
     *  The pool allocator allows us to avoid allocating memory from and releasing memory to the heap over and over for things that are
     *  constantly shifting in the number of allocations (such as items in the game).  It also reduces memory usage overhead slightly.
     *
     *  It should be possible to debug memory leaks from a specific pool easier as well since you can analyze allocations solely from that pool
     *  without getting flooded with allocations from everywhere else.
     */

    void* operator new(size_t);
    void operator delete(void*);

    bool GetIsWriteable();
    bool GetIsReadable();

    const csString &GetSketch(void)
    {
        return creativeStats.creativeType == PSITEMSTATS_CREATIVETYPE_NONE ? GetBaseStats()->GetSketch() : creativeStats.content;
    }
    const csString &GetMusicalSheet(void)
    {
        return creativeStats.creativeType == PSITEMSTATS_CREATIVETYPE_NONE ? GetBaseStats()->GetSketch() : creativeStats.content;
    }
    const csString &GetLiteratureText(void)
    {
        return creativeStats.creativeType == PSITEMSTATS_CREATIVETYPE_NONE ? GetBaseStats()->GetSketch() : creativeStats.content;
    }
    const csString &GetCreativeBackgroundImg()
    {
        return creativeStats.creativeType == PSITEMSTATS_CREATIVETYPE_NONE ? GetBaseStats()->GetCreativeBackgroundImg() : creativeStats.backgroundImg;
    }

    void PrepareCreativeItemInstance();

    float GetRarity();

    csString GetRarityName();

    bool GetIsIdentifiable()
    {
        return ((flags & PSITEM_FLAG_IDENTIFIABLE)? true : false);
    }
    void SetIsIdentifiable(bool v);


private:
    static PoolAllocator<psItem> itempool;

    gemItem* gItem;

    bool pendingsave;

    float rarity;

    float CalculateItemRarity();

protected:
    bool loaded;

#if SAVE_TRACER
private:
    csString last_save_queued_from;
#endif

};


class psScheduledItem
{
public:
    psScheduledItem(int spawnID,uint32 itemID,csVector3 &position, psSectorInfo* sector,InstanceID instance, int interval,int maxrnd,
                    float range, int lock_str = 0, int lock_skill = -1, csString flags = "");

    psItem* CreateItem();
    uint32 GetItemID()
    {
        return itemID;
    }

    psSectorInfo* GetSector()
    {
        return sector;
    }
    csVector3 &GetPosition()
    {
        return pos;
    }
    int MakeInterval(); 
    int GetInterval()
    {
        return interval;
    }
    int GetMaxModifier()
    {
        return maxrnd;
    }

    int GetLockStrength()
    {
        return lock_str;
    }

    int GetLockSkill()
    {
        return lock_skill;
    }

    csString GetFlags()
    {
        return flags;
    }

    void UpdatePosition(csVector3 &positon, const char* sector);
    void ChangeIntervals(int newint, int newrand);
    void ChangeRange(float newRange);
    void ChangeAmount(int newAmount);
    void Remove(); 

    bool WantToDie()
    {
        return wantToDie;
    }

private:
    bool wantToDie;
    int spawnID;           
    uint32 itemID;         
    csVector3 pos;         
    psSectorInfo* sector;  
    InstanceID worldInstance;     
    int interval;          
    int maxrnd;            
    float range;           
    int lock_str;          
    int lock_skill;        
    csString flags;        
};

#endif