Linux multi-monitor fullscreen support

[ryzomcore.git] / ryzom / client / src / entity_cl.h

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This source file has been modified by the following contributors:
// Copyright (C) 2012  Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
// Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
// Copyright (C) 2013-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#ifndef CL_ENTITY_CL_H
#define CL_ENTITY_CL_H


/////////////
// Include //
/////////////
// Misc
#include "nel/misc/types_nl.h"
#include "nel/misc/stream.h"
#include "nel/misc/time_nl.h"                   // Define the TTime
#include "nel/misc/vector.h"                    // Define the CVector
#include "nel/misc/vectord.h"                   // Define the CVector
#include "nel/misc/matrix.h"
#include "nel/misc/sheet_id.h"
// Interface 3D
#include "nel/3d/u_instance.h"
#include "nel/3d/u_skeleton.h"
#include "nel/3d/u_visual_collision_entity.h"
#include "nel/3d/animation_time.h"
#include "nel/3d/logic_info.h"
#include "nel/3d/u_particle_system_instance.h"
// Pacs Interface.
#include "nel/pacs/u_move_primitive.h"
#include "nel/pacs/u_global_position.h"
// Game_Share
#include "game_share/properties.h"
#include "game_share/mode_and_behaviour.h"
#include "game_share/entity_types.h"
#include "game_share/body.h"
#include "game_share/hit_type.h"
#include "game_share/body.h"
#include "game_share/animal_status.h"
#include "game_share/pvp_mode.h"
#include "game_share/pvp_clan.h"
#include "game_share/mount_people.h"
#include "game_share/outpost.h"
// Sheets
#include "client_sheets/ground_fx_sheet.h"
// Client
#include "animation_type.h"
#include "string_manager_client.h"
// Stl
#include <string>
#include <list>
#include <map>

// The update clipped primitive mask
#define RZ_CLIPPED_UPDATE_TIME_MASK 0x7

// Size of the points bars
#define RZ_BARS_LENGTH 127

#define RZ_TIME_TO_BECOME_TRANSPARENT_IN_SECOND 0.25
//
#define TMP_DEBUG_GUIGUI

///////////
// CLASS //
///////////
namespace NL3D
{
        class USkeleton;
        class UPlayList;
        class UParticleSystemInstance;
        class UMaterial;
}

class CEntitySheet;
class CEntityCL;
struct CAttackInfo;

class CItemSheet;

namespace NLMISC{
class CCDBNodeLeaf;
class CCDBNodeBranch;
}

extern CLFECOMMON::TCLEntityId  SlotUnderCursor;

/**
 * Implementation of NL3D::ILogicInfo
 *
 * \author Lionel Berenguier
 * \author Nevrax France
 * \date 2002
 */
class CEntityLogicInfo3D : public NL3D::ILogicInfo
{
public:
        /// My owner
        CEntityCL               *Self;

public:
        /// retrieve light information for the entity skeleton
        virtual void            getStaticLightSetup(NLMISC::CRGBA sunAmbient, std::vector<NL3D::CPointLightInfluence> &pointLightList,
                uint8 &sunContribution, NLMISC::CRGBA &localAmbient);
};



/**
 * Interface to manage an Entity in the client side.
 *
 * \author Guillaume PUZIN
 * \author Nevrax France
 * \date 2001
 */
class CEntityCL : public NLMISC::IStreamable, public STRING_MANAGER::IStringWaitCallback
{
        friend class CUpdateEntitiesColor;

public:
        struct SInstanceCL
        {
                NL3D::UInstance Current;        // Current instance
                std::string CurrentName;        // Current instance name
                const CItemSheet *FXItemSheet;
                std::vector<NL3D::UInstance> StaticFXs;

                NL3D::UInstance Loading;                // Instance loading (to avoid any artefact)
                std::string LoadingName;                // Loading instance name

                std::string StickPoint;
                sint TextureSet;
                bool ApplyColor;
                bool KeepHiddenWhenLoaded;
                sint ACSkin, ACUser, ACHair, ACEyes;

                // ------------------------------------------------------------------------
                SInstanceCL()
                {
                        Current = Loading = NULL;
                        FXItemSheet = NULL;
                        TextureSet = -1;
                        ApplyColor = false;
                        KeepHiddenWhenLoaded = false;
                        ACSkin = ACUser = ACHair = ACEyes = -1;
                        _Scale= NLMISC::CVector(1.f,1.f,1.f);
                }
                ~SInstanceCL()
                {
                        releaseStaticFXs();
                }


                void selectTextureSet(uint8 value, bool async = true);

                // show every static fxs
                void showStaticFXs();

                // hide every static fxs
                void hideStaticFXs();

                // Create the loading instance. return false if shapeName is not empty while still fails to load. else return true.
                bool createLoading(const std::string &shapeName, const std::string &stickPoint=std::string(""), sint texture=-1, bool clearIfFail= true);

                // Apply Colors
                void setColors(sint skin, sint user, sint hair, sint eyes);

                // Create the loading instance from the current instance and copy info from current instance to it
                // If the loading instance already exist do not copy anything from current instance
                NL3D::UInstance createLoadingFromCurrent();

                // Update current instance from loading instance (set loading instance to null)
                // Bind the loading instance to the skeleton
                void updateCurrentFromLoading(NL3D::USkeleton skel);

                void releaseStaticFXs();

                // For Blink
                void    setEmissive(NLMISC::CRGBA emit);
                void    restoreEmissive();

                // For MouseOver player (do it on Current)
                void    makeInstanceTransparent(uint8 opacity, uint8 opacityMin);

                // replace diffuse for all material of this instance (not including alpha)
                void setDiffuse(bool onOff, NLMISC::CRGBA diffuse);

                // Setup the scale for the instance
                void                                    setScale(const NLMISC::CVector &scale);
                const NLMISC::CVector   &getScale() const {return _Scale;}

        private:
                // Wanted Scale
                NLMISC::CVector         _Scale;
        };

public:
        /// Constructor.
        CEntityCL();
        /// Destructor.
        virtual ~CEntityCL();

