gem.h

Go to the documentation of this file.

/*
 * gem.h - author Keith Fulton <[email protected]>
 *
 * 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.
 *
 * This is the cel access class for PS.
 *
 * TODO: This API really needs to be refactored into a set of factories.
 */

#ifndef __GEM_H__
#define __GEM_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <iengine/mesh.h>
#include <iengine/sector.h>
#include <iutil/vfs.h>
#include <csutil/csobject.h>
#include <csutil/csstring.h>
#include <csutil/hash.h>
#include <csutil/weakreferenced.h>

//=============================================================================
// Project Space Includes
//=============================================================================
#include "bulkobjects/activespell.h"
#include "bulkobjects/buffable.h"
#include "bulkobjects/pscharacter.h"

#include "util/gameevent.h"
#include "util/consoleout.h"

#include "net/npcmessages.h"  // required for psNPCCommandsMessage::PerceptionType

//=============================================================================
// Local Space Includes
//=============================================================================
#include "msgmanager.h"
#include "deathcallback.h"

struct iMeshWrapper;

class ProximityList;
class ServerCharManager;
class EntityManager;
class gemObject;
class PlayerGroup;
class psDatabase;
class psItem;
class csMatrix3;
class NPCManager;
class psGlyphList;
class ProgressionManager;
class psNPCDialog;
class psAllEntityPosMessage;
class psActionLocation;
class psSpellCastEvent;
class MathScript;
class gemItem;
class gemActor;
class gemNPC;
class gemPet;
class gemActionLocation;
class ClientConnectionSet;
class PublishVector;
class psLinearMovement;
class gemMesh;

#define BUFF_INDICATOR          "+"
#define DEBUFF_INDICATOR        "-"

#define UNSTICK_TIME 15000


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

class psGemServerMeshAttach : public scfImplementationExt1<psGemServerMeshAttach,
    csObject,
    scfFakeInterface<psGemServerMeshAttach> >
{
public:
    SCF_INTERFACE(psGemServerMeshAttach, 0, 0, 1);

    psGemServerMeshAttach(gemObject* object);

    gemObject* GetObject()
    {
        return object;
    }

private:
    gemObject* object;          
};

class GEMSupervisor : public MessageManager<GEMSupervisor>
{
    EntityManager* entityManager;
    CacheManager* cacheManager;
public:
    iObjectRegistry*        object_reg;                     
    psDatabase*             database;                       
    NPCManager*             npcmanager;                     

    GEMSupervisor(iObjectRegistry* objreg, psDatabase* db, EntityManager* entitymanager, CacheManager* cachemanager);

    virtual ~GEMSupervisor();

    csHash<gemObject*, EID> &GetAllGEMS()
    {
        return entities_by_eid;
    }



    EID        FindItemID(psItem* item);

    gemObject* FindObject(EID cel_id);

    gemObject* FindObject(const csString &name);

    gemActor*  FindPlayerEntity(PID player_id);

    gemNPC*    FindNPCEntity(PID npc_id);

    gemNPC*    FindNPCEntity(EID eid);

    gemItem*   FindItemEntity(uint32 item_id);

    EID  CreateEntity(gemObject* obj);
    void AddEntity(gemObject* obj, EID objEid); 
    void RemoveEntity(gemObject* which);
    void AddActorEntity(gemActor* actor);
    void RemoveActorEntity(gemActor* actor);
    void AddItemEntity(gemItem* item);
    void RemoveItemEntity(gemItem* item, uint32 uid);

    void RemovePlayerFromLootables(PID playerID);

    void UpdateAllDR();
    void UpdateAllStats();

    void GetAllEntityPos(csArray<psAllEntityPosMessage> &msgs);
    int  CountManagedNPCs(AccountID superclientID);
    void FillNPCList(MsgEntry* msg, AccountID superclientID);
    void SendAllNPCStats(AccountID superclientID);
    void ActivateNPCs(AccountID superclientID);
    void StopAllNPCs(AccountID superclientID);

    void GetPlayerObjects(PID playerID, csArray<gemObject*> &list);

    void Teleport(gemObject* object, float x, float y, float z, float rot, const char* sectorname);

    void HandleStatsMessage(MsgEntry* me, Client* client);
    void HandleDamageMessage(MsgEntry* me, Client* client);
    void HandleStatDRUpdateMessage(MsgEntry* me, Client* client);

    void AttachObject(iObject* object, gemObject* gobject);


    void UnattachObject(iObject* object, gemObject* gobject);


    gemObject* FindAttachedObject(iObject* object);


    csArray<gemObject*> FindNearbyEntities(iSector* sector, const csVector3 &pos, InstanceID instance, float radius, bool doInvisible = false);

    csArray<gemObject*> FindSectorEntities(iSector* sector, bool doInvisible = false);

protected:
    EID GetNextID();

