pscelclient.h

Go to the documentation of this file.

/*
 * pscelclient.h                by Matze Braun <MatzeBraun@gmx.de>
 *
 * Copyright (C) 2002-2009 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 __psCelClient_H__
#define __psCelClient_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/cscolor.h>
#include <csutil/parray.h>
#include <csutil/refarr.h>
#include <csutil/list.h>
#include <csutil/hash.h>
#include <csutil/redblacktree.h>
#include <csutil/strhashr.h>
#include <iengine/collection.h>
#include <iengine/sector.h>
#include <imesh/animesh.h>
#include <imesh/animnode/skeleton2anim.h>
#include <imesh/animnode/speed.h>

//=============================================================================
// Project Includes
//=============================================================================

#include "net/cmdbase.h"
#include "engine/linmove.h"

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

struct Trait;
struct iVFS;
struct iSpriteCal3DState;
struct iMeshObject;

class MsgHandler;
class psClientDR;
class psNetPersist;
class psClientVitals;
class psCharAppearance;
class psEntityLabels;
class psShadowManager;
class psWorld;
class psPersistActor;
class psPersistItem;
class GEMClientObject;
class GEMClientActor;
class GEMClientItem;
class GEMClientActionLocation;
class psEffect;
class psSolid;

class UnresolvedPos
{
public:
    GEMClientObject* entity;   

    csVector3 pos;             
    csVector3 rot;
    csString sector;

    UnresolvedPos(GEMClientObject* entity, const csVector3 &pos, const csVector3 &rot, const csString &sector)
    {
        this->entity  = entity;
        this->pos     = pos;
        this->rot     = rot;
        this->sector  = sector;
    }
};

struct InstanceObject : public CS::Utility::FastRefCount<InstanceObject>
{
    csRef<iMeshWrapper> pcmesh;
    csBox3 bbox;
    csWeakRefArray<iSector> sectors;
    csRef<iMeshFactoryWrapper> nullFactory;
    csRef<iThreadReturn> meshFact;
    csRef<iThreadReturn> material;
    ~InstanceObject();
};

class psCelClient : public psClientNetSubscriber
{
private:
    iObjectRegistry* object_reg;
    csPDelArray<GEMClientObject> entities;
    csHash<GEMClientObject*, EID> entities_hash;
    csRefArray<MsgEntry> newActorQueue;
    csRefArray<MsgEntry> newItemQueue;
    bool instantiateItems;

    // Keep seperate for speedups
    csArray<GEMClientActionLocation*> actions;

    struct Effect
    {
        csString effectname;
        csVector3 effectoffset;
        bool rotateWithMesh;
    };

    struct Light
    {
        csColor colour;
        csVector3 lightoffset;
        float radius;
    };

    struct ItemEffect
    {
        bool activeOnGround;
        csPDelArray<Effect> effects;
        csPDelArray<Light> lights;
    };

    csHash<ItemEffect*, csString> effectItems;

    void LoadEffectItems();

    csRedBlackTreeMap<csString, csRef<InstanceObject>,csFixedSizeAllocator<sizeof(CS::Container::RedBlackTreeNode<
            csRedBlackTreePayload<csString,csRef<InstanceObject> > >)>, CS::Container::RedBlackTreeOrderingStrictWeak > instanceObjects;

    csRedBlackTreeMap<csString, csRef<iMeshFactoryWrapper>,csFixedSizeAllocator<sizeof(CS::Container::RedBlackTreeNode<
            csRedBlackTreePayload<csString,csRef<iMeshFactoryWrapper> > >)>, CS::Container::RedBlackTreeOrderingStrictWeak > nullFactories;

public:

    psCelClient();
    virtual ~psCelClient();

    bool Initialize(iObjectRegistry* object_reg, MsgHandler* msghandler);

    void RequestServerWorld();
    bool IsReady();

    GEMClientObject* FindObject(EID eid);

    void RequestActor();
    void SetMainActor(GEMClientActor* object);
    void SetPlayerReady(bool flag);

    void RemoveObject(GEMClientObject* entity);

    psClientDR* GetClientDR()
    {
        return clientdr;
    }
    const csPDelArray<GEMClientObject> &GetEntities() const
    {
        return entities;
    }
    bool IsMeshSubjectToAction(const char* sector,const char* mesh);
    GEMClientActor* GetActorByName(const char* name, bool trueName = true) const;

    virtual void HandleMessage(MsgEntry* me);

    void SetupWorldColliders();

    psEntityLabels* GetEntityLabels()
    {
        return entityLabels;
    }
    psShadowManager* GetShadowManager()
    {
        return shadowManager;
    }

    void SetMainPlayerName(const char* name)
    {
        player_name = name;
    }

    const char* GetMainPlayerName()
    {
        return player_name;
    }

    GEMClientActor* GetMainPlayer()
    {
        return local_player;
    }

    void HandleItemEffect(const char* factName, iMeshWrapper* mw, bool onGround = true, const char* slot = 0,
                          csHash<int, csString>* effectids = 0, csHash<int, csString>* lightids = 0);

    void OnMapsLoaded();

    void OnRegionsDeleted(csArray<iCollection*> &regions);

    psWorld* GetWorld() const
    {
        return gameWorld;
    }

    void HandleUnresolvedPos(GEMClientObject* entity, const csVector3 &pos, const csVector3 &rot, const csString &sector);

    void PruneEntities();

    bool IsUnresSector(iSector* sector)
    {
        return unresSector == sector;
    }
    iSector* GetUnresSector()
    {
        return unresSector;
    }

    int GetRequestStatus()
    {
        return requeststatus;
    }

    void CheckEntityQueues();
    void ForceEntityQueues();

    void Update(bool loaded);


    void AttachObject(iObject* object, GEMClientObject* clientObject);

    void UnattachObject(iObject* object, GEMClientObject* clientObject);

    GEMClientObject* FindAttachedObject(iObject* object);


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

    csPtr<InstanceObject> FindInstanceObject(const char* name) const;

    void AddInstanceObject(const char* name, csRef<InstanceObject> object);

    void RemoveInstanceObject(const char* name);

    csPtr<iMeshFactoryWrapper> FindNullFactory(const char* name) const;
    void AddNullFactory(const char* name, csRef<iMeshFactoryWrapper> object);
    void RemoveNullFactory(const char* name);

    void replaceRacialGroup(csString &string);

    bool InstanceItems()
    {
        return instantiateItems;
    }

protected:
    csList<UnresolvedPos*>::Iterator FindUnresolvedPos(GEMClientObject* entity);

    int requeststatus;
    csRef<iVFS>         vfs;
    csRef<MsgHandler>   msghandler;
    psClientDR* clientdr;

    psEntityLabels* entityLabels;
    psShadowManager* shadowManager;

    psWorld* gameWorld;

    void HandleWorld(MsgEntry* me);
    void HandleActor(MsgEntry* me);
    void HandleItem(MsgEntry* me);
    void HandleActionLocation(MsgEntry* me);
    void HandleObjectRemoval(MsgEntry* me);
    void HandleNameChange(MsgEntry* me);
    void HandleGuildChange(MsgEntry* me);
    void HandleGroupChange(MsgEntry* me);

    void HandleMecsActivate(MsgEntry* me);

    void AddEntity(GEMClientObject* obj);

    void HandleStats(MsgEntry* me);

    GEMClientActor* local_player;
    csString player_name;              

    csList<UnresolvedPos*> unresPos;   
    csRef<iSector> unresSector;        
};

enum GEMOBJECT_TYPE
{
    GEM_OBJECT = 0,
    GEM_ACTOR,
    GEM_ITEM,
    GEM_ACTION_LOC,
    GEM_TYPE_COUNT
};

class GEMClientObject : public DelayedLoader
{
public:
    GEMClientObject();
    GEMClientObject(psCelClient* cel, EID id);
    virtual ~GEMClientObject();

    virtual GEMOBJECT_TYPE GetObjectType()
    {
        return GEM_OBJECT;
    }

    void SubstituteRacialMeshFact();

    void LoadMesh();

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

    void Rotate(float xRot, float yRot, float zRot);

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

    virtual csVector3 GetPosition();

    virtual float GetRotation();

    virtual iSector* GetSector() const;

    virtual iSectorList* GetSectors() const;

    virtual const csBox3 &GetBBox() const;

    EID GetEID()
    {
        return eid;
    }
    csRef<iMeshWrapper> pcmesh;

    virtual int GetMasqueradeType();

    int GetType()
    {
        return type;
    }

    virtual const char* GetName()
    {
        return name;
    }
    virtual void ChangeName(const char* name);

    const char* GetFactName()
    {
        return factName;
    }

    psEffect* GetEntityLabel()
    {
        return entitylabel;
    }
    void      SetEntityLabel(psEffect* el)
    {
        entitylabel = el;
    }

    psEffect* GetShadow()
    {
        return shadow;
    }
    void SetShadow(psEffect* shadow)
    {
        this->shadow = shadow;
    }

    virtual bool IsAlive()
    {
        return false;
    }

    int Flags()
    {
        return flags;
    }

    iMeshWrapper* GetMesh() const;

    virtual void Update();

    float RangeTo(GEMClientObject* obj, bool ignoreY);

    bool HasShadow() const
    {
        return hasShadow;
    }

    bool HasLabel() const
    {
        return hasLabel;
    }

    virtual bool CheckLoadStatus()
    {
        return false;
    }

    virtual void PostLoad(bool /*nullmesh*/) { }

    /* we need to invoke this when we destroy the celClient itself, so the reference to the (now gone) celClient gets unset.
     * Never call this from any other place, since it will unset the celClient reference for *all* GEMClientObjects
     */
    static void UnsetCelClient()
    {
        cel = NULL;
    }