        /// Primitive type
        enum TType
        {
                User = 0,
                Player,
                NPC,
                Fauna,
                Entity,
                ForageSource,
                TypeCount
        } Type;

        /// Return the entity Id (persistent as long as the entity is connected) (CLFECOMMON::INVALID_CLIENT_DATASET_INDEX for an invalid one).
        const CLFECOMMON::TClientDataSetIndex &dataSetId() const {return _DataSetId;}
        /// Set the entity Id (persistent as long as the entity is connected) (CLFECOMMON::INVALID_CLIENT_DATASET_INDEX for an invalid one).
        void dataSetId(CLFECOMMON::TClientDataSetIndex dataSet);

        /// Return the sheet Id of the entity.
        const NLMISC::CSheetId &sheetId() const {return _SheetId;}
        /// Set the sheet Id of the entity.
        void sheetId(const NLMISC::CSheetId &id) {_SheetId = id;}

        /// Return the persistent NPC alias of entity (0 if N/A).
        uint32 npcAlias() const {return _NPCAlias; }
        /// Set the persistent NPC alias of the entity. 
        void npcAlias(uint32 alias) {_NPCAlias = alias; }

        /// Method to call to initialize all members of the right class.
        virtual void initialize();

        /// Build the entity from a sheet.
        virtual bool build(const CEntitySheet *sheet) = 0;

        /// Initialize properties of the entity (according to the class).
        virtual void initProperties();
        /** Initialize the primitive. Return 'true' if the primitive has been created.
         *      clipRadius/clipHeight, specify them if you want special clip values (different from collision ones)
         */
        bool initPrimitive(float radius, float height, float length, float width, NLPACS::UMovePrimitive::TReaction reactionType, NLPACS::UMovePrimitive::TTrigger triggerType, NLPACS::UMovePrimitive::TCollisionMask occlusionMask, NLPACS::UMovePrimitive::TCollisionMask collisionMask, float clipRadius=0.f, float clipHeight=0.f);

        /**
         * Update a visual property from the database.
         * \param gameCycle : when this was sent.
         * \param prop : the property to udapte.
         */
        void updateVisualProperty(const NLMISC::TGameCycle &gameCycle, const uint &prop, const NLMISC::TGameCycle &predictedInterval = 0);

        /// Display the entity name.
        virtual void displayName() {}
        /// Display the Hp Modifiers
        virtual void displayModifiers() {}
        /// Draw Path
        virtual void drawPath() {}
        /// Draw the selection Box
        virtual void drawBox() {}

        /** Method called each frame to manage the entity before the collisions detection.
         * \param time : current time of the frame.
         * \parem target : pointer on the current entity target.
         */
        virtual void updatePreCollision(const NLMISC::TTime &/* time */, CEntityCL * /* target */) {}
        /** Method called each frame to manage the entity after the collisions detection.
         * \param time : current time of the frame.
         * \parem target : pointer on the current entity target.
         */
        virtual void updatePostCollision(const NLMISC::TTime &/* time */, CEntityCL * /* target */) {}
        /** Method called each frame to manage the entity after the clipping test if the primitive is visible.
         * \param time : current time of the frame.
         * \parem target : pointer on the current entity target.
         */
        virtual void updateVisible(const NLMISC::TTime &time, CEntityCL *target);
        /** Method called to manage the entity after the clipping test if the primitive is clipped.
         * This method is called regulary but not at each frame.
         * \param time : current time of the frame.
         * \parem target : pointer on the current entity target.
         */
        virtual void updateSomeClipped(const NLMISC::TTime &time, CEntityCL *target);
        /** Method called to manage the entity after the clipping test if the primitive is clipped.
         * This method is called at each frame.
         * \param time : current time of the frame.
         * \parem target : pointer on the current entity target.
         */
        virtual void updateClipped(const NLMISC::TTime &time, CEntityCL *target);
        /**
         * Update the position of the entity after the motion.
         * \param time : Time for the position of the entity after the motion.
         * \param target : pointer on the current target.
         */
        virtual void updatePos(const NLMISC::TTime &/* time */, CEntityCL * /* target */) {}
        /** Update the entity after the render like for the head offset.
         */
        virtual void updateVisiblePostPos(const NLMISC::TTime &time, CEntityCL *target);
        /** Update the entity after the render like for the head offset.
         */
        virtual void updateVisiblePostRender() {}
        /** Update all the entity after the render visible or not
         */
        virtual void updateAllPostRender() {}

        /**
         * Add an instance to the list of instance composing the entity.
         * \param shapeName : shape filename.
         * \param stickPoint : Name of the bone to stick on.
         * \param texture : texture to use (in multi texture) or -1 for default texture.
         * \param instIdx : if not CEntityCL::BadIndex, the instance will replace the one at this index.
         * \return uint32 : index of the instance created, or CEntityCL::BadIndex.
         */
        uint32 addInstance(const std::string &shapeName, const std::string &stickPoint = "", sint texture = -1, uint32 instIdx = BadIndex);

        // Return true if the primitive is clipped by the camera
        bool clipped (const std::vector<NLMISC::CPlane> &clippingPlanes, const NLMISC::CVector &camPos);

        /** \name NAME
         * Functions to manipulate the Name.
         */
        //@{
        /// Return the Name of the entity. There may be a specification in it (guard, trader, etc ...). It is then surrounded by '$'
        const std::string &getEntityName() const {return _EntityName;}
        /// Return the title from a name. The specification is surrounded by '$', and tells the title of the entity (guard, matis merchant, etc ..)
        static std::string getTitleFromName(const std::string &name);
        /// Remove the specification from a name. The specification is surrounded by '$', and tells the title of the entity (guard, matis merchant, etc ..)
        static std::string removeTitleFromName(const std::string &name);
        /// Remove the shard from a name (if player from the same shard). The shard is surrounded by (), and tells the incoming shard of the entity (aniro, leanon etc...)
        static std::string removeShardFromName(const std::string &name);
        /// Remove both title and shard from name
        static std::string removeTitleAndShardFromName(const std::string &name);
        /// Change the entity name.
        void setEntityName(const std::string &name);
        /// Return a displayable name
        std::string getDisplayName() const
        {
                return removeTitleAndShardFromName(_EntityName);
        }
        /// Return the Name ID of the entity.
        uint32 getNameId() const {return _NameId;}
        //@}