    csHash<gemObject*, EID> entities_by_eid; 
    csHash<gemItem*, uint32> items_by_uid;   
    csHash<gemActor*,  PID> actors_by_pid;   

    uint32              nextEID;             


    csRef<iEngine> engine;                   
};

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

class gemObject : public iDeleteNotificationObject, public CS::Utility::WeakReferenced, public iScriptableVar
{

public:
    virtual ~gemObject();

    EID GetEID()
    {
        return eid;
    }


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

    virtual void Disconnect();

    virtual bool IsValid(void)
    {
        return eid.IsValid();
    }

    bool IsAlive() const
    {
        return is_alive;
    }

    void SetAlive(bool flag, bool queue = true);

    uint32_t GetClientID();

    virtual const char* GetObjectType()
    {
        return "Object";
    }

    gemItem* GetItemPtr();
    gemActor* GetActorPtr();
    gemNPC* GetNPCPtr();
    gemPet* GetPetPtr();
    gemActionLocation* GetALPtr();

    psItem* GetItem();
    virtual psCharacter* GetCharacterData()
    {
        return NULL;
    }

    virtual Client* GetClient() const
    {
        return NULL;
    }

    const char* GetName();
    void SetName(const char* n);

    void SetInstance(InstanceID newInstance)
    {
        worldInstance = newInstance;
    }
    InstanceID  GetInstance()
    {
        return worldInstance;
    }

    void RegisterCallback(iDeleteObjectCallback* receiver)
    {
        receivers.Push(receiver);
    }
    void UnregisterCallback(iDeleteObjectCallback* receiver)
    {
        receivers.Delete(receiver);
    }



    iMeshWrapper* GetMeshWrapper();

    csString GetMesh()
    {
        return factname;
    }

    void Move(const csVector3 &pos,float rotangle,iSector* room);

    bool IsNear(gemObject* obj,float radius, bool ignoreY = false);

    const csVector3 &GetPosition();

    void GetPosition(csVector3 &pos, float &yrot,iSector* &sector);

    void GetPosition(csVector3 &pos, iSector* &sector);

    float GetAngle();

    iSector* GetSector();

    virtual float GetVelocity();

    const char* GetSectorName()
    {
        return GetSector() ? GetSector()->QueryObject()->GetName() : "(null)";
    }

    csArray<gemObject*>* GetObjectsInRange(float range);



    ProximityList* GetProxList()
    {
        return proxlist;
    };

    csArray<PublishDestination> &GetMulticastClients();

    void UpdateProxList(bool force = false);

    void RemoveFromAllProx();

    void SetAlwaysWatching(bool w)
    {
        alwaysWatching = w;
    }

    bool AlwaysWatching()
    {
        return alwaysWatching;
    }

    float RangeTo(gemObject* obj, bool ignoreY = false, bool ignoreInstance = false);

    virtual bool IsUpdateReq(csVector3 const &pos,csVector3 const &oldPos);

    virtual float GetBaseAdvertiseRange()
    {
        return DEF_PROX_DIST;
    };

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);
    virtual csString GetDefaultBehavior(const csString &dfltBehaviors);

    virtual void Dump();




    virtual void Broadcast(int clientnum, bool control);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL)
    {
        return true;
    }

    virtual void SendGroupMessage(MsgEntry* me) { };


    virtual PID GetPID()
    {
        return 0;
    }
    virtual int GetGuildID()
    {
        return 0;
    }
    virtual psGuildInfo* GetGuild()
    {
        return 0;
    }
    virtual bool UpdateDR()
    {
        return false;
    }
    virtual void BroadcastTargetStatDR(ClientConnectionSet* clients) { }
    virtual void SendTargetStatDR(Client* client) { }
    virtual psNPCDialog* GetNPCDialogPtr()
    {
        return 0;
    }
    virtual void GetLastSuperclientPos(csVector3 &pos, InstanceID &instance, csTicks &last) const { }
    virtual void SetLastSuperclientPos(const csVector3 &pos, InstanceID instance, const csTicks &now) { }
    virtual void AddLootablePlayer(PID playerID) { }
    virtual void RemoveLootablePlayer(PID playerID) { }
    virtual bool IsLootablePlayer(PID playerID)
    {
        return false;
    }
    virtual Client* GetRandomLootClient(int range)
    {
        return NULL;
    }
    virtual AccountID GetSuperclientID()
    {
        return 0;
    }
    virtual void SetSuperclientID(AccountID id) { }

    virtual bool GetVisibility()
    {
        return true;
    }
    virtual bool SeesObject(gemObject* object, float range)
    {
        return false;
    }

    virtual gemObject* GetOwner()
    {
        return NULL;
    }

    virtual bool HasKillStealProtection()
    {
        return false;
    }

