pscharacter.h

Go to the documentation of this file.

/*
 * pscharacter.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 __PSCHARACTER_H__
#define __PSCHARACTER_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/sysfunc.h>

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

#include "net/charmessages.h"

#include "../icachedobject.h"
#include "../playergroup.h"
#include "rpgrules/factions.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "buffable.h"
#include "psskills.h"
#include "psstdint.h"
#include "pscharinventory.h"
#include "psinventorycachesvr.h"
#include "psitemstats.h"
#include "servervitals.h"
#include "psguildinfo.h"
#include "psattackqueue.h"
#include "pscharquestmgr.h"

class psServerVitals;
class MsgEntry;
class psItemStats;
class psItem;
class psQuest;

struct psRaceInfo;
class psSectorInfo;

class ExchangeManager;
class MathScript;
class NpcResponse;
class gemActor;
struct psGuildLevel;
class psGuildMember;
class psLootMessage;
class psMerchantInfo;
class psQuestListMessage;
class psSpell;
class psTradeTransformations;
class psTradeProcesses;
class psTrainerInfo;
struct psTrait;
class psWorkGameEvent;

struct Result;
struct Faction;

csString NormalizeCharacterName(const csString &name);


enum PSCHARACTER_TYPE
{
    PSCHARACTER_TYPE_PLAYER    = 0,
    PSCHARACTER_TYPE_NPC       = 1,
    PSCHARACTER_TYPE_PET       = 2,
    PSCHARACTER_TYPE_MOUNT     = 3,
    PSCHARACTER_TYPE_MOUNTPET  = 4,
    PSCHARACTER_TYPE_COUNT     = 5,
    PSCHARACTER_TYPE_UNKNOWN   = ~0
} ;

#define PSCHARACTER_BULK_COUNT INVENTORY_BULK_COUNT
#define PSCHARACTER_BANK_BULK_COUNT 16

class CharacterAttribute
{
protected:
    psCharacter* self;
public:
    CharacterAttribute(psCharacter* character) : self(character) { }
};

// Remember to update the translation table in GetModeStr when adding modes.
enum PSCHARACTER_MODE
{
    PSCHARACTER_MODE_UNKNOWN = 0,
    PSCHARACTER_MODE_PEACE,
    PSCHARACTER_MODE_COMBAT,
    PSCHARACTER_MODE_SPELL_CASTING,
    PSCHARACTER_MODE_WORK,
    PSCHARACTER_MODE_DEAD,
    PSCHARACTER_MODE_SIT,
    PSCHARACTER_MODE_OVERWEIGHT,
    PSCHARACTER_MODE_EXHAUSTED,
    PSCHARACTER_MODE_DEFEATED,
    PSCHARACTER_MODE_STATUE,
    PSCHARACTER_MODE_PLAY,
    PSCHARACTER_MODE_COUNT
};

enum PSCHARACTER_CUSTOM
{
    PSCHARACTER_CUSTOM_EYES = 0,
    PSCHARACTER_CUSTOM_HAIR,
    PSCHARACTER_CUSTOM_BEARD,
    PSCHARACTER_CUSTOM_COLOUR,
    PSCHARACTER_CUSTOM_SKIN,
    PSCHARACTER_CUSTOM_COUNT
};

enum PSCHARACTER_JOINNOTIFICATION
{
    PSCHARACTER_JOINNOTIFICATION_GUILD    = 1,
    PSCHARACTER_JOINNOTIFICATION_ALLIANCE = 2
};



struct GMEventsAssignment
{
    int runningEventIDAsGM;
    int runningEventID;
    csArray<int> completedEventIDsAsGM;
    csArray<int> completedEventIDs;
};

enum PSCHARACTER_WORKSTATE
{
    PSCHARACTER_WORKSTATE_HALTED = 0,
    PSCHARACTER_WORKSTATE_STARTED,
    PSCHARACTER_WORKSTATE_COMPLETE,
    PSCHARACTER_WORKSTATE_OVERDONE
};


#define PSCHARACTER_EQUIPMENTFLAG_AUTOATTACK       0x00000001
#define PSCHARACTER_EQUIPMENTFLAG_SINGLEATTACK     0x00000002
#define PSCHARACTER_EQUIPMENTFLAG_ATTACKIFEMPTY    0x00000004

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

class psBuddyManager
{
public:
    struct Buddy
    {
        csString name;      
        PID playerId;       
    };

    void Initialize(PID charID)
    {
        characterId = charID;
    }

    bool AddBuddy(PID buddyID, csString &name);

    void RemoveBuddy(PID buddyID);

    bool IsBuddy(PID buddyID);

    void AddBuddyOf(PID buddyID);

    void RemoveBuddyOf(PID buddyID);

    bool LoadBuddies(Result &myBuddies, Result &buddyOf);


    csArray<psBuddyManager::Buddy>  GetBuddyList()
    {
        return buddyList;
    }
    csArray<PID>                    GetBuddyOfList()
    {
        return buddyOfList;
    }

private:

    csArray<psBuddyManager::Buddy> buddyList;       
    csArray<PID> buddyOfList;       

    PID characterId;                
};


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

// Need to recalculate Max HP/Mana/Stamina and inventory limits whenever stats
// change (whether via buffs or base value changes).
class SkillStatBuffable : public ClampedPositiveBuffable<int>
{
public:
    void Initialize(psCharacter* c)
    {
        chr = c;
    }
protected:
    virtual void OnChange();
    psCharacter* chr;
};

// When base stats change, we also need to recalculate skill training costs.
// However, since training ignores buffs, we don't need to for all changes.
class CharStat : public SkillStatBuffable
{
public:
    void SetBase(int x);
};

typedef SkillStatBuffable SkillRank;

class StatSet : public CharacterAttribute
{
public:
    StatSet(psCharacter* self);

    CharStat &Get(PSITEMSTATS_STAT attrib);
    CharStat &operator [](PSITEMSTATS_STAT which)
    {
        return Get(which);
    }

protected:
    CharStat stats[PSITEMSTATS_STAT_COUNT];
};

struct Skill
{
    unsigned short z;        
    unsigned short y;        
    SkillRank rank;          

    unsigned short zCost;    
    unsigned short yCost;    
    unsigned short zCostNext;
    unsigned short yCostNext;
    bool dirtyFlag;          

    psSkillInfo* info;       

    Skill()
    {
        Clear();
    }
    void Clear()
    {
        z=y=0;
        zCost=yCost=0;
        info = NULL;
        dirtyFlag = false;
    }

    void CalculateCosts(psCharacter* user);

    bool CanTrain()
    {
        return y < yCost;
    }

    void Train(int yIncrease);

    bool CheckDoRank(psCharacter* user);

    bool Practice(unsigned int amount, unsigned int &actuallyAdded, psCharacter* user);
};


class SkillSet : public CharacterAttribute
{
protected:
    csArray<Skill> skills; 

public:
    SkillSet(psCharacter* self);

    void SetSkillInfo(PSSKILL which, psSkillInfo* info, bool recalculatestats = true);

    void SetSkillPractice(PSSKILL which, int z_value);

    void SetSkillKnowledge(PSSKILL which, int y_value);

    void SetSkillRank(PSSKILL which, unsigned int rank, bool recalculatestats = true);

    void Calculate();

    bool CanTrain(PSSKILL skill);

    void CheckDoRank(PSSKILL skill);


    void Train(PSSKILL skill, int yIncrease);


    SkillRank &GetSkillRank(PSSKILL which);

    unsigned int GetSkillKnowledge(PSSKILL skill);

    unsigned int GetSkillPractice(PSSKILL skill);

    bool  AddToSkillPractice(PSSKILL skill, unsigned int val, unsigned int &added);

    int AddSkillPractice(psSkillInfo* skill, unsigned int val);

    int AddSkillPractice(PSSKILL skill, unsigned int val);

    unsigned int GetBestSkillSlot(bool withBuff);

    Skill &Get(PSSKILL skill);
};

#define ALWAYS_IMPERVIOUS      1
#define TEMPORARILY_IMPERVIOUS 2


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

struct Stance
{
    unsigned int stance_id;
    csString stance_name;
    float stamina_drain_P;
    float stamina_drain_M;
    float attack_speed_mod;
    float attack_damage_mod;
    float defense_avoid_mod;
    float defense_absorb_mod;
};

class charVariable
{
public:
    csString name;          
    csString value;         
    bool dirty;             
    Buffable<int> intBuff;  


    Buffable<int> &GetBuffable()
    {
        return intBuff;
    }

    charVariable() : dirty(false) {}
    charVariable(csString name, csString value) : name(name), value(value), dirty(false)
    {
        intBuff.SetBase(strtoul(value.GetDataSafe(),NULL,0));
    }
    charVariable(csString name, csString value, bool dirty) : name(name), value(value), dirty(dirty)
    {
        intBuff.SetBase(strtoul(value.GetDataSafe(),NULL,0));
    }
};

class OverridableRace : public Overridable<psRaceInfo*>
{
public:

    OverridableRace(psRaceInfo* race) : Overridable<psRaceInfo*>(race) {}

    virtual ~OverridableRace() { }

    void SetCharacter(psCharacter* psChar)
    {
        character = psChar;
    }

protected:

    virtual void OnChange();

    psCharacter* character; 
};

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

class psCharacter : public iScriptableVar, public iCachedObject
{
public:
    enum TradingStatus
    {
        NOT_TRADING,
        SELLING,
        BUYING,
        WITHDRAWING,
        STORING
    };

    struct st_location
    {
        psSectorInfo* loc_sector;
        csVector3 loc;
        float loc_yrot;
        InstanceID worldInstance;
    };

    psCharacter();

    virtual ~psCharacter();

    bool Load(iResultRow &row);

    bool IsStatue()
    {
        return isStatue;
    }

    psCharacterInventory &Inventory()
    {
        return inventory;
    }

    psMoney Money()
    {
        return money;
    }

    psMoney &BankMoney()
    {
        return bankMoney;
    }

    void SetMoney(psMoney m);

    void SetMoney(psItem* &moneyObject);

    void SetMoney(psItemStats* MoneyObject,  int amount);

    void AdjustMoney(psMoney m, bool bank);

    void SaveMoney(bool bank);

    void ResetStats();


    bool NeedsHelpEvent(int which)
    {
        return (helpEventFlags & (1 << which))==0;
    }

    void CompleteHelpEvent(int which)
    {
        helpEventFlags |= (1 << which);
    }

    void SetGuild(psGuildInfo* g)
    {
        guildinfo = g;
    }
    psGuildInfo* GetGuild()
    {
        return guildinfo;
    }
    psGuildLevel* GetGuildLevel();
    psGuildMember* GetGuildMembership();

    bool IsGettingGuildNotifications()
    {
        return (joinNotifications & PSCHARACTER_JOINNOTIFICATION_GUILD);
    }
    bool IsGettingAllianceNotifications()
    {
        return (joinNotifications & PSCHARACTER_JOINNOTIFICATION_ALLIANCE);
    }
    void SetGuildNotifications(bool enabled)
    {
        if(enabled) joinNotifications |= PSCHARACTER_JOINNOTIFICATION_GUILD;
        else joinNotifications &= ~PSCHARACTER_JOINNOTIFICATION_GUILD;
    }
    void SetAllianceNotifications(bool enabled)
    {
        if(enabled) joinNotifications |= PSCHARACTER_JOINNOTIFICATION_ALLIANCE;
        else joinNotifications &= ~PSCHARACTER_JOINNOTIFICATION_ALLIANCE;
    }

    int GetNotifications()
    {
        return joinNotifications;
    }
    void SetNotifications(int notifications)
    {
        joinNotifications = notifications;
    }

    SkillSet &Skills()
    {
        return skills;
    }

    psSkillCache* GetSkillCache()
    {
        return &skillCache;
    }

    void GetSkillValues(MathEnvironment* env);
    void GetSkillBaseValues(MathEnvironment* env);

    // iCachedObject Functions below
    virtual void ProcessCacheTimeout() {}  
    virtual void* RecoverObject()
    {
        return this;    
    }
    virtual void DeleteSelf()
    {
        delete this;    
    }



    bool QuickLoad(iResultRow &row, bool noInventory);

    void LoadIntroductions();

    void LoadActiveSpells();
    void AddSpell(psSpell* spell);
    bool Store(const char* location,const char* slot,psItem* what);

    void SetPID(PID characterID)
    {
        pid = characterID;
    }
    PID GetPID() const
    {
        return pid;
    }

    PID GetMasterNPCID() const
    {
        return npcMasterId ? npcMasterId : pid;
    }

    void SetAccount(AccountID id)
    {
        accountid = id;
    }
    AccountID GetAccount() const
    {
        return accountid;
    }

    void SetName(const char* newName)
    {
        SetFullName(newName,lastname.GetData());
    }
    void SetLastName(const char* newLastName)
    {
        SetFullName(name.GetData(),newLastName);
    }
    void SetFullName(const char* newFirstName, const char* newLastName);
    void SetOldLastName(const char* oldLastName)
    {
        this->oldlastname = oldLastName;
    }

    const char* GetCharName() const
    {
        return name.GetData();
    }
    const char* GetCharLastName() const
    {
        return lastname.GetData();
    }
    const char* GetCharFullName() const
    {
        return fullName.GetData();
    }
    const char* GetOldLastName() const
    {
        return oldlastname.GetData();
    }

    // Introductions
    bool Knows(PID charid);
    bool Knows(psCharacter* c)
    {
        return (c ? Knows(c->GetPID()) : false);
    }
    bool Introduce(psCharacter* c);
    bool Unintroduce(psCharacter* c);

    unsigned int GetCharType() const
    {
        return characterType;
    }
    void SetCharType(unsigned int v)
    {
        CS_ASSERT(v < PSCHARACTER_TYPE_COUNT);
        characterType = v;
    }
    const char* GetCharTypeName()
    {
        return characterTypeName[characterType];
    }

    void SetLastLoginTime();

    csString GetLastLoginTime() const;

    void SetPetElapsedTime(double elapsedTime);

    double GetPetElapsedTime() const;

    void SetSpouseName(const char* name);

    const char* GetSpouseName() const
    {
        return spouseName.GetData();
    }
    void SetIsMarried(bool married)
    {
        isMarried = married;
    }
    bool GetIsMarried() const
    {
        return isMarried;
    }

    void SetRaceInfo(psRaceInfo* rinfo);

    psRaceInfo* GetRaceInfo();

    OverridableRace &GetOverridableRace();

    float GetScale();

    float GetScaleValue();

    bool AddExploredArea(PID explored);

    bool HasExploredArea(PID explored);

    FactionSet* GetFactions()
    {
        return factions;
    }

    void SetLootCategory(int id)
    {
        lootCategoryId = id;
    }
    int  GetLootCategory() const
    {
        return lootCategoryId;
    }

    psItem* RemoveLootItem(int id);

    csArray<psItem*> RemoveLootItems(csArray<csString> categories = csArray<csString>());

    void AddLootItem(psItem* item);
    void AddLootMoney(int money)
    {
        lootMoney += money;
    }
    size_t GetLootItems(psLootMessage &msg, EID entity, int cnum);

    int  GetLootMoney();

    void ClearLoot();

    int GetLastResponse()
    {
        return lastResponse;
    }
    void SetLastResponse(int response)
    {
        lastResponse=response;
    }
    bool CheckResponsePrerequisite(NpcResponse* resp);

    void CombatDrain(int);

    bool HasVariableDefined(const csString &name);

    csString GetVariableValue(const csString &name);

    Buffable<int> &GetBuffableVariable(const csString &name, const csString &value = "0");

    void SetVariable(const csString &name, const csString &value);

    void SetVariable(const csString &name);

    void UnSetVariable(const csString &name);

    csHash<charVariable, csString>::ConstGlobalIterator GetVariables() const;

    unsigned int GetExperiencePoints(); // W
    void SetExperiencePoints(unsigned int W);
    unsigned int AddExperiencePoints(unsigned int W);
    unsigned int AddExperiencePointsNotify(unsigned int W);
    unsigned int CalculateAddExperience(PSSKILL skill, unsigned int awardedPoints, float modifier = 1);
    unsigned int GetProgressionPoints(); // X
    void SetProgressionPoints(unsigned int X,bool save);
    void UseProgressionPoints(unsigned int X);

    int GetMaxAllowedRealm(PSSKILL skill);
    SkillRank &GetSkillRank(PSSKILL skill)
    {
        return skills.GetSkillRank(skill);
    }

    void KilledBy(psCharacter* attacker)
    {
        deaths++;
        if(!attacker) suicides++;
    }
    void Kills(psCharacter* target)
    {
        kills++;
    }

    unsigned int GetKills() const
    {
        return kills;
    }
    unsigned int GetDeaths() const
    {
        return deaths;
    }
    unsigned int GetSuicides() const
    {
        return suicides;
    }

    void DropItem(psItem* &item, csVector3 pos = 0, const csVector3 &rot = csVector3(0), bool guarded = true, bool transient = true, bool inplace = false);

    float GetHP();
    float GetMana();
    float GetStamina(bool pys);

    void SetHitPoints(float v);
    void SetMana(float v);
    void SetStamina(float v, bool pys);

    void AdjustHitPoints(float adjust);
    void AdjustMana(float adjust);
    void AdjustStamina(float adjust, bool pys);

    VitalBuffable &GetMaxHP();
    VitalBuffable &GetMaxMana();
    VitalBuffable &GetMaxPStamina();
    VitalBuffable &GetMaxMStamina();

    VitalBuffable &GetHPRate();
    VitalBuffable &GetManaRate();
    VitalBuffable &GetPStaminaRate();
    VitalBuffable &GetMStaminaRate();

    void SetStaminaRegenerationNone(bool physical = true, bool mental = true);
    void SetStaminaRegenerationWalk(bool physical = true, bool mental = true);
    void SetStaminaRegenerationSitting();
    void SetStaminaRegenerationStill(bool physical = true, bool mental = true);
    void SetStaminaRegenerationWork(int skill);

    void CalculateMaxStamina();

    unsigned int GetStatsDirtyFlags() const;

    void SetAllStatsDirty();

    void ClearStatsDirtyFlags(unsigned int dirtyFlags);

    const char* GetHelmGroup()
    {
        return helmGroup.GetData();
    }
    const char* GetBracerGroup()
    {
        return BracerGroup.GetData();
    }
    const char* GetBeltGroup()
    {
        return BeltGroup.GetData();
    }
    const char* GetCloakGroup()
    {
        return CloakGroup.GetData();
    }

    void SetHelmGroup(const char* Group)
    {
        helmGroup = Group;
    }
    void SetBracerGroup(const char* Group)
    {
        BracerGroup = Group;
    }
    void SetBeltGroup(const char* Group)
    {
        BeltGroup = Group;
    }
    void SetCloakGroup(const char* Group)
    {
        CloakGroup = Group;
    }

    size_t GetAssignedGMEvents(psGMEventListMessage &gmevents, int clientnum);
    void AssignGMEvent(int id, bool playerIsGM);
    void CompleteGMEvent(bool playerIsGM);
    void RemoveGMEvent(int id, bool playerIsGM=false);

    void UpdateRespawn(csVector3 pos, float yrot, psSectorInfo* sector, InstanceID instance);


    bool UpdateFaction(Faction* faction, int delta);

    bool CheckFaction(Faction* faction, int value);

    void StartSong();

    void EndSong(csTicks bonusTime);

    csTicks GetSongStartTime() const
    {
        return songExecutionTime;
    }

    bool IsBanker() const
    {
        return banker;
    }

    bool IsStorage() const
    {
        return IsBanker();
    }
    void RecalculateStats();

    bool IsNPC()
    {
        return characterType == PSCHARACTER_TYPE_NPC;
    }

    bool IsPlayer()
    {
        return characterType == PSCHARACTER_TYPE_PLAYER;
    }

    bool IsPet()
    {
        return (characterType == PSCHARACTER_TYPE_PET || characterType == PSCHARACTER_TYPE_MOUNTPET);
    }
    bool IsMount()
    {
        return (characterType == PSCHARACTER_TYPE_MOUNT || characterType == PSCHARACTER_TYPE_MOUNTPET);
    }
    PID  GetFamiliarID(size_t id)
    {
        return familiarsId.GetSize() > id ? familiarsId.Get(id) : 0;
    }
    void SetFamiliarID(PID v);
    size_t GetNumFamiliars()
    {
        return familiarsId.GetSize();
    }
    bool CanSummonFamiliar()
    {
        return canSummonFamiliar.Current() > 0;
    }
    Buffable<int> &GetCanSummonFamiliar()
    {
        return canSummonFamiliar;
    }
    const char* GetAnimalAffinity()
    {
        return animalAffinity.GetDataSafe();
    }
    void SetAnimialAffinity(const char* v)
    {
        animalAffinity = v;
    }
    PID  GetOwnerID()
    {
        return ownerId;
    }
    void SetOwnerID(PID v)
    {
        ownerId = v;
    }
    bool IsHired()
    {
        return hired;
    }
    void SetHired(bool hired)
    {
        this->hired = hired;
    }

    bool UpdateStatDRData(csTicks now);
    bool SendStatDRMessage(uint32_t clientnum, EID eid, int flags, csRef<PlayerGroup> group = NULL);

    bool GetSlotAttackable(INVENTORY_SLOT_NUMBER slot);

    bool GetSlotAutoAttackable(INVENTORY_SLOT_NUMBER slot);
    bool GetSlotSingleAttackable(INVENTORY_SLOT_NUMBER slot);
    void ResetSwings(csTicks timeofattack);
    void TagEquipmentObject(INVENTORY_SLOT_NUMBER slot,int eventId);
    int GetSlotEventId(INVENTORY_SLOT_NUMBER slot);

    //float GetAttackValue(psItem *slotitem);
    //float GetAttackValueForWeaponInSlot(int slot);
    float GetTargetedBlockValueForWeaponInSlot(INVENTORY_SLOT_NUMBER slot);
    float GetUntargetedBlockValueForWeaponInSlot(INVENTORY_SLOT_NUMBER slot);
    float GetTotalTargetedBlockValue();
    float GetTotalUntargetedBlockValue();
    float GetCounterBlockValueForWeaponInSlot(INVENTORY_SLOT_NUMBER slot);
    float GetDodgeValue();

    Multiplier &AttackModifier()
    {
        return attackModifier;
    }
    Multiplier &DefenseModifier()
    {
        return defenseModifier;
    }

    void PracticeArmorSkills(unsigned int practice, INVENTORY_SLOT_NUMBER attackLocation);
    void PracticeWeaponSkills(unsigned int practice);
    void PracticeWeaponSkills(psItem* weapon, unsigned int practice);

    void SetTraitForLocation(PSTRAIT_LOCATION location,psTrait* trait);
    psTrait* GetTraitForLocation(PSTRAIT_LOCATION location);

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

    void MakeTextureString(csString &textureString);

    void MakeEquipmentString(csString &equipmentString);

    unsigned int GetCharLevel(bool physical);

    bool IsMerchant()
    {
        return (merchantInfo != NULL);
    }
    psMerchantInfo* GetMerchantInfo()
    {
        return merchantInfo;
    }
    bool IsTrainer()
    {
        return (trainerInfo != NULL);
    }
    psTrainerInfo* GetTrainerInfo()
    {
        return trainerInfo;
    }
    psCharacter* GetTrainer()
    {
        return trainer;
    }
    void SetTrainer(psCharacter* trainer)
    {
        this->trainer = trainer;
    }

    bool CanTrain(PSSKILL skill);

    void Train(PSSKILL skill, int yIncrease);

    void SetSkillRank(PSSKILL which, unsigned int rank);

    psSpell* GetSpellByName(const csString &spellName);
    psSpell* GetSpellByIdx(int index);
    csArray<psSpell*> &GetSpellList()
    {
        return spellList;
    }


    psCharacter* GetMerchant()
    {
        return merchant;
    }
    TradingStatus GetTradingStatus()
    {
        return tradingStatus;
    }
    void SetTradingStatus(TradingStatus trading, psCharacter* merchant)
    {
        tradingStatus = trading;
        this->merchant = merchant;
    }

    gemActor* GetActor()
    {
        return actor;
    }
    void SetActor(gemActor* actor);

    bool SetTradingStopped(bool stopped);

    bool ReadyToExchange();

    unsigned int GetOnlineTimeThisSession()
    {
        return (csGetTicks() - startTimeThisSession)/1000;
    }

    unsigned int GetTotalOnlineTime()
    {
        return timeconnected + GetOnlineTimeThisSession();
    }


    unsigned int GetTimeConnected()
    {
        return timeconnected;
    }

    const char* GetDescription();

    void SetDescription(const char* newValue);

    const char* GetOOCDescription();

    void SetOOCDescription(const char* newValue);

    const char* GetCreationInfo();

    void SetCreationInfo(const char* newValue);

    bool GetFactionEventsDescription(csString &factionDescription);

    const char* GetLifeDescription();

    void SetLifeDescription(const char* newValue);

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

    int GetKillExperience()
    {
        return killExp;
    }
    void SetKillExperience(int newValue)
    {
        killExp=newValue;
    }

    void SetImperviousToAttack(int newValue)
    {
        imperviousToAttack=newValue;
    }
    int GetImperviousToAttack()
    {
        return imperviousToAttack;
    }

    void CalculateEquipmentModifiers();
    float GetStatModifier(PSITEMSTATS_STAT attrib);

    bool AppendCharacterSelectData(psAuthApprovedMessage &auth);

    // NPC based functions - should these go here?
    int NPC_GetSpawnRuleID()
    {
        return npcSpawnRuleId;
    }
    void NPC_SetSpawnRuleID(int v)
    {
        npcSpawnRuleId=v;
    }

    psBuddyManager &GetBuddyMgr()
    {
        return buddyManager;
    }
    psCharacterQuestManager &GetQuestMgr()
    {
        return questManager;
    }

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

    AccountID GetAccountId()
    {
        return accountid;
    }

    st_location GetSpawnLocation()
    {
        return spawnLoc;
    }

    st_location GetLocation() const
    {
        return location;
    }

    psAttackQueue* GetAttackQueue() { return attackQueue; } 
    friend class psCharacterLoader;

protected:

    bool LoadSpells(PID use_id);
    bool LoadAdvantages(PID use_id);
    bool LoadSkills(PID use_id);
    bool LoadTraits(PID use_id);
    bool LoadRelationshipInfo(PID pid);
    bool LoadBuddies(Result &myBuddy, Result &buddyOf);
    bool LoadMarriageInfo(Result &result);
    bool LoadFamiliar(Result &pet, Result &owner);
    bool LoadFactions(PID pid);
    void UpdateFactions();

    bool LoadVariables(PID pid);

    void UpdateVariables();

    bool LoadExploration(Result &exploration);
    bool LoadGMEvents();

    psCharacterInventory        inventory;                    
    psGuildInfo*                guildinfo;
    StatSet                     modifiers;
    SkillSet                    skills;
    csSet<PID>                  acquaintances;
    int                         npcMasterId;
    unsigned int                deaths;
    unsigned int                kills;
    unsigned int                suicides;
    bool                        loaded;
    psBuddyManager              buddyManager;
    psCharacterQuestManager     questManager;

    csRef<psMerchantInfo>       merchantInfo;           
    psCharacter*                merchant;               

    bool                        tradingStopped;
    TradingStatus               tradingStatus;          

    gemActor* actor;                
    PID pid;                        
    AccountID accountid;            

    csRef<psTrainerInfo>    trainerInfo;        
    psCharacter*            trainer;            

    csString description;     
    csString oocdescription;  
    csString creationinfo;    
    csString lifedescription; 

    int killExp; 

    Multiplier attackModifier;  
    Multiplier defenseModifier; 

    st_location spawnLoc;

    csString name;
    csString lastname;
    csString fullName;
    csString oldlastname;

    csString spouseName;
    bool     isMarried;

    OverridableRace race; 

    FactionSet* factions;

    csString progressionScriptText; 

    int     imperviousToAttack;

    unsigned int     helpEventFlags;

    st_location location;
    psServerVitals* vitals;

    psTrait* traits[PSTRAIT_LOCATION_COUNT];

    int npcSpawnRuleId;

    int  lootCategoryId;

    csString animalAffinity;
    PID ownerId;
    csArray<PID> familiarsId;
    Buffable<int> canSummonFamiliar;

    unsigned int timeconnected;
    csTicks startTimeThisSession;

    csString lastLoginTime;
    double petElapsedTime;
    double lastSavedPetElapsedTime; 

    psMoney money;                                          
    psMoney bankMoney;                                      

    csArray<psSpell*>         spellList;

    csHash<charVariable, csString> charVariables; 

    psSkillCache              skillCache;
    GMEventsAssignment        assignedEvents;
    csArray<PID>              exploredAreas;

    int joinNotifications;

    float overrideMaxHp,overrideMaxMana;  

    static const char* characterTypeName[];

        // see enum PSCHARACTER_TYPE for list of types
    unsigned int characterType;

    csArray<psItem*> lootPending;
    int  lastResponse;
    int  lootMoney;
    bool isStatue;

    //The attack queue
    csRef<psAttackQueue> attackQueue;
private:
    void CalculateArmorForSlot(INVENTORY_SLOT_NUMBER slot, float &heavy_p, float &med_p, float &light_p);
    bool ArmorUsesSkill(INVENTORY_SLOT_NUMBER slot, PSITEMSTATS_ARMORTYPE skill);

    int FindGlyphSlot(const csArray<glyphSlotInfo> &slots, psItemStats* glyphType, int purifyStatus);

    csTicks songExecutionTime;   

    csString helmGroup;

    csString BracerGroup;

    csString BeltGroup;

    csString CloakGroup;

    bool banker;    

    bool hired;     

    static PoolAllocator<psCharacter> characterpool;
};

#endif