aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-05 01:34:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/client/src/character_cl.h

1078 lines
41 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// 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;
float _CustomScale;
/// 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();
/// 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();
///
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(class NLMISC::IStream &f) throw(NLMISC::EStream);
// 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 */
Reference in a new issue View git blame Copy permalink