protected:
    gemObject(GEMSupervisor* gemsupervisor, EntityManager* entitymanager, CacheManager* cachemanager, const char* name, const char* factname, InstanceID myinstance, iSector* room,
              const csVector3 &pos, float rotangle, int clientnum);

    bool valid;                                 

    gemMesh* pcmesh;                            
    ProximityList* proxlist;                    
    csString name;                              
    static GEMSupervisor* cel;                  
    EntityManager* entityManager;
    CacheManager* cacheManager;
    InstanceID worldInstance;                   
    bool is_alive;                              
    csString factname;                          
    csString matname;                           
    EID eid;                                    
    csRef<iMeshFactoryWrapper> nullfact;        
    bool alwaysWatching;                           

    csArray<iDeleteObjectCallback*> receivers;  

    float prox_distance_desired;                
    float prox_distance_current;                

    bool InitProximityList(float radius,int clientnum);

    void InitMesh(const char* name, const csVector3 &pos, const float rotangle, iSector* room);
};

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

class gemActiveObject : public gemObject
{
public:
    gemActiveObject(GEMSupervisor* gemSupervisor, EntityManager* entitymanager,CacheManager* cachemanager, const char* name,
                    const char* factname,
                    InstanceID myInstance,
                    iSector* room,
                    const csVector3 &pos,
                    float rotangle,
                    int clientnum);

    virtual const char* GetObjectType()
    {
        return "Active object";
    }

    virtual void Broadcast(int clientnum, bool control);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL)
    {
        return true;
    }

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);
    virtual csString GetDefaultBehavior(const csString &dfltBehaviors);

    virtual bool IsPickupable()
    {
        return false;
    }
    virtual bool IsPickupableWeak()
    {
        return false;
    }
    virtual bool IsPickupableStrong()
    {
        return false;
    }
    virtual bool IsLockable()
    {
        return false;
    }
    virtual bool IsLocked()
    {
        return false;
    }
    virtual bool IsConstructible()
    {
        return false;
    }
    virtual bool IsSecutityLocked()
    {
        return false;
    }
    virtual bool IsContainer()
    {
        return false;
    }
};

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

class gemItem : public gemActiveObject
{
protected:
    psItem* itemdata;
    csString itemType;
    float xRot;
    float yRot;
    float zRot;
    uint32_t tribeID; 

public:
    gemItem(GEMSupervisor* gemsupervisor,
            CacheManager* cachemanager,
            EntityManager* entitymanager,
            psItem* item,
            const char* factname,
            InstanceID myInstance,
            iSector* room,
            const csVector3 &pos,
            float xrotangle,
            float yrotangle,
            float zrotangle,
            int clientnum);

    virtual ~gemItem()
    {
        delete itemdata;
    }

    void SetTribeID(uint32_t id)
    {
        tribeID = id;
    }
    uint32_t  GetTribeID()
    {
        return tribeID;
    }

    virtual const char* GetObjectType()
    {
        return itemType.GetData();
    }
    psItem* GetItemData()
    {
        return itemdata;
    }
    void ClearItemData()
    {
        itemdata = NULL;
    }



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

    virtual float GetBaseAdvertiseRange();

    virtual void Broadcast(int clientnum, bool control);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL);

    virtual void SetPosition(const csVector3 &pos,float angle, iSector* sector, InstanceID instance);

    virtual void SetRotation(float xrotangle, float yrotangle, float zrotangle);

    virtual void GetRotation(float &xrotangle, float &yrotangle, float &zrotangle);

    virtual bool IsPickupable();

    virtual bool IsPickupableWeak();

    virtual bool IsPickupableStrong();

    virtual bool IsLockable();
    virtual bool IsLocked();
    virtual bool IsConstructible();
    virtual bool IsSecurityLocked();
    virtual bool IsContainer();
    virtual bool IsUsingCD();

    virtual bool GetCanTransform();
    virtual bool GetVisibility();

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);

private:
    virtual void SendBehaviorMessageTakeAll(const csString &str, gemObject* obj, bool precise);
};

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

class gemContainer : public gemItem
{
protected:
    csArray<psItem*> itemlist;
    bool AddToContainer(psItem* item, Client* fromClient,int slot, bool test);

public:
    gemContainer(GEMSupervisor* gemSupervisor, CacheManager* cachemanager,
                 EntityManager* entitymanager,
                 psItem* item,
                 const char* factname,
                 InstanceID myInstance,
                 iSector* room,
                 const csVector3 &pos,
                 float xrotangle,
                 float yrotangle,
                 float zrotangle,
                 int clientnum);

    ~gemContainer();

    void CleareWithoutDelete();

    bool CanAdd(unsigned short amountToAdd, psItem* item, int slot, csString &reason);
    bool AddToContainer(psItem* item,Client* fromClient, int slot=-1)
    {
        return AddToContainer(item, fromClient, slot, false);
    }
    bool RemoveFromContainer(psItem* item,Client* fromClient);