protected:
    static psCelClient* cel;

    csString name;
    csString factName;
    csString matName;
    EID eid;
    int type;

    int flags;                      
    psEffect* entitylabel;
    psEffect* shadow;
    bool hasLabel;
    bool hasShadow;

    csRef<InstanceObject> instance;
    csRef<csShaderVariable> position;
};

class psDRMessage;


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



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

class GEMClientActor : public GEMClientObject
{
public:

    GEMClientActor(psCelClient* cel, psPersistActor &mesg);
    virtual ~GEMClientActor();

    virtual GEMOBJECT_TYPE GetObjectType()
    {
        return GEM_ACTOR;
    }

    void CopyNewestData(GEMClientActor &oldActor);

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

    const csVector3 GetVelocity() const;

    float GetYRotation() const;

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

    void SetVelocity(const csVector3 &vel);

    void SetYRotation(const float yrot);

    void SetAlive(bool aliveFlag, bool newactor);
    virtual bool IsAlive()
    {
        return alive;
    }
    virtual int GetMasqueradeType()
    {
        return masqueradeType;
    }

    psClientVitals* GetVitalMgr()
    {
        return vitalManager;
    }

    csVector3 Pos() const;
    csVector3 Rot() const;
    iSector* GetSector() const;

    virtual const char* GetName(bool realName = true);

