psitemstats.h

Go to the documentation of this file.

/*
 * psitemstats.h
 *
 * Copyright (C) 2001 Atomic Blue (info@planeshift.it, 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 __PSITEMSTATS_H__
#define __PSITEMSTATS_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/parray.h>
#include <csutil/set.h>

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

#include "rpgrules/psmoney.h"

#include <idal.h>

//=============================================================================
// Local Includes
//=============================================================================
#include "psskills.h"

class ApplicativeScript;
class CacheManager;
class psCharacter;
class psItem;
struct psItemCategory;

enum PSITEMSTATS_WEAPONSKILL_INDEX
{
    PSITEMSTATS_WEAPONSKILL_INDEX_0 = 0,
    PSITEMSTATS_WEAPONSKILL_INDEX_1,
    PSITEMSTATS_WEAPONSKILL_INDEX_2,
    PSITEMSTATS_WEAPONSKILL_INDEX_COUNT
};

enum PSITEMSTATS_ARMORTYPE
{
    PSITEMSTATS_ARMORTYPE_NONE = -1,
    PSITEMSTATS_ARMORTYPE_LIGHT,
    PSITEMSTATS_ARMORTYPE_MEDIUM,
    PSITEMSTATS_ARMORTYPE_HEAVY,
    PSITEMSTATS_ARMORTYPE_COUNT
};

enum PSITEMSTATS_STAT
{
    PSITEMSTATS_STAT_NONE = -1,
    PSITEMSTATS_STAT_STRENGTH,
    PSITEMSTATS_STAT_AGILITY,
    PSITEMSTATS_STAT_ENDURANCE,
    PSITEMSTATS_STAT_INTELLIGENCE,
    PSITEMSTATS_STAT_WILL,
    PSITEMSTATS_STAT_CHARISMA,
    PSITEMSTATS_STAT_CONSTITUTION,
    PSITEMSTATS_STAT_STAMINA,
    PSITEMSTATS_STAT_COUNT
};

//TODO these should supposedly go away...

PSSKILL statToSkill(PSITEMSTATS_STAT stat);


enum PSITEMSTATS_DAMAGETYPE
{
    PSITEMSTATS_DAMAGETYPE_NONE  = -1,
    PSITEMSTATS_DAMAGETYPE_SLASH,
    PSITEMSTATS_DAMAGETYPE_BLUNT,
    PSITEMSTATS_DAMAGETYPE_PIERCE,
    //PSITEMSTATS_DAMAGETYPE_FORCE,
    //PSITEMSTATS_DAMAGETYPE_FIRE,
    //PSITEMSTATS_DAMAGETYPE_ICE,
    //PSITEMSTATS_DAMAGETYPE_AIR,
    //PSITEMSTATS_DAMAGETYPE_POISON,
    //PSITEMSTATS_DAMAGETYPE_DISEASE,
    //PSITEMSTATS_DAMAGETYPE_HOLY,
    //PSITEMSTATS_DAMAGETYPE_UNHOLY,
    PSITEMSTATS_DAMAGETYPE_COUNT
};

enum PSITEMSTATS_AMMOTYPE
{
    PSITEMSTATS_AMMOTYPE_NONE = -1,
    PSITEMSTATS_AMMOTYPE_ARROWS,
    PSITEMSTATS_AMMOTYPE_BOLTS,
    PSITEMSTATS_AMMOTYPE_ROCKS,
    PSITEMSTATS_AMMOTYPE_COUNT
};

enum PSITEMSTATS_CREATIVETYPE
{
    PSITEMSTATS_CREATIVETYPE_NONE = -1,
    PSITEMSTATS_CREATIVETYPE_LITERATURE,
    PSITEMSTATS_CREATIVETYPE_SKETCH,
    PSITEMSTATS_CREATIVETYPE_MUSIC
};

enum PSITEMSTATS_CREATORSTATUS
{
    PSITEMSTATS_CREATOR_VALID = 0,
    PSITEMSTATS_CREATOR_PUBLIC,
    PSITEMSTATS_CREATOR_UNASSIGNED,
    PSITEMSTATS_CREATOR_UNKNOWN          // e.g. creator player deleted
};

/******************************************************/
/* Slots are treated as boolean flag-like values here */
/******************************************************/
#define PSITEMSTATS_SLOT_BULK        0x00000001
#define PSITEMSTATS_SLOT_RIGHTHAND   0x00000002
#define PSITEMSTATS_SLOT_LEFTHAND    0x00000004
#define PSITEMSTATS_SLOT_BOTHHANDS   0x00000008
#define PSITEMSTATS_SLOT_RIGHTFINGER 0x00000010
#define PSITEMSTATS_SLOT_LEFTFINGER  0x00000020
#define PSITEMSTATS_SLOT_HELM        0x00000040
#define PSITEMSTATS_SLOT_NECK        0x00000080
#define PSITEMSTATS_SLOT_BACK        0x00000100
#define PSITEMSTATS_SLOT_ARMS        0x00000200
#define PSITEMSTATS_SLOT_GLOVES      0x00000400
#define PSITEMSTATS_SLOT_BOOTS       0x00000800
#define PSITEMSTATS_SLOT_LEGS        0x00001000
#define PSITEMSTATS_SLOT_BELT        0x00002000
#define PSITEMSTATS_SLOT_BRACERS     0x00004000
#define PSITEMSTATS_SLOT_TORSO       0x00008000
#define PSITEMSTATS_SLOT_MIND        0x00010000
#define PSITEMSTATS_SLOT_BANK        0x00020000
#define PSITEMSTATS_SLOT_CRYSTAL     0x00040000
#define PSITEMSTATS_SLOT_AZURE       0x00080000
#define PSITEMSTATS_SLOT_RED         0x00100000
#define PSITEMSTATS_SLOT_DARK        0x00200000
#define PSITEMSTATS_SLOT_BROWN       0x00400000
#define PSITEMSTATS_SLOT_BLUE        0x00800000