        /// Return the entity permanent content texture name.
        const std::string &getPermanentStatutIcon() const {return _PermanentStatutIcon;}
        /// Change the entity permanent content texture name.
        void setPermanentStatutIcon(const std::string &name) { _PermanentStatutIcon=name; }


        /// Return the parent slot.
        CLFECOMMON::TCLEntityId parent() {return _Parent;}
        /// Set the parelt slot.
        void parent(CLFECOMMON::TCLEntityId p);
        // Add a new child pointer.
        void addChild(CEntityCL *c);
        // Remove a new child pointer.
        void delChild(CEntityCL *c);


        /// Is the entity able to fly.
        void flyer(bool fly) {_Flyer = fly;}
        bool flyer() {return _Flyer;}

        /**
         * Set the skeleton for the entity or an empty string to remove a skeleton.
         * \param filename : file with the skeleton to apply to the entity or empty string to remove a skeleton.
         * \return USkeleton * : pointer on the skeleton handle or NULL.
         */
        NL3D::USkeleton *skeleton(const std::string &filename);
        NL3D::USkeleton *skeleton() {return _Skeleton.empty()?NULL:&_Skeleton;}

        void setStateFx(const std::string &name);
        void removeStateFx();
        const std::string &getStateFx() {return _StateFXName;};
        /** To Inform about another (or self) entity removal (to remove from selection for example).
         * \param slot : Slot of the entity that will be removed.
         */
        virtual void slotRemoved(const CLFECOMMON::TCLEntityId &/* slot */) {}


        /// Return the current slot for the entity or CLFECOMMON::INVALID_SLOT if the entity is not in any slot.
        const CLFECOMMON::TCLEntityId &slot() const {return _Slot;}
        /// Set the current slot for the entity (CLFECOMMON::INVALID_SLOT for no slot).
        void slot(const CLFECOMMON::TCLEntityId &s) {_Slot = s;}


        /** \name TARGET
         * Methods to manage the target.
         */
        //@{
        /// Return the current target of the entity or CLFECOMMON::INVALID_SLOT.
        const CLFECOMMON::TCLEntityId &targetSlot() const {return _TargetSlot;}
        /// Set the current target of the entity (CLFECOMMON::INVALID_SLOT for no target).
        void targetSlot(const CLFECOMMON::TCLEntityId &t) {_TargetSlot = t;}
        /// get the most recent TargeSlot received in updateVisualProperty() (ie wihtout any LCT delay due to _Stages)
        CLFECOMMON::TCLEntityId         getTargetSlotNoLag() const {return _TargetSlotNoLag;}
        /// dir to target
        NLMISC::CVector dirToTarget() const;
        //@}

        /// Set the mode for the entity. return false if it will be impossible to set this mode.
        virtual bool mode(MBEHAV::EMode m) {_Mode = m; return true;}
        /// Return the entity mode.
        virtual MBEHAV::EMode mode() const {return _Mode;}


        /// Return the entity current behaviour.
        MBEHAV::EBehaviour behaviour() const {return _CurrentBehaviour.Behaviour;}

        /**
         * Show or Hide the entity.
         * \param s : if 'true' = entity visible, else invisible.
         */
        void show(bool s);

        void displayable(bool d);
        bool displayable() const {return _Displayable;}


        /** \name POSITION
         * Functions to manage the entity position.
         */
        //@{
        /// Return true if the entity has moved since last frame.
        bool hasMoved() const {return _HasMoved;}
        /// Return the last frame position.
        const NLMISC::CVectorD &lastFramePos() const {return _LastFramePos;}
        /// Return the last frame PACS position.
        bool lastFramePACSPos(NLPACS::UGlobalPosition &result) const;
        /// Return the current PACS position.
        bool currentPACSPos(NLPACS::UGlobalPosition &result) const;
        /// Get the entity position(const method).
        const NLMISC::CVectorD &pos() const {return _Position;}
        // Get the direction matrix
        const NLMISC::CMatrix &dirMatrix() const {return _DirMatrix; }
        /// Get a reference on the entity position(method not const).
        NLMISC::CVectorD &pos() {return _Position;}
        /// Get a reference on the entity position(method not const).
        void pos(const NLMISC::CVectorD &vect);
        /// Change the PACS position and the entity position too. This is slow, prefer pacsMove if you can.
        void pacsPos(const NLMISC::CVectorD &vect, const NLPACS::UGlobalPosition &globPos = NLPACS::UGlobalPosition());
        /// Move the PACS position and the entity position too. This is fast. The PACS position will be available after the PACS::evalCollsion call.
        void pacsMove(const NLMISC::CVectorD &vect);
        /**     Update the PACS position after the evalCollision. The entity position is set too. This is fast.
         *      If the entity position is too far from its PACS position, setGlobalPosition is called.
         *      After this call, the position.z is valid.
         */
        virtual void pacsFinalizeMove();
        /// Get the entity position and set all visual stuff with it.
        virtual void updateDisplay(CEntityCL *parent = 0);
        /// Set the cluster system for the current entity and all of its chidren.
        void setClusterSystem(NL3D::UInstanceGroup *cluster);
        // Get the current cluster system
        NL3D::UInstanceGroup *getClusterSystem();
        /// Choose the right cluster according to the entity position.
        void updateCluster();
        /// Snap the entity on the ground using the visual collision manager.
        virtual void snapToGround();
        //@}


        /// Get the vector up of the entity (method const).
        const NLMISC::CVector &up() const {return _Up;}
        /// Set the vector up of the entity and normalize.
        void up(const NLMISC::CVector &vect);