    bool CanTake(Client* client, psItem* item);

    psItem* RemoveFromContainer(psItem* itemStack, int fromSlot, Client* fromClient, int stackCount);

    psItem* FindItemInSlot(int slot, int stackCount = -1);
    int SlotCount()
    {
        return GetItemData()->GetContainerMaxSlots();
    }
    size_t CountItems()
    {
        return itemlist.GetSize();
    }
    psItem* GetIndexItem(size_t i)
    {
        return itemlist[i];
    }

    class psContainerIterator;

    class psContainerIterator
    {
        size_t current;
        gemContainer* container;

    public:

        psContainerIterator(gemContainer* containerItem);
        bool HasNext();
        psItem* Next();
        psItem* RemoveCurrent(Client* fromClient);
        void UseContainerItem(gemContainer* containerItem);
    };
};

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

class gemActionLocation : public gemActiveObject
{
private:
    psActionLocation* action;
    bool visible;

public:
    gemActionLocation(GEMSupervisor* gemSupervisor,EntityManager* entitymanager,CacheManager* cachemanager,
                      psActionLocation* action, iSector* isec, int clientnum);

    virtual const char* GetObjectType()
    {
        return "ActionLocation";
    }
    virtual psActionLocation* GetAction()
    {
        return action;
    }

    virtual float GetBaseAdvertiseRange();
    virtual bool SeesObject(gemObject* object, float range);

    virtual void Broadcast(int clientnum, bool control);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL);

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);

    virtual bool GetVisibility()
    {
        return visible;
    };
    virtual void SetVisibility(bool vis)
    {
        visible = vis;
    };
};

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

class AttackerHistory
{
public:
    virtual ~AttackerHistory() {}

    gemActor* Attacker() const
    {
        return attacker_ref;
    }
    csTicks TimeOfAttack() const
    {
        return timeOfAttack;
    }
    virtual float Damage() const = 0; // Always positive.
protected:
    AttackerHistory(gemActor* attacker) : attacker_ref(attacker)
    {
        timeOfAttack = csGetTicks();
    }

    csWeakRef<gemActor> attacker_ref;
    csTicks timeOfAttack;
};

class DamageHistory : public AttackerHistory
{
public:
    DamageHistory(gemActor* attacker, float dmg) : AttackerHistory(attacker), damage(dmg)
    {
        CS_ASSERT(damage > 0);
    }
    virtual ~DamageHistory() {}
    virtual float Damage() const
    {
        return damage;
    }
protected:
    float damage;
};

class DOTHistory : public AttackerHistory
{
public:
    DOTHistory(gemActor* attacker, float hpRate, csTicks duration) : AttackerHistory(attacker), hpRate(hpRate), duration(duration)
    {
        CS_ASSERT(hpRate < 0);
    }
    virtual ~DOTHistory() {}
    virtual float Damage() const
    {
        csTicks elapsed = csGetTicks() - timeOfAttack;
        return -hpRate * csMin(duration, elapsed);
    }
protected:
    float hpRate;
    csTicks duration;
};

//-----------------------------------------------------------------------------
class FrozenBuffable : public ClampedPositiveBuffable<int>
{
public:
    void Initialize(gemActor* actor)
    {
        this->actor = actor;
    }

protected:
    gemActor* actor;
    virtual void OnChange();
};

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

class gemActor :  public gemObject, public iDeathNotificationObject
{
protected:
    psCharacter* psChar;
    PID pid;                   
    csRef<PlayerGroup> group;

    psCharacter* mount;

    csVector3 top, bottom, offset;
    csVector3 last_production_pos;

    csWeakRef<Client> clientRef;

    uint8_t attack_cnt; 

    uint8_t DRcounter;  
    uint8_t forceDRcounter; 
    csTicks lastDR;
    csVector3 lastV;

    csVector3 productionStartPos;

    csVector3 lastSentSuperclientPos;
    unsigned int lastSentSuperclientInstance;
    csTicks      lastSentSuperclientTick;

    csArray<iDeathCallback*> deathReceivers;  

    struct DRstate
    {
        csVector3 pos;
        iSector* sector;
        float yrot;
        InstanceID instance;
    } valid_location;

    DRstate newvalid_location;
    DRstate last_location;
    DRstate prev_teleport_location;

    // used by /report command.
    // for details on current /report implementation
    // check PS#2789.

    struct ChatHistoryEntry
    {
        time_t _time;

        csString _line;

        ChatHistoryEntry(const char* szLine, time_t t = 0);

        void GetLogLine(csString &line) const;
    };

    unsigned int activeReports;

    csArray<ChatHistoryEntry> chatHistory;

    csRef<iFile> logging_chat_file;