typedef unsigned int PSITEMSTATS_SLOTLIST;

#define PSITEMSTATS_FLAG_IS_A_MELEE_WEAPON   0x00000001
#define PSITEMSTATS_FLAG_IS_A_RANGED_WEAPON  0x00000002
#define PSITEMSTATS_FLAG_IS_A_SHIELD         0x00000004
#define PSITEMSTATS_FLAG_IS_AMMO             0x00000008
#define PSITEMSTATS_FLAG_IS_A_CONTAINER      0x00000010
#define PSITEMSTATS_FLAG_USES_AMMO           0x00000020
#define PSITEMSTATS_FLAG_IS_STACKABLE        0x00000040
#define PSITEMSTATS_FLAG_IS_GLYPH            0x00000080
#define PSITEMSTATS_FLAG_CAN_TRANSFORM       0x00000100
#define PSITEMSTATS_FLAG_TRIA                0x00000200
#define PSITEMSTATS_FLAG_HEXA                0x00000400
#define PSITEMSTATS_FLAG_OCTA                0x00000800
#define PSITEMSTATS_FLAG_CIRCLE              0x00001000
#define PSITEMSTATS_FLAG_CONSUMABLE          0x00002000
#define PSITEMSTATS_FLAG_IS_READABLE         0x00004000
#define PSITEMSTATS_FLAG_IS_ARMOR            0x00008000
#define PSITEMSTATS_FLAG_IS_EQUIP_STACKABLE  0x00010000
#define PSITEMSTATS_FLAG_IS_WRITEABLE        0x00020000
#define PSITEMSTATS_FLAG_NOPICKUP            0x00040000
#define PSITEMSTATS_FLAG_AVERAGEQUALITY      0x00080000     
#define PSITEMSTATS_FLAG_CREATIVE            0x00100000     
#define PSITEMSTATS_FLAG_BUY_PERSONALISE     0x00200000     
#define PSITEMSTATS_FLAG_IS_RECHARGEABLE     0x00400000
#define PSITEMSTATS_FLAG_IS_A_TRAP           0x00800000
#define PSITEMSTATS_FLAG_IS_CONSTRUCTIBLE    0x01000000
#define PSITEMSTATS_FLAG_IS_RENAMEABLE       0x02000000