        /// Get the front vector (const method).
        const NLMISC::CVector &front() const {return _Front;}
        /** Change the entity front vector.
         * \param vect : new vector to use for the front.
         * \param compute : adjust the param 'vect' to be valid or leave the old front unchanged if impossible.
         * \param check : warning if the param 'vect' is not valid to be the front (vector Null) even with compute=true.
         * \param forceTurn : set front even if the entity cannot turn
         * \return bool : 'true' if the front has been filled, else 'false'.
         */
        bool front(const NLMISC::CVector &vect, bool compute=true, bool check=true, bool forceTurn=false);
        /// Get the front Yaw angle (const method).
        float   frontYaw() const {return (float)atan2(front().y, front().x);}

        /// Get the entity direction(this method is const).
        const NLMISC::CVector &dir() const {return _Dir;}
        /** Change the entity direction vector.
         * \param vect : new vector to use for the direction.
         * \param compute : adjust the param 'vect' to be valid or leave the old direction unchanged if impossible.
         * \param check : warning if the param 'vect' is not valid to be the direction (vector Null) even with compute=true.
         * \return bool : 'true' if the direction has been filled, else 'false'.
         */
        bool dir(const NLMISC::CVector &vect, bool compute=true, bool check=true);

        /**
         * Method to get the position of the head (in the world).
         * \param headPos: will be set with the head position if succeed.
         * \return 'true' if the param has been updated.
         * \warning this method do NOT check if there is a skeleton.
         */
        virtual bool getHeadPos(NLMISC::CVector &) {return false;}

        /** \name BOX.
         * Functions to manage the box around the entity.
         */
        //@{
        /**
         * Set the box.
         * \param box : an axis aligned bounding box to apply to the entity.
         */
        void box(const NLMISC::CAABBox &box);
        /**
         * Return a box around the entity.
         * \return CAABBox : an axis aligned bounding box around the entity.
         */
        const NLMISC::CAABBox &box() const {return _Aabbox;}
        /// Return the selection box.
        virtual const NLMISC::CAABBox &selectBox() {return _SelectBox;}
        /// Return the local select box (not transformed in world). Scale is included
        virtual const NLMISC::CAABBox &localSelectBox();

        //@}


        /** \name ENTITY PROPERTIES.
         * Functions to manage the entity properties.
         */
        //@{
        /**
         * Return a reference on properties.
         * \return CProperties : properties of the entity.
         */
        CProperties                     &properties() {return _Properties;}
        const CProperties       &properties() const {return _Properties;}
        //@}


        /** \name COLLISION
         * Methods to manage the primitive.
         */
        //@{
        /// Create a primitive for the entity.
        virtual void computePrimitive();
        /// Remove the primitive from PACS
        virtual void removePrimitive();
        /** Get the primitive used for the entity.
         * \return UMovePrimitive * : poiner on the primitive used for the entity.
         */
        const NLPACS::UMovePrimitive *getPrimitive() const {return _Primitive;}
        NLPACS::UMovePrimitive *getPrimitive() {return _Primitive;}

        /// Create the collision entity.
        virtual void computeCollisionEntity();
        /// Remove the collision entity.
        void removeCollisionEntity();
        /** Get a pointer on the collision entity (collision with the landscape)
         * \return pointer on the collision entity
         */
        NL3D::UVisualCollisionEntity *getCollisionEntity() {return _CollisionEntity;}
        /** Set the collision entity (collision with the landscape)
         * \param pointer on the collision entity
         */
        void setCollisionEntity( NL3D::UVisualCollisionEntity   * collisionEntity ) {_CollisionEntity = collisionEntity;}
        //@}

        /// Method to return the attack radius of an entity
        virtual double attackRadius() const;

        /** Return the position the attacker should have to combat according to the attack angle.
         * \param ang : 0 = the front, >0 and <Pi = left side, <0 and >-Pi = right side.
         */
        virtual NLMISC::CVectorD getAttackerPos(double ang, double dist) const;
        /// Return true if the opponent is well placed.
        virtual bool isPlacedToFight(const NLMISC::CVectorD &/* posAtk */, const NLMISC::CVector &/* dirAtk */, double /* attackerRadius */) const {return false;}

        /** Play an impact on the entity
         * \param impactType : 0=magic, 1=melee
         * \param type : see behaviour for spell
         * \param intensity : see behaviour for spell
         * \param id : see behaviour for spell
        */
        virtual void impact(uint /* impactType */, uint /* type */, uint /* id */, uint /* intensity */) {}
        /** Try to play a melee impact on this entity.
          */
        virtual void meleeImpact(const CAttackInfo &/* attack */) {}
        /** Play the magic impact on the entity
         * \param type : type of the impact (host/good/neutral).
         * \param intensity : intensity of the impact.
         */
        virtual void magicImpact(uint /* type */, uint /* intensity */) {}

        /** \name DEBUG
         * Methods only here for the debug.
         */
        //@{
        /// Return number of stage remaining.
        virtual uint nbStage() {return 0;}

        /// Return the number of animation FXs remaining to remove.
        virtual uint nbAnimFXToRemove() {return 0;}

        /// Change the entity colors.
        virtual void changeColors(sint /* userColor */, sint /* hair */, sint /* eyes */, sint /* part */) { }
        /// Display Debug Information.
        virtual void displayDebug(float x, float &y, float lineStep);
        /// Display Debug Information for property stages
        virtual void displayDebugPropertyStages(float x, float &y, float lineStep);
        //@}

        /// TEST
        NL3D::UPlayList *playList() {return _PlayList;}
        NL3D::UPlayList *facePlayList() {return _FacePlayList;}

        /// Get a reference for all instances of the entity.
        std::vector<SInstanceCL> &instances() {return _Instances;}
        NL3D::UInstance                  instance() { return _Instance;}

        /**
         * \param pos : result given in this variable. Only valid if return 'true'.
         * \return bool : 'true' if the 'pos' has been filled.
         */
        virtual bool getNamePos(NLMISC::CVectorD &/* pos */) {return false;}