    bool InitLinMove(const csVector3 &pos,float angle, iSector* sector);
    bool InitCharData(Client* c);

    int securityLevel;
    int masqueradeLevel;

    bool isFalling;           
    csVector3 fallStartPos;   
    iSector* fallStartSector; 
    csTicks fallStartTime;

    bool invincible;          
    bool visible;             
    bool viewAllObjects;      

    csWeakRef<gemObject> targetObject; 

    csPDelArray<AttackerHistory> dmgHistory;
    csPDelArray<ProgressionScript> onAttackScripts, onDefenseScripts, onNearlyDeadScripts, onMovementScripts;

    csArray<ActiveSpell*> activeSpells;

    virtual void ApplyStaminaCalculations(const csVector3 &velocity, float times);

    void SetGMDefaults();

    uint8_t movementMode; 
    bool isAllowedToMove; 
    bool atRest;          
    FrozenBuffable isFrozen;  

    PSCHARACTER_MODE player_mode;
    Stance combat_stance;

    psSpellCastGameEvent* spellCasting; 

    psWorkGameEvent* workEvent;

    iSector* forcedSector;

    bool CanSwitchMode(PSCHARACTER_MODE from, PSCHARACTER_MODE to);

    uint32_t activeMagic_seq;

public:
    psLinearMovement* pcmove;

    gemActor(GEMSupervisor* gemsupervisor,
             CacheManager* cachemanager,
             EntityManager* entitymanager,
             psCharacter* chardata, const char* factname,
             InstanceID myInstance,iSector* room,const csVector3 &pos,float rotangle,int clientnum);

    virtual ~gemActor();

    virtual const char* GetObjectType()
    {
        return "Actor";
    }
    virtual psCharacter* GetCharacterData()
    {
        return psChar;
    }
    virtual Client* GetClient() const;

    virtual PID GetPID()
    {
        return pid;
    }


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

    bool SetupCharData();

    void SetTextureParts(const char* parts);
    void SetEquipment(const char* equip);

    psCharacter* GetMount() const
    {
        return mount;
    }

    void SetMount(psCharacter* newMount)
    {
        mount = newMount;
    }

    bool IsMounted()
    {
        return (mount != NULL);
    }


    PSCHARACTER_MODE GetMode()
    {
        return player_mode;
    }
    const char* GetModeStr(); 
    void SetMode(PSCHARACTER_MODE newmode, uint32_t extraData = 0);
    const Stance &GetCombatStance()
    {
        return combat_stance;
    }
    virtual void SetCombatStance(const Stance &stance);
    bool StartAttack()
    {
        if(attack_cnt < 2)
        {
            attack_cnt++;
            return true;
        }
        return false;
    }
    void EndAttack()
    {
        CS_ASSERT(attack_cnt);
        attack_cnt--;
    }
    virtual void SetDefaultAttackID(unsigned)
    {
    }
    virtual unsigned GetDefaultAttackID()
    {
        return 1;
    }

    void SetSpellCasting(psSpellCastGameEvent* event)
    {
        spellCasting = event;
    }
    bool IsSpellCasting()
    {
        return spellCasting != NULL;
    }
    void InterruptSpellCasting()
    {
        if(spellCasting) spellCasting->Interrupt();
    }

    void SetTradeWork(psWorkGameEvent* event)
    {
        workEvent = event;
    }

    psWorkGameEvent* GetTradeWork()
    {
        return workEvent;
    }

    bool IsAllowedToMove()
    {
        return isAllowedToMove;    
    }
    void SetAllowedToMove(bool newvalue);

    void SetFrozen(bool flag)
    {
        isFrozen.SetBase(flag ? 1 : 0);
    }
    bool IsFrozen()
    {
        return (isFrozen.Current() > 0);
    }
    FrozenBuffable &GetBuffableFrozen()
    {
        return isFrozen;
    }

    int GetTargetType(gemObject* target);

    bool IsAllowedToAttack(gemObject* target, csString &msg);


    void Sit();

    void Stand();

    void SetAllowedToDisconnect(bool allowed);

    void SetSecurityLevel(int level);
    void SetMasqueradeLevel(int level);
    int GetSecurityLevel()
    {
        return(securityLevel);
    }
    int GetMasqueradeLevel()
    {
        return(masqueradeLevel);
    }

    // Last Production Pos is used to require people to move around while /digging
    void SetLastProductionPos(csVector3 &pos)
    {
        last_production_pos = pos;
    }
    void GetLastProductionPos(csVector3 &pos)
    {
        pos = last_production_pos;
    }

    const csVector3 &GetProductionStartPos(void) const
    {
        return productionStartPos;
    }

    void SetProductionStartPos(const csVector3 &pos)
    {
        productionStartPos = pos;
    }

    // To be used for the /report command.