    const char* GetGuildName()
    {
        return guildName;
    }
    void SetGuildName(const char* guild)
    {
        guildName = guild;
    }

    bool NeedDRUpdate(unsigned char &priority);
    void SendDRUpdate(unsigned char priority,csStringHashReversible* msgstrings);
    void SetDRData(psDRMessage &drmsg);
    void StopMoving(bool worldVel = false);

    psCharAppearance* CharAppearance()
    {
        return charApp;
    }

    psLinearMovement* linmove;

    psClientVitals* vitalManager;

    void SetMode(uint8_t mode, bool newactor = false);
    uint8_t GetMode()
    {
        return serverMode;
    }
    void SetIdleAnimation(const char* anim);
    void SetAnimationVelocity(const csVector3 &velocity);
    bool SetAnimation(const char* anim, int duration=0);
    void RefreshCal3d();  

    void SetChatBubbleID(unsigned int chatBubbleID);
    unsigned GetChatBubbleID() const;

    csRef<iSpriteCal3DState> cal3dstate;
    csRef<CS::Mesh::iAnimatedMesh> animeshObject;
    csRef<CS::Animation::iSkeletonSpeedNode> speedNode;

    int GetAnimIndex(csStringHashReversible* msgstrings, csStringID animid);

    // The following hash is used by GetAnimIndex().
    csHash<int,csStringID> anim_hash;