        virtual bool getChestPos(NLMISC::CVectorD &/* pos */) const {return false;}

        /// Return true if the character is currently dead.
        virtual bool isDead() const {return (_Mode == MBEHAV::DEATH);}
        /// Return true if the character is really dead. With no lag because of anim or LCT
        virtual bool isReallyDead() const {return false;}

        // Add hit points gain/lost by this entity.
        void addHPOutput(sint16 hp, NLMISC::CRGBA color, float dt=0.0f) { if(_HPModifiers.size()<20) _HPModifiers.push_back(CHPModifier(hp,color,dt));}
        void addHPOutput(const std::string &text, NLMISC::CRGBA color, float dt=0.0f) { if(_HPModifiers.size()<20 && !text.empty()) _HPModifiers.push_back(CHPModifier(text,color,dt));}

        /// Return the entity sheet scale. (return 1.0 if there is any problem).
        virtual float getSheetScale() const {return 1.0f;}
        /// Return the entity collision radius. (return 1.0 if there is any problem).
        virtual float getSheetColRadius() const {return 0.5f;}
        /// Return the entity scale. (return 1.0 if there is any problem).
        virtual float getScale() const {return 1.0;}
        // If entity is a mesh, then returns its default scale (value from export). Returns (1.f, 1.f, 1.f) of not a mesh or skinned
        void  getMeshDefaultScale(NLMISC::CVector &scale) const;

        /// 'True' if the entity is displayed.
        virtual bool isVisible() const {return false;}
        /// (Re-)Build the playlist (Removing the old one too).
        virtual void buildPlaylist() {}


        /// Serialize entity.
        void serial(NLMISC::IStream &f);

        // return vector of ground fxs sorted by ground type, or NULL is ground fxs are not supported for the entity
        virtual const std::vector<CGroundFXSheet> *getGroundFX() const { return NULL; }

        // are ground fx supported by entity ?
        virtual bool supportGroundFX() const { return false; }

        // Was the entity clipped during the last frame ? This is updated during the call CEntityManager::updatePostCamera
        bool getLastClip() const { return _Clipped; }
        void setLastClip(bool lastClip) { _Clipped = lastClip; }

        //--------------//
        // ENTITY INFOS //
        //--------------//

        /// Return the entity speed
        virtual double getSpeed() const {return 0.0;}

        /// Return true if the current position is an indoor position.
        bool indoor() const;

        // Return true if this entity is a user
        bool isUser () const { return Type == User; }

        // Return true if this entity is a neutral entity.
        virtual bool isNeutral () const { return false; }
        // Return true if this entity is a user's friend.
        virtual bool isFriend () const { return false; }
        // Return true if this entity is a user's enemy.
        virtual bool isEnemy () const { return false; }
        // Return true if this entity is a user's ally.
        virtual bool isAlly() const { return false; }
        // Return true if this entity is neutral pvp.
        virtual bool isNeutralPVP() const { return false; }

        /// Return true if this player has the viewing properties of a friend (inscene bars...)
        virtual bool isViewedAsFriend() const { return isNeutral() || isFriend() || isInTeam() || isInSameGuild() || isInSameLeague(); }

        /// Return the People for the entity (unknown by default)
        virtual EGSPD::CPeople::TPeople people() const;
        virtual void setPeople(EGSPD::CPeople::TPeople people);

        // todo handle NPC entities
        // Return true if this entity is a NPC (not a fauna)
        bool isNPC () const { return Type == NPC; }
        
        // Return true if this entity can have missions icons (humanoid NPCs (including Karavan), Kami or Bot Object)
        bool canHaveMissionIcon() const { return isNPC() || isKami() || isUnknownRace(); }

        // Return true if this entity is a Kami
        virtual bool isKami() const { return false; }

        // Return true if this entity has Race set to Unknown
        virtual bool isUnknownRace() const { return false; }

        // Return true if this entity is a fauna (not a NPC)
        bool isFauna () const { return Type == Fauna; }

        // Return true if this entity is a AI (fauna or NPC)
        bool isAI () const { return (Type == Fauna) || (Type == NPC); }

        // Return true if this entity is a forage source
        bool isForageSource() const { return Type == ForageSource; }

        // Return true if this entity is a Player Character
        bool isPlayer () const { return Type == Player; }

        // Return true if this entity is the current user selection. NB: actually test UserEntity->selection() (ie not laggy!)
        bool isTarget () const;

        // Return true if this entity is under the cursor
        bool isUnderCursor () const
        {
                return _Slot == SlotUnderCursor;
        }

        // Is a mission target
        bool isMissionTarget () { return _MissionTarget; }

        // Return true if this entity is in the user group
        bool isInTeam () const { return _IsInTeam; }

        // Return true if this entity is in the user guild
        bool isInSameGuild () const;

        // Return true if this entity is in the user league
        bool isInSameLeague () const;

        // Return true if this entity or the user is in a league
        bool oneInLeague () const;

        // Return true if this entity is a Mount owned by the User
        bool isUserMount () const {return _IsUserMount;}

        // Return true if this entity is a pack animal owned by the User
        bool isUserPackAnimal () const {return _IsUserPackAnimal;}

        // Return info on the guild
        virtual uint32 getGuildNameID () const { return 0; }
        virtual uint64 getGuildSymbol () const { return 0; }

        virtual uint32 getEventFactionID() const { return 0; }
        virtual uint16 getPvpMode() const { return PVP_MODE::None; }
        virtual PVP_CLAN::TPVPClan getPvpClan() const { return PVP_CLAN::None; }
        virtual uint32 getLeagueID() const { return 0; }

        virtual uint16                                  getOutpostId() const { return 0; }
        virtual OUTPOSTENUMS::TPVPSide  getOutpostSide() const { return OUTPOSTENUMS::UnknownPVPSide; }
        bool                                    isAnOutpostEnemy() const;
        bool                                    isAnOutpostAlly() const;