    bool AddChatReport(gemActor* reporter);

    void RemoveChatReport();

    bool IsLoggingChat() const
    {
        return activeReports > 0;
    }

    bool LogChatMessage(const char* who, const psChatMessage &msg);

    bool LogSystemMessage(const char* szLine);

    bool LogLine(const char* szLine);


    void UpdateStats();
    void ProcessStamina();
    void ProcessStamina(const csVector3 &velocity, bool force=false);

    void Teleport(const char* sec, const csVector3 &pos, float yrot, InstanceID instance, int32_t loadDelay = 0, csString background = "", csVector2 point1 = 0, csVector2 point2 = 0, csString widget = "");
    void Teleport(iSector* sector, const csVector3 &pos, float yrot, InstanceID instance, int32_t loadDelay = 0, csString background = "", csVector2 point1 = 0, csVector2 point2 = 0, csString widget = "");
    void Teleport(iSector* sector, const csVector3 &pos, float yrot, int32_t loadDelay = 0, csString background = "", csVector2 point1 = 0, csVector2 point2 = 0, csString widget = "");

    void SetPosition(const csVector3 &pos,float angle, iSector* sector);
    void SetInstance(InstanceID worldInstance);

    void UpdateValidLocation(const csVector3 &pos, float yrot, iSector* sector, InstanceID instance, bool force = false);

    bool SetDRData(psDRMessage &drmsg);
    void MulticastDRUpdate();
    virtual void ForcePositionUpdate(int32_t loadDelay = 0, csString background = "", csVector2 point1 = 0, csVector2 point2 = 0, csString widget = "");

    using gemObject::RegisterCallback;
    using gemObject::UnregisterCallback;
    void RegisterCallback(iDeathCallback* receiver)
    {
        deathReceivers.Push(receiver);
    }
    void UnregisterCallback(iDeathCallback* receiver)
    {
        deathReceivers.Delete(receiver);
    }
    void HandleDeath();

    float GetRelativeFaction(gemActor* speaker);

    csPtr<PlayerGroup> GetGroup();
    void SetGroup(PlayerGroup* group);
    bool InGroup() const;
    bool IsGroupedWith(gemActor* other, bool IncludePets = false) const;
    int GetGroupID();
    void RemoveFromGroup();

    bool IsMyPet(gemActor* other) const;

    const char* GetFirstName()
    {
        return psChar->GetCharName();
    }

    const char* GetGuildName();
    psGuildInfo* GetGuild()
    {
        return psChar->GetGuild();
    }
    psGuildLevel* GetGuildLevel()
    {
        return psChar->GetGuildLevel();
    }

    psGuildMember* GetGuildMembership()
    {
        return psChar->GetGuildMembership();
    }

    void DoDamage(gemActor* attacker, float damage);
    void AddAttackerHistory(gemActor* attacker, float damage); // direct damage version
    void AddAttackerHistory(gemActor* attacker, float hpRate, csTicks duration); // DoT version
    void RemoveAttackerHistory(gemActor* attacker);
    bool CanBeAttackedBy(gemActor* attacker, gemActor* &lastAttacker) const;

    virtual bool HasBeenAttackedBy(gemActor* attacker);

    void Kill(gemActor* attacker)
    {
        DoDamage(attacker, psChar->GetHP());
    }
    void Defeat();
    void Resurrect();

    virtual bool UpdateDR();
    virtual void GetLastSuperclientPos(csVector3 &pos, InstanceID &instance, csTicks &last) const;
    virtual void SetLastSuperclientPos(const csVector3 &pos, InstanceID instance, const csTicks &now);

    virtual void BroadcastTargetStatDR(ClientConnectionSet* clients);
    virtual void SendTargetStatDR(Client* client);
    virtual void SendGroupStats();

    void SetAction(const char* anim,csTicks &timeDelay);