#define CREATIVEDEF_MAX  65535  // Max length for 'text' field in MySQL db.

typedef unsigned int PSITEMSTATS_FLAGS;

struct st_attribute_bonus
{
    PSITEMSTATS_STAT attribute_id;
    short bonus_max;
};

#define PSITEMSTATS_STAT_BONUS_COUNT 3

struct ItemRequirement
{
    csString name;
    float    min_value;
};

struct psWeaponType
{
    unsigned int id;
    csString name;
    PSSKILL  skill;    // a skill that it may be effected by
};

struct psItemAnimation
{
    int id;
    csString anim_name;
    csStringID anim_id;
    int      min_level_required;
    int      flags;
};


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

class psItemArmorStats
{
public:
    friend class psItemStats;
    psItemArmorStats();

    void ReadStats(iResultRow &row);

    PSITEMSTATS_ARMORTYPE Type()
    {
        return armor_type;
    }
    char Class()
    {
        return armor_class;
    }
    float Protection(PSITEMSTATS_DAMAGETYPE dmgtype);
    float Hardness()
    {
        return hardness;
    }

private:
    PSITEMSTATS_ARMORTYPE armor_type; 
    char armor_class;
    float damage_protection[PSITEMSTATS_DAMAGETYPE_COUNT];  
    float hardness;
};

class psItemWeaponStats
{

public:
    friend class psItemStats;
    psItemWeaponStats();

    void ReadStats(iResultRow &row);

    psWeaponType *Type() { return weapon_type; }

    PSSKILL Skill(PSITEMSTATS_WEAPONSKILL_INDEX index);

    float Latency()
    {
        return latency;
    }
    float Damage(PSITEMSTATS_DAMAGETYPE dmgtype);
    float ExtraDamagePercent(PSITEMSTATS_DAMAGETYPE dmgtype);

    float Penetration()
    {
        return penetration;
    }
    float UntargetedBlockValue()
    {
        return untargeted_block_value;
    }
    float TargetedBlockValue()
    {
        return targeted_block_value;
    }
    float CounterBlockValue()
    {
        return counter_block_value;
    }

    PSITEMSTATS_STAT AttributeBonusType(int index);
    float AttributeBonusMax(int index);

private:
    psWeaponType *weapon_type;
    PSSKILL weapon_skill[PSITEMSTATS_WEAPONSKILL_INDEX_COUNT];
    st_attribute_bonus attribute_bonuses[PSITEMSTATS_STAT_BONUS_COUNT];
    float latency;
    float damages[PSITEMSTATS_DAMAGETYPE_COUNT];  // 4.3 precision
    float penetration;
    float untargeted_block_value;
    float targeted_block_value;
    float counter_block_value;
};

class psItemAmmoStats
{
public:
    psItemAmmoStats();
    ~psItemAmmoStats();

    void ReadStats(iResultRow &row);

    PSITEMSTATS_AMMOTYPE AmmoType()
    {
        return ammunition_type;
    }
private:
    PSITEMSTATS_AMMOTYPE ammunition_type;
};

class psItemCreativeStats
{
public:

    //Both psitemstats and psitem make use of this structure. So they need to access
    //all it's elements
    friend class psItemStats;
    friend class psItem;

    psItemCreativeStats();
    ~psItemCreativeStats();

    bool IsThisTheCreator(PID characterID);

    void SetCreator(PID characterID, PSITEMSTATS_CREATORSTATUS creatorStatus);

    PID GetCreator(PSITEMSTATS_CREATORSTATUS &creatorStatus);

private:
    void ReadStats(iResultRow &row);

    void ReadStats();

    bool SetCreativeContent(PSITEMSTATS_CREATIVETYPE, const csString &, uint32);

    bool FormatCreativeContent(void);