        /// Return the entity title
        const std::string &getTitle() const
        {
                return _Title;
        }

        /// Return the entity tags
        const std::string &getTag(uint8 id) const
        {
                if (_Tags.size() > id) {
                        return _Tags[id];
                }
                static const std::string empty;
                return empty;
        }

        /// Return the raw unparsed entity title
        const std::string &getTitleRaw() const
        {
                return _TitleRaw;
        }

        /// Return true if this entity has a reserved title
        bool hasReservedTitle() const { return _HasReservedTitle; }

        /// Return true if this entity can turn
        bool canTurn() const { return _CanTurn; }

        /// Get entity color
        NLMISC::CRGBA   getColor () const;

        // Rebuild in scene interfaces
        virtual void buildInSceneInterface ();

        // enable display of in scene interface. This flag is 'anded' with the final value when calling 'mustShowInsceneInterface'
        void enableInSceneInterface(bool enabled) { _InSceneInterfaceEnabled = enabled; }

        // Update the mission target flag
        void updateMissionTarget ();

        // get the type of the ground below the entity
        uint getGroundType() const;

        virtual void makeTransparent(bool t);
        virtual void makeTransparent(float factor);
        virtual void setDiffuse(bool onOff, NLMISC::CRGBA diffuse);


        static NLMISC::CCDBNodeLeaf *getOpacityDBNode();
        static uint32 getOpacityMin();
        static void setOpacityMin(uint32 value);

        // Update the _IsInTeam flag
        void updateIsInTeam ();

        // update for isUserMount() and isUserPackAnimal()
        void updateIsUserAnimal ();

        // if a pack animal, return the animal status. 0 if not a pack animal
        ANIMAL_STATUS::EAnimalStatus    getPackAnimalStatus() const;

        // if a pack animal, return the animal DB index
        bool    getPackAnimalIndexInDB(sint &dbIndex) const;

        // remove all attached fx of that entity (so that they can be reloaded)
        virtual void removeAllAttachedFX() {}

        // get bone name from a part of the body (base implementation provides the base bones names)
        virtual const char *getBoneNameFromBodyPart(BODY::TBodyPart part, BODY::TSide side) const;
        // ...
        virtual bool getBoneHeight(BODY::TBodyPart /* localisation */, BODY::TSide /* side */, float &/* height */) const {return false;}

        // true if the entity position is valid (related to network lag at creation time)
        bool            firstPositionReceived() const {return !_First_Pos;}

        // VISUAL SELECTION

        // Start a new visual selection
        void visualSelectionStart();

        // Stop the visual selection
        void visualSelectionStop();

        // true if the entity allow to cast a shadowMap (eg: false for userentity in some case). Default to ClientCFG value
        virtual bool    canCastShadowMap() const;

        // call when want to update the CastShadowMap flags of skeleton/instance
        void                    updateCastShadowMap();

        /// \name Static properties (according to entity type / sheet)
        //@{
        // display the entity in the radar
        bool                    getDisplayInRadar() const {return _DisplayInRadar;}
        // name is displayed if (_Sheet->DisplayOSD && DisplayName)
        bool                    getDisplayOSDName() const {return _DisplayOSDName;}
        // bars are displayed if (_Sheet->DisplayOSD && DisplayBars)
        bool                    getDisplayOSDBars() const {return _DisplayOSDBars;}
        // even if ClientCfg.ShowNameUnderCursor==false, force OSD to display when under cursor (not if _Sheet->DisplayOSD=false)
        bool                    getDisplayOSDForceOver() const {return _DisplayOSDForceOver;}
        // the user can traverse this entity after some "force time"
        bool                    getTraversable() const {return _Traversable;}
        //@}


        // set ordering layer (for sorting with transparent surfaces)
        void                    setOrderingLayer(uint layer);
        // reset all sound anim id this entity may own
        virtual void    resetAllSoundAnimId() {}

        // force to evaluate entity & ancestor anim (and snap to  ground if necessary)
        void forceEvalAnim();

        bool isAsyncLoading() const;
protected:
        enum { BadIndex = 0xFFFFFFFF };

        // Entity Id (CLFECOMMON::INVALID_CLIENT_DATASET_INDEX for an invalid one)
        CLFECOMMON::TClientDataSetIndex _DataSetId;
        // Sheet Id of the entity.
        NLMISC::CSheetId                                _SheetId;
        // Persistent NPC Alias of the entity
        uint32                                                  _NPCAlias;
        // Local DB Branch for this entity
        class NLMISC::CCDBNodeBranch                    *_DBEntry;
        // Playlist
        NL3D::UPlayList                                 *_PlayList;
        NL3D::UPlayList                                 *_FacePlayList;
        // Collision entity used to test collision with landscape
        NL3D::UVisualCollisionEntity    *_CollisionEntity;
        // Entity skeleton
        NL3D::USkeleton                                 _Skeleton;
        /// Slot of the entity.
        CLFECOMMON::TCLEntityId                 _Slot;
        // Slot of the target or CLFECOMMON::INVALID_SLOT if there is no target.
        CLFECOMMON::TCLEntityId                 _TargetSlot;
        // same, but see getTargetSlotNoLag()
        CLFECOMMON::TCLEntityId                 _TargetSlotNoLag;

        // Temp Debug GUIGUI
#ifdef TMP_DEBUG_GUIGUI
        // Theoretical Position
        NLMISC::CVectorD                                _TheoreticalPosition;
        // Theoretical Orientation (last orientation received).
        float                                                   _TheoreticalOrientation;
#endif // TMP_DEBUG_GUIGUI