    virtual void Broadcast(int clientnum, bool control);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL);

    virtual void SendGroupMessage(MsgEntry* me);

    gemObject* FindNearbyActorName(const char* name);

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);
    virtual csString GetDefaultBehavior(const csString &dfltBehaviors);

    void FallBegan(const csVector3 &pos, iSector* sector);

    float FallEnded(const csVector3 &pos, iSector* sector);

    bool IsFalling()
    {
        return isFalling;
    }

    csTicks GetFallStartTime()
    {
        return fallStartTime;
    }

    bool AtRest() const
    {
        return atRest;
    }

    virtual bool GetVisibility()
    {
        return visible;
    }
    virtual void SetVisibility(bool visible);
    virtual bool SeesObject(gemObject* object, float range);

    virtual bool GetInvincibility()
    {
        return invincible;
    }
    virtual void SetInvincibility(bool invincible);

    bool GetViewAllObjects()
    {
        return viewAllObjects;
    }
    void SetViewAllObjects(bool v);

    void StopMoving(bool worldVel = false);

    bool MoveToSpawnPos(int32_t delay = 0, csString background = "", csVector2 point1 = 0, csVector2 point2 = 0, csString widget = "");

    bool GetSpawnPos(csVector3 &pos, float &yrot, iSector* &sector, bool useRange = false);

    bool MoveToValidPos(bool force = false);

    void GetValidPos(csVector3 &pos, float &yrot, iSector* &sector, InstanceID &instance);

    void GetLastLocation(csVector3 &pos, float &yrot, iSector* &sector, InstanceID &instance);

    void MoveToLastPos();

    void SetPrevTeleportLocation(const csVector3 &pos, float yrot, iSector* sector, InstanceID instance);
    void GetPrevTeleportLocation(csVector3 &pos, float &yrot, iSector* &sector, InstanceID &instance);

    AttackerHistory* GetDamageHistory(int pos) const
    {
        return dmgHistory.Get(pos);
    }
    size_t GetDamageHistoryCount() const
    {
        return dmgHistory.GetSize();
    }
    void ClearDamageHistory()
    {
        dmgHistory.Empty();
    }

    void AttachScript(ProgressionScript* script, int type);
    void DetachScript(ProgressionScript* script, int type);
    void InvokeAttackScripts(gemActor* defender, psItem* weapon);
    void InvokeDefenseScripts(gemActor* attacker, psItem* weapon);
    void InvokeNearlyDeadScripts(gemActor* defender, psItem* weapon);
    void InvokeMovementScripts();

    void AddActiveSpell(ActiveSpell* asp);
    void SendActiveSpells();
    bool RemoveActiveSpell(ActiveSpell* asp);
    ActiveSpell* FindActiveSpell(const csString &name, SPELL_TYPE type);
    int ActiveSpellCount(const csString &name);
    csArray<ActiveSpell*> &GetActiveSpells()
    {
        return activeSpells;
    }
    void CancelActiveSpellsForDeath();
    void CancelActiveSpellsWhichDamage();
    int FindAnimIndex(const char* name);


    void SetDefaults(bool player);




    bool nevertired;        
    bool infinitemana;      
    bool instantcast;       
    bool safefall;          
    bool questtester;       
    bool givekillexp;       
    bool attackable;        


    bool SetMesh(const char* meshname);

    bool GetFiniteInventory()
    {
        return GetCharacterData()->Inventory().GetDoRestrictions();
    }
    void SetFiniteInventory(bool v)
    {
        GetCharacterData()->Inventory().SetDoRestrictions(v);
    }

    // Target information
    void SetTargetObject(gemObject* object)
    {
        targetObject = object;
    }
    gemObject* GetTargetObject() const
    {
        return targetObject;
    }

    virtual float GetVelocity();

    virtual bool InsideGuardedArea(gemObject* object);

    uint32_t GetActiveMagicSequence()
    {
        activeMagic_seq++;
        return activeMagic_seq;
    }
};

//-----------------------------------------------------------------------------
class NpcDialogMenu;

class gemNPC : public gemActor
{
protected:
    psNPCDialog* npcdialog;
    AccountID superClientID;
    csWeakRef<gemObject>  target;
    csWeakRef<gemObject>  owner;

    csTicks nextVeryShortRangeAvail; 
    csTicks nextShortRangeAvail;     
    csTicks nextLongRangeAvail;      

    csArray<PID> lootablePlayers;

    struct DialogCounter
    {
        csString said;
        csString trigger;
        int      count;
        csTicks  when;
        static int Compare(DialogCounter* const &first,  DialogCounter* const &second)
        {
            if(first->count != second->count)
                return first->count - second->count;
            return first->when - second->when;
//            if (first.count != second.count)
//                return first.count - second.count;
//            return first.when - second.when;
        }
    };

    csPDelArray<DialogCounter> badText;

    unsigned default_attackid;          

    int speakers;

    bool busy; 

public:
    gemNPC(GEMSupervisor* gemSupervisor,
           CacheManager* cachemanager,
           EntityManager* entityManager,
           psCharacter* chardata, const char* factname,
           InstanceID myInstance,iSector* room,const csVector3 &pos,float rotangle,int clientnum);

    virtual ~gemNPC();

    virtual void SetCombatStance(const Stance &stance);
    virtual void SetDefaultAttackID(unsigned id)
    {
        default_attackid = id;
    }
    virtual unsigned GetDefaultAttackID()
    {
        return default_attackid;
    }

    virtual const char* GetObjectType()
    {
        return "NPC";
    }
    virtual psNPCDialog* GetNPCDialogPtr()
    {
        return npcdialog;
    }

    virtual AccountID GetSuperclientID()
    {
        return superClientID;
    }
    virtual void SetSuperclientID(AccountID id)
    {
        superClientID = id;
    }