    void SaveCreation(uint32);

    csString UpdateDescription(PSITEMSTATS_CREATIVETYPE, csString, csString);

    void setInstanceBased(bool value)
    {
        instanceBased = value;
    }

    PSITEMSTATS_CREATIVETYPE creativeType;

    psXMLString creativeDefinitionXML;
    csString content;
    csString backgroundImg; 

    PID creatorID;
    PSITEMSTATS_CREATORSTATUS creatorIDStatus;

    bool instanceBased;

};

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

class psItemStats : public iScriptableVar
{
public:
    psItemStats();
    ~psItemStats();

private:
    uint32       uid;
    csString     uid_str;
    csString     name;
    csString     description;
    float        item_quality;
    csString     sketch_def;

    psItemArmorStats armorStats;
    psItemWeaponStats weaponStats;
    psItemAmmoStats ammoStats;
    psItemCreativeStats creativeStats;

    float weight;

    float size;

    unsigned short container_max_size;

    int container_max_slots;

    float decay_rate;

    ApplicativeScript* equipScript;
    csString consumeScriptName;

    PSITEMSTATS_SLOTLIST valid_slots;
    csArray<INVENTORY_SLOT_NUMBER> valid_slots_array;
    PSITEMSTATS_FLAGS flags;

    float visible_distance;

    csSet<unsigned int> ammo_types;

    csString stat_type;

    csArray<ItemRequirement> reqs;
    int spell_id_on_hit;
    float spell_on_hit_probability;
    int spell_id_feature;
    int spell_feature_charges;
    int spell_feature_timing;

    int maxCharges;

    bool isConsumable;

    bool spawnable;

    csPDelArray<psItemAnimation>* anim_list;

    csString mesh_name;

    csString texture_name;

    csString texturepart_name;

    csString partmesh_name;

    csString image_name;

    /* mesh names, texture names, texture part names, and image names are currently stored as strings
     * on the server and passed over to the client in normal communication.  This is inefficient, and
     * ultimately the client should use a numeric index of these resources, and the server should not
     * need to be aware of the resource name at all.
     *
     * Higher level design tools should be aware of the mapping between resource name and index, and
     * should be able to adjust both the server database references to the index as well as the client
     * index->resource mapping.
     */
    /*
    unsigned int mesh_index;
    unsigned int texture_index;
    unsigned int texturepart_index;
    unsigned int image_index;
    */


    psMoney price;
    psItemCategory* category;

    csString sound;
    csString weapon_type;

    csString itemCommand; 

    csHash<csHash<csString,int> > meshRemovalInfo;

    void LoadMeshRemoval(iResultRow &row);

    void LoadSlots(iResultRow &row);

    void ParseFlags(iResultRow &row);

public:
    psItemArmorStats &Armor()
    {
        return armorStats;
    }
    psItemWeaponStats &Weapon()
    {
        return weaponStats;
    }
    psItemAmmoStats &Ammunition()
    {
        return ammoStats;
    }

    bool ReadItemStats(iResultRow &row);
    PSITEMSTATS_FLAGS GetFlags()
    {
        return flags;
    }
    // Interface
    bool GetIsMeleeWeapon();
    bool GetIsBothHandsWeapon();
    bool GetIsArmor();
    bool GetIsRangeWeapon();
    bool GetIsAmmo();
    bool GetIsShield();
    bool GetIsContainer();
    bool GetIsTrap();
    bool GetIsConstructible();
    bool GetCanTransform();
    bool GetUnmovable();
    bool GetUsesAmmo();
    bool GetIsStackable();
    bool GetIsEquipStackable();
    bool GetIsGlyph();
    bool GetIsRenameable();
    bool GetIsConsumable();
    bool GetIsReadable();
    bool GetIsWriteable();

    bool IsSpawnable();
    PSITEMSTATS_CREATIVETYPE GetCreative();
    bool GetBuyPersonalise();
    float GetRange() const;
    PID GetCreator(PSITEMSTATS_CREATORSTATUS &creatorStatus);
    bool UsesAmmoType(uint32_t id) const
    {
        return ammo_types.In(id);
    }