        // Current entity position.
        NLMISC::CVectorD                                _Position;
        // Useful to limit some noise on positions.
        NLMISC::CVectorD                                _PositionLimiter;
        // Last Frame Position
        NLMISC::CVectorD                                _LastFramePos;
        // Last Frame PACS Position
        NLPACS::UGlobalPosition                 _LastFramePACSPos;
        // Current mode
        MBEHAV::EMode                                   _Mode;
        // Theoretical Current Mode (could be different from the current mode).
        MBEHAV::EMode                                   _TheoreticalMode;
        // Current behaviour
        MBEHAV::CBehaviour                              _CurrentBehaviour;
        // Flags to know what is possible to do with the entity (selectable, liftable, etc.).
        CProperties                                             _Properties;
        // Current Name for the entity
        std::string                                             _EntityName;
        // Current entity title
        std::string                                             _Title;
        // Current entity tags
        std::vector<std::string>                _Tags;
        // Current entity title string id
        std::string                                             _TitleRaw;
        // Current permanent content symbol for the entity
        std::string                                             _PermanentStatutIcon;
        // Has reserved title?
        bool                                                    _HasReservedTitle;

        // Extended Name
        std::string                                             _NameEx;
        // String ID
        uint32                                                  _NameId;
        // Primitive used for the collision in PACS
        NLPACS::UMovePrimitive                  *_Primitive;
        // 3D Logic info for light request.
        CEntityLogicInfo3D                              _LogicInfo3D;
        // Box around the entity.
        NLMISC::CAABBox                                 _Aabbox;
        // Sphere around the entity for 3D clipping (Local to Entity Pos).
        float                                                   _ClipRadius;    // Radius of the clip sphere
        float                                                   _ClipDeltaZ;    // DeltaZ of the sphere center to ground (different from clipradius)

        /// Parent Slot or CLFECOMMON::INVALID_SLOT if there is no parent.
        CLFECOMMON::TCLEntityId                 _Parent;
        /// List of children.
        typedef std::list<CEntityCL *>  TChildren;
        TChildren                                               _Children;
        /// 3D mesh if the entity has no skeleton.
        NL3D::UInstance                                 _Instance;

        /// Meshes to bind to the skeleton if the entity has one.
        std::vector<SInstanceCL>                _Instances;

        // Orientation of the entity.
        NLMISC::CVector                                 _Front;
        // Entity Up.
        NLMISC::CVector                                 _Up;
                // Angle to be linked to the target.
        double                                                  _TargetAngle;
        // Current direction for the entity.
        NLMISC::CVector                                 _Dir;
        // Matrix of the entity direction.
        NLMISC::CMatrix                                 _DirMatrix;
        // The final PACS position
        NLMISC::CVectorD                                _FinalPacsPos;
        /// The last successfully retrieved position as a vector
        NLMISC::CVectorD                                _LastRetrievedPosition;
        /// The last successfully retrieved position as a pacs position
        NLPACS::UGlobalPosition                 _LastRetrievedPacsPosition;
        // Box around the entity.
        NLMISC::CAABBox                                 _SelectBox;
        // Local selection box
        NLMISC::CAABBox                                 _LocalSelectBox;
        // List of modifiers taken by this entity.
        class CHPModifier
        {
        public:
                CHPModifier() {}
                virtual ~CHPModifier() {}
                CHPModifier (sint16 value, NLMISC::CRGBA color, float dt) : Value(value), Color(color), DeltaT(dt) {}
                CHPModifier (const std::string &text, NLMISC::CRGBA color, float dt) : Text(text), Color(color), DeltaT(dt) {}

                sint16                  Value;          // If Text.empty(), take the Value
                std::string             Text;
                NLMISC::CRGBA   Color;
                float                   DeltaT;
        };
        std::list<CHPModifier>                  _HPModifiers;
        //
        class HPMD : public CHPModifier
        {
        public:
                double  Time;
                // DeltaZ between pos() and namePos(). computed only one time
                float   DeltaZ;
                HPMD()
                {
                        DeltaZ= -FLT_MAX;
                }
        };
        std::list<HPMD>                         _HPDisplayed;

        // The transparency factor
        float _TranspFactor; // 0 - opaque 1 - transparent

        // Entities color
        static NLMISC::CRGBA            _EntitiesColor[TypeCount];
        static NLMISC::CRGBA            _DeadColor;
        static NLMISC::CRGBA            _TargetColor;
        static NLMISC::CRGBA            _GroupColor;
        static NLMISC::CRGBA            _GuildColor;
        static NLMISC::CRGBA            _UserMountColor;
        static NLMISC::CRGBA            _UserPackAnimalColor;
        // colors for PvP
        static NLMISC::CRGBA            _PvpEnemyColor;
        static NLMISC::CRGBA            _PvpNeutralColor;
        static NLMISC::CRGBA            _PvpAllyInTeamColor;
        static NLMISC::CRGBA            _PvpAllyInLeagueColor;
        static NLMISC::CRGBA            _PvpAllyColor;
        // colors for GM players
        static NLMISC::CRGBA            _GMTitleColor[CHARACTER_TITLE::EndGmTitle - CHARACTER_TITLE::BeginGmTitle + 1];

        /// invalid gm title id
        static uint8                            _InvalidGMTitleCode;

        // true if all instances are not loaded.
        bool                                                    _AsyncTextureLoading     : 1;
        // true if the lod Texture Need to be recomputed
        bool                                                    _LodTextureDirty         : 1;
        // True as long as the entity has not received any position.
        bool                                                    _First_Pos               : 1;
        //
        bool                                                    _MountRdy                : 1;   // obsolete
        // Id the entity a flyer (NO SNAP TO GROUND)
        bool                                                    _Flyer                   : 1;
        // Set global position not done for this entity
        bool                                                    _SetGlobalPositionDone   : 1;
        // Snap to ground not done for this entity
        bool                                                    _SnapToGroundDone        : 1;
        // Do we have to display or not this entity.
        bool                                                    _Displayable             : 1;
        // Was the entity visible during the last frame ? This is updated during the call to CEntityManager::updatePostCamera
        bool                                                    _Clipped                 : 1;
        // Has the entity moved this fram ?
        bool                                                    _HasMoved                : 1;
        // The entity is a mission target
        bool                                                    _MissionTarget           : 1;
        // The entity is in the team of the player
        bool                                                    _IsInTeam                                : 1;
        // The entity is the User's mount
        bool                                                    _IsUserMount                     : 1;
        // The entity is a User's pack animal
        bool                                                    _IsUserPackAnimal                : 1;
        // Indicate that some of _Instances have enableCastShadowMap(true) set
        bool                                                    _SomeInstanceCastShadowMap : 1;
        // Is this the First Position Managed ?
        bool                                                    _FirstPosManaged         : 1;