    virtual bool CheckLoadStatus();

    csString race;
    csString partName;
    csString mountFactname;
    csString MounterAnim;
    csString helmGroup;
    csString BracerGroup;
    csString BeltGroup;
    csString CloakGroup;
    csString equipment;
    csString traits;
    csVector3 lastSentVelocity,lastSentRotation;
    bool stationary,path_sent;
    csTicks lastDRUpdateTime;
    unsigned short gender;
    float scale;
    float baseScale;
    float mountScale;

    // Access functions for the group var
    bool IsGroupedWith(GEMClientActor* actor);
    bool IsOwnedBy(GEMClientActor* actor);
    unsigned int GetGroupID()
    {
        return groupID;
    }
    void SetGroupID(unsigned int id)
    {
        groupID = id;
    }
    EID  GetOwnerEID()
    {
        return ownerEID;
    }
    void SetOwnerEID(EID id)
    {
        ownerEID = id;
    }

    csPDelArray<Trait> traitList;

    psLinearMovement &Movement();

    virtual void Update();

protected:
    // keep track of allocated ressources
    csRef<iThreadReturn> factory;
    csRef<iThreadReturn> mountFactory;
    csRef<iMeshWrapper> rider;

    psCharAppearance* charApp;

    unsigned int chatBubbleID;
    unsigned int groupID;
    EID ownerEID;
    csString guildName;
    uint8_t  DRcounter;  
    bool DRcounter_set;

    virtual void SwitchToRealMesh(iMeshWrapper* mesh);

    void InitCharData(const char* textures, const char* equipment);

    bool alive;

    int masqueradeType;

    void SetCharacterMode(size_t id);
    size_t movementMode;
    uint8_t serverMode;

    struct PostLoadData
    {
        csVector3 pos;
        float yrot;
        csString sector_name;
        iSector* sector;
        csVector3 top;
        csVector3 bottom;
        csVector3 offset;
        csVector3 vel;
        csString texParts;
    };

    PostLoadData* post_load;
};

class GEMClientItem : public GEMClientObject
{
public:
    GEMClientItem(psCelClient* cel, psPersistItem &mesg);
    virtual ~GEMClientItem();

    virtual GEMOBJECT_TYPE GetObjectType()
    {
        return GEM_ITEM;
    }

    virtual bool CheckLoadStatus();

protected:
    virtual void PostLoad();
    csPtr<iMaterialWrapper> CloneMaterial(iMaterialWrapper* material);

    psSolid* solid;

private:
    struct PostLoadData
    {
        csVector3 pos;
        float xRot;
        float yRot;
        float zRot;
        csString sector;
    };

    PostLoadData* post_load;
    csRef<iThreadReturn> factory;
    csRef<iThreadReturn> material;
    csRef<iShaderManager> shman;
    csRef<iStringSet> strings;
};

class GEMClientActionLocation : public GEMClientObject
{
public:
    GEMClientActionLocation(psCelClient* cel, psPersistActionLocation &mesg);

    virtual GEMOBJECT_TYPE GetObjectType()
    {
        return GEM_ACTION_LOC;
    }

    const char* GetMeshName()
    {
        return meshname;
    }

protected:
    csString meshname;
};

#endif