Add infos into target window

[ryzomcore.git] / ryzom / client / src / character_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>
//
// 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_CHARACTER_CL_H
#define CL_CHARACTER_CL_H


/////////////
// INCLUDE //
/////////////
// Misc.
#include "nel/misc/types_nl.h"
#include "nel/misc/time_nl.h"
// 3d.
#include "nel/3d/u_play_list.h"
#include "nel/3d/target_anim_ctrl.h"
#include "nel/3d/u_particle_system_instance.h"
// Client.
#include "entity_cl.h"
#include "stage.h"
#include "entity_animation_manager.h"
#include "fx_manager.h"
#include "behaviour_context.h"
#include "attack_info.h"
#include "attached_fx.h"
// Client Sheets
#include "client_sheets/character_sheet.h"
#include "client_sheets/fx_sheet.h"
#include "client_sheets/attack_id_sheet.h"
// std
#include <map>
#include <vector>
// Game Share
#include "game_share/slot_types.h"
#include "game_share/gender.h"
#include "game_share/mode_and_behaviour.h"


extern NL3D::UScene *Scene;

///////////
// CLASS //
///////////
class CCharacterSheet;
class CItemSheet;
class CUserEntity;
class CAnimationFX;
class CItemFXSheet;
class CAttack;
class CGroupInSceneBubble;
class CAttackSheet;
class CProjectileBuild;



/**
 * Class to manage a character.
 * \author Guillaume PUZIN
 * \author Nevrax France
 * \date 2001
 */
class CCharacterCL : public CEntityCL
{
        friend class CUserEntity;

public:
        /// Stages to describ entity actions/motion.
        CStageSet                                                                       _Stages;
        enum { MaxNumAura = 2 };
        enum    TAtkHeight
        {
                AtkUnkownHeight = 0,
                AtkLow,
                AtkMiddle,
                AtkHigh
        };

public:
        NLMISC_DECLARE_CLASS(CCharacterCL);

        /** \name CONSTRUCTOR and DESTRUCTOR
         * Functions to construct or destroy the class.
         */
        //@{
        /// Default Constructor
        CCharacterCL();
        /// Default Destructor
        virtual ~CCharacterCL();
        //@}

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

        /// \from CEntityCl
        virtual void updatePreCollision(const NLMISC::TTime &time, CEntityCL *target);
        virtual void updatePostCollision(const NLMISC::TTime &time, CEntityCL *target);
        virtual void updateVisible (const NLMISC::TTime &currentTimeInMs, CEntityCL *target);
        virtual void updateSomeClipped (const NLMISC::TTime &currentTimeInMs, CEntityCL *target);
        virtual void updateClipped (const NLMISC::TTime &currentTimeInMs, CEntityCL *target);

        // Get the move for the MOVE channel with the blend.
        double getTheMove(double loopTimeStep, double oldMovingTimeOffset, double         oldMovingTimeOffsetRun) const;
        // Get the move for any channel.
        double getTheMove(double loopTimeStep, double oldMovingTimeOffset, TAnimationType channel               ) const;

        /**
         * Update the position of the entity after the motion.
         * \param target : pointer on the current target.
         */
        virtual void updatePosCombatFloatChanged(CEntityCL * /* target */) {}
        /**
         * Update the position of the entity after the motion.
         * \param target : pointer on the current target.
         */
        virtual void updatePosCombatFloat(double frameTimeRemaining, 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 &currentTimeInMs, CEntityCL *target);
        /** Update the entity after all positions done.
         */
        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();

        // from CEntityCL
        virtual void computePrimitive();

        /// Get the face instance. Returns NULL if no face.
        virtual SInstanceCL *getFace ();

        /// Update eyes blink. For the moment, called by updatePos.
        void updateBlink(const NLMISC::TTime &currentTimeInMs);

        /// Update system FX
        void updateFX();