        // display the entity in the radar
        bool                                                    _DisplayInRadar                  : 1;
        // name is displayed if (_Sheet->DisplayOSD && DisplayName)
        bool                                                    _DisplayOSDName                  : 1;
        // bars are displayed if (_Sheet->DisplayOSD && DisplayBars)
        bool                                                    _DisplayOSDBars                  : 1;
        // even if ClientCfg.ShowNameUnderCursor==false, force OSD to display when under cursor (not if _Sheet->DisplayOSD=false)
        bool                                                    _DisplayOSDForceOver     : 1;
        // the user can traverse this entity after some "force time"
        bool                                                    _Traversable                     : 1;
        // The entity can turn
        bool                                                    _CanTurn                                 : 1;
        // The entity must not be clipped by camera
        bool                                                    _ForbidClipping                  : 1;
        // bkup state for setVisualSelectionBlink
        bool                                                    _VisualSelectionBlinked  : 1;
        // OSD enabled ?
        bool                                                    _InSceneInterfaceEnabled : 1;

        // The groundType cache
        mutable uint32                                  _GroundTypeCache;
        mutable NLMISC::CVectorD                _GroundTypeCachePos;

        NL3D::UParticleSystemInstance   _SelectionFX;
        NL3D::UParticleSystemInstance   _MouseOverFX;
        NL3D::UParticleSystemInstance   _StateFX;
        std::string                                             _StateFXName;

        /// gamemaster title code of the entity, if any
        uint                                                    _GMTitle;

        // Shadow Stuff
        float                                                   _ShadowMapZDirClamp;
        float                                                   _ShadowMapMaxDepth;
        sint64                                                  _ShadowMapPropertyLastUpdate;

        // Visual selection stuff
        sint64                                                  _VisualSelectionTime;

        // for localSelectBox() computing
        sint64                                                                          _LastLocalSelectBoxComputeTime;

        static NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> _OpacityMinNodeLeaf;
        static NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> _ShowReticleLeaf;

protected:
        /**
         * Change the box position.
         * \param pos contains the new box position.
         */
        void posBox(const NLMISC::CVector &pos);

        /// Update Entity Position.
        virtual void updateVisualPropertyPos          (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, const NLMISC::TGameCycle &/* pI */) {}
        /// Update Entity Orientation.
        virtual void updateVisualPropertyOrient       (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Behaviour.
        virtual void updateVisualPropertyBehaviour    (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Name.
        virtual void updateVisualPropertyName         (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Target.
        virtual void updateVisualPropertyTarget       (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Mode.
        virtual void updateVisualPropertyMode         (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Visual Property A
        virtual void updateVisualPropertyVpa          (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Visual Property B
        virtual void updateVisualPropertyVpb          (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Visual Property C
        virtual void updateVisualPropertyVpc          (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Mount
        virtual void updateVisualPropertyEntityMounted(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Rider
        virtual void updateVisualPropertyRiderEntity  (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update Entity Bars
        virtual void updateVisualPropertyBars                   (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyGuildSymbol    (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyGuildNameID    (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyEventFactionID (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyPvpMode                (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyPvpClan                (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyOwnerPeople    (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        virtual void updateVisualPropertyOutpostInfos   (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}


        /// Update Entity State
        virtual void updateVisualPropertyStatus       (const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Target lists
        virtual void updateVisualPropertyTargetList(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, uint /* listIndex */) {}
        /// Visual FX
        virtual void updateVisualPropertyVisualFX(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */) {}
        /// Update vprop contextual attributes
        virtual void updateVisualPropertyContextual(const NLMISC::TGameCycle &gameCycle, const sint64 &prop);

        /// Return true if the in-scene interface must be shown
        bool            mustShowInsceneInterface( bool enabledInSheet ) const;

        /** Return the instance from its index.
         * \param idx : index of the instance.
         * \return SInstanceCL * : pointer on the instance associated to the index or 0 if idx has no instance.
         */
        SInstanceCL     *idx2Inst(uint idx);

        // Initialize the Object with this function for all constructors.
        void init();

        // hide the entity Skin (all entity instances).
        void hideSkin();

        // called each frame to update some shadowmap properties according to position of player
        void                    updateShadowMapProperties();

        // virtual for special PlayerCL _Face mgt
        virtual void doSetVisualSelectionBlink(bool bOnOff, NLMISC::CRGBA emitColor);


public:
        // Make the selection blinking
        void setVisualSelectionBlink(bool bOnOff, NLMISC::CRGBA emitColor)
        {
                // if already disabled, no need
                // NB: cannot do this if both true, since emitColor may not be the same (emitColor caching not interesting...)
                if(!bOnOff && !_VisualSelectionBlinked)
                        return;
                doSetVisualSelectionBlink(bOnOff, emitColor);
                // cache
                _VisualSelectionBlinked= bOnOff;
        }
/** \name 3D System
         * Methods to manage basics 3D systems
         */
        //@{
        /** update the display of the AsyncTexture of the entity. called in updateDisplay()
         *      Deriver: See CPlayerCL implementation
         *      \return distance from entity to camera computed (helper for deriver)
         */
        virtual float           updateAsyncTexture();
        /// Update the Lod Texture When needed
        virtual void            updateLodTexture();
        //@}

        // Read/Write Variables from/to the stream.
        virtual void readWrite(NLMISC::IStream &f);
        // To call after a read from a stream to re-initialize the entity.
        virtual void load();

private:

        // Override for string reception callback
        virtual void onStringAvailable(uint stringId, const std::string &value);

};


#endif // CL_ENTITY_CL_H

/* End of entity_cl.h */