    float weaponRange;

    bool IsMoney();

    uint32 GetUID();
    const char* GetUIDStr();
    const char* GetDescription() const;
    void SetDescription(const char* v);
    void SaveDescription(void);
    PSITEMSTATS_AMMOTYPE GetAmmoType();
    float GetQuality() const
    {
        return item_quality;
    }
    void SetQuality(float f)
    {
        item_quality = f;
    }

    void GetArmorVsWeaponType(csString &buff);
    void SetArmorVsWeaponType(const char* v);

    float GetWeight();
    float GetSize();
    unsigned short GetContainerMaxSize();

    int GetContainerMaxSlots();
    float GetVisibleDistance();
    PSITEMSTATS_SLOTLIST GetValidSlots();
    bool FitsInSlots(PSITEMSTATS_SLOTLIST slotmask);

    csString GetSlotRemovedMesh(int slot, csString meshName = "");
    float GetDecayRate();

    int GetAttackAnimID(unsigned int skill_level);

    csString FlagsToText();


    const char* GetName() const;
    const csString GetDownCaseName();
    void SetUnique();
    bool GetUnique();
    void SetRandom();
    bool GetRandom();

    psXMLString getCreativeXML()
    {
        return creativeStats.creativeDefinitionXML;
    }
    void SetName(const char* v);
    void SaveName(void);

    const char* GetMeshName();

    void SetMeshName(const char* v);

    const char* GetTextureName();

    void SetTextureName(const char* v);

    const char* GetPartName();

    void SetPartName(const char* v);

    const char* GetPartMeshName();

    void SetPartMeshName(const char* v);

    const char* GetImageName();

    void SetImageName(const char* v);

    // For future use, see notes for mesh_index variables, etc.
    /*
    unsigned int GetMeshIndex();
    void SetMeshIndex(unsigned int v);
    unsigned int GetTextureIndex();
    void SetTextureIndex(unsigned int v);
    unsigned int GetTexturePartIndex();
    void SetTexturePartIndex(unsigned int v);
    unsigned int GetImageIndex();
    void SetImageIndex(unsigned int v);
    */

    void SetPrice(int trias);
    psMoney &GetPrice();
    void SetCategory(psItemCategory* category);
    psItemCategory* GetCategory();
    const csArray<INVENTORY_SLOT_NUMBER>& GetSlots() const
    {
        return valid_slots_array;
    }

    //
    const char* GetSound();
    void SetSound(const char* v);

    ApplicativeScript* GetEquipScript()
    {
        return equipScript;
    }
    const csString &GetConsumeScriptName()
    {
        return consumeScriptName;
    }

    bool SetEquipScript(const csString &script);

    csArray<ItemRequirement> &GetRequirements();
    bool SetRequirement(const csString &statName, float statValue);

    psItem* InstantiateBasicItem(bool transient=false);

    bool Save();
    bool SetAttribute(const csString &op, const csString &attrName, float modifier);

    const csString &GetMusicalSheet(void)
    {
        return creativeStats.content;
    }
    const csString &GetSketch(void)
    {
        return creativeStats.content;
    }
    const csString &GetLiteratureText(void)
    {
        return creativeStats.content;
    }

    bool SetCreation(PSITEMSTATS_CREATIVETYPE, const csString &, csString);

    void SetCreator(PID, PSITEMSTATS_CREATORSTATUS);
    bool IsThisTheCreator(PID);

    const csString &GetCreativeBackgroundImg();

    bool HasCharges() const;
    bool IsRechargeable() const;
    void SetMaxCharges(int charges);
    int GetMaxCharges() const;

    csString GetItemCommand()
    {
        return itemCommand;
    }

    const char* ToString()
    {
        return name.GetDataSafe();
    }

    double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);

    double GetProperty(MathEnvironment* env, const char* ptr);


public:

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

private:
    static PoolAllocator<psItemStats> itempool;
};

#endif