        /// Get the entity position and set all visual stuff with it.
        virtual void updateDisplay(CEntityCL *parent = 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();

        /// Create in-scene interface
        virtual void buildInSceneInterface ();

        /// Destroy inscene interfaces
        void releaseInSceneInterfaces();

        /** \name HEAD_CODE_CONTROL
         * Methods to manage the head code control.
         */
        //@{
        /** Update the head Direction.
         */
        virtual void updateHeadDirection(CEntityCL *target);
        /// Return the bone Id of the entity Head.
        sint headBone() const {return _HeadBoneId;}
        /// Return the bone Id of the entity pelvis.
        //sint pelvisBone() const {return _PelvisBoneId;}
        /**
         * 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 &headPos);
        //@}

        /// Return the selection box.
        virtual const NLMISC::CAABBox &selectBox();


        /// Set the mode for the entity.
        virtual bool mode(MBEHAV::EMode m);
        void setMode(MBEHAV::EMode m) {_Mode = m; _ModeWanted = m;}


        /** To Inform about another (or self) entity removal (to remove from selection for example).
         * This will remove the entity from the target.
         * \param slot : Slot of the entity that will be removed.
         */
        virtual void slotRemoved(const CLFECOMMON::TCLEntityId &slot);

        enum TOnMove
        {
                OnMoveNone = 0,
                OnMoveForward,
                OnMoveBackward,
                OnMoveLeft,
                OnMoveRight
        };
        enum TOnRot
        {
                OnRotNone = 0,
                OnRotLeft,
                OnRotRight
        };
        enum TOnBigBend
        {
                OnBendNone = 0,
                OnBendLeft,
                OnBendRight
        };
        //
        TOnMove    onMove      (const CAutomatonStateSheet &curAnimState);
        //
        TOnRot     onRotation  (const CAutomatonStateSheet &curAnimState, NLMISC::CVector &dirEndA);
        //
        TOnBigBend onBigBend   (const CAutomatonStateSheet &curAnimState, NLMISC::CVector &dirEndA);
        //
        bool       onBadHeading(const CAutomatonStateSheet &curAnimState);

        /** Force an animation.
          */
        void setAnim(TAnimStateKey newKey, TAnimStateKey subKey = (TAnimStateKey)CAnimation::UnknownAnim, uint animID=NL3D::UAnimationSet::NotFound);

        /// Set the LOD animation.
        void setAnimLOD(bool changed);

        GSGENDER::EGender getGender() const { return _Gender; } // 0 -> male     1 -> female     2 -> beast
        void setGender(GSGENDER::EGender gender) {_Gender = gender;}

        /// 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;

        /** 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);
        // from CEntityCL
        virtual void meleeImpact(const CAttackInfo &damage);
        // from CEntityCL
        virtual void magicImpact(uint type, uint intensity);


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

        /// Return the number of attached FXs remaining to remove.
        virtual uint nbAttachedFXToRemove() {return (uint)_AttachedFXListToRemove.size();}

        /// Set the animation state key.
        bool animationStateKey(TAnimationType channel, TAnimStateId value);

        /// Return the current animation name.
        const std::string &currentAnimationName() const;
        /// Return the current animation set name.
        std::string currentAnimationSetName(TAnimationType animType) const;
        /// 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);
        /// set the NameId for debug in local
        void    debugSetNameId(uint32 nameId) {updateVisualPropertyName(0, nameId);}
        //@}

        /**
         * \return the sheet of the character
         */
        const CCharacterSheet *getSheet() const {return _Sheet;}

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

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

        /// TEST
        std::string                                &currentAutomaton()     {return _CurrentAutomaton;}
        std::vector<const CAnimationSet *>         &currentAnimSet()       {return _CurrentAnimSet;}

        void processFrame(const NLMISC::TTime &currentTimeInMs);
        void processStage(CStage &stage);

        CLFECOMMON::TCLEntityId mount() const {return _Mount;}
        CLFECOMMON::TCLEntityId rider() const {return _Rider;}
        void rider(CLFECOMMON::TCLEntityId r) {_Rider = r;}


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

        /**
         * \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 true if the character is swimming (even if dead).
        bool isSwimming() const {return (_Mode == MBEHAV::SWIM || _Mode == MBEHAV::SWIM_DEATH || _Mode == MBEHAV::MOUNT_SWIM);}
        /// Return true if the character is riding.
        bool isRiding() const {return (_Mode == MBEHAV::MOUNT_NORMAL || _Mode == MBEHAV::MOUNT_SWIM);}
        /// Is the entity in combat.
        bool isFighting() const {return (_Mode == MBEHAV::COMBAT || _Mode == MBEHAV::COMBAT_FLOAT);}
        /// Return true if the character is currently dead.
        virtual bool isDead() const {return (_Mode == MBEHAV::DEATH || _Mode == MBEHAV::SWIM_DEATH);}
        /// Return true if the character is really dead. With no lag because of anim or LCT
        virtual bool isReallyDead() const {return (_TheoreticalMode == MBEHAV::DEATH || _TheoreticalMode == MBEHAV::SWIM_DEATH);}

        const CAutomatonStateSheet *currentState() {return _CurrentState;}
        void currentState(const CAutomatonStateSheet *newState) {_CurrentState = newState;}
        /// Return the entity sheet scale. (return 1.0 if there is any problem).
        virtual float getSheetScale() const;
        // Return the entity collision radius. (return 0.5 if there is any problem).
        float getSheetColRadius() const;
        /// Return the entity scale. (return 1.0 if there is any problem).
        virtual float getScale() const;
        /// Return 'true' is the entity is displayed.
        virtual bool isVisible() const {return true;}
        /// (Re-)Build the playlist (Removing the old one too).
        virtual void buildPlaylist();
        // 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;
        virtual bool supportGroundFX() const { return true; }
        //--------------//
        // ENTITY INFOS //
        //--------------//
        /// Return the entity speed
        virtual double getSpeed() const;

        virtual uint32 getGuildNameID () const { return _GuildNameId; }
        virtual uint64 getGuildSymbol () const { return _GuildSymbol; }

        virtual uint32 getEventFactionID() const { return _EventFactionId; }
        virtual uint16 getPvpMode() const { return _PvpMode; }
        void setPvpMode(uint16 mode) { _PvpMode=mode; }
        virtual uint32 getLeagueID() const { return _LeagueId; }
        void setLeagueID(uint32 league) { _LeagueId=league; }

        virtual uint16 getOutpostId() const { return _OutpostId; }
        virtual OUTPOSTENUMS::TPVPSide getOutpostSide() const { return _OutpostSide; }

        // get scale pos of character
        float getScalePos() const { return _CharacterScalePos; }

        // get scale from reference scale (male fyros). For creatures, returns the same than _CharacterScalePos
        virtual float getScaleRef() const { return _CharacterScalePos; }

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

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

        /// *** Ingame interface
        void setBubble (CGroupInSceneBubble *bubble);
        //  *** Ingame interface : get the current bubble assigned
        CGroupInSceneBubble *getBubble () { return _CurrentBubble; }

        // Attach a CAttachedFX  object to that character.
        void     attachFX(const CAttachedFX::TSmartPtr fx);

        /** Apply the behaviour.
         * \param behaviour : the behaviour to apply.
         */
        virtual void applyBehaviour(const CBehaviourContext &behaviour);

        // align an fx to be positionned and oriented like that entity, and put in the same cluster system than this entity
        void alignFX(NL3D::UParticleSystemInstance instance, float scale = 1.f, const NLMISC::CVector &localOffset = NLMISC::CVector::Null) const;

                // align a fx using the given matrix (also add scale & offset) , and put in the same cluster system than this entity
        void alignFX(NL3D::UParticleSystemInstance instance, const NLMISC::CMatrix &matrix, float scale = 1.f, const NLMISC::CVector &localOffset = NLMISC::CVector::Null) const;

        // build a matrix aligned on that entity (includes dir & pos)
        void buildAlignMatrix(NLMISC::CMatrix &dest) const;

        /** Set a new aura fx
          * If pointer is NULL, then previous aura is shutdown over several frames
          * If pointer isn't NULL then a new aura is created. Any previously present aura is immediatly deleted.
          */
        void setAuraFX(uint index, const CAnimationFX *fx);
        /** Set a new link fx.
          * If there's a previous link, the dispell fx is played to make it disappear
          * If fx ptr is NULL then no new link fx is created (but dispell is still played)
          */
        void setLinkFX(const CAnimationFX *fx, const CAnimationFX *dispell);

        // From CEntityCL
        const char *getBoneNameFromBodyPart(BODY::TBodyPart part, BODY::TSide side) const;
        // ...
        virtual bool getBoneHeight(BODY::TBodyPart localisation, BODY::TSide side, float &height) const;
        //
        /// Get the Animation 'State' for an animation channel.
        TAnimStateId                            animState (TAnimationType channel) const;

        // retrieve right hand item sheet
        virtual const CItemSheet *getRightHandItemSheet() const;
        virtual const CItemSheet *getLeftHandItemSheet() const;

        // get attack from an attack id (NULL if not found)
        virtual const CAttack *getAttack(const CAttackIDSheet &id) const;

        /// Return the Entity Current Speed.
        virtual double speed() const;

        /// Ask if the entity is sit
        bool isSit() const {return _Mode == MBEHAV::SIT;}

        /// Ask if the entity is afk (a character is never afk but players can be)
        virtual bool isAFK() const {return false;}

        // reset all sound anim id this entity may own
        virtual void resetAllSoundAnimId();

        // manually set/get the job animation state
        void    setAnimJobSpecialisation(uint32 state) {_AnimJobSpecialisation= state;}
        uint32  getAnimJobSpecialisation() const {return _AnimJobSpecialisation;}

        virtual void removeAllAttachedFX();


        void playCastFX(const CAnimationFXSet *afs, uint power);

        // Can the user select this entity by pressing space key ?
        bool    isSelectableBySpace() { return _SelectableBySpace; }

protected:
        /** A worn item and its attached fxs.
          * The item instance itself is managed by _Instances
          */
        class CWornItem
        {
        public:
                const CItemSheet                          *Sheet;        // sheet of item, or NULL if not used
                NL3D::UInstance                           Trail;        // trail linked to that fx
                NL3D::UParticleSystemInstance AdvantageFX;       // adantage fx linked to that item
        public:
                CWornItem()
                {
                        Sheet = NULL;
                }
                // release (but not remove the mesh, it is managed by _Instances)
                void release()
                {
                        Sheet = NULL;
                        releaseFXs();
                }
                // init item fxs
                void initFXs(SLOTTYPE::EVisualSlot visualSlot, NL3D::UInstance parent);
                // release item fxs
                void releaseFXs();
                /** trigger fxs associated with an attack
                  * \param intensity in [1, 5]
                  */
                void startAttackFX(NL3D::USkeleton skeleton, uint intensity, SLOTTYPE::EVisualSlot visualSlot, bool activateTrail);
                // stop attack fx
                void stopAttackFX();
                // start/stop the advantage fx (advantage fx appears on a weapon that is mastered by user)
                void enableAdvantageFX(NL3D::UInstance parent);
                /** set size of trail (value clamped to [0, 15]). This will map to the values given in the item sheet.
                  * 0 mean that there's no trail
                  */
                void setTrailSize(uint size);
        };

        // the various category of animated fx list
        enum TAttachedFXList
        {
                FXListToRemove,
                FXListCurrentAnim,
                FXListAuto   // the list is determined by the sheet of the fx
        };

        static const uint8                                                      _BadHairIndex;

        /// Stages to describ entity actions/motion.
//      CStageSet                                                                       _Stages;


        /// Sound ids of the current animations (-1 if none set)
        std::vector<NLSOUND::TSoundAnimId>                      _SoundId;
        /// The sound context for animation for this character
        NLSOUND::CSoundContext                                          _SoundContext;

        /// Subsidiary Key for the Animation State (emote).
        TAnimStateId                                                            _SubStateKey;
        /// Pointer on the current Anim Set.
        std::vector<const CAnimationSet *>                      _CurrentAnimSet;

        double                                                                          _LastFrameTime;

        /// Lod Animation ??. false by default
        bool                                                                            _LodCharacterAnimEnabled;
        /// Time for lod animation
        double                                                                          _LodCharacterAnimTimeOffset;
        /// Which playList AnimSlot drive the LodCharacterAnimation. MOVE, by default.
        uint                                                                            _LodCharacterMasterAnimSlot;

        // value to scale the "pos" channel of the animation of the character.
        float                                                                           _CharacterScalePos;

        // First Position.
        NLMISC::CVectorD                                                        _FirstPos;
        // Time of the first Position.
        double                                                                          _FirstTime;
        // Distance to the first stage.
        double                                                                          _DistToFirst;
        // Time at which the first run animation should start in order to avoid pop (computed in updateStages())
        // It is used to accelerate animations that are followed by positions
        double                                                                          _RunStartTimeNoPop;


        // Position of the destination.
        NLMISC::CVectorD                                                        _DestPos;
        // Time of the destiantion.
        double                                                                          _DestTime;
        // Distance to the destination or 0 if destination reached (in meter).
        double                                                                          _DistToDest;

        /// Position that was in the last stage with a position reached.
        NLMISC::CVectorD                                                        _OldPos;
        /// Time of the last stage pos reached.
        double                                                                          _OldPosTime;


        /// Is it a male ? female ? could be a beast :p
        GSGENDER::EGender                                                       _Gender;

        /// Id of the Bone used to display the name.
        sint                                                                            _NameBoneId;
        /// Used to force the bone to be computed (but in CLod form)
        NL3D::UTransform                                                        _NameTransform;
        /// If in Clod form, the name pos is computed with DeltaPos
        mutable float                                                           _NameCLodDeltaZ;
        enum {NameCLodDeltaZNotComputed= -1000000};

        /// Id of the Bone used for the Middle of torso.
        sint                                                                            _ChestBoneId;

        /// Pointers on items for visible slots.
        std::vector<CWornItem>                                          _Items;
        /// Instances Index for visible slots.
        uint32                                                                          _HeadIdx;
        uint32                                                                          _FaceIdx;
        /// Should objects in hands be displayed ?
        bool                                                                            _ObjectsVisible;

////// HEAD
        /// Id of the Bone for the Head. -1 if no bone.
        sint                                                                            _HeadBoneId;
        // Id of the Pelvis Bone. -1 if no bone
        //sint                                                                          _PelvisBoneId;
        /// Offset between the entity position and its head.
        NLMISC::CVector                                                         _HeadOffset;
        /// true if the head offset has been computed at least once
        bool                                                                            _HeadOffsetComputed;


////// ANIMATION
        /// Used to adjust the rotation of the animation to finish with the perfect orientation.
        double                                                                          _RotationFactor;
        /// This is the direction the entity will have at the end of the animation.
        NLMISC::CVector                                                         _DirEndAnim;
        /// ...
        double                                                                          _RotAngle;
        /// Automaton currently in use.
        std::string                                                                     _CurrentAutomaton;
        /// Pointer on the current state.
        const CAutomatonStateSheet                                      *_CurrentState;
        /// The mode the entity should already be but still not the current one.
        MBEHAV::EMode                                                           _ModeWanted;
        /// Number of frame remaining for the blend.
        sint                                                                            _BlendRemaining;
        /// Automaton currently in use.
        std::string                                                                     _OldAutomaton;
        /// Rotation at the end of the last animation for the blend.
        NLMISC::CQuat                                                           _OldRotQuat;
        /// Scale for the skeleton according to the gabarit.
        float                                                                           _CustomScalePos;
        /// Next blink time
        NLMISC::TTime                                                           _NextBlinkTime;
        /// Number of loop of the curren animation.
        uint32                                                                          _NbLoopAnim;
        bool                                                                            _MaxLoop;
        ///
        NL3D::CTargetAnimCtrl                                           _TargetAnimCtrl;
        /// The job specialisation of the character (0 by default). visual prop from server
        uint32                                                                          _AnimJobSpecialisation;

        /** List of animation FXs currently being played. Those FXs are shutdown as soon as an animation switch occurs.
          * When theyareshutdown,theit emitter are stopped, and they are put in _RemoveAnimFXList,waiting for deletion
      */
        std::list<CAttachedFX::TSmartPtr>                       _AttachedFXListForCurrentAnim;
        /// List of attached to remove as soon as possible (when there are no particles left)
        std::list<CAttachedFX::TSmartPtr>                       _AttachedFXListToRemove;

        std::list<CAttachedFX::CBuildInfo>                      _AttachedFXListToStart;

        CAttachedFX::TSmartPtr                                          _AuraFX[MaxNumAura]; // special case for aura
        CAttachedFX::TSmartPtr                                          _LinkFX;             // special case for link

        class CStaticFX : public NLMISC::CRefCount
        {
        public:
                CAnimationFX            AF; // ideally this field should be per sheet, not per instance, but simpler this way
                CAttachedFX::TSmartPtr  FX;
        };

        NLMISC::CSmartPtr<CStaticFX>                            _StaticFX;                        // special case for static fx


        /// FX from the right hand activated.
        bool                                                                            _RightFXActivated;
        /// FX from the left hand activated.
        bool                                                                            _LeftFXActivated;

        CLFECOMMON::TCLEntityId                                         _Mount;
        CLFECOMMON::TCLEntityId                                         _TheoreticalMount;
        CLFECOMMON::TCLEntityId                                         _Rider;
        CLFECOMMON::TCLEntityId                                         _TheoreticalRider;
        MOUNT_PEOPLE::TMountPeople                                      _OwnerPeople;

        bool                                                                            _IsThereAMode;

        // if 0(default), LCT is fully applied, else this is the ServerTick when the LCT impact decrease
        NLMISC::TGameCycle                                                      _StartDecreaseLCTImpact;

        // this time is the estimated time of the first important stage (excluding the first one)
        double                                                                          _ImportantStepTime;

        // The Colour of the entity hair.
        sint8                                                                           _HairColor;
        // The Colour of the entity Eyes.
        sint8                                                                           _EyesColor;
        //
        uint8                                                                           _HairIndex;
        //
        bool                                                                            _LookRdy;

        double                                                                          _Speed;
        double                                                                          _RunFactor;

        /// *** Ingame interface
        class CGroupInSceneUserInfo                                     *_InSceneUserInterface;
        class CGroupInSceneBubble                                       *_CurrentBubble;
        uint32                                                                          _GuildNameId;
        uint64                                                                          _GuildSymbol;
        uint32                                                                          _EventFactionId;
        uint16                                                                          _PvpMode;
        PVP_CLAN::TPVPClan                                                      _PvpClan;
        uint32                                                                          _LeagueId;
        uint16                                                                          _OutpostId;
        OUTPOSTENUMS::TPVPSide                                          _OutpostSide;

        // Can the user select this entity by pressing space key ?
        bool                                                                            _SelectableBySpace;

        // current attack (attacks include magic/melee/range/creature_attack)
        const   CAttack                                                         *_CurrentAttack;
        CAttackIDSheet                                                           _CurrentAttackID;
        CAttackInfo                                                                      _CurrentAttackInfo;

        bool                                                                            _HideSkin;

        // for selectBox() computing
        sint64                                                                          _LastSelectBoxComputeTime;

        bool                                                                            _ScaleDone;
        float                                                                           _CustomScale;
        float                                                                           _BaseCustomScale;
        float                                                                           _StepCustomScale;
        NLMISC::TTime                                                           _StartCustomScale;

        /// Pointer on the Sheet with basic parameters.
        const CCharacterSheet                                           *_Sheet;

protected:
        // Adjust the Predicted Interval to fix some errors according to the distance.
        NLMISC::TGameCycle adjustPI(float x, float y, float z, const NLMISC::TGameCycle &pI);

        // Look at items in hands to change the animation set.
        bool modeWithHiddenItems() const;

        /** Returns true if current behaviour triggers an attack end.
      * (when projectiles & impact fx are created)
          */
        bool isCurrentBehaviourAttackEnd() const;

        /** Build attack infos from current behaviour
          * This convert any attack encoded in current behaviour (magic/melee/range/creature_attack)
          * into a common representation (CAttackInfo)
          */
        void buildAttackInfo(CAttackInfo &dest);

        /** perform current attack
          * list of targets if given by the behaviour context
          * (where projectiles & impact fx are reated)
          */
        void performCurrentAttackEnd(const CBehaviourContext &bc, bool directOffensifSpell, std::vector<double> &targetHitDates, TAnimStateKey animForCombat);

        // update current attack from the current behaviour (this update the "_Attack" field)
        void updateCurrentAttack();


        /** Create part of current attack (a single projectile or/and impact, total attack may contain severals)
          * IMPORTANT: the instance on which this method is invoked is NOT always the caster (secondary missiles can be generated after main target has been reached)
          * NB : target stick mode isn't filled, for this, should use computeTargetStickMode instead
          * NB : once fully filled, the CProjectileBuild object should be inserted in the projectile manager
          */
        bool createCurrentAttackEndPart(CProjectileBuild &destPB,
                                            const CAttack *currentAttack,
                                            const CCharacterCL &target,
                                                                    const CFXStickMode *sm,
                                                                        double spawnDate,
                                                                        double hitDate,
                                                                        bool playImpactFX,
                                                                        bool playImpactAnim,
                                                                        bool magicResist,
                                                                        bool mainImpactIsLocalised,
                                                                        const CAttackInfo &attackInfo,
                                                                        const NLMISC::CVector &additionnalOffset = NLMISC::CVector::Null
                                                                   );


        // Return the automaton type of the entity (homin, creature, etc.)
        virtual std::string automatonType() const;
        // Compute the current automaton for the entity.
        void computeAutomaton();

        // Return the atk height.
        TAtkHeight getAttackHeight(CEntityCL *target, BODY::TBodyPart localisation, BODY::TSide side) const;

////// FX


        /** Stop all attached FXs linked to current anim (this wait until FX have no more particle, after what they are effectively deleted)
          * \param stopLoopingFX If set to true, looping fx are also stopped. A looping fx has RepeatMode == Loop in its sheet.
          */
        void stopAttachedFXForCurrrentAnim(bool stopLoopingFX);

        /** start items attack fxs
        * \param intensity tranges from 1 to 5
        */
        void startItemAttackFXs(bool activateTrails, uint intensity);

        // stop items attack fxs
        void stopItemAttackFXs();

        /** Compute some bone id (name, chest, head...)
         * \warning This method do not check the bone is valid, nor there is a Scene.
         */
        void computeSomeBoneId();


        /// Create the play list for this entity.
        void createPlayList();

        /** Compute each part of the visual equipement of the character
         * \param slot: structure of the equipement.
         * \param visualSlot: visual slot used by this item.
         * \param instIdx : if not CEntityCL::BadIndex, replace the equipement instance at this index.
         * \return uint32 : index of the instance or CEntityCL::BadIndex if there were a problem.
         * \todo GUIGUI : find a better choice to avoid all these slotType tests
         */
        uint32 buildEquipment(const CCharacterSheet::CEquipment &slot, SLOTTYPE::EVisualSlot visualSlot, sint color = -1, uint32 instIdx = CEntityCL::BadIndex);

        /// Compute the animation set to use according to weapons, mode and race.
        virtual void computeAnimSet(sint32 fakeLeftHand = -1, sint32 fakeRightHand = -1);

        /// 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 the NPC Alternative Look Property.
        virtual void updateVisualPropertyVpa           (const NLMISC::TGameCycle &gameCycle, const sint64 &prop);
        virtual void updateVisualPropertyVpb           (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 Status
        virtual void updateVisualPropertyStatus        (const NLMISC::TGameCycle &gameCycle, const sint64 &prop);
        // Update target list
        virtual void updateVisualPropertyTargetList        (const NLMISC::TGameCycle &gameCycle, const sint64 &prop, uint listIndex);
        // Update tvisual fw
        virtual void updateVisualPropertyVisualFX      (const NLMISC::TGameCycle &gameCycle, const sint64 &prop);
        /// Update vprop contextual attributes
        virtual void updateVisualPropertyContextual        (const NLMISC::TGameCycle &gameCycle, const sint64 &prop);
        // Get The Entity Skin
        virtual sint skin() const;

        /// Get the direction that should have the character at the end of the animation.
        const NL3D::CVector &dirEndAnim() {return _DirEndAnim;}
        /// Set the direction that should have the character at the end of the animation.
        void dirEndAnim(const NL3D::CVector &vect);

        /**
         * 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 addColoredInstance(const std::string &shapeName, const std::string &stickPoint = "", sint texture = -1, uint32 instIdx = BadIndex, sint color = -1);

        /// Initialize properties of the entity (according to the class).
        virtual void initProperties();

        /// Method to Flag the character as dead and do everything needed.
        virtual void setDead();
        /// Method to Flag the character as alive and do everything needed.
        virtual void setAlive();

        void scale();
        void applyScale(float oldCustomScale);

        ///
        double computeTimeStep(const double &currentTime);

        ///
        double computeSpeed();
        /**
         * Compute and return the speed factor to apply to the animation.
         * \param speedToDest : evaluted speed to destination.
         * \return double : the speed factor to use for the current animation.
         */
        double computeSpeedFactor(double speedToDest);

        ///
        void updateAnimationState();
        ///
        double computeMotion(const double &oldMovingTimeOffset, TAnimationType channel = MOVE) const;

        /// Apply stage modifications.
        bool applyStage(CStage &stage);
        /// Apply The Current Stage (first stage).
        bool applyCurrentStage();
        /// Apply all stages to the first stage with a position.
        void applyAllStagesToFirstPos();


        virtual void beginCast(const MBEHAV::CBehaviour &behaviour);
        void endCast(const MBEHAV::CBehaviour &behaviour, const MBEHAV::CBehaviour &lastBehaviour);


        /// Play the time step for the loop and truncate to End Anim if Time Step too big.
        void playToEndAnim(const double &startTimeOffset, double &length);

        /// Call this method to give a time for each stage, compute distance to destination and some more information.
        void updateStages();

        /**
         * Manage Events that could be created by the animation (like sound).
         * \param startTime : time to start processing events from the current animation.
         * \param stopTime : time to stop processing events from the current animation.
         */
        void animEventsProcessing(double startTime, double stopTime);

        void applyColorSlot(SInstanceCL &instance, sint skin, sint userColor, sint hair, sint eyes);

        /// Return the current max speed for the entity in meter per sec (!= swim, != mount, etc.)
        virtual double getMaxSpeed() const;
        // Draw the name.
        virtual void drawName(const NLMISC::CMatrix &mat);

        /// Set the Distance from the current entity position to the First Position.
        void   dist2FirstPos(double d2FP);
        /// Return the Distance from the current entity position to the First Position.
        double dist2FirstPos() const;
        /// Set the Distance from the current entity position to the Destination.
        void   dist2Dest(double d2D);
        /// Return the Distance from the current entity position to the Destination.
        double dist2Dest() const;
        /// Set the Entity Current Speed.
        void   speed(double s);
        /// Set the Factor between Walk & Run
        void   runFactor(double factor);
        /// Get the Factor between Walk & Run
        double runFactor() const;
        /// Set the Animation 'Offset' for an animation channel.
        void                                            animOffset(TAnimationType channel, double offset);
        /// Get the Animation 'Offset' for an animation channel.
        double                                          animOffset(TAnimationType channel) const;
        /// Set the Animation 'State' for an animation channel.
        void                                            animState (TAnimationType channel, TAnimStateId state);
        /// Set the Animation 'Index' in the 'State' for an animation channel.
        void                                            animIndex (TAnimationType channel, CAnimation::TAnimId index);
        /// Get the Animation 'Index' in the 'State' for an animation channel.
        CAnimation::TAnimId                     animIndex (TAnimationType channel) const;
        /// Set the Animation 'Id' among all the animations for an animation channel.
        void                                            animId    (TAnimationType channel, uint id);
        /// Get the Animation 'Id' among all the animations for an animation channel.
        uint                                            animId    (TAnimationType channel) const;


        // 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();

        void    showOrHideBodyParts( bool objectsVisible );
        bool    objectsVisible() const { return _ObjectsVisible; };

        /// Return name position on Z axis defined in sheet
        virtual float getNamePosZ() const;

private:
        static const std::string                                        _EmptyString;
        const CCharacterSheet                                           *_ClothesSheet;
        uint32                                                                          _RHandInstIdx;
        uint32                                                                          _LHandInstIdx;
        // Return 'true' if the animation should be played from the end to the start.
        std::vector<bool>                                                       _AnimReversed;
        // Animation 'Offset' for each channel.
        std::vector<double>                                                     _AnimOffset;
        // Animation 'State' for each channel.
        std::vector<TAnimStateId>                                       _AnimState;
        // Animation 'Index' in the 'State' for each channel (-1 if none set).
        std::vector<CAnimation::TAnimId>                        _AnimIndex;
        // Animation 'Id' among all the animations for each channel.
        std::vector<uint>                                                       _AnimId;

        struct CNamePosHistory
        {
                // ctor
                CNamePosHistory() : LastNamePosZ(0.f), LastBonePosZ(0.f) {}

                bool isInitialized() const { return LastNamePosZ != 0.f; }

                float LastNamePosZ;
                float LastBonePosZ;
        };

        CNamePosHistory                                                         _NamePosHistory;

private:
        /// Call it at the end of the current animation to choose the next one.
        void endAnimTransition();

        /** Return the shape pointer from tha item and according to the character gender.
         * \param itemSheet : reference on the item sheet.
         * \return string & : reference on the shape name.
         */
        std::string shapeFromItem(const CItemSheet &itemSheet) const;

        /// Create the instance from an item
        uint32 createItemInstance(const CItemSheet &itemSheet, uint32 instIdx, SLOTTYPE::EVisualSlot visualSlot, const std::string &bindBone, sint8 texture, sint color);

        /** Return if the impact must be played.
         * \param anim : pointer on the current animation (MUST NOT BE NULL).
         * \param currentTime : current time in the animation.
         * \param triggerName : name of the trigger to check.
         * \param isActive : read (and can change) the state.
         * \param timeFactor : when to activate the impact if there is no track (value has to be between 0 and 1 to be valid).
         * \return bool : true if the trigger is valid.
         * \warning This method does not check if the animation is Null.
         */
        bool beginImpact(NL3D::UAnimation *anim, NL3D::TAnimationTime currentTime, const std::string &triggerName, bool &isActive, float timeFactor);
        /** FX played on the weapon when there is an impact.
         * \param index : index of the fx.
         * \param attackPower : power of the current attack.
         */
        void weaponImpactFX(sint index, uint attackPower);

        // update attached fxs
        void updateAttachedFX();


        // Attach a CAttachedFX  object to that character.
        void     attachFXInternal(const CAttachedFX::TSmartPtr fx, TAttachedFXList wantedList);

        //  attach an externally created fx in the given list (alive fx or shutting down fxs)
        void attachFX(NL3D::UParticleSystemInstance instance,
                          const CAnimationFX *sheet,
                                  const CFXStickMode *stickMode,
                                  TAttachedFXList targetList,
                                  float timeOut = FX_MANAGER_DEFAULT_TIMEOUT,
                                  const NLMISC::CVector &stickOffset = NLMISC::CVector::Null,
                                  uint maxNumAnimCount = 0,
                                  uint8 targeterSlot = CLFECOMMON::INVALID_SLOT,
                                  const NLMISC::CMatrix *staticMatrix = NULL
                                 );


        // apply visual fx from packed property (include auras and links)
        virtual void applyVisualFX(sint64 prop);
        /// Helper fct : remove any obsolete reference in a CAnimFX list to an entity  slot that has just been removed.
        static void updateAnimFXListForSlotRemoved(std::list<CAttachedFX::TSmartPtr> &fxList, const CLFECOMMON::TCLEntityId &slotRemoved);

        // compute the best cast ray when creating a projectile (for guard towers)
        void computeBestCastRay(CEntityCL                  &targetEntity,
                                    const CFXStickMode &targetStickMode,
                                                        NLMISC::CVector    &castWorldOrigin,
                                                        NLMISC::CVector    &castWorldPos,
                                                        NLMISC::CVector    &worldOffsetToCasterPivot) const;

        // build cast fxs for static object (such as a guard tower ...)
        void buildStaticObjectCastFX(const NLMISC::CVector &castWorldOrigin,
                                         NLMISC::CVector &castWorldPos,
                                                                 const CAttackSheet &sheet,
                                                                 uint intensity
                                                                );

        // Compute the stick mode on the target for an attack
        void computeTargetStickMode(const CAttackSheet &sheet, const CAttackInfo &attackInfo, CFXStickMode &dest, CEntityCL &target);

        // remove attached fxs that depends on another slot when it has been removed
        void updateAttachedFXListForSlotRemoved(std::list<CAttachedFX::TSmartPtr> &fxList, const CLFECOMMON::TCLEntityId &slotRemoved);

        // apply the flying HP related to behaviour
        void applyBehaviourFlyingHPs(const CBehaviourContext &bc, const MBEHAV::CBehaviour &behaviour, const std::vector<double> &targetHitDates);

protected:
        // retrieve attack from an id and a list of attack lists filenames
        const CAttack *getAttack(const CAttackIDSheet &id, const std::vector<NLMISC::TSStringId> &attackList) const;
        void releaseStaticFX();
        void initStaticFX();
};


#endif // CL_CHARACTER_CL_H

/* End of character_cl.h */