cachemanager.h

Go to the documentation of this file.

/*
 * cachemanager.h
 *
 * Copyright (C) 2003 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 __CACHEMANAGER_H__
#define __CACHEMANAGER_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/stringarray.h>
#include <csutil/hash.h>
#include <csgeom/vector3.h>

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

#include "bulkobjects/pscharacter.h"
#include "bulkobjects/psitemstats.h"

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

class psSectorInfo;
class Client;
class EntityManager;
class psGuildInfo;
class psGuildAlliance;
class psSkillInfo;
class psAccountInfo;
class psQuest;
class psAttack;
class psAttackDefault;
class psTradePatterns;
class psTradeProcesses;
class psTradeCombinations;
class psTradeTransformations;
class psTradeAutoContainers;
class psItemSet;
class psCommandManager;
class psSpell;
class psItemStats;
class psItem;
class RandomizedOverlay;

struct CraftTransInfo;
struct CombinationConstruction;
struct CombinationSet;
struct CraftComboInfo;
struct psItemAnimation;
struct psItemCategory;
struct psWay;
struct Faction;
struct psTrait;
struct psRaceInfo;
struct Stance;
struct MathScript;

struct ArmorVsWeapon
{
    int id;
    float c [3][4];
    csString weapontype;
};

struct psItemStatFlags
{
    csString string;
    int flag;

    psItemStatFlags(const char* s, int f) : string(s), flag(f) { }
    void Set(const char* s,int f)
    {
        string=s;
        flag=f;
    }
};

// HACK TO GET AROUND BAD INCLUSION OF PSCHARACTER.H IN DRMESSAGE.H KWF
#ifndef __PSMOVEMENT_H__
struct psCharMode
{
    uint32 id;
    csString name;
    csVector3 move_mod;       
    csVector3 rotate_mod;     
    csString idle_animation;  
};

struct psMovement
{
    uint32 id;
    csString name;
    csVector3 base_move;    
    csVector3 base_rotate;  
};
#endif

struct psCharacterLimitation
{
    uint32 id;              
    csString limit_type;    
    int      min_score;     
    csString value;         
};


class optionEntry
{
private:
    csString value; 
    csHash<optionEntry,csString> subOptions; 
public:
    void setValue(const csString newValue)
    {
        value = newValue;
    }
    csString getValue()
    {
        return value;
    }
    double getValueAsDouble()
    {
        return atof(value);
    }
    int getValueAsInt()
    {
        return atoi(value);
    }
    csVector3 getValueAsVector();
    bool getValueAsVector(csVector3 &vector);
    bool setOption(const csString path, const csString value);
    optionEntry* getOption(const csString path);
    optionEntry* getOptionSafe(const csString path, const csString fallback);
};

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

    psSectorInfo* GetSectorInfoByName(const char* name);
    psSectorInfo* GetSectorInfoByID(unsigned int id);
    csHash<psSectorInfo*>::GlobalIterator GetSectorIterator();

    psCommandManager* GetCommandManager()
    {
        return commandManager;
    }

    typedef csPDelArray<psTrait>::Iterator TraitIterator;
    psTrait* GetTraitByID(unsigned int id);
    psTrait* GetTraitByName(const char* name);
    TraitIterator GetTraitIterator();

    size_t         GetRaceInfoCount();
    psRaceInfo* GetRaceInfoByIndex(int idx);
    psRaceInfo* GetRaceInfoByID(unsigned int id);
    psRaceInfo* GetRaceInfoByNameGender(const char* name,PSCHARACTER_GENDER gender);
    psRaceInfo* GetRaceInfoByNameGender(unsigned int id, PSCHARACTER_GENDER gender);
    psRaceInfo* GetRaceInfoByMeshName(const csString &meshname);

    psSkillInfo* GetSkillByID(unsigned int id);
    size_t GetSkillAmount();
    psSkillInfo* GetSkillByName(const char* name);

    void GetSkillsListbyCategory(csArray <psSkillInfo*> &listskill,int category);

    const char* FindCommonString(unsigned int id);
    unsigned int FindCommonStringID(const char* name);
    inline void AddCommonStringID(const char* name)
    {
        FindCommonStringID(name);
    }

    csStringSet* GetMsgStrings()
    {
        return &msg_strings;
    }

    void GetCompressedMessageStrings(char* &data, unsigned long &size,
                                     uint32_t &num_strings, csMD5::Digest &digest);

    psGuildInfo* FindGuild(unsigned int id);
    psGuildInfo* FindGuild(const csString &name);
    bool CreateGuild(const char* guildname, Client* client);
    void RemoveGuild(psGuildInfo* which);

    psGuildAlliance* FindAlliance(unsigned int id);
    bool CreateAlliance(const csString &name, psGuildInfo* founder, Client* client);
    bool RemoveAlliance(psGuildAlliance* which);

    psQuest* GetQuestByID(unsigned int id);
    psQuest* GetQuestByName(const char* name);
    psQuest* AddDynamicQuest(const char* name, psQuest* parentQuest, int step);


    bool UnloadQuest(int id);

    bool LoadQuest(int id);
    csHash<psQuest*>::GlobalIterator GetQuestIterator();

        
    psAttack *GetAttackByID(unsigned int id);
    psAttack *GetAttackByName(const char *name);
    csArray<psAttack*>GetAllAttacks();
    bool UnloadAttack(int id);

    bool LoadAttack(int id);
    csHash<psAttack *>::GlobalIterator GetAttackIterator();

    psAccountInfo* GetAccountInfoByID(AccountID accountid);

    psAccountInfo* GetAccountInfoByCharID(PID charid);

    psAccountInfo* GetAccountInfoByUsername(const char* username);

    bool UpdateAccountInfo(psAccountInfo* ainfo);

    unsigned int NewAccountInfo(psAccountInfo* ainfo);

    bool PreloadAll(EntityManager* entitymanager);
    void UnloadAll();

    // Item categories
    psItemCategory* GetItemCategoryByID(unsigned int id);
    psItemCategory* GetItemCategoryByName(const csString &name);

    psItemCategory* GetItemCategoryByPos(size_t pos)
    {
        return itemCategoryList.Get(pos);
    }
    size_t GetItemCategoryAmount()
    {
        return itemCategoryList.GetSize();
    }

    // Item Animations
    csPDelArray<psItemAnimation>* FindAnimationList(int id);

    // Ways
    psWay* GetWayByID(unsigned int id);
    psWay* GetWayByName(const csString &name);

    // attack types
    psAttackType *GetAttackTypeByID(unsigned int id);
    psAttackType *GetAttackTypeByName(csString name);

    // weapon types
    psWeaponType*GetWeaponTypeByID(unsigned int id);
    psWeaponType *GetWeaponTypeByName(csString name);

    // Factions
    Faction* GetFaction(const char* name);
    Faction* GetFaction(int id);
    Faction* GetFactionByName(const char* name);
    csHash<Faction*, int> &GetFactionHash()
    {
        return factions_by_id;
    }

    // Progression Scripts
    ProgressionScript* GetProgressionScript(const char* name);

    // Math scripts
    MathScript* GetMaxCarryWeight() { return maxCarryWeight; }
    MathScript* GetMaxCarryAmount() { return maxCarryAmount; }
    MathScript* GetMaxRealmScript() { return maxRealmScript; }
    MathScript* GetMaxManaScript() { return maxManaScript; }
    MathScript* GetMaxHPScript() { return maxHPScript; }
    MathScript* GetStaminaCalc() { return staminaCalc; }
    MathScript* GetExpSkillCalc() { return expSkillCalc; }
    MathScript* GetStaminaRatioWalk() { return staminaRatioWalk; }
    MathScript* GetStaminaRatioStill() { return staminaRatioStill; }
    MathScript* GetStaminaRatioSit() { return staminaRatioSit; }
    MathScript* GetStaminaRatioWork() { return staminaRatioWork; }
    MathScript* GetStaminaCombat() { return staminaCombat; }
    MathScript* GetDodgeValueCalc() { return dodgeValueCalc; }
    MathScript* GetArmorSkillsPractice() { return armorSkillsPractice; }
    MathScript* GetCharLevelGet() { return charLevelGet; }
    MathScript* GetSkillValuesGet() { return skillValuesGet; }
    MathScript* GetBaseSkillValuesGet() { return baseSkillValuesGet; }
    MathScript* GetSetBaseSkillsScript() { return setBaseSkillsScript; }
    MathScript* GetCalcDecay() { return calc_decay; }
    MathScript* GetCalcItemPrice() { return calcItemPrice; }
    MathScript* GetCalcItemSellPrice() { return calcItemSellPrice; }
    MathScript* GetPlayerSketchLimits() { return playerSketchLimits; }
    MathScript* GetSpellPowerLevel() { return spellPowerLevel; }
    MathScript* GetManaCost() { return manaCost; }
    MathScript* GetCastSuccess() { return castSuccess; }
    MathScript* GetResearchSuccess() { return researchSuccess; }
    MathScript* GetSpellPractice() { return spellPractice; }
    MathScript* GetDoDamage() { return doDamage; }
    MathScript* GetStaminaMove() { return staminaMove; }
    MathScript* GetFamiliarAffinity() { return msAffinity; }

    // Spells
    typedef csPDelArray<psSpell>::Iterator SpellIterator;
    psSpell* GetSpellByID(unsigned int id);
    psSpell* GetSpellByName(const csString &name);
    SpellIterator GetSpellIterator();

    csPDelArray<CombinationConstruction>* FindCombinationsList(uint32 patternid);

    csPDelArray<psTradeTransformations>* FindTransformationsList(uint32 patternid, uint32 targetid);
    bool PreloadUniqueTradeTransformations();
    csArray<uint32>* GetTradeTransUniqueByID(uint32 id);
    bool PreloadTradeProcesses();
    csArray<psTradeProcesses*>* GetTradeProcessesByID(uint32 id);
    bool PreloadTradePatterns();
    csArray<psTradePatterns*> GetTradePatternByItemID(uint32 id);
    psTradePatterns* GetTradePatternByName(csString name);
    csString CreateTransCraftDescription(psTradeTransformations* tran, psTradeProcesses* proc);
    csString CreateComboCraftDescription(CombinationConstruction* combArray);
    csString CreateComboCraftDescription(Result* combArray);
    csArray<CraftTransInfo*>* GetTradeTransInfoByItemID(uint32 id);
    csArray<CraftComboInfo*>* GetTradeComboInfoByItemID(uint32 id);

    psItemStats* GetBasicItemStatsByName(csString name);

    psItemStats* GetBasicItemStatsByID(uint32 id);
    psItemStats* CopyItemStats(uint32 id, csString newName);

    uint32 BasicItemStatsByNameExist(csString name);
    size_t ItemStatsSize(void)
    {
        return itemStats_IDHash.GetSize();
    }

    void CacheNameChange(csString oldName, csString newName);

    bool LoadWorldItems(psSectorInfo* sector, csArray<psItem*> &items);

    float GetArmorVSWeaponResistance(const char* armor_type, const char* weapon_type);
    float GetArmorVSWeaponResistance(psItemStats* armor, psItemStats* weapon);

    void RemoveInstance(psItem* &item);
    void RemoveItemStats(psItemStats* &itemStats);

    PSITEMSTATS_STAT ConvertAttributeString(const char* attributestring);

    const char* Attribute2String(PSITEMSTATS_STAT s);

    PSSKILL               ConvertSkillString(const char* skillstring);
    PSSKILL               ConvertSkill(int skill_id);
    PSCHARACTER_GENDER    ConvertGenderString(const char* genderstring);
    PSITEMSTATS_SLOTLIST  slotMap[PSCHARACTER_SLOT_BULK1];

    //Tips
    void GetTipByID(int id, csString &tip);
    unsigned int GetTipLength(); 

    SlotNameHash slotNameHash;

    // Bad names
    size_t GetBadNamesCount();
    const char* GetBadName(int pos);
    void AddBadName(const char*);
    void DelBadName(const char*);

    csArray<psItemStatFlags> ItemStatFlagArray;

    const char* MakeCacheName(const char* prefix, uint32 id);
    void AddToCache(iCachedObject* obj, const char* name, int max_cache_time_seconds);
    iCachedObject* RemoveFromCache(const char* name);

    const csPDelArray<psCharMode> &GetCharModes() const
    {
        return char_modes;
    }
    const csPDelArray<psMovement> &GetMovements() const
    {
        return movements;
    }
    const psCharMode* GetCharMode(size_t id) const
    {
        return char_modes[id];
    }
    const psMovement* GetMovement(size_t id) const
    {
        return movements[id];
    }
    uint8_t GetCharModeID(const char* name);
    uint8_t GetMovementID(const char* name);

    uint32_t NextEffectUID()
    {
        return ++effectID;
    }

    const psCharacterLimitation* GetLimitation(size_t index);

    csArray<Stance> stances;

    csArray<csString> stanceID;

    void AddItemStatsToHashTable(psItemStats* newitem);

    optionEntry* getOption(const csString path)
    {
        return rootOptionEntry.getOption(path);
    }

    optionEntry* getOptionSafe(const csString path, const csString value)
    {
        return rootOptionEntry.getOptionSafe(path,value);
    }

    LootRandomizer* getLootRandomizer()
    {
        return lootRandomizer;
    }

    void ApplyItemModifiers(psItemStats* baseItem, RandomizedOverlay* overlay, csArray<uint32_t> &modifierIds)
    {
        lootRandomizer->ApplyModifier(baseItem, overlay, modifierIds);
    }

    void RandomizeItem(psItem* item, float maxCost, size_t numModifiers)
    {
        lootRandomizer->RandomizeItem(item, maxCost, false, numModifiers);
    }

    bool ReloadOptions()
    {
        return PreloadOptions();
    }

protected:
    uint32_t effectID;
    char CacheNameBuffer[15];

    bool PreloadSectors();
    bool PreloadRaceInfo();
    bool PreloadSkills();
    bool PreloadAttacks();
    bool PreloadOptions();
    bool PreloadLimitations();
    bool PreloadTraits();
    bool PreloadItemCategories();
    bool PreloadWays();
    bool PreloadAttackTypes();
    bool PreloadWeaponTypes();
    void PreloadFactionCharacterEvents(const char* script, Faction* faction);
    bool PreloadFactions();
    bool PreloadScripts(EntityManager* entitymanager);
    bool PreloadMathScripts();
    bool PreloadSpells();
    bool PreloadItemStatsDatabase();
    bool PreloadItemAnimList();
    bool PreloadQuests();
    bool PreloadTradeCombinations();
    bool PreloadTradeTransformations();
    bool PreloadTips();
    bool PreloadBadNames();
    bool PreloadArmorVsWeapon();
    bool PreloadMovement();
    bool PreloadStances();
    void PreloadCommandGroups();


    bool PreloadLootModifiers();

    bool PreloadCraftMessages();

    bool UniqueInsertIntoItemArray(csArray<uint32>* finalItems, uint32 itemID);

    int Contains(csArray<uint32>* list, uint32 id);

    bool FindFinalItem(csHash<csHash<csPDelArray<psTradeTransformations>*, uint32> *,uint32>* txItemHash, csHash<csHash<csPDelArray<psTradeTransformations>*, uint32> *,uint32>* rxItemHash, csArray<uint32>* finalItems, uint32 itemID, csArray<uint32>* itemStack);

    bool ReconcileFinalItems(csHash<csHash<csPDelArray<psTradeTransformations>*, uint32> *,uint32>* txItemHash, csHash<csHash<csPDelArray<psTradeTransformations>*, uint32> *,uint32>* rxItemHash, csArray<uint32>* finalItems, csArray<uint32>* craftBookItems, uint32 resultID, uint32 patternID, csArray<uint32>* itemStack);

    bool loadTradeTransformationsByPatternAndGroup(Result* result, csHash<csHash<csPDelArray<psTradeTransformations> *,uint32> *,uint32>* txResultHash, csHash<csHash<csPDelArray<psTradeTransformations> *,uint32> *,uint32>* txItemHash);

    bool freeTradeTransformationsByPatternAndGroup(csHash<csHash<csPDelArray<psTradeTransformations> *,uint32> *,uint32>* txItemHash, csHash<csHash<csPDelArray<psTradeTransformations> *,uint32> *,uint32>* txResultHash);

    bool DescribeTransformation(psTradeTransformations* t, csArray<CraftTransInfo*>* newArray);

    bool DescribeMultiTransformation(csPDelArray<psTradeTransformations>* rArray, csArray<CraftTransInfo*>* newArray);

    bool DescribeCombination(Result* combinations, csArray<CraftTransInfo*>* newArray);

    bool ListProductionSteps(csArray<CraftTransInfo*>* newArray, csHash<csHash<csPDelArray<psTradeTransformations>*, uint32> *,uint32>* txResultHash, csArray<uint32>* finalItems, uint32 itemID, uint32 patternID, uint32 groupID, csArray<uint32>* itemStack);

    void CacheCraftTransforms(psMsgCraftingInfo* tradePattern, int patternID, int group);

    void CacheCraftCombos(psMsgCraftingInfo* tradePattern, int patternID, int group);

    PSTRAIT_LOCATION ConvertTraitLocationString(const char* locationstring);

    class psCacheExpireEvent; // forward decl for next decl

    struct CachedObject
    {
        csString name;
        iCachedObject* object;
        psCacheExpireEvent* event;
    };

    class psCacheExpireEvent : public psGameEvent
    {
    protected:
        bool valid;
        CachedObject* myObject;

    public:
        psCacheExpireEvent(int delayticks,CachedObject* object);
        void CancelEvent()
        {
            valid = false;
        }
        virtual void Trigger();  
    };

    csHash<CachedObject*, csString> generic_object_cache;

    // Common strings data.
    csStringSet msg_strings;
    char* compressed_msg_strings;
    unsigned long compressed_msg_strings_size;
    uint32_t num_compressed_strings;
    csMD5::Digest compressed_msg_strings_digest;

    csHash<psSectorInfo*> sectorinfo_by_id;    
    csHash<psSectorInfo*> sectorinfo_by_name;  
    csPDelArray<psTrait > traitlist;
    csPDelArray<psRaceInfo > raceinfolist;

    csHash<psSkillInfo*, int> skillinfo_IDHash;
    csHash<psSkillInfo*, csString> skillinfo_NameHash;
    csHash<psSkillInfo*, int> skillinfo_CategoryHash;

    csPDelArray<psItemCategory > itemCategoryList;
    csPDelArray<psWay > wayList;
    csPDelArray<psAttackType > attackTypeList;
    csPDelArray<psWeaponType > weaponTypeList;
    csHash<Faction*, int> factions_by_id;
    csHash<Faction*, csString> factions;
    csHash<ProgressionScript*,csString> scripts;
    csPDelArray<psSpell > spellList;
    //csArray<psItemStats *> basicitemstatslist;
    csHash<psItemStats*,uint32> itemStats_IDHash;
    csHash<psItemStats*,csString> itemStats_NameHash;
    csPDelArray<csPDelArray<psItemAnimation > > item_anim_list;
    csHash<psGuildInfo*> guildinfo_by_id;
    csHash<psGuildAlliance*> alliance_by_id;
    csHash<psAttack  *> attacks_by_id;
    csHash<psQuest *> quests_by_id;
    csHash<psTradePatterns *,uint32> tradePatterns_IDHash;
    csHash<psTradePatterns *,csString> tradePatterns_NameHash;
    csHash<csArray<psTradeProcesses*> *,uint32> tradeProcesses_IDHash;
    csHash<csPDelArray<CombinationConstruction> *,uint32> tradeCombinations_IDHash;
    csHash<csHash<csPDelArray<psTradeTransformations> *,uint32> *,uint32> tradeTransformations_IDHash;
    csHash<csArray<uint32> *,uint32> tradeTransUnique_IDHash;
    csHash<csArray<CraftTransInfo*> *,uint32> tradeCraftTransInfo_IDHash;
    csHash<csArray<CraftComboInfo*> *,uint32> tradeCraftComboInfo_IDHash;
    csArray<csString> tips_list;                                            
    csStringArray bad_names;
    csPDelArray<ArmorVsWeapon> armor_vs_weapon;
    csPDelArray<psCharMode> char_modes;
    csPDelArray<psMovement> movements;
    csPDelArray<psCharacterLimitation> limits;  
    psCommandManager* commandManager;
    optionEntry rootOptionEntry;

    LootRandomizer* lootRandomizer; 
    MathScript* maxCarryWeight;     
    MathScript* maxCarryAmount;     
    MathScript* maxRealmScript;
    MathScript* maxManaScript;
    MathScript* maxHPScript;
    MathScript* staminaCalc;  
    MathScript* expSkillCalc; 
    MathScript* staminaRatioWalk; 
    MathScript* staminaRatioStill;
    MathScript* staminaRatioSit;  
    MathScript* staminaRatioWork; 
    MathScript* staminaCombat;
    MathScript* dodgeValueCalc; 
    MathScript* armorSkillsPractice; 
    MathScript* charLevelGet; 
    MathScript* skillValuesGet; 
    MathScript* baseSkillValuesGet; 
    MathScript* setBaseSkillsScript;
    MathScript* calc_decay; 
    MathScript* calcItemPrice;
    MathScript* calcItemSellPrice;
    MathScript* playerSketchLimits;
    MathScript* spellPowerLevel;
    MathScript* manaCost;
    MathScript* castSuccess;
    MathScript* researchSuccess;
    MathScript* spellPractice;
    MathScript* doDamage;
    MathScript* staminaMove;
    MathScript* msAffinity;
};


#endif