    void SetupDialog(PID npcID, PID masterNpcID, bool force=false);
    void ReactToPlayerApproach(psNPCCommandsMessage::PerceptionType type, gemActor* player);

    virtual void ApplyStaminaCalculations(const csVector3 &velocity, float times) { } // NPCs usually have 0 stamina.
    // Before this fix, this caused a major long term bug where NPCs would give up attacking after a few hits and expending all stamina.

    virtual void AddLootablePlayer(PID playerID);
    virtual void RemoveLootablePlayer(PID playerID);
    bool IsLootablePlayer(PID playerID);
    const csArray<PID> &GetLootablePlayers() const
    {
        return lootablePlayers;
    }
    virtual Client* GetRandomLootClient(int range);

    void Say(const char* sayText, Client* who, bool sayPublic, csTicks &timeDelay);

    void ActionCommand(bool actionMy, bool actionNarrate, const char* actText, Client* who, bool actionPublic, csTicks &timeDelay);

    void AddBadText(const char* playerSaid,const char* trigger);
    void GetBadText(size_t first,size_t last, csStringArray &saidArray, csStringArray &trigArray);

    virtual bool Send(int clientnum, bool control, bool to_superclients, psPersistAllEntities* allEntities=NULL);

    virtual void Broadcast(int clientnum, bool control);

    virtual void SendBehaviorMessage(const csString &str, gemObject* obj);
    virtual csString GetDefaultBehavior(const csString &dfltBehaviors);
    void ShowPopupMenu(Client* client);

    virtual void SetTarget(gemObject* newTarget)
    {
        target = newTarget;
    }
    virtual gemObject* GetTarget()
    {
        return this->target;
    }

    virtual void SetOwner(gemObject* owner);

    virtual gemObject* GetOwner()
    {
        return this->owner;
    }

    virtual void SetPosition(const csVector3 &pos, float angle, iSector* sector);


    virtual bool HasKillStealProtection()
    {
        return !GetCharacterData()->IsPet();
    }

    virtual void SendGroupStats();
    virtual void ForcePositionUpdate();

    void RegisterSpeaker(Client* client);

    void CheckSpeakers();

    void SetBusy(bool busy);

    bool IsBusy() const;
};

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

class gemPet : public gemNPC
{
public:

    gemPet(GEMSupervisor* gemsupervisor,
           CacheManager* cachemanager,
           EntityManager* entitymanager,
           psCharacter* chardata, const char* factname, InstanceID instance, iSector* room,
           const csVector3 &pos,float rotangle,int clientnum,uint32 id) : gemNPC(gemsupervisor, cachemanager, entitymanager, chardata,factname,instance,room,pos,rotangle,clientnum)
    {
        this->persistanceLevel = "Temporary";
    };

    virtual const char* GetObjectType()
    {
        return "PET";
    }


    void SetPersistanceLevel(const char* level)
    {
        this->persistanceLevel = level;
    };
    const char* SetPersistanceLevel(void)
    {
        return persistanceLevel.GetData();
    };
    bool IsFamiliar(void)
    {
        return this->persistanceLevel.CompareNoCase("Permanent");
    };

private:
    csString persistanceLevel;
};

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

class psGEMEvent : public psGameEvent, public iDeleteObjectCallback
{
public:
    csWeakRef<gemObject> dependency;

    psGEMEvent(csTicks ticks,int offsetticks,gemObject* depends, const char* newType)
        : psGameEvent(ticks,offsetticks,newType)
    {
        dependency = NULL;

        // Register for disconnect events
        if(depends)
        {
            dependency = depends;
            depends->RegisterCallback(this);
        }
    }

    virtual ~psGEMEvent()
    {
        // If DeleteObjectCallback() has not been called normal operation
        // this object have to unregister to prevent the
        // object from calling DeleteObjectCallback() later when destroyed.
        if(dependency.IsValid())
        {
            dependency->UnregisterCallback(this);
            dependency = NULL;
        }
    }

    virtual void DeleteObjectCallback(iDeleteNotificationObject* object)
    {
        SetValid(false); // Prevent the Trigger from beeing called.

        if(dependency.IsValid())
        {
            dependency->UnregisterCallback(this);
            dependency = NULL;
        }
    }
};

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

class psResurrectEvent : public psGameEvent // psGEMEvent
{
protected:
    csWeakRef<gemObject> who;

public:
    psResurrectEvent(csTicks ticks,int offsetticks,gemActor* actor)
        : psGameEvent(ticks,offsetticks,"psResurrectEvent")
    {
        who = actor;
    }

    void Trigger()
    {
        if(who.IsValid())
        {
            gemActor* actor = dynamic_cast<gemActor*>((gemObject*) who);
            actor->Resurrect();
        }
    }
};

#endif