ryzom-core/code/ryzom/client/src/character_cl.cpp

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



/*
 *	Update character position notes
 *	-------------------------------
 *
 *	The update of the character position is done as followed :
 *
 *	For each character
 *		updatePreCollision
 *			updatePos
 *				PACS::move
 *
 *	The characters know where they want to be in 2d (pos().x and pos().y valid).
 *
 *	PACS::evalCollision
 *
 *	For each character
 *		updatePostCollision
 *			pacsFinalizepos
 *				PACS::getGlobalPosition
 *				If real position too far from PACS position
 *					PACS::setGlobalPosition
 *			-- Here pos().z is estimated
 *			snapToGround
 *				NL3D::visualCollisionEntities
 *				-- Here pos().z is good
 *			updateDisplay
 *			updateCluster
 *			updateHeadDirection
 *			-- Here the character is setuped in the engine
 *
 */

/////////////
// INCLUDE //
/////////////
#include "stdpch.h"
// Client.
#include "character_cl.h"
#include "pacs_client.h"
#include "net_manager.h"
#include "entity_animation_manager.h"
#include "time_client.h"
#include "ingame_database_manager.h"
#include "client_chat_manager.h"
#include "motion/user_controls.h"
#include "color_slot_manager.h"
#include "sheet_manager.h"
#include "debug_client.h"
#include "animation_misc.h"
#include "entities.h"						// \todo GUIGUI : try to remove this dependency.
#include "misc.h"
#include "string_manager_client.h"
#include "interface_v3/interface_manager.h"
#include "fx_manager.h"
#include "interface_v3/group_in_scene_user_info.h"
#include "interface_v3/group_in_scene_bubble.h"
#include "client_cfg.h"
#include "user_entity.h"
#include "projectile_manager.h"
#include "init_main_loop.h"
#include "cdb_branch.h"
#include "animation_fx_misc.h"
#include "attack_list.h"
#include "animation_fx_id_array.h"
#include "cursor_functions.h"
#include "interface_v3/bar_manager.h"
// sheets
#include "client_sheets/item_fx_sheet.h"
#include "client_sheets/attack_id_sheet.h"
// Misc
#include "nel/misc/geom_ext.h"
#include "nel/misc/random.h"
// 3D
#include "nel/3d/u_scene.h"
#include "nel/3d/u_camera.h"
#include "nel/3d/u_driver.h"
#include "nel/3d/u_play_list.h"
#include "nel/3d/u_particle_system_instance.h"
#include "nel/3d/u_bone.h"
#include "nel/3d/u_track.h"
#include "nel/3d/u_instance.h"
#include "nel/3d/u_instance_material.h"
// PACS
#include "nel/pacs/u_global_position.h"
// SOUND
#include "nel/sound/sound_anim_manager.h"
// Std.
#include <vector>
// Game share
#include "game_share/intensity_types.h"
#include "game_share/multi_target.h"
#include "game_share/visual_fx.h"
#include "game_share/range_weapon_type.h"
//


////////////
// DEFINE //
////////////
#define INVALID_POS		CVectorD(-1.0,-1.0,-1.0)
#define INVALID_DIST	-1.0
#define INVALID_TIME	-1.0
//#define MAX_HEAD_H_ROTATION		Pi/2.5
#define MAX_HEAD_H_ROTATION		Pi/3.0
#define MAX_HEAD_V_ROTATION		Pi/4.0
#define DEFAULT_BLEND_LENGTH	0


static const double AURA_SHUTDOWN_TIME = 1.f; // number of seconds for auras and links to shutdown

///////////
// USING //
///////////
using namespace NLMISC;
using namespace NL3D;
using namespace NLPACS;
using namespace NLSOUND;
using namespace std;
using namespace MBEHAV;
using namespace CLFECOMMON;


////////////
// EXTERN //
////////////
extern UScene					*Scene;
extern UDriver					*Driver;
extern CEntityAnimationManager	*EAM;
extern CClientChatManager		ChatMngr;
extern UTextContext				*TextContext;
extern UMaterial				GenericMat;
extern UCamera					MainCam;


///////////
// MACRO //
///////////
#if !FINAL_VERSION
	std::string LastMethod;

	#define ADD_METHOD(header) \
	header                     \
	{                          \
		LastMethod = #header;

	#define CHECK(param)                                                            \
	if((param)==false)                                                              \
	{                                                                               \
		nlwarning("entity:%d: Test '%s'", _Slot, #param);                           \
		nlwarning("entity:%d: Last Method called '%s'", _Slot, LastMethod.c_str()); \
		nlstop;                                                                     \
	}
	#define METHOD_NAME(param) LastMethod = (param);

#else
	#define ADD_METHOD(header) \
	header                     \
	{
	#define CHECK(param)
	#define METHOD_NAME(param)
#endif



////////////
// STATIC //
////////////
const std::string CCharacterCL::_EmptyString = "";
const uint8	 CCharacterCL::_BadHairIndex = 0xFF;

H_AUTO_DECL ( RZ_Client_Character_CL_Update_Pos_Combat_Float )
H_AUTO_DECL ( RZ_Client_Entity_CL_Update_Pos_Pacs )
H_AUTO_DECL ( RZ_Client_Entity_CL_Update_Pos_Combat_Float )
H_AUTO_DECL ( RZ_Client_Entity_CL_Update_Pos_Compute_Motion )

/////////////
// METHODS //
/////////////


//---------------------------------------------------
// dirEndAnim :
// Set the direction that should have the character at the end of the animation.
// \param vect : vector used to set the direction at the end of the animation.
//---------------------------------------------------
void CCharacterCL::dirEndAnim(const CVector &vect)
{
	setVect(_DirEndAnim, vect, true, true);
}// dirEndAnim //


//-----------------------------------------------
// CCharacterCL :
// Constructor.
//-----------------------------------------------
CCharacterCL::CCharacterCL()
: CEntityCL()
{
	Type				= NPC;

	_FirstPos			= INVALID_POS;	// Initialize the first with a bad position.
	_FirstTime			= INVALID_TIME;	// Initialize the time for the first position with a bad one.
	dist2FirstPos(INVALID_DIST);		// Initialize the distance to the first position with a bad value.
	_RunStartTimeNoPop	= INVALID_TIME;

	_DestPos			= INVALID_POS;
	_DestTime			= INVALID_TIME;
	dist2Dest(INVALID_DIST);

	_OldPos				= INVALID_POS;
	_OldPosTime			= INVALID_TIME;


	// Initialize the time for the last loop with the current time when entity created.
	_LastFrameTime = 0.0;
	// The animation should be played from the begin to the end.
	_AnimReversed.resize(animTypeCount, false);
	// Id among all the animations for each slot
	_AnimId.resize(animTypeCount, NL3D::UPlayList::empty);
	// Index in the state of the current animation for each slot.
	_AnimIndex.resize(animTypeCount, CAnimation::UnknownAnim);
	// ID of the current sound animation for each slot.
	_SoundId.resize(animTypeCount, -1);
	// ID of the current animation state for each slot.
	_AnimState.resize(animTypeCount, CAnimationStateSheet::Idle);
	// Time offest in the current animation for each slot.
	_AnimOffset.resize(animTypeCount, 0.0);
	// Subsidiary Key for the Animation State (emote).
	_SubStateKey = CAnimationStateSheet::UnknownState;
	// The character does not accept special "job animation" by default
	_AnimJobSpecialisation= 0;

	// Reset Lod.
	_LodCharacterAnimEnabled= false;
	_LodCharacterMasterAnimSlot= MOVE;

	// default POS scale to 1.
	_CharacterScalePos= 1.f;

	// No sheet pointed.
	_Sheet = 0;

	// Unknown gender at the entity creation.
	_Gender = GSGENDER::unknown;

	// The bone for the name is not known for the time
	_NameBoneId = -1;
	// No UTransform for the name needed if there is no name so not allocated for the time.
	_NameTransform = 0;
	// default Clod apparition => force compute the bone
	_NameCLodDeltaZ = NameCLodDeltaZNotComputed;

	// There is no anim set for the time.
	_CurrentAnimSet.resize(animTypeCount, 0);

	// Same as the animation at the beginning.
	_RotationFactor = 1.f;

	_CurrentState = 0;


	_RightFXActivated	= false;
	_LeftFXActivated	= false;


	dirEndAnim(CVector(0.f, 1.f, 0.f));

	// No item associated at the beginning but there is a room for them.
	_Items.resize(SLOTTYPE::NB_SLOT);
	_HeadIdx = CEntityCL::BadIndex;
	_FaceIdx = CEntityCL::BadIndex;

	// No frame remaining forthe blend at the beginning.
	_BlendRemaining = 0;

	// Scale for the skeleton according to the gabarit. Default : 1
	_CustomScalePos = 1.f;

	// Start with "unknown mode wanted by the server"
	_ModeWanted = MBEHAV::UNKNOWN_MODE; //MBEHAV::NORMAL;

	_Mount = CLFECOMMON::INVALID_SLOT;
	_Rider = CLFECOMMON::INVALID_SLOT;
	_TheoreticalMount = CLFECOMMON::INVALID_SLOT;
	_TheoreticalRider = CLFECOMMON::INVALID_SLOT;
	_OwnerPeople = MOUNT_PEOPLE::Unknown;

	// Default is : entity has no bone for the head and Neck.
	_HeadBoneId = -1;

	_IsThereAMode = false;
	_ImportantStepTime= 0.0;
	_StartDecreaseLCTImpact= 0;

	// Entity has no look and so is not displayable for the time.
	_LookRdy = false;

	// Index of the instance in the right hand (0xFFFFFFFF = no index).
	_RHandInstIdx = CEntityCL::BadIndex;
	// Index of the instance in the left hand (0xFFFFFFFF = no index).
	_LHandInstIdx = CEntityCL::BadIndex;

	_HairColor = 0;
	_EyesColor = 0;
	// No Hair Index at the beginning.
	_HairIndex = _BadHairIndex;
	_ClothesSheet = 0;

	_NbLoopAnim = 0;
	_MaxLoop = false;

	setAlive();

	_InSceneUserInterface = NULL;
	_CurrentBubble = NULL;

	// Initialize the head offset with a Null Vector.
	_HeadOffset = CVector::Null;
	_HeadOffsetComputed = false;
	// Initialize the Run Factor
	runFactor(0.0);
	// Initialize the Speed
	speed(0.0);



	_CurrentAttack = NULL;
	_CurrentAttackID.Type = CAttackIDSheet::Unknown;

	//_PelvisBoneId = -1;

	_ChestBoneId = -1;


	_HideSkin = false;


	_GuildNameId = 0;
	_GuildSymbol = 0;

	_EventFactionId = 0;
	_PvpMode = PVP_MODE::None;
	_PvpClan = PVP_CLAN::None;

	for (uint8 i = 0; i < PVP_CLAN::NbClans; i++)
	{
		_PvpAllies[i] = false;
		_PvpEnemies[i] = false;
	}

	_ClanCivMaxFame  = PVP_CLAN::None;
	_ClanCultMaxFame = PVP_CLAN::None;

	_OutpostId = 0;
	_OutpostSide = OUTPOSTENUMS::UnknownPVPSide;

	_SelectableBySpace = true;

	_LastSelectBoxComputeTime= 0;



	_CustomScale = 1.f;
}// CCharacterCL //

//-----------------------------------------------
// ~CCharacterCL:
// Default Destructor
// \warning : Do not remove sheets before the entity.
//-----------------------------------------------
CCharacterCL::~CCharacterCL()
{
	// Delete the UTransform used to compute the Bone for the Name.
	if(!_NameTransform.empty())
	{
		if(Scene)
		{
			if (!_Skeleton.empty())
				_Skeleton.detachSkeletonSon(_NameTransform);
			Scene->deleteTransform(_NameTransform);
		}
		_NameTransform = 0;
	}

	// No more sheet pointed.
	_Sheet = NULL;

	// Release items (but not their mesh, because they are managed by _Instances)
	for(uint k = 0; k < _Items.size(); ++k)
	{
		_Items[k].release();
	}

	// Delete previous interface
	releaseInSceneInterfaces();

	if (_CurrentBubble)
	{
		_CurrentBubble->unlink();
	}

}

//-----------------------------------------------
// computePrimitive :
// Create (or re-create) a primitive.
//-----------------------------------------------
void CCharacterCL::computePrimitive()
{
	// Initialize the primitive.
	if (_Sheet)
	{
		initPrimitive(_Sheet->ColRadius*getScale(), _Sheet->ColHeight*getScale(), _Sheet->ColLength, _Sheet->ColWidth, UMovePrimitive::DoNothing, UMovePrimitive::NotATrigger, MaskColNpc, MaskColNone, _Sheet->ClipRadius, _Sheet->ClipHeight);
	}
	else
	{
		initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::DoNothing, UMovePrimitive::NotATrigger, MaskColNpc, MaskColNone);
	}
	if(_Primitive)
		_Primitive->insertInWorldImage(dynamicWI);
	// Set the position.
	pacsPos(pos());
}// computePrimitive //


//-----------------------------------------------
void CCharacterCL::removeAllAttachedFX()
{
	_AttachedFXListForCurrentAnim.clear();
	_AttachedFXListToRemove.clear();
	_StaticFX = NULL;
	for(uint k = 0; k < MaxNumAura; ++k)
	{
		_AuraFX[k] = NULL;
	}
	_LinkFX = NULL;
}


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

void CCharacterCL::releaseInSceneInterfaces()
{
	if (_InSceneUserInterface)
	{
		CInterfaceManager::getInstance()->unMakeWindow(_InSceneUserInterface);
		if (_InSceneUserInterface->getParent())
		{
			_InSceneUserInterface->getParent()->delGroup(_InSceneUserInterface);
		}
		else
		{
			delete _InSceneUserInterface;
		}

		_InSceneUserInterface = NULL;
	}
}

//-----------------------------------------------
// stopAttachedFXForCurrrentAnim
// Stop all attached fxs linked  to current animation
//-----------------------------------------------
void CCharacterCL::stopAttachedFXForCurrrentAnim(bool stopLoopingFX)
{
	// shutdown fxs for current anim
	std::list<CAttachedFX::TSmartPtr>::iterator itAttachedFx = _AttachedFXListForCurrentAnim.begin();
	while(itAttachedFx != _AttachedFXListForCurrentAnim.end())
	{
		std::list<CAttachedFX::TSmartPtr>::iterator tmpItAttached = itAttachedFx;
		++itAttachedFx;
		if (!(!stopLoopingFX && (*tmpItAttached)->AniFX && (*tmpItAttached)->AniFX->Sheet->RepeatMode == CAnimationFXSheet::Loop)) // dont remove looping fx if it is requested
		{
			// test if emitters should be shutdown at the end of the anim
			if ((*tmpItAttached)->AniFX &&
				(*tmpItAttached)->AniFX->Sheet->RepeatMode != CAnimationFXSheet::Respawn &&
				(*tmpItAttached)->StickMode != CFXStickMode::SpawnPermanent
			   )
			{
				if(!(*tmpItAttached)->FX.empty())
				{
					if (!(*tmpItAttached)->FX.removeByID('STOP') && !(*tmpItAttached)->FX.removeByID('main'))
					{
						(*tmpItAttached)->FX.activateEmitters(false);
					}
				}
			}
			_AttachedFXListToRemove.splice(_AttachedFXListToRemove.begin(), _AttachedFXListForCurrentAnim, tmpItAttached);
			_AttachedFXListToRemove.front()->TimeOutDate += TimeInSec; // compute absolute timeout date
		}
	}
	/** Removes fx that lives on more that a given count of animation
	  * Useful if framerate is low to avoid that fx overlap
	  */
	itAttachedFx = _AttachedFXListToRemove.begin();
	while(itAttachedFx != _AttachedFXListToRemove.end())
	{
		std::list<CAttachedFX::TSmartPtr>::iterator tmpItAttachedFX = itAttachedFx;
		++itAttachedFx;
		if ((*tmpItAttachedFX)->AniFX)
		{
			if ((*tmpItAttachedFX)->MaxAnimCount != 0) // if there a limit to the number of animation during which the fx can live ?
			{
				(*tmpItAttachedFX)->MaxAnimCount -= 1;
				if ((*tmpItAttachedFX)->MaxAnimCount == 0)
				{
					// remove the fx
					_AttachedFXListToRemove.erase(tmpItAttachedFX);
				}
			}
		}
	}
}


//-----------------------------------------------
// applyColorSlot :
//-----------------------------------------------
void CCharacterCL::applyColorSlot(SInstanceCL &instance, sint skin, sint userColor, sint hair, sint eyes)
{
	CColorSlotManager::TIntCouple array[4];

	// Skin
	array[0].first = (uint)0; array[0].second = (uint)skin;

	// User Color
	array[1].first = (uint)1; array[1].second = (uint)userColor;

	// Hair Color
	array[2].first = (uint)2; array[2].second = (uint)hair;

	// Eyes Color
	array[3].first = (uint)3; array[3].second = (uint)eyes;

	// Set Values.
	UInstance inst = instance.createLoadingFromCurrent();
	if (!inst.empty())
	{
		instance.setColors(skin, userColor, hair, eyes);
		ColorSlotManager.setInstanceSlot(inst, array, 4);
	}
}// applyColorSlot //


//-----------------------------------------------
// changeColors :
//-----------------------------------------------
void CCharacterCL::changeColors(sint userColor, sint hair, sint eyes, sint part)	// virtual
{
	// Color Just a part of the entity.
	if(part >= 0)
	{
		if((uint)part < _Instances.size())
			applyColorSlot(_Instances[part], skin(), userColor, hair, eyes);
	}
	// Color the whole entity.
	else
	{
		for(uint i=0; i<_Instances.size(); i++)
			applyColorSlot(_Instances[i], skin(), userColor, hair, eyes);
	}
}// changeColors //

//-----------------------------------------------
// addColoredInstance :
//-----------------------------------------------
uint32 CCharacterCL::addColoredInstance(const std::string &shapeName, const std::string &stickPoint, sint texture, uint32 instIdx, sint color)
{
	// Get the instance
	uint32 idx = addInstance(shapeName, stickPoint, texture, instIdx);
	SInstanceCL *instance = idx2Inst(idx);
	if(instance)
		applyColorSlot(*instance, skin(), color, _HairColor, _EyesColor);
	else
		nlwarning("CH::addColoredInstance: cannot create the instance for the shape '%s'.", shapeName.c_str());

	return idx;
}// addColoredInstance //


//-----------------------------------------------
// buildEquipment :
// \param slot: structure of the equipement.
// \param visualSlot: visual slot used by this item.
// \return uint32 : index of the instance or 0xFFFFFFFF.
// \todo GUIGUI : find a better choice to avoid all visualSlot checks
//-----------------------------------------------
uint32 CCharacterCL::buildEquipment(const CCharacterSheet::CEquipment &slot, SLOTTYPE::EVisualSlot visualSlot, sint color, uint32 instIdx)
{
	uint32 idx = CEntityCL::BadIndex;

	// Do something only if the slot is not empty.
	if(slot.getItem().empty())
		return idx;

	sint slotColor = slot.Color;

	// This is a reference on an item (the file is store with an UPPER case so check in UPPER CASE).
	string ext = CFile::getExtension(slot.getItem());
	if((ext == "item") || (ext == "sitem"))
	{
		// IS the item a valid one ?
		CSheetId itemId;
		if(itemId.buildSheetId(NLMISC::strlwr(slot.getItem())))
		{
			// Is it stored in the database ?
			CEntitySheet *entitySheet = SheetMngr.get(itemId);
			if(entitySheet)
			{
				_Items[visualSlot].Sheet = dynamic_cast<CItemSheet *>(entitySheet);
				if(_Items[visualSlot].Sheet)
				{
					const CItemSheet &itemSheet = *(_Items[visualSlot].Sheet);

					// Compute the bind point
					string bindBone;
					switch(visualSlot)
					{
						// Right Hand
					case SLOTTYPE::RIGHT_HAND_SLOT:
						if( itemSheet.ItemType != ITEM_TYPE::MAGICIAN_STAFF )
							bindBone = "box_arme";
						break;
						// Left Hand
					case SLOTTYPE::LEFT_HAND_SLOT:
						// Shields are not stick to the same point.
						if(itemSheet.getAnimSet() == "s")
							bindBone = "Box_bouclier";
						else
							bindBone = "box_arme_gauche";
						break;
					default:
						bindBone = slot.getBindPoint();
						break;
					}

					// Choose the right colour.
					if(color==-1)
					{
						// Color in the item
						if(slotColor < 0)
						{
							// Get the item color
							slotColor = itemSheet.Color;
							// Bad item color -> set to 0
							if(slotColor < 0)
								slotColor = 0;
						}
					}
					else
						slotColor = color;

					idx = createItemInstance(itemSheet, instIdx, visualSlot, bindBone, slot.Texture, slotColor);
				}
				else
					nlwarning("CH::buildEquipment: the sheet '%s' is not an item one.", slot.getItem().c_str());
			}
			else
				nlwarning("CH::buildEquipment: the sheet '%s' is not stored in the database.", slot.getItem().c_str());
		}
		else
			nlwarning("CH::buildEquipment: item '%s' is not in the Sheet Id list.", slot.getItem().c_str());
	}
	// This is a shape.
	else
	{
		if(color==-1)
		{
			if(slotColor < 0)
				slotColor = 0;
		}
		else
			slotColor = color;

		// Get the instance
		idx = addColoredInstance(slot.getItem(), slot.getBindPoint(), slot.Texture, instIdx, slotColor);
	}

	// Return the index.
	return idx;
}// buildEquipment //

//-----------------------------------------------
// computeSomeBoneId :
// Compute the bone for the name, head...
// \warning This method do not check the bone is valid, nor there is a Scene.
//-----------------------------------------------
void CCharacterCL::computeSomeBoneId()
{
	// **** Get the Bone for the name.
	_NameBoneId = _Skeleton.getBoneIdByName("name");
	// Dummy found -> return the name position.
	if(_NameBoneId != -1)
	{
		// Just to force the bone to be compute (else not computed if not used).
		_NameTransform = Scene->createTransform();
		if(!_NameTransform.empty())
			_Skeleton.stickObject(_NameTransform, _NameBoneId);
	}
	// No Bone for the Name.
	else
	{
#if !FINAL_VERSION
		pushDebugStr("The Bone for the name is missing.");
#endif // FINAL_VERSION
	}

	// **** Get the head bone.
	_HeadBoneId = _Skeleton.getBoneIdByName("Bip01 Head");
	// Bone found
	if(_HeadBoneId == -1)
	{
#if !FINAL_VERSION
		pushDebugStr("The Bone for the Head is missing.");
#endif // FINAL_VERSION
	}
	else
	{
		_TargetAnimCtrl.EyePos = CVector::Null;
		_Skeleton.setBoneAnimCtrl(_HeadBoneId, &_TargetAnimCtrl);
	}

	// **** Get the "chest" bone. take spine1.
	_ChestBoneId = _Skeleton.getBoneIdByName("Bip01 Spine1");
	if(_ChestBoneId == -1)
	{
#if !FINAL_VERSION
		pushDebugStr("The Bone for the Chest 'Bip01 Spine1' is missing.");
#endif // FINAL_VERSION
	}
}// computeSomeBoneId //


//-----------------------------------------------
// createPlayList :
// Create the play list for this entity.
//-----------------------------------------------
void CCharacterCL::createPlayList()
{
	// Release the old animation playlist.
	if(_PlayList)
	{
		EAM->deletePlayList(_PlayList);
		_PlayList = 0;
	}

	// Create the new animation playlist.
	_PlayList = EAM->createPlayList();
	if(!_PlayList)
	{
		pushDebugStr("Cannot create a playlist for the entity.");
		return;
	}

	// Initialize the new playlist.
	// MOVE Channel
	_PlayList->setSpeedFactor	(MOVE, 1.f);
	_PlayList->setWrapMode		(MOVE, UPlayList::Clamp);
	// ACTION Channel
	_PlayList->setSpeedFactor	(ACTION, 1.f);
	_PlayList->setWrapMode		(ACTION, UPlayList::Clamp);
}// createPlayList //



//-----------------------------------------------
// getGroundFX :
// retrieve ground fxs for that entity
//-----------------------------------------------
const std::vector<CGroundFXSheet> *CCharacterCL::getGroundFX() const
{
	return &(_Sheet->GroundFX);
}

//-----------------------------------------------
// build :
// Build the entity from a sheet.
//-----------------------------------------------
bool CCharacterCL::build(const CEntitySheet *sheet)	// virtual
{
	// Cast the sheet in the right type.
	_Sheet = dynamic_cast<const CCharacterSheet *>(sheet);
	if(!_Sheet)
	{
		pushDebugStr("This is not a character sheet -> entity not initialized.");
		return false;
	}

	// Type
	Type = (_Sheet->Race >= EGSPD::CPeople::Creature) ? Fauna : NPC;

	// Names
	if (Type == Fauna)
	{
		// Get the fauna name in the sheet
		const ucstring creatureName(STRING_MANAGER::CStringManagerClient::getCreatureLocalizedName(_Sheet->Id));
		if (creatureName.find(ucstring("<NotExist:")) != 0)
			_EntityName = creatureName;
	}
	else
	{
		// Name and title will be send by the server
	}

	// Get the DB Entry
	if(IngameDbMngr.getNodePtr())
	{
		CCDBNodeBranch *nodeRoot = dynamic_cast<CCDBNodeBranch *>(IngameDbMngr.getNodePtr()->getNode(0));
		if(nodeRoot)
		{
			_DBEntry = dynamic_cast<CCDBNodeBranch *>(nodeRoot->getNode(_Slot));
			if(_DBEntry == 0)
				pushDebugStr("Cannot get a pointer on the DB entry.");
		}
	}

	if (!ClientCfg.Light && !_Sheet->getSkelFilename().empty())
	{
		// Create the Playlist for the entity.
		createPlayList();
	}
	// Compute the first automaton.
	_CurrentAutomaton = automatonType() + "_normal.automaton";

	// Get the Character gender.
	_Gender = (GSGENDER::EGender)_Sheet->Gender;

	// Initialize the internal time.
	_LastFrameTime = ((double)T1) * 0.001;

	// Set the skeleton.
	if(!ClientCfg.Light && !_Sheet->getSkelFilename().empty() && skeleton(_Sheet->getSkelFilename()))
	{
		// Set the skeleton scale.
		skeleton()->setScale(getScale(), getScale(), getScale());

		// Can create all characters except NPC.
		if(isNPC()== false)
		{
			// Eyes Color
			if(_Sheet->EyesColor >= SheetMngr.nbEyesColor())
			{
				if (SheetMngr.nbEyesColor() == 0)
					_EyesColor = 0;
				else
					_EyesColor = rand()%SheetMngr.nbEyesColor();
			}
			else
			{
				_EyesColor = _Sheet->EyesColor;
			}

			// Hair Color
			if(_Sheet->HairColor >= SheetMngr.nbHairColor())
			{
				if (SheetMngr.nbHairColor() == 0)
					_HairColor = 0;
				else
					_HairColor = rand()%SheetMngr.nbHairColor();
			}
			else
			{
				_HairColor = _Sheet->HairColor;
			}

			// -- Dress the character --


			// Top Items
			buildEquipment(_Sheet->Body,	SLOTTYPE::CHEST_SLOT);
			buildEquipment(_Sheet->Arms,	SLOTTYPE::ARMS_SLOT);
			buildEquipment(_Sheet->Hands,	SLOTTYPE::HANDS_SLOT);
			// Bottom Items
			buildEquipment(_Sheet->Legs,	SLOTTYPE::LEGS_SLOT);
			buildEquipment(_Sheet->Feet,	SLOTTYPE::FEET_SLOT);
			// Face
			_FaceIdx = buildEquipment(_Sheet->Face,	SLOTTYPE::FACE_SLOT);

			// -- Manage the Head --
			// Display the helm.
			if(!_Sheet->Head.getItem().empty())
			{
				// Create the Helm.
				_HeadIdx = buildEquipment(_Sheet->Head, SLOTTYPE::HEAD_SLOT, -1, _HeadIdx);
				// Hide the face
				SInstanceCL *pInstFace = getFace();
				if(pInstFace)
				{
					if(!pInstFace->Current.empty())
						pInstFace->Current.hide();
					else
						pInstFace->KeepHiddenWhenLoaded = true;
				}
			}
			// Display the Hair.
			else
			{
				// Create the Hair.
				if(_HairIndex != _BadHairIndex)
					_HeadIdx = buildEquipment(_Sheet->HairItemList[_HairIndex], SLOTTYPE::HEAD_SLOT, -1, _HeadIdx);
				// Display the face.
				SInstanceCL *pInstFace = getFace();
				if(pInstFace)
					if(!pInstFace->Current.empty())
						pInstFace->Current.show();
			}

			// Objects in Hands
			_RHandInstIdx = buildEquipment(_Sheet->ObjectInRightHand, SLOTTYPE::RIGHT_HAND_SLOT, -1, _RHandInstIdx);	// In The Right Hand
			_LHandInstIdx = buildEquipment(_Sheet->ObjectInLeftHand,  SLOTTYPE::LEFT_HAND_SLOT,  -1, _LHandInstIdx);	// In The Left Hand

			// Look is now ready.
			_LookRdy = true;
		}
		// Cannot build as long as the alternative look property not received, so hide the entity.
		else
			skeleton()->hide();

		// Compute the animation set (after weapons are set to choose the right animation set).
		computeAnimSet();
		// Check the animation set is correct.
		if(_CurrentAnimSet[MOVE] == 0)
			pushDebugStr("Bad animation set");

		// Set the animation to idle.
		setAnim(CAnimationStateSheet::Idle);

		// Compute the bone for the name.
		computeSomeBoneId();

		// Compute pelvis bone
		//_PelvisBoneId = _Skeleton.getBoneIdByName("Bip01 Pelvis");

		// Setup Lod Character skeleton and shapes colors, if skeleton exist
		// Get Lod Character Id from the sheet.
		sint clodId = getLodCharacterId(*Scene, _Sheet->getLodCharacterName());
		if(clodId >= 0)
		{
			// Setup Lod Character shapes, if enabled.
			skeleton()->setLodCharacterShape(clodId);
			skeleton()->setLodCharacterDistance(_Sheet->LodCharacterDistance);
		}
	}
	// Instances
	else
	{
		uint32	idx= buildEquipment(_Sheet->Body,	SLOTTYPE::CHEST_SLOT);
		// must set the scale for the BotObject too
		if(idx<_Instances.size())
		{
			float	s= getScale();
			_Instances[idx].setScale(CVector(s,s,s));
		}
	}

	// Setup _CharacterScalePos
	_CharacterScalePos = _Sheet->CharacterScalePos;

	// Adjust the custom scale position according to the entity scale.
	_CustomScalePos *= getScale();

	// Create PACS Primitive.
	initPrimitive(_Sheet->ColRadius*getScale(), _Sheet->ColHeight*getScale(), _Sheet->ColLength, _Sheet->ColWidth, UMovePrimitive::DoNothing, UMovePrimitive::NotATrigger, MaskColNpc, MaskColNone, _Sheet->ClipRadius, _Sheet->ClipHeight);

	// Compute the element to be able to snap the entity to the ground.
	computeCollisionEntity();

	// Initialize properties of the entity (selectable/attackable/etc.).
	initProperties();

	// copy some properties (special bot objects). before buildInSceneInterface
	_DisplayInRadar= _Sheet->DisplayInRadar;
	_DisplayOSDName= _Sheet->DisplayOSDName;
	_DisplayOSDBars= _Sheet->DisplayOSDBars;
	_DisplayOSDForceOver= _Sheet->DisplayOSDForceOver;
	_Traversable= _Sheet->Traversable;
	_CanTurn = _Sheet->Turn;

	_SelectableBySpace = _Sheet->SelectableBySpace;

	// Rebuild interface
	buildInSceneInterface ();


	initStaticFX();



	// Entity created.
	return true;
}// build //

//-----------------------------------------------
// isKami()
//-----------------------------------------------
bool CCharacterCL::isKami() const
{
	if (!_Sheet)
		return false;
	return (_Sheet->Race == EGSPD::CPeople::Kami);
}

//-----------------------------------------------
// isUnknownRace()
//-----------------------------------------------
bool CCharacterCL::isUnknownRace() const
{
	if (!_Sheet)
		return false;
	return (_Sheet->Race == EGSPD::CPeople::Unknown);
}

//-----------------------------------------------
// getAttackHeight :
// Return the atk height.
//-----------------------------------------------
CCharacterCL::TAtkHeight CCharacterCL::getAttackHeight(CEntityCL *target, BODY::TBodyPart localisation, BODY::TSide side) const
{
	// Check there is a target.
	if(target == 0)
		return CCharacterCL::AtkMiddle;
	// Get the position for a bone.
	float height;
	if(target->getBoneHeight(localisation, side, height))
	{
		// Low
		if(height < 1.0f)
			return CCharacterCL::AtkLow;
		// High
		else if(height > 2.0f)
			return CCharacterCL::AtkHigh;
	}
	// Default is Middle atk.
	return CCharacterCL::AtkMiddle;
}// getAttackHeight //

//-----------------------------------------------
// getBoneHeight :
//-----------------------------------------------
bool CCharacterCL::getBoneHeight(BODY::TBodyPart localisation, BODY::TSide side, float &height) const	// virtual
{
	// If there is no skeleton return false
	if(_Skeleton.empty())
		return false;
	// Get the Bone Name
	const char *boneName = getBoneNameFromBodyPart(localisation, side);
	if(boneName == 0)
		return false;
	// Get the Bone Id
	sint boneId = _Skeleton.getBoneIdByName(std::string(boneName));
	if (boneId == -1)
		return false;
	if(_Skeleton.isBoneComputed(boneId) == false)
		return false;
	NL3D::UBone bone = _Skeleton.getBone(boneId);
	CMatrix BoneMat = bone.getLastWorldMatrixComputed();
	height = (float)(BoneMat.getPos().z-pos().z);
	if(height < 0.0f)
		height = 0.0f;
	else if(height > 10.0f)
		height = 10.0f;
	return true;
}// getBoneHeight //


//-----------------------------------------------
// lookAtItemsInHands :
// Look at items in hands to change the animation set.
// \return true if the mode is a mode where items in hands should be hidden
//-----------------------------------------------
bool CCharacterCL::modeWithHiddenItems() const
{
	return ((ClientCfg.PutBackItems && !isFighting()) || isSit() || _Mode==MBEHAV::SWIM || isRiding() || _Mode==MBEHAV::SWIM_DEATH || _Mode==MBEHAV::REST);
}// lookAtItemsInHands //


//-----------------------------------------------
// automatonType :
//-----------------------------------------------
string CCharacterCL::automatonType() const	// virtual
{
	return _Sheet->getAutomaton();
}// automatonType //

//-----------------------------------------------
// computeAutomaton :
// Compute the current automaton for the entity.
//-----------------------------------------------
void CCharacterCL::computeAutomaton()
{
	_CurrentAutomaton = automatonType() + "_" + NLMISC::strlwr(MBEHAV::modeToString(_Mode)) + ".automaton";
}// computeAutomaton //


//-----------------------------------------------
// computeAnimSet :
// Compute the animation set to use according to weapons, mode and race.
//-----------------------------------------------
void CCharacterCL::computeAnimSet()
{
	if(ClientCfg.Light)
		return;
	// Use the generic method to compute the animation set.
	if(!::computeAnimSet(_CurrentAnimSet[MOVE], _Mode, _Sheet->getAnimSetBaseName(), _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet, _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet, !modeWithHiddenItems()))
	{
		//nlwarning("CH:computeAnimSet:%d: pb when trying to compute the animset. Sheet Id '%u(%s)'.", _Slot, _SheetId.asInt(), _SheetId.toString().c_str());
	}

}// computeAnimSet //

//-----------------------------------------------
// adjustPI :
// Adjust the Predicted Interval to fix some errors according to the distance.
//-----------------------------------------------
NLMISC::TGameCycle CCharacterCL::adjustPI(float x , float y, float /* z */, const NLMISC::TGameCycle &pI)
{
	NLMISC::TGameCycle adjustedPI = pI;
	if(ClientCfg.RestrainPI && adjustedPI > 0)
	{
		double dist = (x-UserEntity->pos().x)*(x-UserEntity->pos().x) + (y-UserEntity->pos().y)*(y-UserEntity->pos().y);
		// If under 50m check Predicted Interval
		if(dist < 50*50)
		{
			NLMISC::TGameCycle maxPi = (NLMISC::TGameCycle)(sqrt(dist)/5.0)+1;
			if(adjustedPI > maxPi)
			{
				adjustedPI = maxPi;
				if(VerboseAnimSelection && _Slot == UserEntity->selection())
					nlinfo("CH:updtVPPos:%d: dist'%f' PI'%d' newPI'%d'.", _Slot, sqrt(dist), pI, adjustedPI);
			}
		}
	}
	return adjustedPI;
}// adjustPI //

//-----------------------------------------------
// updateVisualPropertyPos :
// Received a new position for the entity.
// \warning Do not send position for the user
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyPos(const NLMISC::TGameCycle &gameCycle, const sint64 &prop, const NLMISC::TGameCycle &pI)
{
	// Check the DB entry (the warning is already done in the build method).
	if(_DBEntry == 0)
		return;
	// Get The property 'Y'.
	CCDBNodeLeaf *nodeY	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSY));
	if(nodeY == 0)
	{
		nlwarning("CH::updtVPPos:%d: Cannot find the property 'PROPERTY_POSY(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSY);
		return;
	}
	// Get The property 'Z'.
	CCDBNodeLeaf *nodeZ	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSZ));
	if(nodeZ == 0)
	{
		nlwarning("CH::updtVPPos:%d: Cannot find the property 'PROPERTY_POSZ(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSZ);
		return;
	}

	// Convert Database into a Position
	float x = (float)(prop)/1000.0f;
	float y = (float)(nodeY->getValue64())/1000.0f;
	float z = (float)(nodeZ->getValue64())/1000.0f;

#ifdef TMP_DEBUG_GUIGUI
	// Theoretical Position
	_TheoreticalPosition = CVectorD((double)x, (double)y, (double)z);
#endif // TMP_DEBUG_GUIGUI

	// First position Managed -> set the PACS Position
	if(_FirstPosManaged)
	{
		pacsPos(CVectorD(x, y, z));
		_FirstPosManaged = false;
		return;
	}

	// Wait for the entity to be spawned
	if(_First_Pos)
		return;

	// Stock the position (except if this is the user mount because it's the user that control him not the server)
	if( !isRiding() || _Rider != 0)
	{
		// Adjust the Predicted Interval to fix some "bug" into the Prediction Algo.
		NLMISC::TGameCycle adjustedPI = adjustPI(x, y, z, pI);
		// Add Stage.
		_Stages.addStage(gameCycle, PROPERTY_POSX, prop, adjustedPI);
		_Stages.addStage(gameCycle, PROPERTY_POSY, nodeY->getValue64());
		_Stages.addStage(gameCycle, PROPERTY_POSZ, nodeZ->getValue64());
	}
}// updateVisualPropertyPos //

//-----------------------------------------------
// updateVisualPropertyOrient :
// Received a new orientation.
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyOrient(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
#ifdef TMP_DEBUG_GUIGUI
	// Backup the last orientation received.
	_TheoreticalOrientation = *(float *)(&prop);
#endif	// TMP_DEBUG_GUIGUI

	// New Mode Received.
	if(verboseVP(this))
	{
		float ori = *(float *)(&prop);
		nlinfo("(%05d,%03d) CH::updateVPOri:%d: '%f' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, ori);
	}

	// if no skeleton we set the orientation
	if(_Skeleton.empty())
	{
		// server forces the entity orientation even if it cannot turn
		front(CVector((float)cos(_TheoreticalOrientation), (float)sin(_TheoreticalOrientation), 0.f), true, true, true);
		dir(front(), false, false);
		if(_Primitive)
			_Primitive->setOrientation(_TheoreticalOrientation, dynamicWI);
	}
	else
	{
		if( !isRiding() || _Rider != 0 )
		{
			// Add in right stage.
			_Stages.addStage(gameCycle, PROPERTY_ORIENTATION, prop);
		}
	}
}// updateVisualPropertyOrient //

//-----------------------------------------------
// updateVisualPropertyMode :
// New mode received.
// \warning For the first mode, we must have received the position and orientation (but this should be the case).
// \warning Read the position or orientation from the database when reading the mode (no more updated in updateVisualPropertyPos and updateVisualPropertyOrient).
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyMode(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	if(verboseVP(this))
		nlinfo("(%05d,%03d) CH:updtVPMode:%d: '%s(%d)' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, modeToString((MBEHAV::EMode)prop).c_str(), (MBEHAV::EMode)prop);
	// New Mode Received : Set the Theoretical Current Mode if different.
	if(_TheoreticalMode != (MBEHAV::EMode)(prop & 0xffff))
		_TheoreticalMode = (MBEHAV::EMode)(prop & 0xffff);
	else
	{
		nlwarning("CH:updtVPMode:%d: The mode '%s(%d)' sent is the same as the current one.", _Slot, modeToString(_TheoreticalMode).c_str(), _TheoreticalMode);
		return;
	}
	// If it is the first mode, set the mode.
	if(_Mode == MBEHAV::UNKNOWN_MODE)
	{
		// SET THE FIRST POSITION
		//-----------------------
		// Check the DB entry (the warning is already done in the build method).
		if(_DBEntry == 0)
			return;
		// Get The property 'PROPERTY_POSX'.
		CCDBNodeLeaf *nodeX	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSX));
		if(nodeX == 0)
		{
			nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSX(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSX);
			return;
		}
		// Get The property 'PROPERTY_POSY'.
		CCDBNodeLeaf *nodeY	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSY));
		if(nodeY == 0)
		{
			nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSY(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSY);
			return;
		}
		// Get The property 'PROPERTY_POSZ'.
		CCDBNodeLeaf *nodeZ	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSZ));
		if(nodeZ == 0)
		{
			nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSZ(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSZ);
			return;
		}
		// Next position will no longer be the first one.
		_First_Pos = false;
		// Insert the primitive into the world.
		if(_Primitive)
			_Primitive->insertInWorldImage(dynamicWI);
		// float makes a few cm error
		double x = (double)(nodeX->getValue64())/1000.0;
		double y = (double)(nodeY->getValue64())/1000.0;
		double z = (double)(nodeZ->getValue64())/1000.0;
		// Set the primitive position.
		pacsPos(CVectorD(x, y, z));
		// SET THE FIRST ORIENTATION
		//--------------------------
		// Get The property 'PROPERTY_ORIENTATION'.
		CCDBNodeLeaf *nodeOri = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_ORIENTATION));
		if(nodeOri == 0)
		{
			nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_ORIENTATION(%d)'.", _Slot, CLFECOMMON::PROPERTY_ORIENTATION);
			return;
		}
		const sint64 &ori = nodeOri->getValue64();
		float angleZ = *(float *)(&ori);
		// server forces the entity orientation even if it cannot turn
		front(CVector((float)cos(angleZ), (float)sin(angleZ), 0.f), true, true, true);
		dir(front(), false, false);
		_TargetAngle = angleZ;
		if(_Primitive)
			_Primitive->setOrientation(angleZ, dynamicWI);
		// SET THE FIRST MODE
		//-------------------
		// Set the mode Now
		_Mode       = _TheoreticalMode;
		_ModeWanted = _TheoreticalMode;
		if((_Mode == MBEHAV::MOUNT_NORMAL) && (_Rider == CLFECOMMON::INVALID_SLOT))
		{
			_Mode = MBEHAV::NORMAL;
			_ModeWanted = MBEHAV::MOUNT_NORMAL;
			// See also updateVisualPropertyRiderEntity() for the case when _Rider is received after the mode
			computeAutomaton();
			computeAnimSet();
			setAnim(CAnimationStateSheet::Idle);
			// Add the mode to the stage.
			_Stages.addStage(gameCycle, PROPERTY_MODE, prop);
		}
		computeAutomaton();
		computeAnimSet();
		setAnim(CAnimationStateSheet::Idle);
	}
	// Not the first mode -> Add to a stage.
	else
	{
		// Add the mode to the stage.
		_Stages.addStage(gameCycle, PROPERTY_MODE, prop);
		// Float mode push the orientation
		if(_TheoreticalMode == MBEHAV::COMBAT_FLOAT)
		{
			// Get The property 'PROPERTY_ORIENTATION'.
			CCDBNodeLeaf *nodeOri = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_ORIENTATION));
			if(nodeOri == 0)
			{
				nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_ORIENTATION(%d)'.", _Slot, CLFECOMMON::PROPERTY_ORIENTATION);
				return;
			}
			_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_ORIENTATION, nodeOri->getValue64());
		}
		// Any other mode push the position
		else
		{
			if(_TheoreticalMode != MBEHAV::MOUNT_NORMAL)
			{
				// Check the DB entry (the warning is already done in the build method).
				if(_DBEntry == 0)
					return;
				// Get The property 'PROPERTY_POSX'.
				CCDBNodeLeaf *nodeX	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSX));
				if(nodeX == 0)
				{
					nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSX(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSX);
					return;
				}
				// Get The property 'PROPERTY_POSY'.
				CCDBNodeLeaf *nodeY	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSY));
				if(nodeY == 0)
				{
					nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSY(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSY);
					return;
				}
				// Get The property 'PROPERTY_POSZ'.
				CCDBNodeLeaf *nodeZ	= dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSZ));
				if(nodeZ == 0)
				{
					nlwarning("CH::updtVPMode:%d: Cannot find the property 'PROPERTY_POSZ(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSZ);
					return;
				}
				// Add Stage.
				_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_POSX, nodeX->getValue64());
				_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_POSY, nodeY->getValue64());
				_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_POSZ, nodeZ->getValue64());
			}
		}
	}
}// updateVisualPropertyMode //

//-----------------------------------------------
// updateVisualPropertyBehaviour :
// New Behaviour received.
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyBehaviour(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	// New Behaviour Received.
	CBehaviour beh(prop);
	if(verboseVP(this))
		nlinfo("(%05d,%03d) CH::updateVPBeha:%d: '%s(%d)' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, behaviourToString((EBehaviour)beh.Behaviour).c_str(), beh.Behaviour);

	// Add in right stage.
	_Stages.addStage(gameCycle, PROPERTY_BEHAVIOUR, prop);
}// updateVisualPropertyBehaviour //

void CCharacterCL::updateVisualPropertyTargetList(const NLMISC::TGameCycle &gameCycle, const sint64 &prop, uint listIndex)
{
	// Add in right stage.
	_Stages.addStage(gameCycle, PROPERTY_TARGET_LIST_0 + listIndex, prop);
}

void CCharacterCL::updateVisualPropertyVisualFX(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	_Stages.addStage(gameCycle, PROPERTY_VISUAL_FX, prop);
}
//-----------------------------------------------
// updateVisualPropertyName :
// Received the name Id.
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyName(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	// Update the entity name (do not need to be managed with LCT).
	uint32 nameId = *(uint32 *)(&prop);

	// Store the name Id
	_NameId = nameId;

//	STRING_MANAGER::CStringManagerClient::instance()->waitString(nameId, this, &_Name);
	STRING_MANAGER::CStringManagerClient::instance()->waitString(nameId, this);

	//if(!getEntityName().empty())
	//	nlwarning("CH::updateVPName:%d: name Id '%d' received but no name allocated.", _Slot, nameId);
	//else if(verboseVP(this))
	//	nlinfo("(%05d,%03d) CH::updateVPName:%d: name '%s(%d)' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, getEntityName().toString().c_str(), nameId);

	updateMissionTarget();
}// updateVisualPropertyName //

//-----------------------------------------------
// updateVisualPropertyTarget :
// Received the new target for the entity
// \todo GUIGUI : should be added in a stage.
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyTarget(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	// New target Received.
	sint targ = (sint)prop;

	if(verboseVP(this))
		nlinfo("(%05d,%03d) CH::updateVPTarget:%d: '%d' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, targ);

	// New entity target
	_TargetSlotNoLag = (CLFECOMMON::TCLEntityId)targ;

	// Add in right stage.
	_Stages.addStage(gameCycle, PROPERTY_TARGET_ID, prop);
}// updateVisualPropertyTarget //

//-----------------------------------------------
// updateVisualPropertyVpa :
// Received the new target for the entity
// \todo GUIGUI : should be added in a stage.
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyVpa(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	// VPA only useful for NPC
	if(isNPC()==false)
	{
		//nlwarning("CH:updtVPVpa:%d: VPA received but NOT an NPC. Sheet Id '%u(%s)'.", _Slot, _SheetId.asInt(), _SheetId.toString().c_str());
		return;
	}

	// NO SKELETON -> NO VPA
	if(_Skeleton.empty())
		return;

	// Get the alternative look property.
	SAltLookProp altLookProp = *(SAltLookProp *)(&prop);
	// Display debug infos
	if(verboseVP(this))
	{
		nlinfo("(%05d,%03d) CH:updtVPVpa:%d: TopColor(%d) BotColor(%d) RH(%d) LH(%d) Hat(%d) Seed(%d) HairColor(%d)",
			sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot,
			(uint)altLookProp.Element.ColorTop,        (uint)altLookProp.Element.ColorBot,
			(uint)altLookProp.Element.WeaponRightHand, (uint)altLookProp.Element.WeaponLeftHand,
			(uint)altLookProp.Element.Hat,             (uint)altLookProp.Element.Seed,
			(uint)altLookProp.Element.ColorHair);
	}

	// Dress the character.
	if(!_LookRdy)
	{
		// The entity is now visually ready.
		_LookRdy = true;

		// Generate a new random.
		NLMISC::CRandom rnd;
		rnd.srand((sint)altLookProp.Element.Seed);

		// Retrieve the right sheet for clothes.
		_ClothesSheet = _Sheet;
		if(_Sheet->IdAlternativeClothes.size() > 0)
		{
			sint32 num = rnd.rand()%(_Sheet->IdAlternativeClothes.size()+1);
			if(num > 0)
			{
				CSheetId altClothesId(_Sheet->getAlternativeClothes(num-1));
				const CEntitySheet *sheetAlt = SheetMngr.get(altClothesId);
				if(dynamic_cast<const CCharacterSheet *>(sheetAlt))
					_ClothesSheet = dynamic_cast<const CCharacterSheet *>(sheetAlt);
			}
		}

		// Eyes Color
		if(_Sheet->EyesColor >= SheetMngr.nbEyesColor())
		{
			if (SheetMngr.nbEyesColor() == 0)
				_EyesColor = 0;
			else
				_EyesColor = (sint8)(rnd.rand()%SheetMngr.nbEyesColor());
		}
		else
			_EyesColor = _Sheet->EyesColor;
		// Hair Color
		if (SheetMngr.nbHairColor() == 0)
			_HairColor = 0;
		else
			_HairColor = (sint8)altLookProp.Element.ColorHair%SheetMngr.nbHairColor();
		// Hair Index
		if(_Sheet->HairItemList.size() > 0)
		{
			sint32 num = rnd.rand()%_Sheet->HairItemList.size();
			if(num>=0 && num <_BadHairIndex)
				_HairIndex = (uint8)num;
			else
				nlwarning("CH:updtVPVpa:%d: Bad Hair Index '%d'", _Slot, num);
		}

		// -- Dress the character -- (all parts that should not change)
		/** tmp : remove all fx item
		  * \TODO delete an item only if changed
		  */
		buildEquipment(_ClothesSheet->Body,		SLOTTYPE::CHEST_SLOT,	altLookProp.Element.ColorTop);		// Chest
		buildEquipment(_ClothesSheet->Arms,		SLOTTYPE::ARMS_SLOT,	altLookProp.Element.ColorArm);		// Arms
		buildEquipment(_ClothesSheet->Hands,	SLOTTYPE::HANDS_SLOT,	altLookProp.Element.ColorGlove);	// Gloves
		buildEquipment(_ClothesSheet->Legs,		SLOTTYPE::LEGS_SLOT,	altLookProp.Element.ColorBot);		// Legs
		buildEquipment(_ClothesSheet->Feet,		SLOTTYPE::FEET_SLOT,	altLookProp.Element.ColorBoot);		// Boots
		// Face
		_FaceIdx = buildEquipment(_Sheet->Face,			SLOTTYPE::FACE_SLOT);

		// Entity is now dressed
		skeleton()->show();
	}

	// -- Manage the Head --
	// Display the helm.
	if(altLookProp.Element.Hat!=0 && !_ClothesSheet->Head.getItem().empty())
	{
		// Create the Helm.
		_HeadIdx = buildEquipment(_ClothesSheet->Head, SLOTTYPE::HEAD_SLOT, altLookProp.Element.ColorHair, _HeadIdx);
		// Hide the face.
		SInstanceCL *pInstFace = getFace();
		if(pInstFace)
		{
			if(pInstFace->Current.empty() == false)
				pInstFace->Current.hide();
			else
				pInstFace->KeepHiddenWhenLoaded = true;
		}
	}
	// Display the Hair.
	else
	{
		// Create the Hair.
		if(_HairIndex != _BadHairIndex)
			_HeadIdx = buildEquipment(_Sheet->HairItemList[_HairIndex], SLOTTYPE::HEAD_SLOT, altLookProp.Element.ColorHair, _HeadIdx);
		// Display the face.
		SInstanceCL *pInstFace = getFace();
		if(pInstFace)
			if(!pInstFace->Current.empty())
				pInstFace->Current.show();
	}

	// -- Manage weapons -- (weapons can change)

	// Right Hand
	const CItemSheet *newRightHand = SheetMngr.getItem(SLOTTYPE::RIGHT_HAND_SLOT, (uint)altLookProp.Element.WeaponRightHand);
	if (newRightHand != _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet) // item changed ?
	{
		// Remove the old Item in the right hand
		if(_RHandInstIdx != CEntityCL::BadIndex)
		{
			// remove shape
			_RHandInstIdx = addInstance("", "", -1, _RHandInstIdx);
			// remove fxs
			_Items[SLOTTYPE::RIGHT_HAND_SLOT].release();
		}
		// set new one
		_Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet = newRightHand;
		if (newRightHand)
		{
			if( newRightHand->ItemType != ITEM_TYPE::MAGICIAN_STAFF )
				_RHandInstIdx = createItemInstance(*newRightHand, _RHandInstIdx, SLOTTYPE::RIGHT_HAND_SLOT, "box_arme", -1, -1);
			else
				_RHandInstIdx = createItemInstance(*newRightHand, _RHandInstIdx, SLOTTYPE::RIGHT_HAND_SLOT, "", -1, -1);
		}
	}
	// update fx for right hand (trail may have been activated, or advantage fx)
	if (newRightHand)
	{
		SInstanceCL *instCLRH = idx2Inst(_RHandInstIdx);
		if(instCLRH)
		{
			NL3D::UInstance itemInstance = (!instCLRH->Loading.empty()) ? instCLRH->Loading : instCLRH->Current;
			if (!itemInstance.empty())
			{
				// update fxs
				_Items[SLOTTYPE::RIGHT_HAND_SLOT].enableAdvantageFX(itemInstance);
				if ( _CurrentBehaviour.Behaviour != MBEHAV::EXTRACTING )
					_Items[SLOTTYPE::RIGHT_HAND_SLOT].setTrailSize(altLookProp.Element.RTrail);
			}
		}
	}

	// Left Hand
	const CItemSheet *newLeftHand = SheetMngr.getItem(SLOTTYPE::LEFT_HAND_SLOT, (uint)altLookProp.Element.WeaponLeftHand);
	if (newLeftHand != _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet) // item changed ?
	{
		// Remove the old Item in the left hand
		if(_LHandInstIdx != CEntityCL::BadIndex)
		{
			// remove shape
			_LHandInstIdx = addInstance("", "", -1, _LHandInstIdx);
			// remove fxs
			_Items[SLOTTYPE::LEFT_HAND_SLOT].release();
		}
		// set new one
		_Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet = newLeftHand;
		if (newLeftHand)
		{
			string bindBone;
			if(newLeftHand->getAnimSet() == "s")
				bindBone = "Box_bouclier";
			else
				bindBone = "box_arme_gauche";
			_LHandInstIdx = createItemInstance(*newLeftHand, _LHandInstIdx, SLOTTYPE::LEFT_HAND_SLOT, bindBone, -1, -1);
		}
	}
	// update fx for left hand (trail may have been activated, or advantage fx)
	if (newLeftHand)
	{
		SInstanceCL *instCLLH = idx2Inst(_LHandInstIdx);
		if(instCLLH)
		{
			NL3D::UInstance itemInstance = (!instCLLH->Loading.empty()) ? instCLLH->Loading : instCLLH->Current;
			if (!itemInstance.empty())
			{
				// update fxs
				_Items[SLOTTYPE::LEFT_HAND_SLOT].enableAdvantageFX(itemInstance);
				_Items[SLOTTYPE::LEFT_HAND_SLOT].setTrailSize((uint) (2 * altLookProp.Element.LTrail));
			}
		}
	}


	// -- Update Animation --  (after all those changes animation could change).
	computeAnimSet();
	setAnim(animState(MOVE));
}// updateVisualPropertyVpb //

//-----------------------------------------------
// updateVisualPropertyVpb :
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyVpb(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	// Get the alternative look property.
	SAltLookProp2 altLookProp = *(SAltLookProp2 *)(&prop);
	// Display debug infos
	if(verboseVP(this))
	{
		nlinfo("(%05d,%03d) CH:updtVPVpb:%d: Scale(%d)", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot,
			(uint)altLookProp.PropertySubData.Scale);
	}
	// Save old scale
	float oldCustomScale = _CustomScale;
	// Set new scale
	if (altLookProp.PropertySubData.Scale==0)
		_CustomScale = 1.f;
	else
		_CustomScale = (float)altLookProp.PropertySubData.Scale/100.f;
	// Apply modification
	_CustomScalePos /= oldCustomScale;
	_CustomScalePos *= _CustomScale;
	// change the scale of the skeleton according to the new people
	USkeleton * skel = skeleton();
	if( skel )
	{
		skel->setScale(getScale(), getScale(), getScale());

		// modify the stick bone scale to not propagate scale to child
		sint boneID = skel->getBoneIdByName("stick_1");
		if( boneID != -1 )
		{
			UBone bone = skel->getBone(boneID);
			CVector newBoneScale = bone.getScale() * oldCustomScale/_CustomScale;
			bone.setScale( newBoneScale );
		}
	}
	// must set the new scale for the BotObject too
	else if(!_Instances.empty())
	{
		float	s= getScale();
		_Instances[0].setScale(CVector(s,s,s));
	}

}// updateVisualPropertyVpb //

//-----------------------------------------------
// updateVisualPropertyEntityMounted :
// Update Entity Mount
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyEntityMounted(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	// New target Received.
	sint mountSlot = (sint)prop;
	_TheoreticalMount = (CLFECOMMON::TCLEntityId)mountSlot;
	if(verboseVP(this))
		nlinfo("(%05d,%03d) CH::updateVPMount:%d: '%d' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, mountSlot);

	// Add in right stage.
	_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_ENTITY_MOUNTED_ID, prop);
}// updateVisualPropertyEntityMounted //

//-----------------------------------------------
// updateVisualPropertyRiderEntity :
// Update Entity Rider
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyRiderEntity(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	// New target Received.
	sint riderSlot = (sint)prop;
	_TheoreticalRider = (CLFECOMMON::TCLEntityId)riderSlot;
	if(verboseVP(this))
		nlinfo("(%05d,%03d) CH::updateVPRider:%d: '%d' received.", sint32(T1%100000), NetMngr.getCurrentServerTick(), _Slot, riderSlot);

	// Add in right stage.
	_Stages.addStage(gameCycle, CLFECOMMON::PROPERTY_RIDER_ENTITY_ID, prop);
}// updateVisualPropertyRiderEntity //

//-----------------------------------------------
// updateVisualPropertyBars :
// Update Entity Bars
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyBars(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)	// virtual
{
	CBarManager::CBarInfo	barInfo;

	// Encode HP to 7 bits
	barInfo.Score[SCORES::hit_points]	= (sint8)((prop&0x7ff) * 127 / 1023);
	// NB: barInfo are sint8, but no problem, since anything following is 7 bits.
    barInfo.Score[SCORES::stamina]		= (uint8)((prop>>11)&0x7f);
    barInfo.Score[SCORES::sap]			= (uint8)((prop>>18)&0x7f);
    barInfo.Score[SCORES::focus]		= (uint8)((prop>>25)&0x7f);

	// update The Bar manager
	CBarManager	*pBM= CBarManager::getInstance();
	/* ***********
	  WHY gameCycle+1 ?????  (yoyo)
		It's because sometimes I have a bug With target DB update and VP update. This is the scenario
		where I suppose the problem rises:
		tick=320:	EGS::tickUpdate(): player.DBTargetHP.setProp(49)
		tick=321:	EGS::combat update, target ennemy receives a Hit, VPHp=10 => transmitted to client with timestamp=321
					EGS::databaseUpdate(), DB updated, with timestamp=321!!!

		Thus I receives on client:
			first the VP with Hp=10, timestamp=321
			second the DB with Hp=49, timestamp=321 too => replaced => BUG
		NB: DB is typically sent at low frequency by FrontEnd, thus received later on client.

		Since databaseUpdate() is called every 2 ticks, adding +1 to VP timestamps solve easily the problem.

		NB: the problem occurs because tickUpdate() and databaseUpdate() are called typically with 1 tick shift (tickUpdate()
			on even ticks, and databaseUpdate() on odd ticks for instance).

		NB: moreover, tickupdate() is called every 8 (or 16) ticks, and databaseUpdate() every 2 ticks. So there is one more
			possible bug:
			318:	EGS::tickUpdate(): player.DBTargetHP.setProp(49)
			319:	EGS::combat update, target ennemy receives a Hit, VPHp=10 => transmitted to client with timestamp=319
					EGS::databaseUpdate(), BUT decide to send only a small subset of DB (because lot of things to send)
						=> our TargetHP is not updated
			320:	nothing. tickupdate() is not called, since every 8 ticks
			321:	EGS::databaseUpdate(), update TargetHP, with timestamp=321 !!!!! => Bug

		(remind that we cannot store a timestamp for each DB property, else would be too big to store and to send...)

		BTW, this last bug should be very rare, so don't care.
	*********** */
	pBM->updateBars(dataSetId(), barInfo, gameCycle+1,
		CBarManager::HpFlag | CBarManager::StaFlag | CBarManager::SapFlag | CBarManager::FocusFlag);

}// updateVisualPropertyBars //

//-----------------------------------------------
// updateVisualPropertyGuildSymbol :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyGuildSymbol(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	_GuildSymbol = prop;

	// maybe need to rebuild the in scene interface
	if(_InSceneUserInterface && _InSceneUserInterface->needGuildSymbolId())
		buildInSceneInterface();
} // updateVisualPropertyGuildSymbol //

//-----------------------------------------------
// updateVisualPropertyGuildNameID :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyGuildNameID(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	_GuildNameId = uint32(prop);

	// maybe need to rebuild the in scene interface
	if(_InSceneUserInterface && _InSceneUserInterface->needGuildNameId())
		buildInSceneInterface();
} // updateVisualPropertyGuildNameID //

//-----------------------------------------------
// updateVisualPropertyEventFactionID :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyEventFactionID(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	_EventFactionId = uint32(prop);
	buildInSceneInterface();

} // updateVisualPropertyEventFactionID //

//-----------------------------------------------
// updateVisualPropertyPvpMode :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyPvpMode(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	_PvpMode = (uint8)prop;
	buildInSceneInterface();

} // updateVisualPropertyPvpMode //

//-----------------------------------------------
// updateVisualPropertyPvpClan :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyPvpClan(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	// get fames signs from prop
	for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
	{
		_PvpAllies[fameIdx] = (prop & (SINT64_CONSTANT(1) << (2*fameIdx))) != 0;
		_PvpEnemies[fameIdx] = (prop & (SINT64_CONSTANT(1) << (2*fameIdx+1))) != 0;
	}

	_ClanCivMaxFame = PVP_CLAN::TPVPClan((prop & (0x03 << 2*7)) >> 2*7);
	_ClanCultMaxFame = PVP_CLAN::TPVPClan(4 + ((prop & (0x03 << 2*8)) >> 2*8));

	buildInSceneInterface();

} // updateVisualPropertyPvpClan //

//-----------------------------------------------
// updateVisualPropertyStatus :
// Update Entity Status
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyStatus(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */)	// virtual
{
	nlinfo("CH:updtVPStatus:%d: received.", _Slot);
}// updateVisualPropertyStatus //

//-----------------------------------------------
// updateVisualPropertyContextual :
// Update Entity Status
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyContextual(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	bool	precAttackable= _Properties.attackable();

	// call parent
	CEntityCL::updateVisualPropertyContextual(gameCycle, prop);

	// if attack modified, and npc/fauna, must rebuild the in scene interface,
	// cause sheets 'Attackable' property not always correclty filled
	if( (isNPC()||isFauna()) && precAttackable!=_Properties.attackable())
		buildInSceneInterface();
}


//-----------------------------------------------
// updateVisualPropertyOwnerPeople :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyOwnerPeople(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	if( _OwnerPeople != MOUNT_PEOPLE::TMountPeople(prop) )
	{
		// reset scale pos
		float oldPeopleScaleFactor;
		switch( _OwnerPeople )
		{
			case MOUNT_PEOPLE::Fyros : oldPeopleScaleFactor = ClientCfg.FyrosScale; break;
			case MOUNT_PEOPLE::Matis : oldPeopleScaleFactor = ClientCfg.MatisScale; break;
			case MOUNT_PEOPLE::Tryker : oldPeopleScaleFactor = ClientCfg.TrykerScale; break;
			case MOUNT_PEOPLE::Zorai : oldPeopleScaleFactor = ClientCfg.ZoraiScale; break;
			default:
				oldPeopleScaleFactor = 1.f;
		}
		_CustomScalePos /= oldPeopleScaleFactor;

		// set the new scale pos
		float newPeopleScaleFactor;
		_OwnerPeople = MOUNT_PEOPLE::TMountPeople(prop);
		switch( _OwnerPeople )
		{
			case MOUNT_PEOPLE::Fyros : newPeopleScaleFactor = ClientCfg.FyrosScale; break;
			case MOUNT_PEOPLE::Matis : newPeopleScaleFactor = ClientCfg.MatisScale; break;
			case MOUNT_PEOPLE::Tryker : newPeopleScaleFactor = ClientCfg.TrykerScale; break;
			case MOUNT_PEOPLE::Zorai : newPeopleScaleFactor = ClientCfg.ZoraiScale; break;
			default:
				newPeopleScaleFactor = 1.f;
		}
		_CustomScalePos *= newPeopleScaleFactor;

		// change the scale of the skeleton according to the new people
		USkeleton * skel = skeleton();
		if( skel )
		{
			skel->setScale(getScale(), getScale(), getScale());

			// modify the stick bone scale to not propagate scale to child
			sint boneID = skel->getBoneIdByName("stick_1");
			if( boneID != -1 )
			{
				UBone bone = skel->getBone(boneID);
				CVector newBoneScale = bone.getScale() * oldPeopleScaleFactor/newPeopleScaleFactor;
				bone.setScale( newBoneScale );
			}
		}
	}

} // updateVisualPropertyOwnerPeople //



//-----------------------------------------------
// updateVisualPropertyOutpostInfos :
//
//-----------------------------------------------
void CCharacterCL::updateVisualPropertyOutpostInfos(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	_OutpostId = ((uint16)prop)&0x7FFF;
	uint16 side = (((uint16)prop)&0x8000)>>15;
	_OutpostSide = (OUTPOSTENUMS::TPVPSide)side;

	nldebug("<CCharacterCL::updateVisualPropertyOutpostInfos> prop = %d, id=%d side=%d",(uint16)prop,_OutpostId,_OutpostSide);

	buildInSceneInterface();

} // updateVisualPropertyOutpostInfos //


//-----------------------------------------------
// skin :
// Get The Entity Skin
//-----------------------------------------------
sint CCharacterCL::skin() const	// virtual
{
	return _Sheet->Skin;
}// skin //


//-----------------------------------------------
// initProperties :
// Initialize properties of the entity (according to the class).
//-----------------------------------------------
void CCharacterCL::initProperties()
{
	properties().selectable(_Sheet->Selectable);
	properties().talkableTo(_Sheet->Talkable);
	properties().attackable(_Sheet->Attackable);
	properties().givable(_Sheet->Givable);
	properties().mountable(_Sheet->Mountable);
	properties().invitable(false);										// You cannot group with a bot.
	properties().afk(false);

	switch(_Sheet->HLState)
	{
	case LHSTATE::LOOTABLE:
		properties().lootable(true);		// You can loot the creature
		properties().harvestable(false);	// You cannot harvest the creature
		break;
	case LHSTATE::HARVESTABLE:
		properties().lootable(false);		// You cannot loot the creature
		properties().harvestable(true);		// You can harvest the creature
		break;
	case LHSTATE::LOOTABLE_HARVESTABLE:
		properties().lootable(true);		// You can loot the creature
		properties().harvestable(true);		// You can harvest the creature
		break;

	default:
		properties().lootable(false);		// You cannot loot the creature
		properties().harvestable(false);	// You cannot harvest the creature
		break;
	}
}// initProperties //


//-----------------------------------------------
// computeTimeStep :
// Compute the elapsed time since last call.
// \param currentTime : current time in sec.
// \return double : elapsed time.
//-----------------------------------------------
double CCharacterCL::computeTimeStep(const double &currentTime)
{
	// Last Time greater than Current Time.
	if(_LastFrameTime > currentTime)
	{
		nlwarning("CCharacterCL::computeTimeStep : Time since last frame is negative (%f). Set _LastFrameTime with currentTime", _LastFrameTime - currentTime);
		_LastFrameTime = currentTime;
	}

	// Time since last Time >= 0
	return currentTime - _LastFrameTime;
}// computeTimeStep //


//-----------------------------------------------
// computeSpeed :
// \todo GUIGUI : to do an average speed, there is a problem if time become very small because small frame or _LastFrameTime increase when looping
//-----------------------------------------------
double CCharacterCL::computeSpeed()
{
	double spd;
	double t = _DestTime - _LastFrameTime;
	if(dist2Dest() <= 0.0)					// Already at destination.
		spd = 0.0;
	else if(_LastFrameTime == 0.0)			// First frame
		spd = 1.0;
	else if(t < 0.0001)	// We should already be at destination.
		spd = 1000.0;//-1.0;
	else
	{
		spd = dist2Dest()/t;
		if(spd>0 && spd<0.001)
			spd = 0.001;
		if(spd > 1000.0)
			spd = 1000.0;
	}
	speed(spd);
	return spd;
}// computeSpeed //

//-----------------------------------------------
// computeSpeedFactor :
// 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.
// \todo GUIGUI : revoir les histoire de scale, faire ca mieux.
//-----------------------------------------------
double CCharacterCL::computeSpeedFactor(double speedToDest)
{
	double speedFactor = 1.0;

	// \todo GUIGUI : faire cette histoire de emote beaucoup mieux, C NULL.
	const CAnimationState *animStatePtr;
	// If the current animation is an emote, get the right animation state.
	if(animState(MOVE) == CAnimationStateSheet::Emote)
		animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(_SubStateKey);
	else
		animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
	if(animStatePtr)
	{
		// Get the animation
		const CAnimation *anim = animStatePtr->getAnimation(animIndex(MOVE));
		if(anim)
		{
			// If the animation is a move (not idle, turn, etc.).
			if(_CurrentState)
			{
				// Move : adjust speed factor according to the animation.
				if(_CurrentState->Move)
				{
					// Check for oo speed.
					if(speedToDest != -1)
					{
						// Compute the animation average speed according to the scale.
						double animSpeed = EAM->getAnimationAverageSpeed(anim->id())*getSheetScale()*_CustomScalePos*_CharacterScalePos;
						if(animSpeed > 0.0)
							speedFactor = speedToDest / animSpeed;
						else
							nlwarning("The animation is a move but animation speed is %f !", animSpeed);
					}
					// \todo GUIGUI : unlimited speed, perhaps return a special value.
					// We should be arrived so speed is maximum.
					else
						speedFactor = 1000.0;
				}
				// The current animation is a rotation so adjust the rotation speed according to the angle.
				if(_CurrentState->Rotation && _RotationFactor > 0.0)
				{
					speedFactor /= _RotationFactor;
					speedFactor = std::min(speedFactor, 1.5);
					speedFactor = std::max(speedFactor, 0.5);
				}
				// This animation must be play in a maximum time when there is someting to do after.
				// (must be done after the rotation speed adjustment)
				if(_CurrentState->MaxAnimDuration > 0.00f)
				{
					if(dist2Dest() >= 0.0)
					{
						double animLength = EAM->getAnimationLength(anim->id());
						double speedFactorBackup = speedFactor;
						speedFactor = animLength/_CurrentState->MaxAnimDuration;
						// If the animation speed should have been greater, let it play faster.
						if(speedFactor < speedFactorBackup)
							speedFactor = speedFactorBackup;
					}
				}
				// Panic mode (too late => accelerate)
				if(!_CurrentState->Move && _ImportantStepTime!=0.0)
				{
					const float	beginPanic= 1.5f;		// start panic when too late of 1.5 seconds
					const float endPanic= 5.f;			// max panic factor at 5 seconds of interval
					const float	maxPanicSpeedFactor= 10.f;
					float	t= float(TimeInSec - _ImportantStepTime);
					if(t>beginPanic)
					{
						float	lerp= (t-beginPanic)/(endPanic-beginPanic);
						clamp(lerp, 0.f, 1.f);
						float	panicSF= lerp*maxPanicSpeedFactor;
						if(panicSF>speedFactor)
							speedFactor= panicSF;
					}
				}
				// Special panic mode because there is a position just after
				// NB: don't accelerate animations that can be breaked because of move
				// But still allow acceleration for mode animation transition (_Mode!=_ModeWanted)
				if( !_CurrentState->Move && _RunStartTimeNoPop!=INVALID_TIME &&
					(!_CurrentState->BreakableOnMove || _Mode!=_ModeWanted) )
				{
					const float maxPanicSpeedFactor= 1.5f;
					// compare time of rest of animation, to remain time to the first move
					float	remainAnimTime= float(EAM->getAnimationLength(anim->id()) - animOffset(MOVE));
					remainAnimTime= max(remainAnimTime, 0.f);
					float	panicSF;
					// if already too late, then maximize speed
					if(TimeInSec>=_RunStartTimeNoPop)
					{
						panicSF= maxPanicSpeedFactor;
					}
					// else target the animation speed so it ends at estimated start of move
					else
					{
						panicSF= float(remainAnimTime/(_RunStartTimeNoPop-TimeInSec));
						panicSF= min(panicSF, maxPanicSpeedFactor);
					}
					// only if greater than prec
					if(panicSF>speedFactor)
						speedFactor= panicSF;
				}

				// TestYoyo
				/*
				if(_Slot==WatchedEntitySlot && EntitiesMngr.isLogingStageChange())
				{
					sint64	refLT= EntitiesMngr.getLogStageChangeStartLocalTime();
					NLMISC::createDebug();
					NLMISC::DebugLog->displayRawNL("** Entity %d: (t=%3d) animState %s: %.2f/%.2f. move: %d. rstnp: %d. sf: %.2f",
						(sint32)_Slot, sint32(T1-refLT),
						CAnimationState::getAnimationStateName(animStatePtr->state()).c_str(),
						float(animOffset(MOVE)), float(EAM->getAnimationLength(anim->id())),
						uint(_CurrentState->Move), _RunStartTimeNoPop==INVALID_TIME?-1:sint32(sint64(_RunStartTimeNoPop*1000)-refLT),
						speedFactor
						);
				}
				*/
			}
		}
	}

	// \todo GUIGUI : corriger pour enlever le speed factor min.
	// Adjuste speed factor
	if(speedFactor < 0.5)
		speedFactor = 0.5;

	// Check negative or null speed factor.
	if(speedFactor <= 0.0)
	{
		nlwarning("CCharacterCL::computeSpeedFactor: speedFactor = %f and this should never be <= 0.", speedFactor);
		speedFactor = 1.0;
	}

	// Return the speed factor.
	return speedFactor;
}// computeSpeedFactor //

//-----------------------------------------------
// endAnimTransition :
// Call it at the end of the current animation to choose the next one.
//-----------------------------------------------
void CCharacterCL::endAnimTransition()
{
	// One more animation played.
	_NbLoopAnim++;

	// Hide the entity if needed.
	if(_HideSkin)
		hideSkin();

	// Debug Animation for the selection
	if(VerboseAnimSelection && _Slot == UserEntity->selection())
		nlinfo("CH:endAnimTransition:%d: current animation finished.", _Slot);
	// If the animation is a rotation, set the character direction he should have at the end of the animation.
	if(_CurrentState->Rotation)
	{
		if(isUser())
		{
			nldebug("<CCharacterCL::endAnimTransition> rotation : set dir as end anim dir");
		}

		dir(dirEndAnim());
	}
	// Fit the current direction to the target when attacking.
	if(_CurrentState->Attack)
	{
		dir(front());
	}
	// If user is in range attack and not moving, set dir to target
	if( isUser() )
	{
		if(_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK && _Mode==MBEHAV::COMBAT && !UserControls.isMoving())
		{
			dir( dirToTarget() );

			float frontYawBefore = frontYaw();
			front(dir());
			float frontYawAfter = frontYaw();
			float	deltaYaw= frontYawAfter - frontYawBefore;
			UserControls.appendCameraDeltaYaw(-deltaYaw);

			if( ClientCfg.AutomaticCamera )
			{
				UserControls.resetSmoothCameraDeltaYaw();
			}
		}
	}

	// If the next mode in the automaton != Current Mode
	if(_CurrentState->NextMode != _Mode)
	{
		if(ClientCfg.UsePACSForAll && _Primitive)
			_Primitive->setCollisionMask(MaskColNone);
		//// AJOUT ////
		switch(_CurrentState->NextMode)
		{
		// Combat
		case MBEHAV::COMBAT:
		case MBEHAV::COMBAT_FLOAT:
			if(ClientCfg.UsePACSForAll && _Primitive)
				_Primitive->setCollisionMask(MaskColPlayer | MaskColNpc | MaskColDoor);	// Collision with player and npc.
			break;
		// Mount
		case MBEHAV::MOUNT_NORMAL:
			parent(_Mount);
			// Remove collisions if needed.
			if(_Mount != CLFECOMMON::INVALID_SLOT)
			{
				if(_Primitive)
					_Primitive->setOcclusionMask(MaskColNone);
			}
			break;
		// Death
		case MBEHAV::DEATH:
			setDead();
			break;
		// UNKNOWN
		case MBEHAV::UNKNOWN_MODE:
			if(ClientCfg.Check)
				nlstop;
			// NO BREAK is Normal here
		// Normal
		case MBEHAV::NORMAL:
//			_Mount = CLFECOMMON::INVALID_SLOT;
//			_Rider = CLFECOMMON::INVALID_SLOT;
			parent(CLFECOMMON::INVALID_SLOT);
			dir(front());
			/*
			front(CVector(1.f, 0.f, 0.f));
			dir(front());
			*/
			break;
		default:
			break;
		}
		// Change the current mode.
		if ( _ModeWanted != MBEHAV::UNKNOWN_MODE )
		{
			_Mode = _CurrentState->NextMode;
		}
		//else
		//	nlinfo( "NO mode change from %u to %u, %s S%hu", _Mode, _CurrentState->NextMode, _SheetId.toString().c_str(), _Slot );
		// Change the current automaton.
		computeAutomaton();
		// Update the animation set according to the new automaton.
		computeAnimSet();
	}
	// Select the Default Next Animation.
	setAnim(_CurrentState->NextState);
}// endAnimTransition //

//-----------------------------------------------
// onMove :
//-----------------------------------------------
CCharacterCL::TOnMove CCharacterCL::onMove(const CAutomatonStateSheet &curAnimState)
{
	// Animation is breakable if the distance to destination is long enough (at least > 0).
	if(curAnimState.BreakableOnMove && dist2Dest()>0.0)
	{
		// \todo GUIGUI : take the next position to current one (it could be possible this position was the same as the first).
		CVectorD dirToFirstPos = _FirstPos-pos();
		dirToFirstPos.z = 0.0;
		if(dirToFirstPos != CVectorD::Null)
			dirToFirstPos.normalize();
		else
		{
			nlwarning("CH:onMove:%d: First pos == pos -> take the dir(%f,%f,%f) instead.", _Slot, dir().x, dir().y, dir().z);
			dirToFirstPos = dir();
		}

		// Compute Angle between the front and the first position.
		double angToDest = computeShortestAngle(atan2(front().y, front().x), atan2(dirToFirstPos.y, dirToFirstPos.x));
		if(!_MaxLoop)
		{
			// Strafe Left
			if(curAnimState.OnMoveLeft     != CAnimationStateSheet::UnknownState)
				if((angToDest>Pi/3.0) && (angToDest<2.0*Pi/3.0))
					return OnMoveLeft;
			// Strafe Right
			if(curAnimState.OnMoveRight    != CAnimationStateSheet::UnknownState)
				if((angToDest<-Pi/3.0) && (angToDest>-2.0*Pi/3.0))
					return OnMoveRight;
			// Backward
			if(curAnimState.OnMoveBackward != CAnimationStateSheet::UnknownState)
				if(fabs(angToDest)>1.92)
					return OnMoveBackward;
		}
		// Forward (default)
		if(curAnimState.OnMoveForward  != CAnimationStateSheet::UnknownState)
		{
//			if(_MaxLoop || fabs(angToDest)<=1.92)
				return OnMoveForward;
		}
		else
			nlwarning("CH:onMove:%d: the current state is breakable on Move and the dist to dest is not Null, but there is no animation to move.", _Slot);
	}
	// No Move
	return OnMoveNone;
}// onMove //

//-----------------------------------------------
// onRotation :
//-----------------------------------------------
CCharacterCL::TOnRot CCharacterCL::onRotation(const CAutomatonStateSheet &curAnimState, CVector &dirEndA)
{
	// Turn and About Face
	if(curAnimState.BreakableOnRotation)
	{
		CVector bodyDir = dir();
		CVector destDir = front();

		// when user is attacking, his dest is his target
		if( isUser() && _CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK && _Mode==MBEHAV::COMBAT && !UserControls.isMoving() )
		{
			destDir = dirToTarget();
		}

		// Compute the angle between the current heading and computed heading.
		double angToDest = computeShortestAngle(atan2(bodyDir.y, bodyDir.x), atan2(destDir.y, destDir.x));
		// Rotation to the left.
		if(angToDest >=  (ClientCfg.AnimatedAngleThreshold*Pi/180.0))
		{
			dirEndA = destDir;
			return OnRotLeft;
		}
		// Rotation to the right.
		if(angToDest <= -(ClientCfg.AnimatedAngleThreshold*Pi/180.0))
		{
			dirEndA = destDir;
			return OnRotRight;
		}
	}
	// No Rot
	return OnRotNone;
}// onRotation //

//-----------------------------------------------
// onBigBend :
//-----------------------------------------------
CCharacterCL::TOnBigBend CCharacterCL::onBigBend(const CAutomatonStateSheet &curAnimState, CVector &dirEndA)
{
	// If the current direction is too different of the direction to the first destination -> play a rotation.
	if(curAnimState.BrkOnBigBend)
	{
		CVector dirToFirstPos;
		if(setVect(dirToFirstPos, _FirstPos - pos(), true, false))
		{
			dirToFirstPos = curAnimState.getMatrix()*dirToFirstPos;
			double angToDest = computeShortestAngle(atan2(dir().y, dir().x), atan2(dirToFirstPos.y, dirToFirstPos.x));
			// Rotation to the left.
			if(angToDest >= 1.5)
			{
				dirEndA = dirToFirstPos;
				return OnBendLeft;
			}
			// Rotation to the right.
			if(angToDest <= -1.5)
			{
				dirEndA = dirToFirstPos;
				return OnBendRight;
			}
			// Smooth dir
			if(fabs(angToDest) > 0.1)
			{
				double newAngle = atan2(dir().y, dir().x) + angToDest/2.0;
				dir(CVector((float)cos(newAngle), (float)sin(newAngle), dir().z));
			}
			else
				dir(dirToFirstPos);
		}
	}
	// No Bend
	return OnBendNone;
}// onBigBend //

//-----------------------------------------------
// onBadHeading :
//-----------------------------------------------
bool CCharacterCL::onBadHeading(const CAutomatonStateSheet &curAnimState)
{
	// Bad Heading
	if(curAnimState.BreakableOnBadHeading && !_MaxLoop)
	{
		CVector dirToFirstPos;
		if(setVect(dirToFirstPos, _FirstPos - pos(), true, false))
		{
			// Compute the angle between the front and the next body direction.
			double angToDest = computeShortestAngle(atan2(front().y, front().x), atan2(dirToFirstPos.y, dirToFirstPos.x));
			if(curAnimState.BadHeadingMin <= curAnimState.BadHeadingMax)
			{
				if((angToDest<curAnimState.BadHeadingMin) || (angToDest>curAnimState.BadHeadingMax))
					return true;
			}
			else
			{
				if((angToDest<curAnimState.BadHeadingMin) && (angToDest>curAnimState.BadHeadingMax))
					return true;
			}
		}
	}
	// No bad Heading
	return false;
}// onBadHeading //

//-----------------------------------------------
// setAnim :
// Select a new animation for the entity.
// \todo GUIGUI : better manage when there is no skeleton
// \todo GUIGUI : simplify head control
//-----------------------------------------------
ADD_METHOD(void CCharacterCL::setAnim(TAnimStateKey newKey, TAnimStateKey subKey, uint animID))
	if(ClientCfg.Light)
		return;

	// Debug Animation for the target
	if(VerboseAnimSelection && _Slot == UserEntity->selection())
		nlinfo("CH:setAnim:%d: state '%s'.", _Slot, CAnimationState::getAnimationStateName (newKey).c_str());


	// RELEASE THE OLD ANIMATION
	TAnimStateId lastAnimStateId = animState(MOVE);	// Bkup the current anim state Id.

	// \todo GUIGUI : Faire une fonction pour savoir si on a changer de type d'animation.
	// Reset loop counter
	if((newKey != animState(MOVE)) || (_OldAutomaton != _CurrentAutomaton))
		_NbLoopAnim = 0;

	// RESET THE CURRENT ANIMATION
	_HideSkin = false;
	CAnimation::TAnimId buIndex = animIndex(MOVE);
	animIndex (MOVE,           CAnimation::UnknownAnim);				// Reset the current animation Index
	animState (MOVE,	       CAnimationStateSheet::UnknownState);		// Reset the current animation state
	animOffset(MOVE,           0.0);									// Reset the current animation offset
	animIndex (MOVE_BLEND_OUT, CAnimation::UnknownAnim);				// Reset the current animation Index
	animState (MOVE_BLEND_OUT, CAnimationStateSheet::UnknownState);		// Reset the current animation state
	animOffset(MOVE_BLEND_OUT, 0.0);									// Reset the current animation offset
	_RotationFactor		= 1.0;											// New animation -> default rotation factor for the time.
	_RightFXActivated	= false;
	_LeftFXActivated	= false;
	_RotationFactor		= 1.0f;											// Rotation factor as the animation for the time.
	_SubStateKey		= CAnimationStateSheet::UnknownState;			// No SubStateKey for the time.
	dirEndAnim(dir());													// For the time the direction at the end of the animation is the current direction.

	// CHECK
	// If there is no animation set ->There is nothing we can do properly.
	if(_CurrentAnimSet[MOVE] == 0)
		return;


	// INITIALIZE
	if(!animationStateKey(MOVE, newKey))
	{
		nlwarning("CH:setAnim:%d: automaton '%s': animation state key '%s' asked is not valid -> trying Idle.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (newKey).c_str());
		if(!animationStateKey(MOVE, CAnimationStateSheet::Idle))
			nlwarning("CH:setAnim:%d: Idle is not warking too", _Slot);
	}

	// Compute Speed
	double speedToDest = computeSpeed();
	// Compute the direction to the first position (direction = front if there is not first pos)
	CVector dirToFirstPos;
	if(dist2FirstPos() > 0.0)
		dirToFirstPos = (_FirstPos - pos()).normed();
	else
		dirToFirstPos = front();

	uint antiFreezeCounter = 0;
// Loop until the process find a steady state.
KeyChosen:
	// Get the state for the current animation.
	const CAutomatonStateSheet *state = EAM->mState(_CurrentAutomaton, animState(MOVE));
	if(state == 0)
	{
		nlwarning("CH:setAnim:%d: State '%s' not in the automaton '%s'.", _Slot, CAnimationStateSheet::getAnimationStateName(animState(MOVE)).c_str(), _CurrentAutomaton.c_str());
		// No animation playing
		if(_PlayList)
			_PlayList->setAnimation(MOVE, UPlayList::empty);
		return;
	}
	const CAutomatonStateSheet &curAnimState = *state;
	//--------------------//
	//--------------------//
	// ANTI-FREEZE SYSTEM //
	// If too many loop, display some infos
	if(antiFreezeCounter > 10)
	{
/*
		nlwarning("CH:setAnim:anitFreeze:%d: Automaton '%s'",           _Slot, _CurrentAutomaton.c_str());
		nlwarning("CH:setAnim:anitFreeze:%d: _IsThereAMode '%s'",       _Slot, _IsThereAMode?"true":"false");
		nlwarning("CH:setAnim:anitFreeze:%d: dist2Dest '%f'",           _Slot, dist2Dest());
		nlwarning("CH:setAnim:anitFreeze:%d: Mode '%s(%d)'",            _Slot, modeToString(_Mode).c_str(), _Mode);
		nlwarning("CH:setAnim:anitFreeze:%d: Mode Wanted '%s(%d)'",     _Slot, modeToString(_ModeWanted).c_str(), _ModeWanted);
		nlwarning("CH:setAnim:anitFreeze:%d: Anim State Move '%s(%d)'", _Slot, CAnimationStateSheet::getAnimationStateName(animState(MOVE)).c_str(), animState(MOVE));
*/
		// Once too many more time reached, leave the method.
		if(antiFreezeCounter > 20)
			return;
	}
	// Update antiFreezeCounter.
	++antiFreezeCounter;
	// ANTI-FREEZE SYSTEM //
	//--------------------//
	//--------------------//
	// Is there a mode in the queue
//	if(_IsThereAMode && (dist2Dest()==INVALID_DIST))
	{
		// Is the current mode not already the mode wanted.
		if((_Mode != _ModeWanted) && (dist2Dest()==INVALID_DIST))
		{
			TAnimStateKey transition;
			// Check Default Mode Connection.
			if(curAnimState.getModeConnection(_ModeWanted, transition))
			{
				// Mode Mount need to be synchro
				if(_ModeWanted == MBEHAV::MOUNT_NORMAL || _ModeWanted == MBEHAV::MOUNT_SWIM)
				{
					// The Mount
					if(_Rider != CLFECOMMON::INVALID_SLOT)
					{
						if(animationStateKey(MOVE, transition))
							goto KeyChosen;
						else
							nlwarning("CH:setAnim:%d: Mode Wanted '%d' : automaton '%s': state '%s': Transition '%s' is not valid.", _Slot, _ModeWanted, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName (transition).c_str());
					}
					// The Rider
					else if(_Mount != CLFECOMMON::INVALID_SLOT)
					{
						CEntityCL *mountTmp = EntitiesMngr.entity(_Mount);
						CCharacterCL *mount = dynamic_cast<CCharacterCL *>(mountTmp);
						if(mount)
						{
							if(mountTmp->mode() == _ModeWanted)
							{
								if(animationStateKey(MOVE, transition))
									goto KeyChosen;
								else
								{
									nlwarning("CH:setAnim:%d: automaton '%s': state '%s': MountDefaultModeTransition '%s' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName (transition).c_str());
								}
							}
						}
						else
						{
							nlwarning("CH:setAnim:%d: Mode Wanted '%s' but the mount does not exist.", _Slot, MBEHAV::modeToString(_ModeWanted).c_str());
						}
					}
				}
				// Other modes have the same code.
				else
				{
					if(animationStateKey(MOVE, transition))
						goto KeyChosen;
					else
						nlwarning("CH:setAnim:%d: Mode Wanted '%d' : automaton '%s': state '%s': Transition '%s' is not valid.", _Slot, _ModeWanted, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName (transition).c_str());
				}
			}
		}
	}


	// Should we stop the animation once at destination.
	if(curAnimState.BrkAtDest && (dist2Dest() <= ClientCfg.DestThreshold))
	{
		_MaxLoop = false;
		if(animationStateKey(MOVE, CAnimationStateSheet::Idle))
			goto KeyChosen;
		else
			nlwarning("CH:setAnim:%d: automaton '%s': state '%s': BrkAtDest 'idle' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str());
	}

	// On Move
	switch(onMove(curAnimState))
	{
	// On Move Forward
	case OnMoveForward:
		if(animationStateKey(MOVE, curAnimState.OnMoveForward))
			goto KeyChosen;
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnMoveForeward '%s' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnMoveForward).c_str());
		break;
	// On Move Backward
	case OnMoveBackward:
		if(animationStateKey(MOVE, curAnimState.OnMoveBackward))
			goto KeyChosen;
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnMoveBackward '%s' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnMoveBackward).c_str());
		break;
	// On Move Left
	case OnMoveLeft:
		if(animationStateKey(MOVE, curAnimState.OnMoveLeft))
			goto KeyChosen;
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnMoveLeft '%s' is not valid.",     _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnMoveLeft).c_str());
		break;
	// On Move Right
	case OnMoveRight:
		if(animationStateKey(MOVE, curAnimState.OnMoveRight))
			goto KeyChosen;
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnMoveRight '%s' is not valid.",    _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnMoveRight).c_str());
		break;
	default:
		break;
	}

	// On Rotation/About Face
	CVector dirEndA(0.0f, 0.0f, 0.0f);
	switch(onRotation(curAnimState, dirEndA))
	{
	// On Rot Left
	case OnRotLeft:
		if(animationStateKey(MOVE, curAnimState.OnLeftRotation))
		{
			dirEndAnim(dirEndA);
			goto KeyChosen;
		}
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnLeftRotation '%s' is not valid.",     _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnLeftRotation).c_str());
		break;
	// On Rot Right
	case OnRotRight:
		if(animationStateKey(MOVE, curAnimState.OnRightRotation))
		{
			dirEndAnim(dirEndA);
			goto KeyChosen;
		}
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnRightRotation '%s' is not valid.",    _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnRightRotation).c_str());
		break;
	default:
		break;
	}

	// Max Loop
	if(curAnimState.MaxLoop && curAnimState.MaxLoop<=_NbLoopAnim)
	{
		if(animationStateKey(MOVE, CAnimationStateSheet::Idle))
		{
			_MaxLoop = true;
			_NbLoopAnim = 0;
			goto KeyChosen;
		}
	}

	// On Bad Heading
	if(onBadHeading(curAnimState))
	{
		if(animationStateKey(MOVE, CAnimationStateSheet::Idle))
			goto KeyChosen;
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': 'Idle' is not valid.",    _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str());
	}

	// On Big Bend
	switch(onBigBend(curAnimState, dirEndA))
	{
		// On Bend Left
	case OnBendLeft:
		if(animationStateKey(MOVE, curAnimState.OnBigBendLeft))
		{
			dirEndAnim(dirEndA);
			goto KeyChosen;
		}
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnBigBendLeft '%s' is not valid.",     _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnBigBendLeft).c_str());
		break;
		// On Bend Right
	case OnBendRight:
		if(animationStateKey(MOVE, curAnimState.OnBigBendRight))
		{
			dirEndAnim(dirEndA);
			goto KeyChosen;
		}
		else
			nlwarning("CH::setAnim:%d: automaton '%s': state '%s': OnBigBendRight '%s' is not valid.",    _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName(curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName(curAnimState.OnBigBendRight).c_str());
		break;
	default:
		break;
	}

	// If the animation change according to a high speed and speed high enough or oo.
	if(ClientCfg.BlendForward == false)
	{
		if(curAnimState.OnMaxSpeed.Breakable)
		{
			if(speedToDest >= _CurrentAnimSet[MOVE]->speedToRun() ||  speedToDest == -1.0)
			{
				if(animationStateKey(MOVE, curAnimState.OnMaxSpeed.NextStateKey))
					goto KeyChosen;
				else
					nlwarning("CH::setAnim: Char '%d': automaton '%s': state '%s': OnMaxSpeed.NextStateKey '%s' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName (curAnimState.OnMaxSpeed.NextStateKey).c_str());
			}
		}
	}

	// If the animation can change with a low speed.
	if(curAnimState.OnMinSpeed.Breakable)
	{
		// If the speed is low enough (check this is not -1 (infinite speed)) -> update the animation to play.
		if(speedToDest != -1.0 && speedToDest <= _CurrentAnimSet[MOVE]->speedToWalk())
		{
			if(animationStateKey(MOVE, curAnimState.OnMinSpeed.NextStateKey))
				goto KeyChosen;
			else
				 nlwarning("CH::setAnim: Char '%d': automaton '%s': state '%s': OnMinSpeed.NextStateKey '%s' is not valid.", _Slot, _CurrentAutomaton.c_str(), CAnimationState::getAnimationStateName (curAnimState.MoveState).c_str(), CAnimationState::getAnimationStateName (curAnimState.OnMinSpeed.NextStateKey).c_str());
		}
	}
	//// END LOOP /////


	// \todo GUIGUI : better manage automate change
	// Current animation is not of the same kind as the old one.
	bool sameAnim = lastAnimStateId == animState(MOVE) && _OldAutomaton == _CurrentAutomaton;
	if(!sameAnim)
	{
		// Stop FXs.
		stopItemAttackFXs();
		stopAttachedFXForCurrrentAnim(true); // stop all anim fx, including looping fxs
	}
	else
	{
		stopAttachedFXForCurrrentAnim(false); // stop all anim fxs, but do not stop looping fxs (because the same anim is repeating)
	}

	// Compute the current animation state.
	_CurrentState = EAM->mState(_CurrentAutomaton, animState(MOVE));
	// If the state does not exist.
	if(_CurrentState == 0)
	{
		nlwarning("CH:setAnim:%d: State '%s' not in the automaton '%s'.", _Slot, CAnimationStateSheet::getAnimationStateName (animState(MOVE)).c_str(), _CurrentAutomaton.c_str());

		// No animation playing
		if(_PlayList)
			_PlayList->setAnimation(MOVE, UPlayList::empty);
	}
	// The state is valid.
	else
	{
		double angToDest = 0.0;
		// If the new state is a rotation.
		if(_CurrentState->Rotation)
			angToDest = computeShortestAngle(atan2(dir().y, dir().x), atan2(dirEndAnim().y, dirEndAnim().x));
		// Get the right animation state and choose an animation.
		{
			// Get the animation state
			const CAnimationState *animationState = 0;
			if(animState(MOVE) == CAnimationStateSheet::Emote)
			{
				_SubStateKey = subKey;
				animationState = _CurrentAnimSet[MOVE]->getAnimationState(_SubStateKey);
			}
			else
				animationState = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
			if(animationState)
			{
				// Choose the animation
				CAnimation::TAnimId index;
				if(sameAnim)
					index = buIndex;
				else
					index = CAnimation::UnknownAnim;
				animIndex(MOVE, animationState->chooseAnim(_AnimJobSpecialisation, people(), getGender(), angToDest, index));
				if(animID != NL3D::UAnimationSet::NotFound)
					animId(MOVE, animID);


				// Should the objects in hands be displayed ?
				_ObjectsVisible = animationState->areObjectsVisible();
				showOrHideBodyParts( _ObjectsVisible );

				// in case of user manage the internal view
				if( isUser() )
				{
					UserEntity->updateVisualDisplay();
				}
			}
		}
		// Initialize the animation
		if(animIndex(MOVE) != CAnimation::UnknownAnim)
		{
			// If the new state is a rotation.
			if(_CurrentState->Rotation)
			{
				// Get the animation rotation.
				double animAngle = CAnimationMisc::getAnimationRotation(EAM->getAnimationSet(), animId(MOVE));
				// Compute the rotation factor.
				if(animAngle != 0.0)
					_RotationFactor = fabs(angToDest/animAngle);
				else
					_RotationFactor = -1.0;	// \todo GUIGUI : see which value we should use if we have a rot anim without rot and which should rotate character
			}

			// If the animation is an atk or forage extraction -> Start all dynamic FXs.
			if (_CurrentBehaviour.Behaviour == MBEHAV::EXTRACTING)
			{
				// True Extract Animation only for Use AnimationState type
				// \todo yoyo: ugly?
				if( animState(MOVE)==CAnimationStateSheet::UseLoop )
				{
					_Items[SLOTTYPE::RIGHT_HAND_SLOT].setTrailSize(_CurrentBehaviour.ForageExtraction.Level);
					startItemAttackFXs(true, 1);
				}
			}
			else if (_CurrentState->Attack)
			{
				if(_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK)
				{
					startItemAttackFXs(_CurrentBehaviour.Range.ImpactIntensity != 0, _CurrentBehaviour.Range.ImpactIntensity);
				}
				else
				{
					startItemAttackFXs(_CurrentBehaviour.Combat.ImpactIntensity != 0 && _CurrentBehaviour.Combat.HitType != HITTYPE::Failed, _CurrentBehaviour.Combat.ImpactIntensity);
				}
			}


			// Initialize the new animation.
			if(_PlayList)
			{
				// Blend the last animation and the new one.
				if(ClientCfg.BlendFrameNumber && _BlendRemaining <= 0								// Blend On ?
				&& animIndex(ACTION) != CAnimation::UnknownAnim										// Last Animation Valid ?
				&& ((lastAnimStateId != animState(MOVE)) || (_OldAutomaton != _CurrentAutomaton)
				   || (animState(MOVE) == CAnimationStateSheet::Emote))	// Last anim != or automaton != ?
				&& !isRiding())											// No Blend on a mount. \todo GUIGUI trouver un meilleur moyen.
				{
					// Get the rotation of the last animation for the blend.
					if(!_Skeleton.empty())
						_OldRotQuat = _Skeleton.getRotQuat();
					_BlendRemaining = ClientCfg.BlendFrameNumber;
					// Set animation
					_PlayList->setAnimation(ACTION, animId(ACTION));
					// Compute weight step.
					float w = 1.f/((float)(ClientCfg.BlendFrameNumber+1));
					// Set Old Anim Weight.
					_PlayList->setWeight(ACTION, 1.f-w);
					// Set New Anim Weight.
					_PlayList->setWeight(MOVE, w);
					// Copy Reverse
					_AnimReversed[ACTION] = _AnimReversed[MOVE];
				}
				// Set Animation.
				_PlayList->setAnimation (MOVE, animId(MOVE));
				// Blend between Walk and Run.
				if(ClientCfg.BlendForward && (animState(MOVE) == CAnimationStateSheet::Walk))
				{
					_CurrentAnimSet[MOVE_BLEND_OUT] = _CurrentAnimSet[MOVE];
					animState(MOVE_BLEND_OUT, CAnimationStateSheet::Run);
					const CAnimationState *animationBlendState = _CurrentAnimSet[MOVE_BLEND_OUT]->getAnimationState(animState(MOVE_BLEND_OUT));
					if(animationBlendState)
					{
						animIndex(MOVE_BLEND_OUT, animationBlendState->chooseAnim(_AnimJobSpecialisation, people(), getGender()));
						_PlayList->setAnimation(MOVE_BLEND_OUT, animId(MOVE_BLEND_OUT));
						_PlayList->setWeight(MOVE_BLEND_OUT, 1.0f);		// \todo GUIGUI : verify what is happening if animId is "empty".
					}
					else
						nlwarning("setAnim:%d: animationBlendState is Null.", _Slot);
				}

				// Set children animation.
				std::list<CEntityCL *>::iterator it = _Children.begin();
				while(it != _Children.end())
				{
					if(*it)
					{
						CCharacterCL *child = dynamic_cast<CCharacterCL *>(*it);
						if(child)
						{
							// Set the Child as the parent.
							child->computeAnimSet();
							child->currentAutomaton() = _CurrentAutomaton;	// \todo GUIGUI : CA VA PAS MARCHER A CAUSE DU TYPE !!!
							child->animOffset(MOVE, animOffset(MOVE));
							child->animState(MOVE, animState(MOVE));
							child->currentState(currentState());
							child->animIndex(MOVE, CAnimation::UnknownAnim);
							const CAnimationState *animStatePtr = child->currentAnimSet()[MOVE]->getAnimationState(child->animState(MOVE));
							if(animStatePtr)
							{
								child->animIndex(MOVE, animStatePtr->chooseAnim(_AnimJobSpecialisation, people(), getGender(), angToDest));
								child->playList()->setAnimation(MOVE, child->animId(MOVE));
							}
							// TEMP : \todo GUIGUI : Pour le moment on enlever le Blend sur les montures.
							{
								child->playList()->setAnimation(ACTION, UPlayList::empty);
								child->currentAnimSet()[ACTION]       = child->currentAnimSet()[MOVE];
								child->animState (ACTION, child->animState (MOVE));
								child->animIndex (ACTION, child->animIndex (MOVE));
								child->animOffset(ACTION, child->animOffset(MOVE));
							}

						}
						else
							nlwarning("CH:setAnim:%d: Child is not a 'CCharacterCL'.", _Slot);
					}
					else
						nlwarning("CH:setAnim:%d: Child not allocated.", _Slot);

					// Next Child
					++it;
				}
			}

			// Get the animation.
			const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState((animState(MOVE) ==  CAnimationStateSheet::Emote)?subKey:animState(MOVE));
			if(animStatePtr)
			{
				const CAnimation *anim = animStatePtr->getAnimation(animIndex(MOVE));
				if(anim)
				{
					_HideSkin = anim->hideAtEndAnim();
					// Reverse ?
					_AnimReversed[MOVE] = anim->isReverse();
					// Is the head controlable.
					_TargetAnimCtrl.Enabled = anim->headControlable();
					// Select the sound ID
					_SoundId[MOVE] = anim->soundId();
					// look in behaviour if there's a spell to play
					if (_CurrentAttack)
					{
						if (_CurrentAttackInfo.Intensity >= 1 &&  _CurrentAttackInfo.Intensity <= MAGICFX::NUM_SPELL_POWER)
						{
							MAGICFX::TSpellCastStage attackStage;
							switch(newKey)
							{
								case CAnimationStateSheet::OffensiveCastBegin:
								case CAnimationStateSheet::CurativeCastBegin:
								case CAnimationStateSheet::MixedCastBegin:
								case CAnimationStateSheet::AcidCastInit:
								case CAnimationStateSheet::BlindCastInit:
								case CAnimationStateSheet::ColdCastInit:
								case CAnimationStateSheet::ElecCastInit:
								case CAnimationStateSheet::FearCastInit:
								case CAnimationStateSheet::FireCastInit:
								case CAnimationStateSheet::HealHPCastInit:
								case CAnimationStateSheet::MadCastInit:
								case CAnimationStateSheet::PoisonCastInit:
								case CAnimationStateSheet::RootCastInit:
								case CAnimationStateSheet::RotCastInit:
								case CAnimationStateSheet::ShockCastInit:
								case CAnimationStateSheet::SleepCastInit:
								case CAnimationStateSheet::SlowCastInit:
								case CAnimationStateSheet::StunCastInit:
									attackStage = MAGICFX::CastBegin;
								break;
								case CAnimationStateSheet::OffensiveCastLoop:
								case CAnimationStateSheet::CurativeCastLoop:
								case CAnimationStateSheet::MixedCastLoop:
								case CAnimationStateSheet::AcidCastLoop:
								case CAnimationStateSheet::BlindCastLoop:
								case CAnimationStateSheet::ColdCastLoop:
								case CAnimationStateSheet::ElecCastLoop:
								case CAnimationStateSheet::FearCastLoop:
								case CAnimationStateSheet::FireCastLoop:
								case CAnimationStateSheet::HealHPCastLoop:
								case CAnimationStateSheet::MadCastLoop:
								case CAnimationStateSheet::PoisonCastLoop:
								case CAnimationStateSheet::RootCastLoop:
								case CAnimationStateSheet::RotCastLoop:
								case CAnimationStateSheet::ShockCastLoop:
								case CAnimationStateSheet::SleepCastLoop:
								case CAnimationStateSheet::SlowCastLoop:
								case CAnimationStateSheet::StunCastLoop:
									attackStage = MAGICFX::CastLoop;
								break;
								case CAnimationStateSheet::OffensiveCastSuccess:
								case CAnimationStateSheet::CurativeCastSuccess:
								case CAnimationStateSheet::MixedCastSuccess:
								case CAnimationStateSheet::AcidCastEnd:
								case CAnimationStateSheet::BlindCastEnd:
								case CAnimationStateSheet::ColdCastEnd:
								case CAnimationStateSheet::ElecCastEnd:
								case CAnimationStateSheet::FearCastEnd:
								case CAnimationStateSheet::FireCastEnd:
								case CAnimationStateSheet::HealHPCastEnd:
								case CAnimationStateSheet::MadCastEnd:
								case CAnimationStateSheet::PoisonCastEnd:
								case CAnimationStateSheet::RootCastEnd:
								case CAnimationStateSheet::RotCastEnd:
								case CAnimationStateSheet::ShockCastEnd:
								case CAnimationStateSheet::SleepCastEnd:
								case CAnimationStateSheet::SlowCastEnd:
								case CAnimationStateSheet::StunCastEnd:
									attackStage = MAGICFX::CastEnd;
								break;
								case CAnimationStateSheet::OffensiveCastFail:
								case CAnimationStateSheet::OffensiveCastFumble:
								case CAnimationStateSheet::CurativeCastFail:
								case CAnimationStateSheet::CurativeCastFumble:
								case CAnimationStateSheet::MixedCastFail:
								case CAnimationStateSheet::MixedCastFumble:
								case CAnimationStateSheet::AcidCastFail:
								case CAnimationStateSheet::BlindCastFail:
								case CAnimationStateSheet::ColdCastFail:
								case CAnimationStateSheet::ElecCastFail:
								case CAnimationStateSheet::FearCastFail:
								case CAnimationStateSheet::FireCastFail:
								case CAnimationStateSheet::HealHPCastFail:
								case CAnimationStateSheet::MadCastFail:
								case CAnimationStateSheet::PoisonCastFail:
								case CAnimationStateSheet::RootCastFail:
								case CAnimationStateSheet::RotCastFail:
								case CAnimationStateSheet::ShockCastFail:
								case CAnimationStateSheet::SleepCastFail:
								case CAnimationStateSheet::SlowCastFail:
								case CAnimationStateSheet::StunCastFail:
									attackStage = MAGICFX::CastFail;
								break;
								// attacks
								case CAnimationStateSheet::DefaultAtkLow:
								case CAnimationStateSheet::DefaultAtkMiddle:
								case CAnimationStateSheet::DefaultAtkHigh:
								case CAnimationStateSheet::PowerfulAtkLow:
								case CAnimationStateSheet::PowerfulAtkMiddle:
								case CAnimationStateSheet::PowerfulAtkHigh:
								case CAnimationStateSheet::AreaAtkLow:
								case CAnimationStateSheet::AreaAtkMiddle:
								case CAnimationStateSheet::AreaAtkHigh:
								case CAnimationStateSheet::Attack1:
								case CAnimationStateSheet::Attack2:
								case CAnimationStateSheet::FirstPersonAttack:
									attackStage = MAGICFX::CastEnd;
								break;
								default:
									attackStage = MAGICFX::SpellCastStageCount;
								break;
							}
							const CAnimationFXSet *afs = NULL;
							switch(attackStage)
							{
								case MAGICFX::CastBegin: afs = &_CurrentAttack->AttackBeginFX; break;
								case MAGICFX::CastLoop:  afs = &_CurrentAttack->AttackLoopFX; break;
								case MAGICFX::CastEnd:   afs = &_CurrentAttack->AttackEndFX; break;
								case MAGICFX::CastFail:  afs = &_CurrentAttack->AttackFailFX; break;
								default: break;
							}
							playCastFX(afs, _CurrentAttackInfo.Intensity);
						}
					}
					// start forage prospection anim fx(s)
					if ( (behaviour() == MBEHAV::PROSPECTING) || (behaviour() == MBEHAV::PROSPECTING_END) )
					{
						const CAnimationFXSet& fxSet = anim->getFXSet();
						std::vector<UParticleSystemInstance> fxInstances;
						CAttachedFX::CBuildInfo bi;
						CAttachedFX::CTargeterInfo ti;
						for (uint k = 0; k < fxSet.FX.size(); ++k)
						{
							CAttachedFX::TSmartPtr fx = new CAttachedFX;
							bi.Sheet = &(fxSet.FX[k]);
							fx->create(*this, bi, ti);
							if (!fx->FX.empty())
							{

								attachFXInternal(fx,FXListCurrentAnim);
								if (k == 0)
								{
									// Set user param for size of prospection area
									{
										fx->FX.setUserParam( 0, ((float)(_CurrentBehaviour.ForageProspection.Range)) / 127.0f );
										float up [3];
										switch ( _CurrentBehaviour.ForageProspection.Angle )
										{
										case 0:	up[2] = up[1] = up[0] = 0.0f; break;
										case 1: up[0]=1.0f; up[1]=0.0f; up[2]=0.0f; break;
										case 2: up[0]=1.0f; up[1]=1.0f; up[2]=0.0f; break;
										default: up[0]=1.0f; up[1]=1.0f; up[2]=1.0f; break;
										}
										fx->FX.setUserParam( 1, up[0] );
										fx->FX.setUserParam( 2, up[1] );
										fx->FX.setUserParam( 3, up[2] );
										//nlinfo( "Prospection %s %u %u", behaviour()==MBEHAV::PROSPECTING?"PROSPTG":(behaviour()==MBEHAV::PROSPECTING_END?"PRO_END":"OTHER"), _CurrentBehaviour.ForageProspection.Range, _CurrentBehaviour.ForageProspection.Angle );
									}
								}
								else if (k == 1)
								{
									// Set user param for level of prospection
									float up [4];
									switch ( _CurrentBehaviour.ForageProspection.Level )
									{
									case 0: up[3] = up[2] = up[1] = up[0] = 0.0f; break;
									case 1: up[0]=0.0f; up[1]=1.0f; up[2]=0.0f; up[3]=0.0f; break;
									case 2: up[0]=1.0f; up[1]=1.0f; up[2]=0.0f; up[3]=0.0f; break;
									case 3: up[0]=1.0f; up[1]=1.0f; up[2]=1.0f; up[3]=0.0f; break;
									default: up[3] = up[2] = up[1] = up[0] = 1.0f; break;
									}
									fx->FX.setUserParam( 0, up[0] );
									fx->FX.setUserParam( 1, up[1] );
									fx->FX.setUserParam( 2, up[2] );
									fx->FX.setUserParam( 3, up[3] );
								}
							}
						}
					}
					// start standard anim fx
					else
					{
						CAttachedFX::CBuildInfo bi;
						CAttachedFX::CTargeterInfo ti;
						bi.MaxNumAnimCount = MAX_FX_ANIM_COUNT;
						for (uint k = 0; k < anim->getFXSet().FX.size(); ++k)
						{
							// if the fx is in looping mode, & the anim has already done a loop, then don't recreate it
							if (anim->getFXSet().FX[k].Sheet->RepeatMode == CAnimationFXSheet::Loop && sameAnim) continue;
							CAttachedFX::TSmartPtr fx = new CAttachedFX;
							bi.Sheet = &(anim->getFXSet().FX[k]);
							//bi.StickMode = &bi.Sheet->FX[k].StickMode;
							if (anim->getFXSet().FX[k].Sheet)
							{
								bi.StickMode = &(anim->getFXSet().FX[k].Sheet->StickMode);
							}
							fx->create(*this, bi, ti);
							if (!fx->FX.empty())
							{
								attachFXInternal(fx, FXListAuto);
							}
						}
					}
				}
			}
			else
				nlwarning("CH:setAnim:%d: cannot get the pointer on the animation.", _Slot);
		}
		// No animation found -> check if it is just a transition or is there really an animation missing
		else
		{
			// INFO : Verbose mode for Animations of the selection.
			if(VerboseAnimSelection && _Slot == UserEntity->selection())
				nlinfo("CH:setAnim:%d: Anim Not Found, state '%s'.", _Slot, CAnimationState::getAnimationStateName(animState(MOVE)).c_str());

			// If the next animation or automaton is not the same -> this is a transition -> no animation needed.
			if(_CurrentState->MoveState != _CurrentState->NextState || (_CurrentState->NextMode != _Mode))
			{
				// Choose the next animation.
				endAnimTransition();
			}
			// Else -> Animation Missing.
		}
	}
	// Set the LOD Animation.
	setAnimLOD(((lastAnimStateId != animState(MOVE)) || (_OldAutomaton != _CurrentAutomaton)));
}// setAnim //


//-----------------------------------------------
// playCastFX
//-----------------------------------------------
void CCharacterCL::playCastFX(const CAnimationFXSet *afs, uint power)
{
	if (!afs) return;
	if (power <= 0 || power > 5) return;
	static const float castFXUserParams[MAGICFX::NUM_SPELL_POWER][4] =
	{
		{ 0.f, 0.f, 0.f, 0.f},
		{ 1.f, 0.f, 0.f, 0.f},
		{ 1.f, 1.f, 0.f, 0.f},
		{ 1.f, 1.f, 1.f, 0.f},
		{ 1.f, 1.f, 1.f, 1.f}
	};
	CAttachedFX::CBuildInfo bi;
	CAttachedFX::CTargeterInfo ti;
	for (uint k = 0; k < afs->FX.size(); ++k)
	{
		CAttachedFX::TSmartPtr fx = new CAttachedFX;
		bi.Sheet = &afs->FX[k];
		fx->create(*this, bi, ti);
		if (!fx->FX.empty())
		{
				for(uint l = 0; l < 4; ++l)
				{
					fx->FX.setUserParam(l, castFXUserParams[power - 1][l]);
				}
				attachFXInternal(fx, FXListCurrentAnim);
		}
	}
}


//-----------------------------------------------
// showOrHideBodyParts
//-----------------------------------------------
void CCharacterCL::showOrHideBodyParts( bool objectsVisible )
{
	// UnHide all user body parts.
	for(uint i=0; i<_Instances.size(); ++i)
		if(!_Instances[i].Current.empty())
			_Instances[i].Current.show();

	// hide or show the face
	if( _Items[SLOTTYPE::HEAD_SLOT].Sheet && _Items[SLOTTYPE::HEAD_SLOT].Sheet->Family == ITEMFAMILY::ARMOR )
	{
		// Get the face
		SInstanceCL *face = getFace ();

		// hide if helmet
		if(face)
		{
			if(!face->Current.empty())
				face->Current.hide();
			else
				face->KeepHiddenWhenLoaded = true;
		}
	}
	else
	{
		// Get the face
		SInstanceCL *face = getFace ();

		// hide if helmet
		if(face)
		{
			if(!face->Current.empty())
				face->Current.show();
			else
				face->KeepHiddenWhenLoaded = false;
		}
	}

	// get the instance index for right hand and left hand
	uint32 rHandInstIdx;
	uint32 lHandInstIdx;
	if( isPlayer() || isUser() )
	{
		rHandInstIdx = SLOTTYPE::RIGHT_HAND_SLOT;
		lHandInstIdx = SLOTTYPE::LEFT_HAND_SLOT;

		// hide gloves(armor) if player has magician amplifier
		if( _Items[rHandInstIdx].Sheet && (_Items[rHandInstIdx].Sheet->ItemType == ITEM_TYPE::MAGICIAN_STAFF) )
		{
			if( !_Instances[SLOTTYPE::HANDS_SLOT].Current.empty() )
				_Instances[SLOTTYPE::HANDS_SLOT].Current.hide();
			else
				_Instances[SLOTTYPE::HANDS_SLOT].KeepHiddenWhenLoaded = true;
		}
	}
	else
	{
		rHandInstIdx = _RHandInstIdx;
		lHandInstIdx = _LHandInstIdx;
	}

	// if not already hidden and need to hide :
	if( !objectsVisible )
	{
		// Right Hand
		if(rHandInstIdx<_Instances.size())
			if( !(_Items[rHandInstIdx].Sheet && _Items[rHandInstIdx].Sheet->NeverHideWhenEquiped ) )
				if(!_Instances[rHandInstIdx].Current.empty())
				{
					_Instances[rHandInstIdx].Current.hide();
					_Instances[rHandInstIdx].hideStaticFXs();
				}
		// Left Hand
		if(lHandInstIdx <_Instances.size())
			if( !(_Items[lHandInstIdx].Sheet && _Items[lHandInstIdx].Sheet->NeverHideWhenEquiped ) )
				if(!_Instances[lHandInstIdx].Current.empty())
				{
					_Instances[lHandInstIdx].Current.hide();
					_Instances[lHandInstIdx].hideStaticFXs();
				}
	}
	else
	{
		// Right Hand
		if(rHandInstIdx<_Instances.size())
			if(!_Instances[rHandInstIdx].Current.empty())
			{
				_Instances[rHandInstIdx].Current.show();
				_Instances[rHandInstIdx].showStaticFXs();
			}
		// Left Hand
		if(lHandInstIdx <_Instances.size())
			if(!_Instances[lHandInstIdx].Current.empty())
			{
				_Instances[lHandInstIdx].Current.show();
				_Instances[lHandInstIdx].showStaticFXs();
			}
	}
}

//-----------------------------------------------
// setAnimLOD :
// Set the LOD animation.
//-----------------------------------------------
ADD_METHOD(void CCharacterCL::setAnimLOD(bool changed))
	// reset LOD animation.
	_LodCharacterAnimEnabled = false;
	// Setup new LOD animation.
	if(skeleton())
	{
		// if the entity has a lod Character
		sint lodId = skeleton()->getLodCharacterShape();
		if(lodId >= 0)
		{
			// Setup Lod anim.
			_LodCharacterAnimEnabled	= true;
			_LodCharacterMasterAnimSlot	= MOVE;
			_LodCharacterAnimTimeOffset	= 0;
			// do complex stuff only if the anim state has really changed.
			if(changed)
			{
				// get the anim state from the set.
				const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
				// if animStatePtr found.
				if(animStatePtr)
				{
					// get Lod Character animation Name from the anim state.
					const string &lodAnimName = animStatePtr->getLodCharacterAnimation();
					// Find the anim in the UScene LodCharacterManager
					sint animId = Scene->getCLodAnimIdByName(lodId, lodAnimName);
					// if Anim not found, get the "idle" anim, with the Id 0.
					if(animId < 0)
						animId = 0;
					// setup the skeleton.
					skeleton()->setLodCharacterAnimId(animId);
				}
			}
		}
	}
}// setAnimLOD //


//-----------------------------------------------
// updateAnimationState :
// \todo GUIGUI : precalculate distance to destination when receiving Stages.
// \todo GUIGUI : improve, we are setting often 'idle' to recompute orientation at the end of animation instead of doing directly the right one.
//-----------------------------------------------
ADD_METHOD(void CCharacterCL::updateAnimationState())
	// If the current state is invalid -> return.
	if(_CurrentState == 0)
		return;

	// Get the Animation Length.
	double animLength = EAM->getAnimationLength(animId(MOVE));
	// Check Anim length
	if(animOffset(MOVE) >= animLength)
	{
		// Choose the next animation.
		endAnimTransition();
	}
	// Last animation not finished check for some chances to break current animation.
	else
	{
		// Check Modes.
//		if(_IsThereAMode && (dist2Dest()==INVALID_DIST))
		{
			// Is the current mode not already the mode wanted.
			if((_Mode != _ModeWanted) && (dist2Dest()==INVALID_DIST))
			{
				if((_ModeWanted != MBEHAV::MOUNT_NORMAL && _ModeWanted != MBEHAV::MOUNT_SWIM) || (_Rider != CLFECOMMON::INVALID_SLOT))
				{
					// Is there a possible connection with the mode wanted.
					TAnimStateKey transition;
					if(_CurrentState->getModeConnection(_ModeWanted, transition))
					{
						setAnim(transition);
						return;
					}
				}
				else
				{
					//InfoLog->displayRawNL("(%d)_Rider=%d  _Mount=%d  _ModeWanted=%s  _Mode=%s  offset=%f  length=%f",_Slot,_Rider,_Mount,MBEHAV::modeToString(_ModeWanted).c_str(),MBEHAV::modeToString(_Mode).c_str(),animOffset(MOVE),animLength);
					// anti-bug : sometimes _rider is not set yet and we stay in an infinite move
					_Rider = _TheoreticalRider;
				}
			}
		}

		// Should we stop the animation once at destination.
		if(_CurrentState->BrkAtDest && dist2Dest() <= ClientCfg.DestThreshold)
		{
			_MaxLoop = false;
			setAnim(CAnimationStateSheet::Idle);
			return;
		}

		// ON MOVE
		switch(onMove(*_CurrentState))
		{
		// On Move Forward
		case OnMoveForward:
			setAnim(_CurrentState->OnMoveForward);
			return;
		// On Move Backward
		case OnMoveBackward:
			setAnim(_CurrentState->OnMoveBackward);
			return;
		// On Move Left
		case OnMoveLeft:
			setAnim(_CurrentState->OnMoveLeft);
			return;
		// On Move Right
		case OnMoveRight:
			setAnim(_CurrentState->OnMoveRight);
			return;
		default:
			break;
		}

		// ON ROTATION
		CVector tmp;
		switch(onRotation(*_CurrentState, tmp))
		{
		// Rotation Left
		case OnRotLeft:
			setAnim(CAnimationStateSheet::Idle);
			return;
		// Rotation Right
		case OnRotRight:
			setAnim(CAnimationStateSheet::Idle);
			return;
		default:
			break;
		}

		// ON BAD HEADING
		if(onBadHeading(*_CurrentState))
		{
			setAnim(CAnimationStateSheet::Idle);
			return;
		}

		// ON BIG BEND
		switch(onBigBend(*_CurrentState, tmp))
		{
		// Big Bend Left and Right
		case OnBendLeft:
		case OnBendRight:
			setAnim(_CurrentState->MoveState);
			return;
		default:
			break;
		}

		// \todo GUIGUI : changer de place cette partie je pense.
		// Adjust the direction to fit the front
		if( !(isUser() && ClientCfg.AutomaticCamera==false) )
		{
			if(_CurrentState->AdjustOri)
			{
				// Adjust before the half of the attack animation.
				const double animL = animLength/2.0;
				// Half already reatch, dir should be as the front now
				if(animOffset(MOVE) > animL)
					dir(front());
				else
				{
					double ang = computeShortestAngle(atan2(dir().y, dir().x), atan2(front().y, front().x));
					if(ang)
					{
						double ang2 = (animOffset(MOVE)/animL)*ang/animL;
						double angleZ = ang2+atan2(dir().y, dir().x);
						dir(CVector((float)cos(angleZ), (float)sin(angleZ), 0.f));
					}
				}
			}
		}
	}
}// updateAnimationState //

//-----------------------------------------------
// computeMotion :
//-----------------------------------------------
ADD_METHOD(double CCharacterCL::computeMotion(const double &oldMovingTimeOffset, TAnimationType channel) const)
	H_AUTO_USE ( RZ_Client_Entity_CL_Update_Pos_Compute_Motion )

	// Check the state is valid.
	if(_CurrentState == 0)
		return 0.0;

	// Calculate movement for given animation segment.
	if(_CurrentState->Move)
	{
		// Animation is unknown, no move in it.
		if(animIndex(channel) == CAnimation::UnknownAnim)
			return 0.0;

		CVector	oldPos, newPos;
		uint animID = animId(channel);
		if(EAM->interpolate(animID, oldMovingTimeOffset, oldPos))
		{
			if(EAM->interpolate(animID, animOffset(channel), newPos))
			{
				CVector mov = newPos - oldPos;
				// Scale it by the CharacterScalePos, if needed, according to the animation.
				bool mustApplyCharacterScalePosFactor = true;
				const CAnimationState *animStatePtr = _CurrentAnimSet[channel]->getAnimationState(animState(channel));
				if(animStatePtr)
				{
					const CAnimation *anim = animStatePtr->getAnimation(animIndex(channel));
					if(anim)
						mustApplyCharacterScalePosFactor = anim->applyCharacterScalePosFactor();
				}
				// scale it according to the species.
				if(mustApplyCharacterScalePosFactor)
					mov*= _CharacterScalePos;
				// Scale according to the gabarit.
				mov *= _CustomScalePos;
				// Return a significant move.
				double distDone = mov.norm();
				if(distDone>0.0 && distDone<ClientCfg.SignificantDist)
					distDone = ClientCfg.SignificantDist;
				return distDone;
			}
		}

		// Miss the position's track.
		nlwarning("CCharacterCL::computeMotion : Animation should have a track for the position.");
		return 0.0;
	}
	// The animation is not one to move.
	else
		return 0.0;
}// computeMotion //

//-----------------------------------------------
// beginCast :
//-----------------------------------------------
void CCharacterCL::beginCast(const MBEHAV::CBehaviour &behaviour)
{
	// if the player has a target, force him to face this target
	CEntityCL *target = EntitiesMngr.entity(targetSlot());
	if(target && !target->isUser() )
	{
		CVectorD dirToTarget = target->pos() - pos();
		dirToTarget.z = 0;
		dirToTarget.normalize();
		front( dirToTarget );
		dir( dirToTarget );
	}

	switch(behaviour.Behaviour)
	{
	////////////////
	// BEGIN CAST //
	// OFFENSIVE CAST BEGIN
	case MBEHAV::CAST_OFF:
		setAnim(CAnimationStateSheet::OffensiveCastInit);
		break;
	// CURATIVE CAST BEGIN
	case MBEHAV::CAST_CUR:
		setAnim(CAnimationStateSheet::CurativeCastInit);
		break;
	// MIXED CAST BEGIN
	case MBEHAV::CAST_MIX:
		setAnim(CAnimationStateSheet::MixedCastInit);
		break;
	// IDLE
	case MBEHAV::IDLE:
		setAnim(CAnimationStateSheet::Idle);
		break;
	//
	case MBEHAV::CAST_ACID:
		setAnim(CAnimationStateSheet::AcidCastInit);
		break;
	case MBEHAV::CAST_BLIND:
		setAnim(CAnimationStateSheet::BlindCastInit);
		break;
	case MBEHAV::CAST_COLD:
		setAnim(CAnimationStateSheet::ColdCastInit);
		break;
	case MBEHAV::CAST_ELEC:
		setAnim(CAnimationStateSheet::ElecCastInit);
		break;
	case MBEHAV::CAST_FEAR:
		setAnim(CAnimationStateSheet::FearCastInit);
		break;
	case MBEHAV::CAST_FIRE:
		setAnim(CAnimationStateSheet::FireCastInit);
		break;
	case MBEHAV::CAST_HEALHP:
		setAnim(CAnimationStateSheet::HealHPCastInit);
		break;
	case MBEHAV::CAST_MAD:
		setAnim(CAnimationStateSheet::MadCastInit);
		break;
	case MBEHAV::CAST_POISON:
		setAnim(CAnimationStateSheet::PoisonCastInit);
		break;
	case MBEHAV::CAST_ROOT:
		setAnim(CAnimationStateSheet::RootCastInit);
		break;
	case MBEHAV::CAST_ROT:
		setAnim(CAnimationStateSheet::RotCastInit);
		break;
	case MBEHAV::CAST_SHOCK:
		setAnim(CAnimationStateSheet::ShockCastInit);
		break;
	case MBEHAV::CAST_SLEEP:
		setAnim(CAnimationStateSheet::SleepCastInit);
		break;
	case MBEHAV::CAST_SLOW:
		setAnim(CAnimationStateSheet::SlowCastInit);
		break;
	case MBEHAV::CAST_STUN:
		setAnim(CAnimationStateSheet::StunCastInit);
		break;
	default:
		break;
	}
}// beginCast //

//-----------------------------------------------
// endCast :
//-----------------------------------------------
void CCharacterCL::endCast(const MBEHAV::CBehaviour &behaviour, const MBEHAV::CBehaviour &lastBehaviour)
{
	if( !(isUser() && isSit()) )
	{
		switch(lastBehaviour.Behaviour)
		{
		case MBEHAV::CAST_ACID:
			setAnim(CAnimationStateSheet::AcidCastEnd);
			break;
		case MBEHAV::CAST_BLIND:
			setAnim(CAnimationStateSheet::BlindCastEnd);
			break;
		case MBEHAV::CAST_COLD:
			setAnim(CAnimationStateSheet::ColdCastEnd);
			break;
		case MBEHAV::CAST_ELEC:
			setAnim(CAnimationStateSheet::ElecCastEnd);
			break;
		case MBEHAV::CAST_FEAR:
			setAnim(CAnimationStateSheet::FearCastEnd);
			break;
		case MBEHAV::CAST_FIRE:
			setAnim(CAnimationStateSheet::FireCastEnd);
			break;
		case MBEHAV::CAST_HEALHP:
			setAnim(CAnimationStateSheet::HealHPCastEnd);
			break;
		case MBEHAV::CAST_MAD:
			setAnim(CAnimationStateSheet::MadCastEnd);
			break;
		case MBEHAV::CAST_POISON:
			setAnim(CAnimationStateSheet::PoisonCastEnd);
			break;
		case MBEHAV::CAST_ROOT:
			setAnim(CAnimationStateSheet::RootCastEnd);
			break;
		case MBEHAV::CAST_ROT:
			setAnim(CAnimationStateSheet::RotCastEnd);
			break;
		case MBEHAV::CAST_SHOCK:
			setAnim(CAnimationStateSheet::ShockCastEnd);
			break;
		case MBEHAV::CAST_SLEEP:
			setAnim(CAnimationStateSheet::SleepCastEnd);
			break;
		case MBEHAV::CAST_SLOW:
			setAnim(CAnimationStateSheet::SlowCastEnd);
			break;
		case MBEHAV::CAST_STUN:
			setAnim(CAnimationStateSheet::StunCastEnd);
			break;
		case MBEHAV::IDLE:
			setAnim(CAnimationStateSheet::Idle);
			break;
		// Old One
		default:
			{
				switch(behaviour.Behaviour)
				{
					//////////////
					// END CAST //
					// OFFENSIVE CAST END
				case MBEHAV::CAST_OFF_FAIL:
					setAnim(CAnimationStateSheet::OffensiveCastFail);
					break;
				case MBEHAV::CAST_OFF_FUMBLE:
					setAnim(CAnimationStateSheet::OffensiveCastFumble);
					break;
				case MBEHAV::CAST_OFF_SUCCESS:
					setAnim(CAnimationStateSheet::OffensiveCastSuccess);
					break;
				case MBEHAV::CAST_OFF_LINK:
					setAnim(CAnimationStateSheet::OffensiveCastLink);
					break;
					// CURATIVE CAST END
				case MBEHAV::CAST_CUR_FAIL:
					setAnim(CAnimationStateSheet::CurativeCastFail);
					break;
				case MBEHAV::CAST_CUR_FUMBLE:
					setAnim(CAnimationStateSheet::CurativeCastFumble);
					break;
				case MBEHAV::CAST_CUR_SUCCESS:
					setAnim(CAnimationStateSheet::CurativeCastSuccess);
					break;
				case MBEHAV::CAST_CUR_LINK:
					setAnim(CAnimationStateSheet::CurativeCastLink);
					break;
					// MIXED CAST END
				case MBEHAV::CAST_MIX_FAIL:
					setAnim(CAnimationStateSheet::MixedCastFail);
					break;
				case MBEHAV::CAST_MIX_FUMBLE:
					setAnim(CAnimationStateSheet::MixedCastFumble);
					break;
				case MBEHAV::CAST_MIX_SUCCESS:
					setAnim(CAnimationStateSheet::MixedCastSuccess);
					break;
				case MBEHAV::CAST_MIX_LINK:
					setAnim(CAnimationStateSheet::MixedCastLink);
					break;
				default:
					break;
				}
			}
			break;
		}
	}
}// endCast //


// *************************************************************************************************
void CCharacterCL::updateCurrentAttack()
{
	// This is a behaviour for the magic.
	if(_CurrentBehaviour.isMagic())
	{
		_CurrentAttackID.Type = CAttackIDSheet::Magic;
		_CurrentAttackID.SpellInfo.Mode = (MAGICFX::TSpellMode) _CurrentBehaviour.Spell.SpellMode;
		_CurrentAttackID.SpellInfo.ID = (MAGICFX::TMagicFx) _CurrentBehaviour.Spell.SpellId;
	}
	// This is a behaviour for the combat.
	else if(_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK)
	{
		_CurrentAttackID.Type = CAttackIDSheet::Range;
		_CurrentAttackID.RangeWeaponType = (RANGE_WEAPON_TYPE::TRangeWeaponType) _CurrentBehaviour.Range.WeaponType;
	}
	else if (_CurrentBehaviour.isCombat())
	{
		_CurrentAttackID.Type = CAttackIDSheet::Melee;
	}
	else if (_CurrentBehaviour.isCreatureAttack())
	{
		_CurrentAttackID.Type = CAttackIDSheet::Creature;
		_CurrentAttackID.CreatureAttackIndex = _CurrentBehaviour.Behaviour == MBEHAV::CREATURE_ATTACK_0 ? 0 : 1;
	}
	else
	{
		// the behaviour does not generate an attack
		_CurrentAttack = NULL;
		_CurrentAttackID.Type = CAttackIDSheet::Unknown;
		return;
	}
	_CurrentAttack = getAttack(_CurrentAttackID);
	// update current attack infos
	if(_CurrentBehaviour.isMagic())
	{
		_CurrentAttackInfo.Intensity = _CurrentBehaviour.Spell.SpellIntensity;
		// physical damge are irrelevant for magic
		_CurrentAttackInfo.DamageType = DMGTYPE::UNDEFINED;
		_CurrentAttackInfo.HitType = HITTYPE::Undefined;
		_CurrentAttackInfo.Localisation = BODY::UnknownBodyPart;
		_CurrentAttackInfo.PhysicalImpactIntensity = 0;
	}
	// This is a behaviour for the combat.
	else if(_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK)
	{
		_CurrentAttackInfo.Intensity = _CurrentBehaviour.Range.ImpactIntensity;
		_CurrentAttackInfo.DamageType = DMGTYPE::UNDEFINED;
		_CurrentAttackInfo.HitType = HITTYPE::Undefined;
		_CurrentAttackInfo.Localisation = (BODY::TBodyPart) _CurrentBehaviour.Range.Localisation;
		_CurrentAttackInfo.PhysicalImpactIntensity = 0;
	}
	else if (_CurrentBehaviour.isCombat())
	{
		_CurrentAttackInfo.Intensity = _CurrentBehaviour.Combat.ImpactIntensity;
		_CurrentAttackInfo.DamageType = (DMGTYPE::EDamageType) _CurrentBehaviour.Combat2.DamageType;
		_CurrentAttackInfo.HitType = (HITTYPE::THitType) _CurrentBehaviour.Combat.HitType;
		_CurrentAttackInfo.Localisation = (BODY::TBodyPart) _CurrentBehaviour.Combat.Localisation;
		_CurrentAttackInfo.PhysicalImpactIntensity = _CurrentBehaviour.Combat.ImpactIntensity;
	}
	else if (_CurrentBehaviour.isCreatureAttack())
	{
		// creature attack is the most general form
		_CurrentAttackInfo.Intensity = _CurrentBehaviour.CreatureAttack.MagicImpactIntensity;
		_CurrentAttackInfo.DamageType = (DMGTYPE::EDamageType) _CurrentBehaviour.CreatureAttack2.DamageType;
		_CurrentAttackInfo.HitType = (HITTYPE::THitType) _CurrentBehaviour.CreatureAttack2.HitType;
		_CurrentAttackInfo.Localisation = (BODY::TBodyPart) _CurrentBehaviour.CreatureAttack.Localisation;
		_CurrentAttackInfo.PhysicalImpactIntensity = _CurrentBehaviour.CreatureAttack.ImpactIntensity;
	}
	_CurrentAttackInfo.Side = (rand() & 1) ? BODY::Left : BODY::Right;
}


// utility function for performCurrentAttackEnd
inline static void getResistAndDistance(uint8 packedInfo, bool isDirectAttack, bool isCombat, bool &resist, uint &distance)
{
	// get the distance from attacker to defender (consider 0 if a direct attack)
	if (isDirectAttack)
		distance = 0;
	else
		distance = packedInfo & 127;
	// resisted?
	if(isCombat)
		resist= false;
	else
		resist = (packedInfo & 128) != 0;
}

// *********************************************************************************************
void CCharacterCL::performCurrentAttackEnd(const CBehaviourContext &bc, bool directOffensifSpell, vector<double> &targetHitDates, TAnimStateKey animForCombat)
{
	if (!_CurrentAttack) return;
	if (!_CurrentAttack->Sheet) return;
	if (bc.Targets.Targets.empty())
	{
		nlwarning ("No target available for current attack.");
		return;
	}
	nlassert(targetHitDates.size() == bc.Targets.Targets.size());

	CAttackInfo attackInfo = _CurrentAttackInfo;

	const CAttackSheet &sheet = *_CurrentAttack->Sheet;


	// should cast FX for static Objects like towers be used ?
	bool usesStaticCastFX = _Sheet && !_Sheet->ProjectileCastRay.empty();

	CProjectileBuild pb;


	// ray of cast for static object with several cast points
	CVector castWorldOrigin;
	CVector castWorldPos;
	CVector additionnalOffset = NLMISC::CVector::Null;
	bool castRayValid = false;
	uint mainCastFXIntensity = attackInfo.Intensity;


	// *** Compute castStartTime (time at which the projectile is casted)

	// *** Compute castStartTime (time at which the projectile is casted)

	float delay = 0.f; // by default, no delay before impact
	double timeFactor = 1;

	// Combat (range or melee) => no resist (yoyo: legacy code. Actually the server should set the resist bit to 0 in Target.Info)
	bool isCombat= _CurrentBehaviour.isCombat();

	// An attack is said 'direct' when no projectile is casted (Generally those are melee attack, but also pistol range attack for instance)
	// In this case, all targets are hit at the same time, no matter what date is supplied for them.
	bool isDirectAttack = sheet.ProjectileFX.empty();

	if (isDirectAttack)
	{
		///////////////////
		// DIRECT ATTACK //
		///////////////////
		// compute impact date. It is given by the trigger on right hand in the animation
		// Get the current animation id.
		if (sheet.ForceUseProjectileDelay)
		{
			delay = sheet.ProjectileDelay;
		}
		else
		if (!directOffensifSpell)
		{
			if ((_CurrentAttackID.Type != CAttackIDSheet::Range) && (_PlayList != NULL))
			{
				// default
				delay= 0.5f;
				// if the animation has been correctly chosen
				if(animForCombat!=CAnimationStateSheet::UnknownState)
				{
					// try to get the MeleeImpactDelay that is stored in the sheet (given by graphists)
					const CAnimationSet	*animSet= currentAnimSet()[MOVE];
					if(animSet)
					{
						const CAnimationState *animState  = animSet->getAnimationState(animForCombat);
						if(animState)
							delay= animState->getMeleeImpactDelay();
					}
				}
			}
			else
			{
				// see if weapon is known, and in this case, delay the impact by the same amount
				const CItemSheet *sheet = _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet;
				if (sheet) delay = sheet->FX.ImpactFXDelay;
			}
		}
		// all target are reached at the same time
		timeFactor = 0;
	}
	else
	{
		// there's a projectile
		if (usesStaticCastFX)
		{
			delay = sheet.StaticObjectProjectileDelay;
		}
		else
		{
			if (!directOffensifSpell)
			{
				// if object has a list of cast rays, then we assume it is a static object (like guard towers)
				// projectile cast from a character
				delay = sheet.ProjectileDelay;
			}
		}
	}

	// then castStartTime is just start of behav + animation delay
	double	castStartTime;
	// Special for direct attack. because of lag sometimes behavTime<TimeInSec, which results
	// on too early played hits regarding animation played
	if(isDirectAttack)
	{
		// start at max(behavTime, TimeInSec), but with a limit of bc.BehavTime+0.5 sec
		if(TimeInSec > bc.BehavTime+0.5)
			castStartTime= bc.BehavTime + 0.5;
		else if(TimeInSec > bc.BehavTime)
			castStartTime= TimeInSec;
		else
			castStartTime= bc.BehavTime;
		// add the delay
		castStartTime+= delay;
	}
	else
	{
		// In case of magic or range (with projectile), this is not required because the projectilemanager should take cares of
		// cast start time and current time (and therfore advance the projectile if required)
		castStartTime= bc.BehavTime + delay;
	}

	// *** Casts projectiles and Impacts
	bool resist;
	uint distance;
	// there's a projectile
	switch(sheet.ProjectileMode)
	{
		// TODO: homin code for projectile look quite similar, maybe can merge ?
		case MAGICFX::Bomb:
		{
			getResistAndDistance(bc.Targets.Targets[0].Info, isDirectAttack, isCombat, resist, distance);
			double mainStartDate = castStartTime;
			double mainEndDate = mainStartDate + timeFactor * double(distance * MULTI_TARGET_DISTANCE_UNIT / MAGICFX::PROJECTILE_SPEED);
			CCharacterCL *mainTarget = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(bc.Targets.Targets[0].TargetSlot));
			if (mainTarget)
			{
				computeTargetStickMode(*_CurrentAttack->Sheet, attackInfo, pb.ProjectileAimingPoint, *mainTarget);
				if (usesStaticCastFX)
				{
					// compute the cast pos
					computeBestCastRay(*mainTarget, pb.ProjectileAimingPoint, castWorldOrigin, castWorldPos, additionnalOffset);
					castRayValid = true;
				}

				// the target hit date
				targetHitDates[0]= mainEndDate;

				// Add the projectile to queue
				if (createCurrentAttackEndPart(pb,
					                           _CurrentAttack,
											   *mainTarget,
											   NULL,
											   mainStartDate,
											   mainEndDate,
											   true,
											   sheet.PlayImpactAnim,
											   resist,
											   sheet.IsImpactLocalised,
											   attackInfo,
											   additionnalOffset
											  ))
				{
					CProjectileManager::getInstance().addProjectileToQueue(pb);

				}
				attackInfo.Intensity = attackInfo.Intensity != 0 ? 1 : 0;
				attackInfo.PhysicalImpactIntensity =  attackInfo.PhysicalImpactIntensity != 0 ? 1 : 0;
				// all subsequent projectiles are casted from the secondary target, from the first impact point, and have level 1
				for(uint k = 1; k < bc.Targets.Targets.size(); ++k)
				{
					getResistAndDistance(bc.Targets.Targets[k].Info, isDirectAttack, isCombat, resist, distance);
					double secondaryEndDate = mainEndDate + timeFactor * ((double) (distance * MULTI_TARGET_DISTANCE_UNIT / MAGICFX::PROJECTILE_SPEED));
					CCharacterCL *secondaryTarget = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(bc.Targets.Targets[k].TargetSlot));
					if (secondaryTarget)
					{
						// the target hit date
						targetHitDates[k]= secondaryEndDate;

						// Add the projectile to queue
						if (mainTarget->createCurrentAttackEndPart(pb,
							                                       _CurrentAttack,
																   *secondaryTarget,
																   &pb.ProjectileAimingPoint,
																   mainEndDate,
																   secondaryEndDate,
																   k != 0 ? !sheet.PlayImpactFXOnlyOnMainTarget : true,
																   sheet.PlayImpactAnim,
																   resist,
																   sheet.IsImpactLocalised,
																   attackInfo
																  ))
						{
							computeTargetStickMode(*_CurrentAttack->Sheet, attackInfo, pb.ProjectileAimingPoint, *secondaryTarget);
							CProjectileManager::getInstance().addProjectileToQueue(pb);
						}
					}
				}
			}
		}
		break;
		case MAGICFX::Chain:
		{
			double currDate = castStartTime;
			CCharacterCL *currCaster = this;
			const CFXStickMode *projectileStartPoint = NULL; // by default, start at caster hand
			CFXStickMode currStickMode;
			for(uint k = 0; k < bc.Targets.Targets.size(); ++k)
			{
				if (k == 1)
				{
					// for secondary impacts, intensity is 0 or 1
					attackInfo.Intensity = attackInfo.Intensity != 0 ? 1 : 0;
					attackInfo.PhysicalImpactIntensity =  attackInfo.PhysicalImpactIntensity != 0 ? 1 : 0;
				}
				getResistAndDistance(bc.Targets.Targets[k].Info, isDirectAttack, isCombat, resist, distance);
				double nextDate = currDate + timeFactor * ((double) (distance * MULTI_TARGET_DISTANCE_UNIT / MAGICFX::PROJECTILE_SPEED));
				CCharacterCL *currTarget = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(bc.Targets.Targets[k].TargetSlot));
				if (!currTarget) break;


				computeTargetStickMode(*_CurrentAttack->Sheet, attackInfo, pb.ProjectileAimingPoint, *currTarget);


				if (k == 0 && usesStaticCastFX)
				{
					// compute the initial cast pos for objects with multiple possible cast positions
					computeBestCastRay(*currTarget, pb.ProjectileAimingPoint, castWorldOrigin, castWorldPos, additionnalOffset);
					castRayValid = true;
				}

				// the target hit date
				targetHitDates[k]= nextDate;

				// Add the projectile to queue
				if (currCaster->createCurrentAttackEndPart(pb,
														   _CurrentAttack,
														   *currTarget,
														   projectileStartPoint,
														   currDate,
														   nextDate,
														   k != 0 ? !sheet.PlayImpactFXOnlyOnMainTarget : true,
														   sheet.PlayImpactAnim,
														   resist,
														   sheet.IsImpactLocalised,
														   attackInfo,
														   k == 0 ? additionnalOffset : CVector::Null
														  ))
				{
					CProjectileManager::getInstance().addProjectileToQueue(pb);
				}
				currStickMode = pb.ProjectileAimingPoint;
				projectileStartPoint = &currStickMode;
				currCaster = currTarget;
				if (!currCaster) break;
				currDate = nextDate;
			}
		}
		break;
		case MAGICFX::Spray:
		{
			for(uint k = 0; k < bc.Targets.Targets.size(); ++k)
			{
				getResistAndDistance(bc.Targets.Targets[k].Info, isDirectAttack, isCombat, resist, distance);
				double startDate = castStartTime;
				double endDate = startDate + timeFactor * ((double) (distance * MULTI_TARGET_DISTANCE_UNIT / MAGICFX::PROJECTILE_SPEED));
				CCharacterCL *currTarget = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(bc.Targets.Targets[k].TargetSlot));
				if (k == 1)
				{
					// for secondary impacts, intensity is 0 or 1
					attackInfo.Intensity = attackInfo.Intensity != 0 ? 1 : 0;
					attackInfo.PhysicalImpactIntensity =  attackInfo.PhysicalImpactIntensity != 0 ? 1 : 0;
				}
				if (currTarget)
				{
					computeTargetStickMode(*_CurrentAttack->Sheet, attackInfo, pb.ProjectileAimingPoint, *currTarget);
					if (k == 0 && usesStaticCastFX)
					{
						// compute the initial cast pos for objects with multiple possible cast positions
						computeBestCastRay(*currTarget, pb.ProjectileAimingPoint, castWorldOrigin, castWorldPos, additionnalOffset);
						castRayValid = true;
					}

					// the target hit date
					targetHitDates[k]= endDate;

					// nb : only main target display the spell with full power
					if (createCurrentAttackEndPart(pb,
						                           _CurrentAttack,
												   *currTarget,
												   NULL,
												   startDate,
												   endDate,
												   k != 0 ? !sheet.PlayImpactFXOnlyOnMainTarget : true,
												   sheet.PlayImpactAnim,
												   resist,
												   sheet.IsImpactLocalised,
												   attackInfo,
												   k == 0 ? additionnalOffset : CVector::Null
												  ))
					{
						CProjectileManager::getInstance().addProjectileToQueue(pb);
					}
				}
			}
		}
		break;
		default:
		break;
	}

	// if object has a list of cast rays, then we assume it is a static object (like guard towers)
	if (usesStaticCastFX && castRayValid)
	{
		buildStaticObjectCastFX(castWorldOrigin, castWorldPos, *_CurrentAttack->Sheet, mainCastFXIntensity);
	}


	// *** Play damage shields when melee attack is done
	/*
	// TODO: to finalize (server code not done).
	if (ClientCfg.DamageShieldEnabled && _CurrentBehaviour.isCombat() && _CurrentBehaviour.todoNotRange())
	{
		for(uint k = 0; k < bc.Targets.Targets.size(); ++k)
		{
			uint power = bc.Targets.Targets[k].Info & 7;
			if (power)
			{
				uint dmType = bc.Targets.Targets[k].Info >> 3;
				//
				CAttackIDSheet damageShieldID;
				damageShieldID.Type = CAttackIDSheet::DamageShield;
				damageShieldID.DamageShieldType = dmType;
				CCharacterCL *currTarget = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(bc.Targets.Targets[k].TargetSlot));
				if (!currTarget) continue;
				const CAttack *damageShieldReaction = currTarget->getAttack(damageShieldID);
				if (!damageShieldReaction) continue;
				CAttackInfo attackInfo;
				attackInfo.Intensity = power;
				attackInfo.PhysicalImpactIntensity = 0;
				attackInfo.Localisation = BODY::UnknownBodyPart;
				// no physical part
				const CAttackSheet &damageShieldSheet = *damageShieldReaction->Sheet;
				computeTargetStickMode(damageShieldSheet, attackInfo, pb.ProjectileAimingPoint, *this);
				if (currTarget->createCurrentAttackEndPart(pb,
					                                   damageShieldReaction,
													   *this,
													   NULL,
													   castStartTime,
													   castStartTime,
													   true,
													   damageShieldSheet.PlayImpactAnim,
													   false,
													   false,
													   attackInfo))
				{
					// play "CastEnd" at the good date (if any ...)
					pb.CastAspect = &damageShieldReaction->AttackEndFX;
					pb.CastPower = power;
					pb.ForcePlayImpact = true;
					CProjectileManager::getInstance().addProjectileToQueue(pb);
				}
			}
		}
	}
	*/
}

// *********************************************************************************************
void CCharacterCL::buildStaticObjectCastFX(const NLMISC::CVector &castWorldOrigin, NLMISC::CVector &castWorldPos, const CAttackSheet &/* sheet */, uint intensity)
{
	if (intensity == 0) return;
	const float *userParams = CProjectileManager::getProjectileFXUserParams(intensity);
	// create additionnal cast fxs on the tower or other static object (if any)
	// Build lookat matrix (with respect to axis) looking from castWorldOrigin to castWorldPos
	CVector dir = castWorldPos - castWorldOrigin;
	CVector I = dir.normed();
	CVector K = (CVector::K - (I * CVector::K) * I).normed();
	CMatrix castMat;
	castMat.setPos(castWorldPos);
	castMat.setRot(I, K ^ I, K);
	CAttachedFX::CBuildInfo bi;
	CAttachedFX::CTargeterInfo ti;
	bi.StaticMatrix = &castMat;
	const CAnimationFXSet &afs =_CurrentAttack->AttackStaticObjectCastFX;
	for (uint k = 0; k < afs.FX.size(); ++k)
	{
		// if the fx is in looping mode, & the anim has already done a loop, then don't recreate it
		CAttachedFX::TSmartPtr fx = new CAttachedFX;
		bi.Sheet = &afs.FX[k];
		fx->create(*this, bi, ti);
		if (!fx->FX.empty())
		{
			if (userParams)
			{
				for(uint l = 0; l < 4; ++l)
				{
					fx->FX.setUserParam(l, userParams[l]);
				}
			}
			attachFX(fx);
		}
	}
}

// *********************************************************************************************
void CCharacterCL::computeTargetStickMode(const CAttackSheet &sheet, const CAttackInfo &attackInfo, CFXStickMode &dest, CEntityCL &target)
{
	bool hasPhysicalImpact = false;
	if (attackInfo.Localisation != BODY::UnknownBodyPart &&
		attackInfo.PhysicalImpactIntensity >= 1 &&
		attackInfo.PhysicalImpactIntensity <= MAGICFX::NUM_SPELL_POWER &&
		attackInfo.HitType != HITTYPE::Failed &&
		attackInfo.HitType != HITTYPE::Undefined &&
		attackInfo.DamageType != DMGTYPE::UNDEFINED)
	{
		hasPhysicalImpact = true;
	}

	if (sheet.IsImpactLocalised || hasPhysicalImpact)
	{
		// get projectile impact point from localisation
		// & generate stick mode
		const char *targetBoneName = target.getBoneNameFromBodyPart(attackInfo.Localisation, attackInfo.Side);
		if (targetBoneName)
		{
			if (sheet.DefaultAimingPoint.Mode == CFXStickMode::UserBoneOrientedTowardTargeter)
			{
				dest.Mode = CFXStickMode::UserBoneOrientedTowardTargeter;
			}
			else
			{
				dest.Mode = CFXStickMode::UserBone;
			}
			dest.UserBoneName = CStringMapper::map(targetBoneName);
		}
	}
	else
	{
		// use default aiming point given in sheet
		dest = sheet.DefaultAimingPoint;
	}
}


// *********************************************************************************************
bool CCharacterCL::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*/
										     )
{
	if (!currentAttack) return false;
	if (!currentAttack->Sheet) return false;


	const CAttackSheet &sheet = *currentAttack->Sheet;

	// dates
	destPB.StartDate = spawnDate;
	destPB.EndDate = hitDate;
	// choose fx for projectile
	if (attackInfo.Intensity >= 1 && attackInfo.Intensity <= MAGICFX::NUM_SPELL_POWER)
	{
		destPB.ProjectileAspect = &currentAttack->ProjectileFX;
	}
	else
	{
		destPB.ProjectileAspect = NULL;
	}
	// choose fx for impact
	if (!playImpactFX)
	{
		destPB.ImpactAspect = NULL;
	}
	else
	{
		if (attackInfo.Intensity  >= 1 && attackInfo.Intensity <= MAGICFX::NUM_SPELL_POWER) // impact has same intensity than projectile
		{
			destPB.ImpactAspect = &currentAttack->ImpactFX;
		}
		else
		{
			destPB.ImpactAspect = NULL;
		}
	}

	// FILL PROJECTILE BUILD
	destPB.AttackInfo = attackInfo;
	destPB.TargeterInfo.Slot = slot();
	//

	destPB.LocalizedImpact = sheet.IsImpactLocalised;
	// If this is a secondary projectile, it may start from another location, which is the impact point of the previous projectile
	// (so it doesn't start from the caster hand, or any around settings that is read from the spell sheet)
	if (sm) // start stickmode wanted ?
	{
		destPB.TargeterInfo.StickMode = *sm;
	}
	else
	{
		// if no stick mode is not forced, then use the one given in the  projectile sheet
		if (destPB.ProjectileAspect && !destPB.ProjectileAspect->FX.empty())
		{
			destPB.TargeterInfo.StickMode = destPB.ProjectileAspect->FX[0].Sheet->StickMode;
		}
		else
		{
			// if no projectile is given, then uses the default casting point
			destPB.TargeterInfo.StickMode = sheet.DefaultCastingPoint;
		}
	}
	destPB.Mode = sheet.ProjectileMode;
	destPB.Target.Slot = target.slot();
	destPB.TargeterInfo.StickOffset = CVector::Null;
	destPB.PlayImpactAnim = playImpactAnim;
	destPB.LetProjectileStickedOnTarget = sheet.LetProjectileStickedOnTarget;
	destPB.TargeterInfo.DefaultPos = pos().asVector();
	//
	destPB.MagicResist = magicResist;
	// offset if projectile is launched from a range weapon and projectile is sticked to box_arme
	if (destPB.TargeterInfo.StickMode.Mode == CFXStickMode::UserBone && sheet.ApplyItemOffsetToWeaponBone)
	{
		// should be fired from the 'box_arme' bone, which means it is fired from a weapon
		if (CStringMapper::unmap(destPB.TargeterInfo.StickMode.UserBoneName) == "box_arme")
		{
			NLMISC::CVector projectileOffset = NLMISC::CVector::Null;
			const CItemSheet *is = getRightHandItemSheet();
			if (is)
			{
				destPB.TargeterInfo.StickOffset = is->FX.AttackFXOffset;
			}
			destPB.TargeterInfo.StickOffset += additionnalOffset;
		}
	}
	destPB.TargeterInfo.StickOffset += sheet.AdditionnalStartOffset;
	return true;
}


// *********************************************************************************************
void CCharacterCL::computeBestCastRay(CEntityCL			 &targetEntity,
									  const CFXStickMode &targetStickMode,
									  NLMISC::CVector    &castWorldOrigin,
									  NLMISC::CVector    &castWorldPos,
									  NLMISC::CVector    &worldOffsetToCasterPivot
									 ) const
{
	// additionnal offset taken from sheet. Useful for towers that have no bones, but can fire projectiles anyway
	nlassert(_Sheet && !_Sheet->ProjectileCastRay.empty());
	// if several offsets are provided, then choose the one that has the smallest angle towards target
	CVector target;
	CProjectileManager::evalFXPosition(&targetStickMode, targetEntity, target);
	float   maxDP3 = -FLT_MAX;
	// NB : the offset is relative to object pivot, not to a bone
	CMatrix casterMatrix;
	buildAlignMatrix(casterMatrix);
	for(uint k = 0; k < _Sheet->ProjectileCastRay.size(); ++k)
	{
		CVector currCastWorldPos    = casterMatrix * _Sheet->ProjectileCastRay[k].Pos;
		CVector currCastWorldOrigin = casterMatrix * _Sheet->ProjectileCastRay[k].Origin;
		float dp3 = (target - currCastWorldPos).normed() * (currCastWorldPos - currCastWorldOrigin).normed();
		if (dp3 > maxDP3)
		{
			maxDP3 = dp3;
			worldOffsetToCasterPivot = casterMatrix.mulVector(_Sheet->ProjectileCastRay[k].Pos);
			castWorldOrigin = currCastWorldOrigin;
			castWorldPos = currCastWorldPos;
		}
	}
}

// *********************************************************************************************
bool CCharacterCL::isCurrentBehaviourAttackEnd() const
{
	switch(_CurrentBehaviour.Behaviour)
	{
		case MBEHAV::CAST_OFF_SUCCESS:
		case MBEHAV::CAST_OFF_LINK:
		case MBEHAV::CAST_CUR_SUCCESS:
		case MBEHAV::CAST_CUR_LINK:
		case MBEHAV::CAST_MIX_SUCCESS:
		case MBEHAV::CAST_MIX_LINK:
		case MBEHAV::RANGE_ATTACK:
		case MBEHAV::CREATURE_ATTACK_0:
		case MBEHAV::CREATURE_ATTACK_1:
		case MBEHAV::DEFAULT_ATTACK:
		case MBEHAV::POWERFUL_ATTACK:
		case MBEHAV::AREA_ATTACK:
			return true;
		default:
			return false;
	}
}


// ***************************************************************************
void CCharacterCL::applyBehaviourFlyingHPs(const CBehaviourContext &bc, const MBEHAV::CBehaviour &behaviour,
								 const vector<double> &targetHitDates)
{
	nlassert(targetHitDates.size()==bc.Targets.Targets.size());

	if(!bc.Targets.Targets.empty())
	{
		if(behaviour.DeltaHP != 0)
		{
			CRGBA deltaHPColor;
			// if it's a hit
			if( behaviour.DeltaHP < 0 )
			{
				// if the behaviour is casted by the user
				if( slot() == 0 )
				{
					deltaHPColor = ClientCfg.SystemInfoParams["dgm"].Color;
				}
				else
					// if the behaviour is casted by an entity that target the user
					if( targetSlot() == 0 )
					{
						CEntityCL *actor = EntitiesMngr.entity(slot());
						if( actor )
						{
							// if actor is player : use pvp color
							if( actor->isPlayer() )
								deltaHPColor = ClientCfg.SystemInfoParams["dgp"].Color;
							else
								deltaHPColor = ClientCfg.SystemInfoParams["dg"].Color;
						}
					}
					else
					{
						deltaHPColor = CRGBA(127,127,127);
					}
			}
			else
			{
				deltaHPColor = CRGBA(0,220,0);
			}

			// Set the delta HP
			for (size_t i=0; i<bc.Targets.Targets.size(); ++i)
			{
				CEntityCL *target2 = EntitiesMngr.entity(bc.Targets.Targets[i].TargetSlot);
				if(target2)
					target2->addHPOutput(behaviour.DeltaHP, deltaHPColor, float(targetHitDates[i]-TimeInSec));
			}
		}
	}
}


//-----------------------------------------------
// Apply the behaviour.
// \param behaviour : the behaviour to apply.
//-----------------------------------------------
void CCharacterCL::applyBehaviour(const CBehaviourContext &bc)	// virtual
{
	// Backup the current behaviour.
	CBehaviour previousBehaviour = _CurrentBehaviour;
	_CurrentBehaviour = bc.Behav;
	const CBehaviour &behaviour = bc.Behav;

	// check if self-target
	bool selfSpell = false;
	if (bc.Targets.Targets.size() == 1)
	{
		if (bc.Targets.Targets[0].TargetSlot == 0)
		{
			selfSpell = true;
		}
	}
	bool isOffensif;
	switch(behaviour.Behaviour)
	{
		case MBEHAV::CAST_OFF:
		case MBEHAV::CAST_OFF_FAIL:
		case MBEHAV::CAST_OFF_SUCCESS:
		case MBEHAV::CAST_OFF_LINK:
			isOffensif = true;
		break;
		default:
			isOffensif = false;
		break;
	}

	// Get a pointer on the target.
	CEntityCL *target = EntitiesMngr.entity(targetSlot());


	// ***** Choose Combat Animation to apply

	TAnimStateKey	combatAnimState= CAnimationStateSheet::UnknownState;
	bool			isMovingCombatAnimState= false;
	// if the behaviour is for combat, compute now the animation to apply
	if( !behaviour.isMagic() && ( behaviour.isCombat() || behaviour.isCreatureAttack() ) )
	{
		// Atk Animation when moving
		if(_CurrentState && _CurrentState->Move && (_CurrentState->OnAtk != CAnimationStateSheet::UnknownState))
		{
			combatAnimState= _CurrentState->OnAtk;
			isMovingCombatAnimState= true;
		}
		// Atk Animation when NOT moving
		else
		{
			// select the combat animation.
			switch(behaviour.Behaviour)
			{
			case CREATURE_ATTACK_0:
				combatAnimState= CAnimationStateSheet::Attack1;
				break;
			case CREATURE_ATTACK_1:
				combatAnimState= CAnimationStateSheet::Attack2;
				break;
			// Default Animation
			case DEFAULT_ATTACK:
				switch(getAttackHeight(target, (BODY::TBodyPart)behaviour.Combat.Localisation, BODY::Right))
				{
				// LOW
				case CCharacterCL::AtkLow:
					combatAnimState= CAnimationStateSheet::DefaultAtkLow;
					break;
				// HIGH
				case CCharacterCL::AtkHigh:
					combatAnimState= CAnimationStateSheet::DefaultAtkHigh;
					break;
				// MIDDLE or Default
				case CCharacterCL::AtkMiddle:
				default:
					combatAnimState= CAnimationStateSheet::DefaultAtkMiddle;
					break;
				}
				break;
			// Powerful Animation
			case POWERFUL_ATTACK:
				switch(getAttackHeight(target, (BODY::TBodyPart)behaviour.Combat.Localisation, BODY::Right))
				{
				// LOW
				case CCharacterCL::AtkLow:
					combatAnimState= CAnimationStateSheet::PowerfulAtkLow;
					break;
				// HIGH
				case CCharacterCL::AtkHigh:
					combatAnimState= CAnimationStateSheet::PowerfulAtkHigh;
					break;
				// MIDDLE or Default
				case CCharacterCL::AtkMiddle:
				default:
					combatAnimState= CAnimationStateSheet::PowerfulAtkMiddle;
					break;
				}
				break;
			// Area Animation
			case AREA_ATTACK:
				switch(getAttackHeight(target, (BODY::TBodyPart)behaviour.Combat.Localisation, BODY::Right))
				{
				// LOW
				case CCharacterCL::AtkLow:
					combatAnimState= CAnimationStateSheet::AreaAtkLow;
					break;
				// HIGH
				case CCharacterCL::AtkHigh:
					combatAnimState= CAnimationStateSheet::AreaAtkHigh;
					break;
				// MIDDLE or Default
				case CCharacterCL::AtkMiddle:
				default:
					combatAnimState= CAnimationStateSheet::AreaAtkMiddle;
					break;
				}
				break;
			// Range Animation
			case RANGE_ATTACK:
				combatAnimState= CAnimationStateSheet::Attack1;
				break;
			default:
				break;
			}
		}
	}


	// ***** Compute Impact delays and cast missiles

	// Default target hit dates
	static	vector<double>	targetHitDates;
	targetHitDates.clear();
	targetHitDates.resize(bc.Targets.Targets.size(), TimeInSec);

	// Update Attack Projectiles and FXs
	updateCurrentAttack();
	if (isCurrentBehaviourAttackEnd())
	{
		// retrieve target hit dates, so flying HPs have the correct ones
		performCurrentAttackEnd(bc, selfSpell && isOffensif, targetHitDates, combatAnimState);
	}

	// INFO : display some debug information.
	if((VerboseAnimUser && _Slot==0) || (VerboseAnimSelection && _Slot == UserEntity->selection()))
		nlinfo("CH:applyBeh:%d: '%d(%s)'", _Slot, behaviour.Behaviour, behaviourToString((EBehaviour)behaviour.Behaviour).c_str());


	// ***** Apply the behaviour according to type

	// This is a behaviour for the magic.
	if(behaviour.isMagic())
	{
		// Execute the magic behaviour.
		switch(behaviour.Behaviour)
		{
			////////////////
			// BEGIN CAST //
			case MBEHAV::CAST_OFF:
			case MBEHAV::CAST_CUR:
			case MBEHAV::CAST_MIX:
			case MBEHAV::CAST_ACID:
			case MBEHAV::CAST_BLIND:
			case MBEHAV::CAST_COLD:
			case MBEHAV::CAST_ELEC:
			case MBEHAV::CAST_FEAR:
			case MBEHAV::CAST_FIRE:
			case MBEHAV::CAST_HEALHP:
			case MBEHAV::CAST_MAD:
			case MBEHAV::CAST_POISON:
			case MBEHAV::CAST_ROOT:
			case MBEHAV::CAST_ROT:
			case MBEHAV::CAST_SHOCK:
			case MBEHAV::CAST_SLEEP:
			case MBEHAV::CAST_SLOW:
			case MBEHAV::CAST_STUN:
				beginCast(behaviour);
				break;
			//////////////
			// END CAST //
			case MBEHAV::CAST_OFF_FAIL:
			case MBEHAV::CAST_OFF_FUMBLE:
				if (!selfSpell) endCast(behaviour, previousBehaviour);
			break;
			case MBEHAV::CAST_OFF_SUCCESS:
			case MBEHAV::CAST_OFF_LINK:
				endCast(behaviour, previousBehaviour);
			break;
			case MBEHAV::CAST_CUR_FAIL:
			case MBEHAV::CAST_CUR_FUMBLE:
				endCast(behaviour, previousBehaviour);
			break;
			case MBEHAV::CAST_CUR_SUCCESS:
			case MBEHAV::CAST_CUR_LINK:
				endCast(behaviour, previousBehaviour);
			break;
			case MBEHAV::CAST_MIX_FAIL:
			case MBEHAV::CAST_MIX_FUMBLE:
				endCast(behaviour, previousBehaviour);
			break;
			case MBEHAV::CAST_MIX_SUCCESS:
			case MBEHAV::CAST_MIX_LINK:
				endCast(behaviour, previousBehaviour);
			break;
			default:
			break;
		}
		// DeltaHP
		applyBehaviourFlyingHPs(bc, behaviour, targetHitDates);
	}
	// This is a behaviour for the combat.
	else if(behaviour.isCombat() || behaviour.isCreatureAttack())
	{
		float frontYawBefore = 0.f;
		float frontYawAfter = 0.f;

		// Atk Animation when NOT moving?
		if(target && !isMovingCombatAnimState)
		{
			// orientate to target
			CVectorD dirToTarget = target->pos() - pos();
			dirToTarget.z = 0;
			dirToTarget.normalize();
			if( !(isUser() && ClientCfg.AutomaticCamera == false) )
			{
				// backup front yaw
				frontYawBefore = frontYaw();
				front( dirToTarget );
			}
			dir( dirToTarget );
		}

		// Apply the state animation chosen before
		if(combatAnimState!=CAnimationStateSheet::UnknownState)
			setAnim(combatAnimState);

		// move camera so view doesn't change
		if( isUser() && frontYawBefore != 0.f )
		{
			frontYawAfter = frontYaw();
			float deltaYaw = frontYawAfter - frontYawBefore;
			if( deltaYaw !=0 )
			{
				UserControls.appendCameraDeltaYaw(-deltaYaw);
			}
		}

		// reset yaw smoothly to center view behind user
		if( isUser() && target && !target->isUser() && ClientCfg.AutomaticCamera )
		{
			UserControls.resetSmoothCameraDeltaYaw();
		}

		// DeltaHP
		applyBehaviourFlyingHPs(bc, behaviour, targetHitDates);
	}
	// Emote
	else if(behaviour.isEmote())
	{
		if(ClientCfg.Light==false && ClientCfg.EAMEnabled)
		{
			TAnimStateId emot;
			if (EAM)
			{
				/*
				// old code : fxs attached to emotes
				uint emoteIndex = behaviour.Behaviour-EMOTE_BEGIN;
				CTextEmotListSheet *pTELS = dynamic_cast<CTextEmotListSheet*>(SheetMngr.get(CSheetId("list.text_emotes")));
				if (pTELS)
				{
					if (emoteIndex < pTELS->TextEmotList.size())
					{
						const CTextEmotListSheet::STextEmot &emot = pTELS->TextEmotList[emoteIndex];
						if (!emot.FXToSpawn.empty())
						{
							// Compute the direction Matrix
							CMatrix fxMatrix;
							CVector vi = dir() ^ CVector::K;
							CVector vk = vi ^ dir();
							fxMatrix.setRot(vi, UserEntity->dir(), vk, true);
							fxMatrix.setPos(pos().asVector() + fxMatrix.getJ() * emot.FXSpawnDist);
							FXMngr.deferFX(emot.FXToSpawn, fxMatrix, emot.FXSpawnDelay);
						}
					}
				}
				*/
				if(EAM->getEmot(behaviour.Behaviour-EMOTE_BEGIN, emot))
					setAnim(CAnimationStateSheet::Emote, emot);
				else
					nlwarning("CH:applyBeh:%d: Emot '%d' unknown.", _Slot, behaviour.Behaviour-EMOTE_BEGIN);
			}
		}
	}
	// Others
	else
	{
		switch(behaviour.Behaviour)
		{
		// Loot Begin
		case MBEHAV::LOOT_INIT:
			setAnim(CAnimationStateSheet::LootInit);
			break;
		// Loot End
		case MBEHAV::LOOT_END:
			setAnim(CAnimationStateSheet::LootEnd);
			break;
		// Prospecting Begin
		case MBEHAV::PROSPECTING:
			setAnim(CAnimationStateSheet::ProspectingInit);
			break;
		// Prospecting End
		case MBEHAV::PROSPECTING_END:
			setAnim(CAnimationStateSheet::ProspectingEnd);
			break;
		// Extracting Begin
		case MBEHAV::EXTRACTING:
			// DeltaHP
			if(target)
				if(behaviour.DeltaHP != 0)
					target->addHPOutput(behaviour.DeltaHP,CRGBA(0,220,0));
			// If receiving a new DeltaHP in the current extraction, don't reset the animation
			if ( previousBehaviour.Behaviour != _CurrentBehaviour.Behaviour )
				setAnim(CAnimationStateSheet::UseInit);
			break;
		// Extracting End
		case MBEHAV::EXTRACTING_END:
			setAnim(CAnimationStateSheet::UseEnd);
			break;
		// Care Begin
		case MBEHAV::CARE:
			setAnim(CAnimationStateSheet::CareInit);
			break;
		// Care End
		case MBEHAV::CARE_END:
			setAnim(CAnimationStateSheet::CareEnd);
			break;

		// Begin to use a tool
		case MBEHAV::HARVESTING:
		case MBEHAV::FABER:
		case MBEHAV::REPAIR:
		case MBEHAV::REFINE:
		case MBEHAV::TRAINING:
			setAnim(CAnimationStateSheet::UseInit);
			break;

		// End to use a tool
		case MBEHAV::HARVESTING_END:
		case MBEHAV::FABER_END:
		case MBEHAV::REPAIR_END:
		case MBEHAV::REFINE_END:
		case MBEHAV::TRAINING_END:
			setAnim(CAnimationStateSheet::UseEnd);
			break;

		// Begin Stun
		case MBEHAV::STUNNED:
			setAnim(CAnimationStateSheet::StunBegin);
			break;

		// End Stun
		case MBEHAV::STUN_END:
			setAnim(CAnimationStateSheet::StunEnd);
			break;

		// Idle
		case IDLE:
			break;

		// Unknown behaviour -> idle.
		case UNKNOWN_BEHAVIOUR:
		default:
			nlwarning("CH::computeBehaviour : Entity in slot %d has an unknown behaviour %d to manage.", _Slot, (sint)behaviour.Behaviour);
			break;
		}
	}
}// computeBehaviour //

//-----------------------------------------------
// impact :
// 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
//-----------------------------------------------
void CCharacterCL::impact(uint /* impactType */, uint type, uint id, uint intensity)	// virtual
{
	// Display Magic Debug Infos
	if(Verbose & VerboseMagic)
		nlinfo("CH:impact:%d: type: %d, id: %d, intensity: %d", _Slot, type, id, intensity);
	// No Intensity -> No Impact
	if(intensity==0)
		return;
	// Invalid Intensity -> No Impact
	else if(intensity>5)
	{
		nlwarning("CH:impact:%d: invalid intensity %u", _Slot, intensity);
		return;
	}
	// RESIST : temp until resist is in the enum.
	if(type==0)
	{
		// Create the FX
		NL3D::UInstance resistFX = Scene->createInstance("Sp_Resist_Lev5.ps");
		if(!resistFX.empty())
			resistFX.setPos(pos());
		return;
	}
	// Compute the impact name
	string impact;
	if(id < ClientCfg.OffImpactFX.size())
		impact = ClientCfg.OffImpactFX[id];
	// Create the FX
	if(!impact.empty())
	{

		NL3D::UInstance impactFX = Scene->createInstance(impact);
		if(!impactFX.empty())
		{
			impactFX.setPos(pos());
			UParticleSystemInstance instFX;
			instFX.cast (impactFX);
			if(!instFX.empty())
			{
				// UserParam  |  Intensity 1  |  Intensity 2  |  Intensity 3  |  Intensity 4  |  Intensity 5
				//     0      |       0       |       0       |       1       |       1       |       1
				//     1      |       0       |       1       |       1       |       1       |       1
				//     2      |       0       |       0       |       0       |       1       |       1
				//     3      |       0       |       0       |       0       |       0       |       1
				float userParam0 = 0.0f;
				float userParam1 = 0.0f;
				float userParam2 = 0.0f;
				float userParam3 = 0.0f;
				// WARNING : there is no break and this is correct.
				switch(intensity)
				{
				case 5:
					userParam3 = 1.0f;
				case 4:
					userParam2 = 1.0f;
				case 3:
					userParam0 = 1.0f;
				case 2:
					userParam1 = 1.0f;
				}
				instFX.setUserParam(0, userParam0);
				instFX.setUserParam(1, userParam1);
				instFX.setUserParam(2, userParam2);
				instFX.setUserParam(3, userParam3);
			}
		}
	}
}// impact //

//-----------------------------------------------
// meleeImpact ::
//-----------------------------------------------
void CCharacterCL::meleeImpact(const CAttackInfo &attack)
{
	if (_Skeleton.empty()) return;
	if (attack.PhysicalImpactIntensity < 1 || attack.PhysicalImpactIntensity > 5) return;
	if (attack.HitType == HITTYPE::Failed) return;
	const char *boneName = getBoneNameFromBodyPart(attack.Localisation, attack.Side);
	if (!boneName) return;
	sint boneId = _Skeleton.getBoneIdByName(std::string(boneName));
	if (boneId == -1) return;
	if (!Scene) return;
	// choose good fx depending on the kind of damage
	NL3D::UInstance instance;
	switch(attack.DamageType)
	{
		case DMGTYPE::BLUNT:    instance = Scene->createInstance("mel_impactblunt.ps"); break;
		case DMGTYPE::SLASHING: instance = Scene->createInstance("mel_impactslashing.ps"); break;
		case DMGTYPE::PIERCING: instance = Scene->createInstance("mel_impactpiercing.ps"); break;
		default:
			return; // other types not supported
		break;
	}
	if (instance.empty()) return;
	UParticleSystemInstance impact;
	impact.cast (instance);
	if (impact.empty())
	{
		Scene->deleteInstance(instance);
		return;
	}
	// the 2 first user params of the fx are used to modulate intensity
	static const float intensityUP[5][2] =
	{
		{ 0.f,  0.f},
		{ 0.f,  0.5f},
		{ 0.5f, 0.5f},
		{ 0.5f, 1.f},
		{ 1.f,  1.f}
	};
	impact.setUserParam(0, intensityUP[attack.PhysicalImpactIntensity - 1][0]);
	impact.setUserParam(1, intensityUP[attack.PhysicalImpactIntensity - 1][1]);
	impact.setUserParam(2, (attack.HitType == HITTYPE::CriticalHit || attack.HitType == HITTYPE::CriticalHitResidual) ? 1.f : 0.f);
	impact.setUserParam(3, (attack.HitType == HITTYPE::HitResidual || attack.HitType == HITTYPE::CriticalHitResidual) ? 1.f : 0.f);
	//
	_Skeleton.stickObject(impact, boneId);
	// delegate managment of the impact to the fx manager
	FXMngr.fx2remove(impact);
}// meleeImpact //


//-----------------------------------------------
// magicImpact :
// Play the magic impact on the entity
// \param type : type of the impact (host/good/neutral).
// \param intensity : intensity of the impact.
//-----------------------------------------------
void CCharacterCL::magicImpact(uint type, uint intensity)	// virtual
{
	// --- FX --- //
	// Choose the FX.
	string impact;
	switch(type)
	{
	// Resist
	case 0:
		impact = "Sp_Resist_Lev";
		break;
	// Good
	case 1:
		impact = "Sp_Bien_Cure_Lev";
		break;
	// Neutral
	case 2:
		impact = "Sp_Neutre_Protect_Lev";
		break;
	// Bad
	case 3:
		impact = "Sp_Host_Hurt_Lev";
		break;
	default:
		nlwarning("CH:magicImpact:%d: Unknown type '%d'.", _Slot, type);
		return;
	}
	// Intensity
	switch(intensity)
	{
	// Too weak
	case INTENSITY_TYPE::IMPACT_NONE:
		return;

	case INTENSITY_TYPE::IMPACT_INSIGNIFICANT:
		impact += "1.ps";
		break;
	case INTENSITY_TYPE::IMPACT_VERY_WEAK:
		impact += "2.ps";
		break;
	case INTENSITY_TYPE::IMPACT_WEAK:
		impact += "3.ps";
		break;
	case INTENSITY_TYPE::IMPACT_AVERAGE:
		impact += "4.ps";
		break;
	case INTENSITY_TYPE::IMPACT_STRONG:
		impact += "5.ps";
		break;

	// Unknown
	default:
		nlwarning("CH:magicImpact:%d: Unknown intensity '%d'.", _Slot, intensity);
	}
	// Create the FX
	if(!impact.empty())
	{
		NL3D::UInstance resistFX = Scene->createInstance(impact);
		if(!resistFX.empty())
			resistFX.setPos(pos());
	}
}// resist //


//-----------------------------------------------
// getMaxSpeed :
// Return the basic max speed for the entity in meter per sec
//-----------------------------------------------
double CCharacterCL::getMaxSpeed()	const // virtual
{
	return _Sheet->MaxSpeed;
}// getMaxSpeed //


//-----------------------------------------------
// mode :
// Method called to change the mode (Combat/Mount/etc.).
//-----------------------------------------------
bool CCharacterCL::mode(MBEHAV::EMode m)
{
	// DEBUG INFOS
	if(VerboseAnimSelection && _Slot == UserEntity->selection())
	{
		nlinfo("CH::mode:%d: m'%s(%d)', _ModeWanted'%s(%d)', _Mode'%s(%d)'", _Slot,
			MBEHAV::modeToString(m          ).c_str(), m,
			MBEHAV::modeToString(_ModeWanted).c_str(), _ModeWanted,
			MBEHAV::modeToString(_Mode      ).c_str(), _Mode);
	}
	// Is the mode wanted valid ?
	if(m == MBEHAV::UNKNOWN_MODE || m >= MBEHAV::NUMBER_OF_MODES)
	{
		nlwarning("CH::mode:%d: Invalid Mode Wanted '%s(%d)' -> keep '%s(%d)'.",
			_Slot, MBEHAV::modeToString(m).c_str(), m, MBEHAV::modeToString(_Mode).c_str(), _Mode);
		return false;
	}
	// Set the mode wanted.
	_ModeWanted = m;
	if(_CurrentState == 0)
		_Mode = _ModeWanted;
	return true;
}// mode //


//-----------------------------------------------
// applyStage :
// Apply stage modifications.
// \todo GUIGUI ; ameliorer gestion mode.
//-----------------------------------------------
bool CCharacterCL::applyStage(CStage &stage)
{
	bool stageDone = true;

	// If the Stage has a position, backup the position and the stage time.
	if(stage.getPos(_OldPos))
	{
		// Backup the time
		_OldPosTime = stage.time();
		// Remove the property.
		stage.removeProperty(PROPERTY_POSX);
		stage.removeProperty(PROPERTY_POSY);
		stage.removeProperty(PROPERTY_POSZ);
	}

	// Apply orientation.
	pair<bool, sint64> resultTeta = stage.property(PROPERTY_ORIENTATION);
	if(resultTeta.first)
	{
		float angleZ = *(float *)(&resultTeta.second);
		// server forces the entity orientation even if it cannot turn
		front(CVector((float)cos(angleZ), (float)sin(angleZ), 0.f), true, true, true);

		_TargetAngle = (float)angleZ;
		// Remove the property.
		stage.removeProperty(PROPERTY_ORIENTATION);
	}

	// Apply Mode.
	pair<bool, sint64> resultMode = stage.property(PROPERTY_MODE);
	if(resultMode.first)
	{
		// Get the mode from stage.
		uint8 mo = *(uint8 *)(&resultMode.second);
		// If the mode wanted is not the same, change the mode wanted.
		if(mo != _ModeWanted)
		{
			if(mode((MBEHAV::EMode)mo))
			{
				//stageDone = false;
				if(_Mode != _ModeWanted)
					stageDone = false;
				else
					stage.removeProperty(PROPERTY_MODE);
			}
			else
				stage.removeProperty(PROPERTY_MODE);
		}
		// If the mode wanted is not the same as the current mode -> Stage not done.
		else if(_Mode != _ModeWanted)
			stageDone = false;
		// Property applied -> Remove the property form stage.
		else
			stage.removeProperty(PROPERTY_MODE);
	}

	// Apply Behaviour.
	pair<bool, sint64> resultBehaviour = stage.property(PROPERTY_BEHAVIOUR);
	if(resultBehaviour.first)
	{
		CBehaviourContext bc;
		bc.Behav     = CBehaviour(resultBehaviour.second);
		bc.BehavTime = stage.time();
		// See if there's a list of target associated with that behaviour (for multitarget spells)
		uint64 spellTarget[4];
		uint numTargets = 0;
		for(uint k = 0; k < 4; ++k)
		{
			pair<bool, sint64> stProp = stage.property(PROPERTY_TARGET_LIST_0 + k);
			if (!stProp.first) break;
			spellTarget[k] = (uint64) stProp.second;
			++ numTargets;
			stage.removeProperty(PROPERTY_TARGET_LIST_0 + k);
		}

		if (numTargets > 0)
		{
			// get the list of targets from the visual properties
			bc.Targets.unpack(spellTarget, numTargets);
		}
		// Compute the beheviour.

		applyBehaviour(bc);
		// Remove the property.
		stage.removeProperty(PROPERTY_BEHAVIOUR);
	}

	// Apply the target.
	pair<bool, sint64> resultTarget = stage.property(PROPERTY_TARGET_ID);
	if(resultTarget.first)
	{
		// Change the entity target.
		targetSlot((CLFECOMMON::TCLEntityId)resultTarget.second);
		// Remove the property.
		stage.removeProperty(PROPERTY_TARGET_ID);
	}

	// The Mount
	pair<bool, sint64> resultParent = stage.property(CLFECOMMON::PROPERTY_ENTITY_MOUNTED_ID);
	if(resultParent.first)
	{
		_Mount = (CLFECOMMON::TCLEntityId)resultParent.second;

		// Remove the property.
		stage.removeProperty(CLFECOMMON::PROPERTY_ENTITY_MOUNTED_ID);
	}

	// The Rider
	pair<bool, sint64> resultRider = stage.property(CLFECOMMON::PROPERTY_RIDER_ENTITY_ID);
	if(resultRider.first)
	{
		_Rider = (CLFECOMMON::TCLEntityId)resultRider.second;

		// Remove the property.
		stage.removeProperty(CLFECOMMON::PROPERTY_RIDER_ENTITY_ID);
	}

	// visual fxs : links and auras
	pair<bool, sint64> resultVisualFX = stage.property(CLFECOMMON::PROPERTY_VISUAL_FX);
	if (resultVisualFX.first)
	{
		applyVisualFX(resultVisualFX.second);
		stage.removeProperty(CLFECOMMON::PROPERTY_VISUAL_FX);
	}


	return stageDone;
}// applyStage //

//-----------------------------------------------
// applyCurrentStage :
// Apply The Current Stage (first stage).
//-----------------------------------------------
bool CCharacterCL::applyCurrentStage()
{
	bool bRet = true;

	CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
	if(it != _Stages._StageSet.end())
	{
		// Apply the Stage and remove it if stage done.
		if(applyStage((*it).second))
			_Stages._StageSet.erase(it);
		else
			bRet = false;
	}
	else
		nlwarning("CCharacterCL::applyCurrentStage: there is no stage.");

	// Update information from remaining stages.
	updateStages();

	return bRet;
}// applyCurrentStage //


//-----------------------------------------------
// applyAllStagesToFirstPos :
// Apply all stages to the first stage with a position.
//-----------------------------------------------
void CCharacterCL::applyAllStagesToFirstPos()
{
	CVectorD stagePos;
	CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
	while(it != _Stages._StageSet.end() && !(*it).second.getPos(stagePos))
	{
		// Apply the Stage.
		if(!applyStage((*it).second))
		{
			updateStages();
			return;
		}

		// Backup the iterator to remove
		CStageSet::TStageSet::iterator itTmp = it;
		// Next Stage.
		++it;
		// Remove the stage done.
		_Stages._StageSet.erase(itTmp);
	}

	// Apply the stage with the position.
	if(it != _Stages._StageSet.end())
	{
		// Apply the Stage.
		if(applyStage((*it).second))
			// Remove the stage done.
			_Stages._StageSet.erase(it);
	}
	else
		nlwarning("CH:applyAllStagesToFirstPos:%d: There is no stage with a position.", _Slot);

	// Upate information from remaining stages.
	updateStages();
}// applyAllStagesToFirstPos //


//-----------------------------------------------
// playToEndAnim :
// Play the time step for the loop and truncate to End Anim if Time Step too big.
//-----------------------------------------------
ADD_METHOD(void CCharacterCL::playToEndAnim(const double &startTimeOffset, double &length))
	// Average Speed
	double speedToDest = speed();
	// Blend Walk/Run
	if(ClientCfg.BlendForward && (animState(MOVE) == CAnimationStateSheet::Walk))
	{
		uint animWalkId = animId(MOVE);
		uint animRunId  = animId(MOVE_BLEND_OUT);
		double animWalkSpeed = EAM->getAnimationAverageSpeed(animWalkId)*getSheetScale()*_CustomScalePos*_CharacterScalePos;
		double animRunSpeed  = EAM->getAnimationAverageSpeed(animRunId)*getSheetScale()*_CustomScalePos*_CharacterScalePos;
		if(animWalkSpeed<=animRunSpeed)
		{
			double startTimeOffRun = animOffset(MOVE_BLEND_OUT);
			double animWalkLength = EAM->getAnimationLength(animWalkId);
			double animRunLength  = EAM->getAnimationLength(animRunId);
			// Current Speed <= Walk Speed, so use the walk animation only.
			if(speed() <= animWalkSpeed)
			{
				runFactor(0.0);
				double speedFactor = speed()/animWalkSpeed;
				double animTimeOffWalk = animOffset(MOVE) + length*speedFactor;
				if(animTimeOffWalk > animWalkLength)
				{
					animOffset(MOVE,           animWalkLength);
					animOffset(MOVE_BLEND_OUT, animRunLength);
					length = (animWalkLength - startTimeOffset) / speedFactor;
				}
				// Adjust Time Offset for the Run Channel
				else
				{
					animOffset(MOVE,           animTimeOffWalk);
					animOffset(MOVE_BLEND_OUT, animRunLength*(animTimeOffWalk/animWalkLength));
				}
			}
			// Current Speed >= Run Speed, so use the run animation only.
			else if(speed() >= animRunSpeed)
			{
				runFactor(1.0);
				double speedFactor = speed()/animRunSpeed;
				double animTimeOffRun = animOffset(MOVE_BLEND_OUT) + length*speedFactor;
				if(animTimeOffRun > animRunLength)
				{
					animOffset(MOVE,           animWalkLength);
					animOffset(MOVE_BLEND_OUT, animRunLength);
					length = (animRunLength - startTimeOffRun) / speedFactor;
				}
				// Adjust Time Offset for the Walk Channel
				else
				{
					animOffset(MOVE,           animWalkLength*(animTimeOffRun/animRunLength));
					animOffset(MOVE_BLEND_OUT, animTimeOffRun);
				}
			}
			// Current Speed > Walk Speed & < Run Speed, so mix Walk and Run animation.
			else
			{
				double t1 = animRunSpeed-animWalkSpeed;
				double t2 =      speed()-animWalkSpeed;
				runFactor(t2/t1);
				double mixLength = runFactor()*animRunLength + (1.0-runFactor())*animWalkLength;
				double animTimeOffWalk = animOffset(MOVE) + animWalkLength/mixLength*length;
				if(animTimeOffWalk > animWalkLength)
				{
					animOffset(MOVE,           animWalkLength);
					animOffset(MOVE_BLEND_OUT, animRunLength);
					length = (animWalkLength - startTimeOffset) / (animWalkLength/mixLength);
				}
				else
				{
					animOffset(MOVE,           animTimeOffWalk);
					animOffset(MOVE_BLEND_OUT, animRunLength*animTimeOffWalk/animWalkLength);	// Same percentage in the animation than the Walk one.
				}
			}
			return;
		}
		//else
			//nlwarning("playToEndAnim:%d: animWalkSpeed > animRunSpeed", _Slot);
	}
	// No Mix between Walk and Run.
	runFactor(0.0);
	// Speed Factor
	double speedFactor = computeSpeedFactor(speedToDest);
	// Compute the desired new time offset.
	double animTimeOffMove = animOffset(MOVE) + length * speedFactor;
	// Truncate animation time offset if it over-runs end of animation and change the loopTimeOffset too.
	double animationLength = EAM->getAnimationLength(animId(MOVE));
	if(animTimeOffMove > animationLength)
	{
		animOffset(MOVE, animationLength);
		length = (animationLength - startTimeOffset) / speedFactor;
	}
	else
		animOffset(MOVE, animTimeOffMove);
}// playToEndAnim //

//-----------------------------------------------
// updateStages :
// Call this method to give a time for each stage, compute distance to destination and some more information.
// \todo GUIGUI : clean up
//-----------------------------------------------
void CCharacterCL::updateStages()
{
	H_AUTO ( RZ_Client_Entity_CL_updateStages );

	_FirstPos			= INVALID_POS;	// No First Position
	_FirstTime			= INVALID_TIME;	//- No First Position
	dist2FirstPos(INVALID_DIST);		// No First Position
	_DestPos			= INVALID_POS;	// No Destination
	_DestTime			= INVALID_TIME;	// No Destination
	dist2Dest(INVALID_DIST);			// No Destination
	CVectorD posTmp		= pos();
	_IsThereAMode		= false;
	_ImportantStepTime= 0.0;


	// ***** update predicted interval: if a new pos B is found after a pos A, then the interval B-A is known!
	CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
	CStageSet::TStageSet::iterator itPosPrec= _Stages._StageSet.end();
	bool	somePosFoundEarly= false;
	while(it != _Stages._StageSet.end())
	{
		// if this stage has a position
		if(it->second.isPresent(PROPERTY_POSITION))
		{
			somePosFoundEarly= true;
			// then it's cool we can set the new accurate interval to the prec stage wich has a pos
			if(itPosPrec!=_Stages._StageSet.end())
			{
				uint dgc= it->first - itPosPrec->first;
				itPosPrec->second.predictedInterval(dgc);
			}
			// bkup
			itPosPrec= it;
		}
		it++;
	}


	// ***** Compute the current LCT Impact for this character
	// NB: used only in mode CClientConfig::StageUsePosOnlyLCT
	sint32	charLCTI;
	// If disabled, full LCT impact
	if(_StartDecreaseLCTImpact==0)
		charLCTI= 256;
	else
	{
		const	sint32	decreaseTick= 20;	// 2 seconds
		// blend according to the start of decrease
		sint32	dt= NetMngr.getCurrentServerTick() - _StartDecreaseLCTImpact;
		if(dt<=0)
			charLCTI= 256;
		else if(dt>=decreaseTick)
			charLCTI= 0;
		else
			charLCTI= ((decreaseTick-dt)*256)/decreaseTick;
		// hence, at end of blend, charLCTI is 0
	}


	// ***** Compute Stages to give them a time and get some information from those stages.
	// yoyo: use any stage with no LCT, until it is to be played AFTER a position
	bool	stageForceLCTFound= false;
	CStageSet::TStageSet::iterator itTmp;
	it = _Stages._StageSet.begin();
	while(it != _Stages._StageSet.end())
	{
		CStage &stage = (*it).second;

		// *** retrieve position in stage if any
		CVectorD	posInStage;
		bool		hasPos= stage.getPos(posInStage);
		// check the first pos is correct
		if(hasPos && dist2Dest()==INVALID_DIST)
		{
			// Compute the distance to the first position
			double distToFirst   = (CVectorD(posInStage.x, posInStage.y, 0.0) - CVectorD(          posTmp.x,           posTmp.y, 0.0)).norm();
			double distToLimiter = (CVectorD(posInStage.x, posInStage.y, 0.0) - CVectorD(_PositionLimiter.x, _PositionLimiter.y, 0.0)).norm();
			// Check if the first pos is Not the same as the current entity pos
			if((distToFirst   < ClientCfg.DestThreshold)
			|| (distToLimiter <=  ClientCfg.PositionLimiterRadius))
			{
				// The FIRST POSITION is the SAME as the CURRENT entity POSITION -> REMOVE POSITION in the stage
				stage.removeProperty(CLFECOMMON::PROPERTY_POSX);
				stage.removeProperty(CLFECOMMON::PROPERTY_POSY);
				stage.removeProperty(CLFECOMMON::PROPERTY_POSZ);
				hasPos= false;
				//
				if(VerboseAnimSelection && _Slot == UserEntity->selection())
					nlinfo("CH:updateStages:%d: Bad First, distToFirst(%f), ClientCfg.DestThreshold(%f), distToLimiter(%f), ClientCfg.PositionLimiterRadius(%f)", _Slot,
					distToFirst, ClientCfg.DestThreshold, distToLimiter, ClientCfg.PositionLimiterRadius);
			}
		}

		// stage has pos? => force LCT for it and after
		stageForceLCTFound= stageForceLCTFound || hasPos;


		// *** Compute the estimated Time for the Stage.
		// Compute difference in Game Cycle Between the current Game Cycle and the current Stage.
		sint32 t;
		if(ClientCfg.StageLCTUsage==CClientConfig::StageUseAllLCT)
			t= (*it).first - NetMngr.getCurrentClientTick();
		else if(ClientCfg.StageLCTUsage==CClientConfig::StageUseNoLCT)
			t= (*it).first - NetMngr.getCurrentServerTick();
		else
		{
			// Update LCTImpact for the stage
			if(stageForceLCTFound)
			{
				// Force full impact for stage after or including a POS
				stage.setLCTImpact(256);
			}
			else
			{
				/* minimize the LCT impact with the current char one
					Hence, if the stage had a lct impact lowered, but LCT decrease was canceled,
					the stage will keep its LCT impact
				*/
				stage.setLCTImpact(min(stage.getLCTImpact(), charLCTI));
			}

			sint32	lcti= stage.getLCTImpact();

			// if full impact
			if(lcti>=256)
				t= (*it).first - NetMngr.getCurrentClientTick();
			// if no impact
			else if(lcti<=0)
				t= (*it).first - NetMngr.getCurrentServerTick();
			// else blend
			else
			{
				sint32	twlct= (*it).first - NetMngr.getCurrentClientTick();
				sint32	twolct= (*it).first - NetMngr.getCurrentServerTick();
				t= (twlct*lcti + twolct*(256-lcti))>>8;
			}
		}
		// Compute the estimated Time for the Stage.
		stage.time( (double)(NetMngr.getMachineTimeAtTick() + t*NetMngr.getMsPerTick())/1000.0 );


		// *** Important step is used for "Panic mode" animation acceleration. skip the first stage
		if(_ImportantStepTime==0.0 && it!=_Stages._StageSet.begin())
		{
			// Important steps are ones that takes times (pos, orientation, mode, animation etc....)
			if(	stage.isPresent(PROPERTY_POSITION) ||
				stage.isPresent(PROPERTY_MODE) ||
				stage.isPresent(PROPERTY_ORIENTATION) ||
				stage.isPresent(PROPERTY_ENTITY_MOUNTED_ID) ||
				stage.isPresent(PROPERTY_RIDER_ENTITY_ID) ||
				stage.isPresent(PROPERTY_BEHAVIOUR))
				_ImportantStepTime= stage.time();
		}


		// *** Compute dist2dest (until a mode) if has pos
		if((_IsThereAMode==false) && hasPos)
		{
			// Set the destination pos and time.
			_DestPos= posInStage;
			_DestTime = stage.time() + (double)(stage.predictedInterval()*NetMngr.getMsPerTick())/1000.0;
			// Update First Pos.
			if(dist2Dest() == INVALID_DIST)
			{
				_FirstPos = _DestPos;
				_FirstTime = stage.time();
				// Compute the distance to the first position
				double distToFirst   = (CVectorD(_DestPos.x, _DestPos.y, 0.0) - CVectorD(posTmp.x,posTmp.y, 0.0)).norm();
				// Set the Distance to the Destination as the distance to the first position.
				dist2Dest(distToFirst);
				// Set the distance to First Stage.
				dist2FirstPos(distToFirst);
			}
			// Increase distance to destination.
			else
				dist2Dest(dist2Dest() + (CVectorD(_DestPos.x, _DestPos.y, 0.0) - CVectorD(posTmp.x, posTmp.y, 0.0)).norm());
			// Backup the last pos.
			posTmp = _DestPos;
		}
		// Stop if there is a mode in the stage.
		if(stage.isPresent(CLFECOMMON::PROPERTY_MODE))
			_IsThereAMode = true;


		// *** NEXT STAGE
		itTmp = it;
		++it;
		// REMOVE EMPTY STAGE (because only position and the same as the current one).
		if(stage.empty())
			_Stages._StageSet.erase(itTmp);
	}

	// If there is no mode in queue, mode wanted is the current mode
	// It must usually be the theorical one except for some mode used only by the client like SWIM
	if(!_IsThereAMode)
		_ModeWanted = _Mode;

	// ***** update _StartDecreaseLCTImpact
	// If a stage that force LCT has been found in the list
	if(stageForceLCTFound)
		// Decrease of LCT is disabled
		_StartDecreaseLCTImpact= 0;
	else if(_StartDecreaseLCTImpact==0)
		// Start to decrease LCT
		_StartDecreaseLCTImpact= NetMngr.getCurrentServerTick();


	// ***** compute _RunStartTimeNoPop (see _RunStartTimeNoPop)
	_RunStartTimeNoPop= INVALID_TIME;
	// only if have some pos in the queue
	if(somePosFoundEarly)
	{
		double	d2fp = 0.0;
		double	fpTime= INVALID_TIME;
		// if the first pos is computed, use it
		if(_FirstTime!=INVALID_TIME)
		{
			d2fp= dist2FirstPos();
			fpTime= _FirstTime;
		}
		// else try to compute the first pos, WIHTOUT regarding if there is a mode or not
		// (because even mode anim can be accelerated....)
		else
		{
			it = _Stages._StageSet.begin();
			while(it != _Stages._StageSet.end())
			{
				CStage &stage = (*it).second;
				CVectorD	firstPos;
				if(stage.getPos(firstPos))
				{
					fpTime = stage.time() + (double)(stage.predictedInterval()*NetMngr.getMsPerTick())/1000.0;
					d2fp= CVectorD(firstPos.x-pos().x, firstPos.y-pos().y, 0.0).norm();
					break;
				}
				it++;
			}
		}

		// with d2fp, fpTime, and maxSpeed, we can estimate the moment where the run should start
		if(fpTime!=INVALID_TIME)
		{
			float	maxSpeed= (float)getMaxSpeed();
			if(maxSpeed>0)
			{
				// compute at wich time the first move should begin so it doesn't have to accelerate
				_RunStartTimeNoPop= fpTime - d2fp/maxSpeed;
			}
		}
	}

}// updateStages //

//-----------------------------------------------
// beginImpact :
// 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.
//-----------------------------------------------
ADD_METHOD(bool CCharacterCL::beginImpact(NL3D::UAnimation *anim, NL3D::TAnimationTime currentTime, const std::string &triggerName, bool &isActive, float timeFactor))
	// Is the impact already activeated.
	if(isActive)
		return false;

	// Try to find the impact trigger in the animation.
	UTrack *Track = anim->getTrackByName(triggerName.c_str());
	// No track -> just check with 2/3 animation
	if(Track)
	{
		if(Track->interpolate(currentTime, isActive))
			return isActive;
		else
			nlwarning("CH:beginImpact:%d: Wrong type asked.", _Slot);
	}

	// No Track or pb with it so try with the animation length.
	float length = (float)(anim->getEndTime()-anim->getBeginTime());
	isActive = (animOffset(MOVE) >= length*timeFactor);
	return isActive;
}// beginImpact //

//-----------------------------------------------
// animEventsProcessing :
// 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.
// \todo GUIGUI : Optimize FXs launch when we would have time
//-----------------------------------------------
void CCharacterCL::animEventsProcessing(double startTime, double stopTime)
{
	if (_CurrentState == 0)
		return;

	// \todo Vianney : temp le temps de savoir comment on joue les son pour le propre joueur
	// No sound for the player.
	if(_Slot != 0 || _Mode != MBEHAV::NORMAL)
	{
		// Retreive the surface material
		uint32 matId= getGroundType();
		// Set the material id var
		_SoundContext.Args[0] = matId;
		if(_Sheet)
		{
			// Set the sound family var
			_SoundContext.Args[2] = _Sheet->SoundFamily;
			// Set the sound variation var
			_SoundContext.Args[3] = _Sheet->SoundVariation;
		}
		else
		{
			// Set the sound family var
			_SoundContext.Args[2] = 0;
			// Set the sound variation var
			_SoundContext.Args[3] = 0;
		}
		// Sound Process.
		CSoundAnimManager* sndMngr = CSoundAnimManager::instance();
		if(sndMngr && (_SoundId[MOVE] != CSoundAnimationNoId))
		{
			_SoundContext.Position = pos();
			// Look for the cluster(s) containing this character...
			std::vector<NL3D::CCluster*>	clusters;
			if (!_Instance.empty())
			{
				// single meshed
				_Instance.getLastParentClusters(clusters);
			}
			else if (!_Skeleton.empty())
			{
				// Skel meshed
				_Skeleton.getLastParentClusters(clusters);
			}
			CCluster *pcluster = 0;
			// use the first cluster if at leat one available
			if (!clusters.empty())
				pcluster = clusters.front();
			sndMngr->playAnimation(_SoundId[MOVE], (float) startTime, (float) stopTime, pcluster, _SoundContext);
		}
	}

}// animEventsProcessing //

//-----------------------------------------------
// updatePreCollision :
// Method called each frame to manage the entity.
// \param time : current time of the frame.
// \parem target : pointer on the current entity target.
//-----------------------------------------------
void CCharacterCL::updatePreCollision(const TTime &currentTimeInMs, CEntityCL *target)	// virtual
{
	H_AUTO ( RZ_Client_Entity_CL_Update_Pre_Collision );
	// Set the Last frame PACS Pos.
	if(_Primitive)
		_Primitive->getGlobalPosition(_LastFramePACSPos, dynamicWI);
	// Set the previous position before changing the current one.
	_LastFramePos = _Position;

	// Turn towards the target when in COMBAT_FLOAT mode.
	if(_Mode == MBEHAV::COMBAT_FLOAT)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Combat )

		// Check there is a valid target and it's not the entity itself.
		if(targetSlot() != CLFECOMMON::INVALID_SLOT
		&& targetSlot() != slot()
		&& target)
			// Set the new entity direction
			front(target->pos() - pos(), true, false);
	}

	// Update Position if not a child & displayable.
	if(parent() == CLFECOMMON::INVALID_SLOT && _Displayable)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos )
		updatePos(currentTimeInMs, target);
	}
}// updatePreCollision //

//-----------------------------------------------
// updateFX :
// Apply track on fxs
// Check if some FX should be removed.
//-----------------------------------------------
inline void CCharacterCL::updateFX()
{
	updateAttachedFX();
}// updateFX //


//-----------------------------------------------
// updateAttachedFX :
// Apply track on animated fxs
// Remove those that should be removed
//-----------------------------------------------
void CCharacterCL::updateAttachedFX()
{
	// build align matrix
	CMatrix alignMatrix;
	buildAlignMatrix(alignMatrix);

	// update tracks & pos for anim attachedfxs
	std::list<CAttachedFX::TSmartPtr>::iterator itAttachedFx = _AttachedFXListForCurrentAnim.begin();
	while(itAttachedFx != _AttachedFXListForCurrentAnim.end())
	{
		nlassert(*itAttachedFx);
		CAttachedFX &attachedFX = **itAttachedFx;
		attachedFX.update(*this, alignMatrix);
		if (!attachedFX.FX.empty()) attachedFX.FX.setUserMatrix(alignMatrix);
		++itAttachedFx;
	}

	// Try to remove animation FXs still not removed.
	itAttachedFx = _AttachedFXListToRemove.begin();
	while(itAttachedFx != _AttachedFXListToRemove.end())
	{
		// If the FX is not present or valid -> remove the FX.
		bool mustDelete = false;
		CAttachedFX &attachedFX = **itAttachedFx;
		if (attachedFX.SpawnTime != TimeInSec)
		{
			if(attachedFX.FX.empty() || !attachedFX.FX.isSystemPresent() || !attachedFX.FX.isValid())
			{
				mustDelete = true;
			}
		}
		if (attachedFX.TimeOutDate != 0)
		{
			if (TimeInSec >= attachedFX.TimeOutDate)
			{
				mustDelete = true;
			}
		}
		if (mustDelete)
		{
			// Remove from the list.
			itAttachedFx = _AttachedFXListToRemove.erase(itAttachedFx);
		}
		else
		{
			attachedFX.update(*this, alignMatrix);
			if (!attachedFX.FX.empty()) attachedFX.FX.setUserMatrix(alignMatrix);
			++itAttachedFx;
		}
	}

	// update the aura fx
	for(uint k = 0; k < MaxNumAura; ++k)
	{
		if (_AuraFX[k])
		{
			if (_AuraFX[k]->TimeOutDate != 0.f) // we use that flag to mark the aura as 'shutting down'
			{
				if (TimeInSec >= _AuraFX[k]->TimeOutDate)
				{
					_AuraFX[k] = NULL;
				}
				else
				{
					float lifeRatio = (float) ((_AuraFX[k]->TimeOutDate - TimeInSec) / AURA_SHUTDOWN_TIME);
					if (!_AuraFX[k]->FX.empty()) _AuraFX[k]->FX.setUserParam(0, 1.f - lifeRatio);
				}
			}
			if (_AuraFX[k]) // not deleted yet ?
			{
				// update position & orientation
				_AuraFX[k]->update(*this, alignMatrix);
			}
		}
	}

	// update the link fx
	if (_LinkFX)
	{
		_LinkFX->update(*this, alignMatrix);
	}
	if (_StaticFX)
	{
		_StaticFX->FX->update(*this, alignMatrix);
	}
}




//-----------------------------------------------
// updateVisible :
//-----------------------------------------------
void CCharacterCL::updateVisible (const TTime &currentTimeInMs, CEntityCL *target)
{
	// Changes the skeleton state
	if(!_Skeleton.empty())
	{
		_Skeleton.show();
	}
	// Changes the instance position.
	else if(!_Instance.empty())
	{
		_Instance.show();
	}

	// Snap the entity to the ground.
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Snap_To_Ground )
		snapToGround();
	}

	// Apply the new entity position to the visual of the entity (apply x and z movement due to animation).
	if(parent() == CLFECOMMON::INVALID_SLOT)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Display )
		updateDisplay();
	}

	// Change the cluster of the entity.
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Cluster )
		updateCluster();
	}

	// Update the LodCharacter Animation.
	if(_LodCharacterAnimEnabled)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Lod_Animation )

		// set this value to the skeleton
		if(skeleton())
			skeleton()->setLodCharacterAnimTime(_LodCharacterAnimTimeOffset);
	}

	// Update FX
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_FX )
		updateFX();
	}

	// Update Modifiers
	if(!_HPModifiers.empty())
	{
		HPMD mod;
		mod.CHPModifier::operator= (*_HPModifiers.begin());
		mod.Time = TimeInSec + mod.DeltaT;
		_HPDisplayed.push_back(mod);
		_HPModifiers.erase(_HPModifiers.begin());
	}

	// Parent
	CEntityCL::updateVisible(currentTimeInMs, target);
}// updateVisible //

//-----------------------------------------------
// updateSomeClipped :
//-----------------------------------------------
void CCharacterCL::updateSomeClipped (const TTime &currentTimeInMs, CEntityCL *target)
{
	// Snap the entity to the ground.
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Snap_To_Ground )
		snapToGround();
	}

	// Changes the skeleton position.
	if(!_Skeleton.empty())
	{
		_Skeleton.setPos(pos());
		_Skeleton.hide();
	}
	// Changes the instance position.
	else if(!_Instance.empty())
	{
		_Instance.setPos(pos());
		_Instance.hide();
	}

	if(!ClientCfg.Light)
	{
		// Update texture Async Loading
		updateAsyncTexture();
		// Update lod Texture
		updateLodTexture();

		// Update FX
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_FX )
			updateFX();
		}
	}

	// Remove Modifiers.
	_HPModifiers.clear();
	_HPDisplayed.clear();

	// Parent
	CEntityCL::updateSomeClipped(currentTimeInMs, target);
}// updateSomeClipped //

//-----------------------------------------------
// updateClipped :
//-----------------------------------------------
void CCharacterCL::updateClipped (const TTime &currentTimeInMs, CEntityCL *target)
{
	// hide the scene interface
	if (_InSceneUserInterface)
	{
		if (_InSceneUserInterface->getActive())
			_InSceneUserInterface->setActive (false);
	}
	if (_CurrentBubble)
	{
		if (_CurrentBubble->getActive())
			_CurrentBubble->setActive (false);
	}

	// parent
	CEntityCL::updateClipped(currentTimeInMs, target);
}// updateClipped //

//-----------------------------------------------
// updateVisiblePostPos :
// Update the entity after all positions done.
//-----------------------------------------------
void CCharacterCL::updateVisiblePostPos(const NLMISC::TTime &currentTimeInMs, CEntityCL *target)	// virtual
{
	// Stuff to do only when alive.
	if(!isDead())
	{
		// Update the head direction.
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Head_Direction )
				updateHeadDirection(target);
		}
		// Update Blink.
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Blink )
				updateBlink(currentTimeInMs);
		}
	}

	// Update in scene interface
	if(_InSceneUserInterface || _CurrentBubble)
	{
		// Draw the entity Name if asked or under the cursor.
		bool showIS = mustShowInsceneInterface( (!_Sheet) || (_Sheet->DisplayOSD) );
		bool showBubble = true;

		// Don't show bubble if lod
		if (!_Skeleton.empty() && _Skeleton.isDisplayedAsLodCharacter())
		{
			showBubble = false;
		}

		// If the name of the character is unknown, no user info
		if (_EntityName.empty() && _Title.empty())
			showIS = false;

		// if mounted : don't display name
		if( _Rider != CLFECOMMON::INVALID_SLOT)
		{
			showIS = false;
		}


		// User Info
		if (_InSceneUserInterface)
		{
			// Activate
			if (_InSceneUserInterface->getActive() != showIS)
				_InSceneUserInterface->setActive (showIS);

			if (showIS)
			{
				// Update dynamic data
				_InSceneUserInterface->updateDynamicData ();

				NLMISC::CVectorD pos;
				if (getNamePos(pos))
				{
					// Check the pos validity
					if((isValidDouble(pos.x) && isValidDouble(pos.y) && isValidDouble(pos.z)) == false)
					{
						nlwarning("CH:updateVisiblePostPos:%d: invalid pos %f %f %f", _Slot, pos.x, pos.y, pos.z);
						nlstop;
					}
					_InSceneUserInterface->Position = pos;
				}
				else
				{
					pos = (box().getMin() + box().getMax())/2;
					pos.z = box().getMax().z;
					nlassert(isValidDouble(pos.x) && isValidDouble(pos.y) && isValidDouble(pos.z));
					_InSceneUserInterface->Position = pos;
				}
			}
		}

		// Bubble ?
		if (_CurrentBubble)
		{
			showBubble &= _CurrentBubble->canBeShown();

			// Activate
			if (_CurrentBubble->getActive() != showBubble)
				_CurrentBubble->setActive (showBubble);

			if (showBubble)
			{
				// Offset X
				sint offsetX = 0;
				if (_InSceneUserInterface)
					offsetX = - 10 -  (_InSceneUserInterface->getWReal() / 2);
				_CurrentBubble->setOffsetX (offsetX);

				NLMISC::CVectorD pos;
				if (!getNamePos(pos))
				{
					pos = (box().getMin() + box().getMax())/2;
					pos.z = box().getMax().z;
				}
				nlassert(isValidDouble(pos.x) && isValidDouble(pos.y) && isValidDouble(pos.z));
				_CurrentBubble->Position = pos;
			}
		}
	}

	// parent
	CEntityCL::updateVisiblePostPos(currentTimeInMs, target);
}// updateVisiblePostPos //


//-----------------------------------------------
// updatePostCollision :
// Method called each frame to manage the entity.
// \param time : current time of the frame.
// \parem target : pointer on the current entity target.
//-----------------------------------------------
void CCharacterCL::updatePostCollision(const TTime &/* currentTimeInMs */, CEntityCL * /* target */)	// virtual
{
	H_AUTO ( RZ_Client_Entity_CL_Update_Post_Collision )

	// Finalize PACS position
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Finalize_Move )
		pacsFinalizeMove();
		// \todo GUIGUI : fait rapidement pour voir les autres se baigner pour la video, faire mieux.

		// changed : Malkav , also do this for mektoub (as they can swim)
		if(PACS && _Primitive
			&& (isPlayer() || isNPC()
				|| (_Sheet && (_Sheet->Race == EGSPD::CPeople::MektoubMount || _Sheet->Race == EGSPD::CPeople::MektoubPacker))
				)
			)
		{
			// Is in water ?
			if(GR)
			{
				UGlobalPosition gPos;
				_Primitive->getGlobalPosition(gPos, dynamicWI);
				float waterHeight;
				if(GR->isWaterPosition(gPos, waterHeight))
				{
					if(isSwimming()==false)
					{
						if(isDead())
						{
							_Mode = MBEHAV::SWIM_DEATH;
						}
						else if (isRiding())
						{
							_Mode = MBEHAV::MOUNT_SWIM;

							// also change mounted entity mode
							if (_Mount != CLFECOMMON::INVALID_SLOT)
							{
								CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
								if(mount)
								{
									// Set the mount.
									mount->setMode(MBEHAV::MOUNT_SWIM);
									mount->computeAutomaton();
									mount->computeAnimSet();
									mount->setAnim(CAnimationStateSheet::Idle);
								}
							}
						}
						else
						{
							_Mode = MBEHAV::SWIM;
						}

						// Compute the current automaton
						computeAutomaton();
						// Update the animation set according to the mode.
						computeAnimSet();
						// Animset changed -> update current animation
						setAnim(CAnimationStateSheet::Idle);
					}
				}
				else
				{
					if(isSwimming())
					{
						if(isDead())
						{
							_Mode = MBEHAV::DEATH;
						}
						else if (isRiding())
						{
							_Mode = MBEHAV::MOUNT_NORMAL;
							// also change mounted entity mode
							if (_Mount != CLFECOMMON::INVALID_SLOT)
							{
								CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
								if(mount)
								{
									// Set the mount.
									mount->setMode(MBEHAV::MOUNT_NORMAL);
									mount->computeAutomaton();
									mount->computeAnimSet();
									mount->setAnim(CAnimationStateSheet::Idle);
								}
							}
						}
						else
						{
							_Mode = MBEHAV::NORMAL;
						}

						// Compute the current automaton
						computeAutomaton();
						// Update the animation set according to the mode.
						computeAnimSet();
						// Animset changed -> update current animation
						setAnim(CAnimationStateSheet::Idle);
					}
				}
			}
		}
	}
}// updatePostCollision //


//-----------------------------------------------
// getTheMove :
//-----------------------------------------------
double CCharacterCL::getTheMove(double loopTimeStep, double oldMovingTimeOffset, double oldMovingTimeOffsetRun) const
{
	double move;
	if(_CurrentState)
	{
		// A Real Move State
		if(_CurrentState->Move)
		{
			// Get the covered distance from the animation.
			move = getTheMove(loopTimeStep, oldMovingTimeOffset, MOVE);
			if(runFactor() > 0.0)
			{
				// Blend the 2 move (Walk & Run).
				move = move*(1.0-runFactor()) + getTheMove(loopTimeStep, oldMovingTimeOffsetRun, MOVE_BLEND_OUT)*runFactor();
				// The move must be significant.
				if((move>0.0) && (move<ClientCfg.SignificantDist))
					move = ClientCfg.SignificantDist;
			}
		}
		// Slide
		else if(_CurrentState->Slide)
		{
			move = speed() * loopTimeStep;
			// The move must be significant.
			if((move>0.0) && (move<ClientCfg.SignificantDist))
				move = ClientCfg.SignificantDist;
		}
		else
			move = 0.0;
	}
	else
	{
		move = speed() * loopTimeStep;
		// The move must be significant.
		if((move>0.0) && (move<ClientCfg.SignificantDist))
			move = ClientCfg.SignificantDist;
	}
	// Check the move is significant.
	CHECK(!((move>0.0) && (move<ClientCfg.SignificantDist)));
	// Return the move done by the entity since last time.
	return move;
}// getTheMove //
//-----------------------------------------------
// getTheMove :
//-----------------------------------------------
double CCharacterCL::getTheMove(double loopTimeStep, double oldMovingTimeOffset, TAnimationType channel) const
{
	double move;
	// Compute a linear motion when the animation is missing.
	if(animIndex(channel) == CAnimation::UnknownAnim)
	{
		double offsetT = _DestTime - _LastFrameTime;
		if(offsetT <= 0.0)
		{
			// \todo GUIGUI : in this case, 'loopTimeStep' should not decrease so FIX IT.
			move = dist2Dest();
		}
		else
		{
			move = dist2Dest() * (loopTimeStep / offsetT);
			// The move must be significant.
			if((move>0.0) && (move<ClientCfg.SignificantDist))
				move = ClientCfg.SignificantDist;
		}
	}
	// Get the motion done by the animation.
	else
		move = computeMotion(oldMovingTimeOffset, channel);

	CHECK(!(move>0.0 && move<ClientCfg.SignificantDist));
	return move;
}// getTheMove //

//-----------------------------------------------
// updatePosCombatFloat :
//-----------------------------------------------
void CCharacterCL::updatePosCombatFloat(double /* frameTimeRemaining */, CEntityCL *target)	// virtual
{
	H_AUTO_USE ( RZ_Client_Character_CL_Update_Pos_Combat_Float )

	// The target is valid
	if(target)
	{
		// Get the position where the attacker should go to attack his target according to the attack angle.
		CVectorD dirToTarget = target->pos() - pos();
		dirToTarget.z = 0.0;
		if(ClientCfg.Local
		|| ((dirToTarget != CVectorD::Null)
		&& fabs(target->pos().x-target->lastFramePos().x)>0.01
		&& fabs(target->pos().y-target->lastFramePos().y)>0.01))
		{
			double angToTarget = atan2(dirToTarget.y, dirToTarget.x);
			_DestPos = target->getAttackerPos(angToTarget, attackRadius() + ClientCfg.AttackDist);
		}
		else
			_DestPos = target->getAttackerPos(_TargetAngle, attackRadius() + ClientCfg.AttackDist);
		// Compute the distance to destination.
		CVectorD vectToDest = _DestPos - pos();
		vectToDest.z = 0.0;
		// Distance to destination is big enough.
		if(vectToDest.norm() > ClientCfg.DestThreshold)
		{
			dist2Dest(vectToDest.norm());
			// Compute the time to reach the destination at the max speed.
			double lenghtOfTimeToDest = 0.0; // 0 = No Speed Limit
			_FirstPos	= _DestPos;
			_DestTime	= _LastFrameTime + lenghtOfTimeToDest + ClientCfg.ChaseReactionTime;
			_FirstTime	= _DestTime;
/*
			// The time remaining will be enough to reach the destination
			if(frameTimeRemaining >= lenghtOfTimeToDest)
			{
				_FirstPos	= _DestPos;
				_DestTime	= _LastFrameTime + lenghtOfTimeToDest + ClientCfg.ChaseReactionTime;
				_FirstTime	= _DestTime;
			}
			// The time remaining is not enough to reach the destination at max speed -> compute a first pos possible to reach.
			else
			{
				_FirstPos	= pos() + vectToDest*frameTimeRemaining/lenghtOfTimeToDest;
				_DestTime	= _LastFrameTime + lenghtOfTimeToDest + ClientCfg.ChaseReactionTime;
				_FirstTime	= _LastFrameTime + frameTimeRemaining + ClientCfg.ChaseReactionTime;
			}
*/
			// Compute the distance to the first position.
			CVectorD tmp2computeDist2FirstPos = _FirstPos-pos();
			tmp2computeDist2FirstPos.z = 0.0;
			dist2FirstPos(tmp2computeDist2FirstPos.norm());

			updatePosCombatFloatChanged(target);
		}
		// Destination is too close (will consider to be at destination.
		else
		{
			_FirstPos		= _DestPos		= pos();
			dist2Dest(0.0);
			dist2FirstPos(0.0);
			_FirstTime		= _DestTime		= _LastFrameTime;
		}
	}
	// The target is not allocated.
	else
	{
		_FirstPos		= _DestPos		= pos();
		dist2Dest(0.0);
		dist2FirstPos(0.0);
		_FirstTime		= _DestTime		= _LastFrameTime;
	}
}// updatePosCombatFloat //

//-----------------------------------------------
// updatePos :
// Upadte the player position
// \param time : Time for the position of the entity after the motion.
// \param target : pointer on the current target.
// \todo GUIGUI : compute it when receiving a new stage instead of every frame (should be faster).
// \todo GUIGUI: recompute distance to destination even if the Stage not reached.
//-----------------------------------------------
ADD_METHOD(void CCharacterCL::updatePos(const TTime &currentTimeInMs, CEntityCL *target))
	_OldAutomaton = _CurrentAutomaton;
	// Compute the Time Step.
	double frameTimeRemaining = computeTimeStep(((double)currentTimeInMs)*0.001);
	// Update the LodCharacter Animation.
	if(_LodCharacterAnimEnabled)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Lod_Animation );
		// \todo GUIGUI : replace 'getSpeedFactor' by the correct speed factor !!
		// update lod anim time. multiply by speed factor of the most important slot.
		_LodCharacterAnimTimeOffset += DT * _PlayList->getSpeedFactor(_LodCharacterMasterAnimSlot);
	}
	// BLEND
	if(_PlayList)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Set_Play_List );
		// \todo GUIGUI : do something better for the blend (mounts there).
		if(isRiding() || ClientCfg.BlendFrameNumber == 0 || _BlendRemaining <= 0)
		{
			_BlendRemaining = 0;
			_PlayList->setAnimation(ACTION, UPlayList::empty);
			_PlayList->setWeight(ACTION, 0.0f);
			if(runFactor() < 0.5 || (_CurrentAnimSet[MOVE_BLEND_OUT]==0))
			{
				if(_CurrentAnimSet[MOVE])
				{
					_CurrentAnimSet[ACTION] = _CurrentAnimSet      [MOVE];
					animState (ACTION, animState (MOVE));
					animIndex (ACTION, animIndex (MOVE));			// This also call "animId" and set it.
					animOffset(ACTION, animOffset(MOVE));
				}
				else
				{
					_CurrentAnimSet[ACTION] = 0;
					animState (ACTION, CAnimationStateSheet::UnknownState);
					animIndex (ACTION, CAnimation::UnknownAnim);	// This also call "animId" and set it.
					animOffset(ACTION, 0.0);
				}
			}
			else
			{
				_CurrentAnimSet[ACTION] = _CurrentAnimSet      [MOVE_BLEND_OUT];
				animState (ACTION, animState (MOVE_BLEND_OUT));
				animIndex (ACTION, animIndex (MOVE_BLEND_OUT));	// This also call "animId" and set it.
				animOffset(ACTION, animOffset(MOVE_BLEND_OUT));
			}
			_AnimReversed[ACTION] = false;
		}
		else
		{
			double animLength = EAM->getAnimationLength(animId(ACTION));
			// Check Anim length
			if(animOffset(ACTION)+frameTimeRemaining > animLength)
				animOffset(ACTION, animLength);
			else
				animOffset(ACTION, animOffset(ACTION)+frameTimeRemaining);
			// Compute weight step.
			float w = (float)_BlendRemaining/(float)(ClientCfg.BlendFrameNumber+1);
			// Set Old Anim Weight.
			_PlayList->setWeight(ACTION, w);
			// Set New Anim Weight.
			_PlayList->setWeight(MOVE, 1.f-w);
		}
	}
	uint antiFreezeCounter = 0;
	// While the time Step is not Null.
	while(frameTimeRemaining > 0)
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos_WhileStep );

		//--------------------//
		//--------------------//
		// ANTI-FREEZE SYSTEM //
		// If too many loop, display some infos
		if(antiFreezeCounter > 50)
		{
/*
			nlwarning("CH:updatePos:antiFreeze:%d: frameTimeRemaining '%f'",  _Slot, frameTimeRemaining);
			nlwarning("CH:updatePos:antiFreeze:%d: Automaton '%s'",           _Slot, _CurrentAutomaton.c_str());
			nlwarning("CH:updatePos:antiFreeze:%d: _IsThereAMode '%s'",       _Slot, _IsThereAMode?"true":"false");
			nlwarning("CH:updatePos:antiFreeze:%d: dist2Dest '%f'",           _Slot, dist2Dest());
			nlwarning("CH:updatePos:antiFreeze:%d: Mode '%s(%d)'",            _Slot, modeToString(_Mode).c_str(), _Mode);
			nlwarning("CH:updatePos:antiFreeze:%d: Mode Wanted '%s(%d)'",     _Slot, modeToString(_ModeWanted).c_str(), _ModeWanted);
			nlwarning("CH:updatePos:antiFreeze:%d: Anim State Move '%s(%d)'", _Slot, CAnimationState::getAnimationStateName(animState(MOVE)).c_str(), animState(MOVE));
*/
			// Once too many more time reached, leave the method.
			if(antiFreezeCounter > 60)
				break;
		}
		// Update antiFreezeCounter.
		++antiFreezeCounter;
		// ANTI-FREEZE SYSTEM //
		//--------------------//
		//--------------------//
		// \todo GUIGUI : improve dist2first and dist2dest
		// Update Stages
		updateStages();
		// \todo GUIGUI : Bug with _TargetAngle in fight float, we overwrite here angle sent by the server ?
		// If the entity is too far (orientation not received yet), set the front vector as the moving direction.
		CVectorD distToUser = pos()-UserEntity->pos();
		distToUser.z = 0.0;
		if(distToUser.norm()*1000.0 > CLFECOMMON::THRESHOLD_ORIENTATION*0.9)
		{
			if(_FirstPos != INVALID_POS)
			{
				CVectorD dirToFirstP = _FirstPos-pos();
				dirToFirstP.z = 0.0;
				if(dirToFirstP != CVectorD::Null)
				{
					front(dirToFirstP.normed(), false, false);
					_TargetAngle = atan2(front().y, front().x);
				}
			}
		}
		// Mode Combat Float :
		if(!_IsThereAMode && (_Mode == MBEHAV::COMBAT_FLOAT))
		{
			// Update the position in combat float.
			updatePosCombatFloat(frameTimeRemaining, target);
		}
		// Compute the average speed to the destination.
		// double spd = 
		computeSpeed();


		bool stageReach = false;
		bool allToFirstPos = false;
		// Compute time to Stage or full Time Step if Stage too far.
		double loopTimeStep = frameTimeRemaining;
		double buLoopTimeStep = 0.0;
		double checkLoopTimeStep = loopTimeStep;
		// Update the animation used according to the speed/end anim/etc..
		updateAnimationState();
		// Backup the old time offset.
		double oldMovingTimeOffset    = animOffset(MOVE);
		double oldMovingTimeOffsetRun = animOffset(MOVE_BLEND_OUT);
		// WARNING -> Unknown Animation Selected.
		// Play the time step for the loop and truncate to End Anim if Time Step too big.
		if((_CurrentState != 0) && (animIndex(MOVE) != CAnimation::UnknownAnim))
			playToEndAnim(oldMovingTimeOffset, loopTimeStep);
		/////////////////
		// -- CHECK -- //
		if(loopTimeStep > checkLoopTimeStep)
		{
			nlwarning("CH:updtPos:%d: loopTimeStep(%f) > checkLoopTimeStep(%f).", _Slot, loopTimeStep, checkLoopTimeStep);
			if(ClientCfg.Check)
				nlstop;
			loopTimeStep = checkLoopTimeStep;
		}
		checkLoopTimeStep = loopTimeStep;
		// -- END CHECK -- //
		/////////////////////
		// (DEBUG) : Backup the Animation Time Offset after the adjustment with end anim to make some checks.
		double backupAnimTimeOff = animOffset(MOVE);
		//
		bool posInStage = false;
		double stageTime = -1.0;
		if(!_Stages._StageSet.empty())
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Move );
			// Get the reference on the current stage.
			CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
			CStage &stage = (*it).second;
			if(_Mode == MBEHAV::COMBAT_FLOAT && !_IsThereAMode)
				posInStage = false;
			else
				posInStage = stage.isPresent(CLFECOMMON::PROPERTY_POSITION);
			stageTime  = stage.time();
		}
		// dist2FirstPos() should not be Null if the destination is not Null (because of the code in updateStage).
		if(dist2FirstPos() > 0.0)
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Pos_dist2FirstPos_gt_0 );

			// Get the covered distance from the animation.
			double move = getTheMove(loopTimeStep, oldMovingTimeOffset, oldMovingTimeOffsetRun);
			// The move is big enough to reach the first step with motion.
			if(move >= dist2FirstPos())	// dist2FirstPos() > 0 -> move > 0.
			{
				double percent = dist2FirstPos() / move;
				// Adjust loopTimeStep
				loopTimeStep *= percent;
				if(loopTimeStep > checkLoopTimeStep)	// prevent bugs because of the double's precision
					loopTimeStep = checkLoopTimeStep;
				if(loopTimeStep < 0.0)
					loopTimeStep = 0.0;
				// Update Animation Time Offset (move greater than the dist to next stage; update animation time to get them equal).
				animOffset(MOVE,           oldMovingTimeOffset    + (animOffset(MOVE)          -oldMovingTimeOffset   )*percent);
				animOffset(MOVE_BLEND_OUT, oldMovingTimeOffsetRun + (animOffset(MOVE_BLEND_OUT)-oldMovingTimeOffsetRun)*percent);
				// \todo GUIGUI : check if the following line is necessary
				buLoopTimeStep = loopTimeStep;
				// First Position Reached
				pos(_FirstPos);
				dist2FirstPos(0.0);	// Current entity position is now the same as the First position so dis is Null.
				// Complete the Stage.
				if(_Mode != MBEHAV::COMBAT_FLOAT || _IsThereAMode)
				{
					if(posInStage)
						stageReach = true;
					else
						allToFirstPos = true;
				}
			}
			// Even if the movement is not enough to reach the first position, move the entity to this position.
			else if(move > 0.0)
			{
				// Compute the vector to the first stage with a position.
				CVectorD vectToFirstPos = _FirstPos - pos();
				vectToFirstPos.z = 0.0f;
				// Update entity position.
				if(vectToFirstPos != CVectorD::Null)
					pos(pos() + vectToFirstPos*(move/dist2FirstPos()));
			}
			// Else : There is no move.
		}
		else
		{
			CHECK(posInStage==false && dist2Dest()<=0.0);
		}

		// If there is no position in the next stage and the stage should be done already.
		if(!_Stages._StageSet.empty() && !posInStage && !stageReach && !allToFirstPos && ((_LastFrameTime+loopTimeStep) >= stageTime))
		{
			// Backup 'loopTimeStep' just in case of the stage could not be done.
			buLoopTimeStep = loopTimeStep;
			// Adjust loopTimeStep
			loopTimeStep = stageTime - _LastFrameTime;
			if(loopTimeStep > checkLoopTimeStep)	// prevent bugs because of the double's precision
				loopTimeStep = checkLoopTimeStep;
			if(loopTimeStep < 0.0)
				loopTimeStep = 0.0;
			//
			// \todo GUIGUI : adjust timeOffset, because we stopped the loop before
			//
			// Stage complete.
			stageReach = true;
		}
		/////////////////
		// -- CHECK -- //
		// Check the Animation Time Offset is not became greater than the old.
		if(animOffset(MOVE) > backupAnimTimeOff)
		{
			nlwarning("CH:updtPos:%d: backupAnimTimeOff(%f) < AnimationsTimeOffset(%f) animLen(%f) -> animOffset(MOVE) = backupAnimTimeOff",
				_Slot, backupAnimTimeOff, animOffset(MOVE), EAM->getAnimationLength(animId(MOVE)));
			if(ClientCfg.Check)
				nlstop;
			animOffset(MOVE, backupAnimTimeOff);
		}
		// Check loopTimeStep is not < 0;
		if(loopTimeStep < 0.0)
		{
			nlwarning("CH:updtPos:%d: loopTimeStep(%f) < 0 -> loopTimeStep=0.0.", _Slot, loopTimeStep);
			if(ClientCfg.Check)
				nlstop;
			loopTimeStep = 0.0;
		}
		// time spent could not be bigger than the time remaining
		if(loopTimeStep > frameTimeRemaining)
		{
			nlwarning("CH:updtPos:%d: loopTimeStep(%f) > frameTimeRemaining(%f) -> loopTimeStep=frameTimeRemaining.", _Slot, loopTimeStep, frameTimeRemaining);
			if(ClientCfg.Check)
				nlstop;
			loopTimeStep = frameTimeRemaining;
		}
		// -- END CHECK -- //
		/////////////////////
		// Manage Events that could be created by the animation (like sound).
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Anim_Event )
			animEventsProcessing(oldMovingTimeOffset, animOffset(MOVE));
		}
		// Apply all stages until the first stage with a pos.
		if(allToFirstPos)
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Apply_All_Stage_To_First_Pos );
			applyAllStagesToFirstPos();
		}
		// Stage is complete, apply modifications.
		else if(stageReach)
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Apply_Current_Stage );
			if(!applyCurrentStage())
				loopTimeStep = buLoopTimeStep;
		}
		// Compute the remaining Time Step.
		frameTimeRemaining -= loopTimeStep;
		// Update the last Time.
		_LastFrameTime += loopTimeStep;
	}// while(frameTimeRemaining > 0) //

	////////////////////////////////
	// UPDATE THE ENTITY POSITION //
	// Set the new position into PACS.
	{
		H_AUTO_USE ( RZ_Client_Entity_CL_Update_Pos_Pacs );
		pacsMove(pos());
	}

	/// (DEBUG) ///
	// Check frameTimeRemaining is perfectly equal to 0.
	if(frameTimeRemaining < 0.0)
		nlwarning("CCharacterCL::updatePos : frameTimeRemaining(%f) < 0 ! This should never happen.", frameTimeRemaining);
	/// (END DEBUG) ///

	// Update the children display.
	{
		H_AUTO ( RZ_Client_Entity_CL_Update_Pos_Children );
		std::list<CEntityCL *>::iterator itTmp, it = _Children.begin();
		while(it != _Children.end())
		{
			itTmp = it;
			// Next Child (done before just in case child is detached during his processFrame).
			it++;

			if(*itTmp)
			{
				CCharacterCL *child = dynamic_cast<CCharacterCL *>(*itTmp);
				if(child)
				{
					if ( ! ClientCfg.Light )
					{
						// Update the animation offset for the child.
						double animLength = EAM->getAnimationLength(animId(MOVE));
						if(animLength > 0.0)
						{
							double factor = animOffset(MOVE) / animLength;
							if(factor > 1.0)
								factor = 1.0;
							double childTimeOffset = factor*EAM->getAnimationLength(child->animId(MOVE));
							child->animOffset(MOVE, childTimeOffset);
						}
						else
							child->animOffset(MOVE, 0.0);
						child->processFrame(currentTimeInMs);
					}
					child->pacsMove(pos());	// Move the child at the same position than the parent.
				}
				else
					nlwarning("Character '%d': Child is not a 'CCharacterCL'.", _Slot);
			}
			else
				nlwarning("Character '%d': Child not allocated.", _Slot);
		}
	}
}// updatePos //

//-----------------------------------------------
// updateVisiblePostRender :
// Update the entity after the render like for the head offset.
//-----------------------------------------------
void CCharacterCL::updateVisiblePostRender()	// virtual
{
	// Compute the headoffset
	if(_HeadBoneId != -1 && !_Skeleton.empty())
	{
		if(_Skeleton.getLastClippedState() && _Skeleton.isBoneComputed(_HeadBoneId))
		{
			UBone headBone=_Skeleton.getBone(_HeadBoneId);
			const CMatrix &headMat = headBone.getLastWorldMatrixComputed();
			_HeadOffset = headMat.getPos()-pos();
			_HeadOffsetComputed= true;
		}
	}
}// updateVisiblePostRender //

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

void CCharacterCL::updateAllPostRender()
{
}

//-----------------------------------------------
// processFrame :
//-----------------------------------------------
void CCharacterCL::processFrame(const TTime &currentTimeInMs)
{
	// Prepare stages and update information from them.
	updateStages();

	// Compute the time remaining until frame completely processed.
	double timeRemaining = computeTimeStep(((double)currentTimeInMs)*0.001);

	// Compute the time spent between 2 frames.
	while(timeRemaining > 0.0)
	{
		// Time already processed until now.
		double timeProcessed = timeRemaining;

		// Process Stages.
		if(!_Stages._StageSet.empty())
		{
			// Get the reference on the current stage.
			CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
			CStage &stage = (*it).second;

			// Check if the stage should be done already.
			if((_LastFrameTime+timeProcessed) >= stage.time())
			{
				// Stage Done during the Frame.
				if(stage.time() > _LastFrameTime)
					timeProcessed = stage.time() - _LastFrameTime;
				// This Stage should have been done already before last frame
				else
					timeProcessed = 0.0;

				// Process the stage.
				processStage(stage);

				// Stage complete.
				_Stages._StageSet.erase(it);
			}
		}

		// Compute the remaining Time Step.
		timeRemaining -= timeProcessed;
		// Update the last Time.
		_LastFrameTime += timeProcessed;
	}

	// Just to be sure, Last frame time = current time once all is done.
	_LastFrameTime = ((double)currentTimeInMs)*0.001;
}// processFrame //

//-----------------------------------------------
// processStage :
// Process the stage.
//-----------------------------------------------
void CCharacterCL::processStage(CStage &stage)
{
	// Apply Mode (if there is a mode, there is a position too).
	pair<bool, sint64> resultMode = stage.property(PROPERTY_MODE);
	if(resultMode.first)
	{
		uint8 mo = *(uint8 *)(&resultMode.second);
		MBEHAV::EMode mode = (MBEHAV::EMode)mo;
		if(mode != _Mode)
		{
			// release the old mode.
			if ( (_Mode == MBEHAV::MOUNT_NORMAL || _Mode == MBEHAV::MOUNT_SWIM)
				&& (mode != MBEHAV::MOUNT_NORMAL && mode != MBEHAV::MOUNT_SWIM)
				)
			{
				// Unlink the mount and the rider.
				parent(CLFECOMMON::INVALID_SLOT);
				_Mount = CLFECOMMON::INVALID_SLOT;
				_Rider = CLFECOMMON::INVALID_SLOT;

				// Restore collisions.
				if(_Primitive)
				{
					// \todo GUIGUI : do that without dynamic cast
					if(dynamic_cast<CPlayerCL *>(this))
						_Primitive->setOcclusionMask(MaskColPlayer);
					else
						_Primitive->setOcclusionMask(MaskColNpc);
				}

				// Get stage position.
				if(stage.getPos(_OldPos))
				{
					// Backup the time
					_OldPosTime = stage.time();
					// Unseat the entity at the position given in the stage.
					pacsMove(_OldPos);
				}
				else
					nlwarning("CH:processStage:%d: The stage should have a position with the mode.", _Slot);
			}

			// Set the new mode.
			_Mode				= mode;
			_ModeWanted			= mode;
			// Compute the automaton
			computeAutomaton();
			computeAnimSet();
			setAnim(CAnimationStateSheet::Idle);
		}
	}
	// Not a mode -> so search for a position.
}// processStage //


//-----------------------------------------------
// updateBlink :
// Update the player blink state
//-----------------------------------------------
void CCharacterCL::updateBlink(const TTime &currentTimeInMs)
{
	// Only for homine
	GSGENDER::EGender gender = getGender();
	if ((gender == GSGENDER::male) || (gender == GSGENDER::female))
	{
		float blend;

		// Some parameters
		static const double blinkTime = 100.f;
		static const double minBlinkLength = 500.f;
		static const double maxBlinkLength = 5000.f;

		// Next blink time is valid ?
		bool validTime = (_NextBlinkTime + blinkTime >= currentTimeInMs) && (_NextBlinkTime <= (currentTimeInMs + maxBlinkLength));

		// Blink end ?
		bool blinkEnd = (currentTimeInMs >= _NextBlinkTime + blinkTime);

		// Blink is finished or next blink time is invalid ?
		if ( blinkEnd || !validTime )
		{
			blend = 0;

			// Compute next time
			_NextBlinkTime = (TTime)(((double)rand () / (double)RAND_MAX) * (maxBlinkLength - minBlinkLength) + minBlinkLength + (double)currentTimeInMs);
		}
		else
		{
			// Blink time ?
			if (currentTimeInMs >= _NextBlinkTime)
			{
				blend = 100.f;
			}
			else
			{
				// Do nothing
				return;
			}
		}

		// Get the face
		SInstanceCL *face = getFace ();

		// Set the blend shape
		if(face && !face->Current.empty())
			face->Current.setBlendShapeFactor ("visage_100", blend, true);
	}
}// updateBlink //


//-----------------------------------------------
// getFace :
// Update eyes blink. For the moment, called by updatePos.
//-----------------------------------------------
CEntityCL::SInstanceCL *CCharacterCL::getFace ()
{
	// Implemented in CPlayerCL
	return idx2Inst(_FaceIdx);
}


//---------------------------------------------------
// updateDisplay :
// Get the entity position and set all visual stuff with it.
// \todo GUIGUI : put this method 'virtual' to have a different code for the user (no playlist).
// \todo GUIGUI : manage the parent better.
//---------------------------------------------------
ADD_METHOD(void CCharacterCL::updateDisplay(CEntityCL *parent))
	// Animable ?
	if(_PlayList)
	{
		// Reverse the animation if needed.
		const double animOffsetMOV = _AnimReversed[MOVE]           ? EAM->getAnimationLength(animId(MOVE))           - animOffset(MOVE)          : animOffset(MOVE);
		const double animOffsetACT = _AnimReversed[ACTION]         ? EAM->getAnimationLength(animId(ACTION))         - animOffset(ACTION)        : animOffset(ACTION);
		const double animOffsetBLE = _AnimReversed[MOVE_BLEND_OUT] ? EAM->getAnimationLength(animId(MOVE_BLEND_OUT)) - animOffset(MOVE_BLEND_OUT): animOffset(MOVE_BLEND_OUT);
		// Update Speed Factor
		_PlayList->setTimeOrigin(MOVE,           TimeInSec-animOffsetMOV);
		_PlayList->setTimeOrigin(ACTION,         TimeInSec-animOffsetACT);
		_PlayList->setTimeOrigin(MOVE_BLEND_OUT, TimeInSec-animOffsetBLE);
		float weight;
		if(_BlendRemaining)
			weight = _PlayList->getLocalWeight(MOVE, TimeInSec);
		else
			weight = 1.0f;
		_PlayList->setWeight(MOVE,           weight*(float)(1.0-runFactor()));
		_PlayList->setWeight(MOVE_BLEND_OUT, weight*(float)runFactor());
		// If the animation exist update the display.
		if(animIndex(MOVE) != CAnimation::UnknownAnim)
		{
			// POSITION //
			// Get the 3D position for the current time in the animation (Vector Null if animation has no move).
			CVector currentAnimPos;
			if(!EAM->interpolate(animId(MOVE), animOffsetMOV, currentAnimPos))
				currentAnimPos = CVector::Null;
			else
			{
				// If the current animation state is a move, do not take the Y move in the animation because it's the code that compute the move.
				if(_CurrentState && _CurrentState->Move)
				{
					CVector currentAnimPosStart;
					if(!EAM->interpolate(animId(MOVE), 0.0, currentAnimPosStart))
						currentAnimPosStart = CVector::Null;
					if(_CurrentState->XFactor) currentAnimPos.x = currentAnimPosStart.x;
					if(_CurrentState->YFactor) currentAnimPos.y = currentAnimPosStart.y;
					if(_CurrentState->ZFactor) currentAnimPos.z = currentAnimPosStart.z;
				}
				// Scale the animation with the Character Scale Pos if the animation need it.
				{
					bool applyCharacterScalePosFactor = true;
					// \todo GUIGUI : faire cette histoire de emote beaucoup mieux, C NULL.
					const CAnimationState *animStatePtr;
					// If the current animation is an emote, get the right animation state.
					if(animState(MOVE) == CAnimationStateSheet::Emote)
						animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(_SubStateKey);
					else
						animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
					if(animStatePtr)
					{
						const CAnimation *anim = animStatePtr->getAnimation(animIndex(MOVE));
						if(anim)
							applyCharacterScalePosFactor = anim->applyCharacterScalePosFactor();
					}
					// scale it.
					if(applyCharacterScalePosFactor)
						currentAnimPos *= _CharacterScalePos;
				}
				// Scale according to the gabarit (choose at the character creation).
				currentAnimPos *= _CustomScalePos;
			}
			// Blend Walk/Run
			if(runFactor() > 0.0)
			{
				CVector currentAnimPosRun;
				if(!EAM->interpolate(animId(MOVE_BLEND_OUT), animOffsetBLE, currentAnimPosRun))
					currentAnimPosRun = CVector::Null;
				else
				{
					// If the current animation state is a move, do not take the Y move in the animation because it's the code that compute the move.
					if(_CurrentState && _CurrentState->Move)
					{
						CVector currentAnimPosStart;
						if(!EAM->interpolate(animId(MOVE_BLEND_OUT), 0.0, currentAnimPosStart))
							currentAnimPosStart = CVector::Null;
						if(_CurrentState->XFactor) currentAnimPosRun.x = currentAnimPosStart.x;
						if(_CurrentState->YFactor) currentAnimPosRun.y = currentAnimPosStart.y;
						if(_CurrentState->ZFactor) currentAnimPosRun.z = currentAnimPosStart.z;
					}
					// Scale it by the CharacterScalePos, if needed, according to the animation.
					bool applyCharacterScalePosFactor = true;
					const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE_BLEND_OUT]->getAnimationState(animState(MOVE_BLEND_OUT));
					if(animStatePtr)
					{
						const CAnimation *anim = animStatePtr->getAnimation(animIndex(MOVE_BLEND_OUT));
						if(anim)
							applyCharacterScalePosFactor = anim->applyCharacterScalePosFactor();
					}
					// scale it.
					if(applyCharacterScalePosFactor)
						currentAnimPosRun *= _CharacterScalePos;
					// Scale according to the gabarit.
					currentAnimPosRun *= _CustomScalePos;
				}

				currentAnimPos = currentAnimPos*(float)(1.0-runFactor()) + currentAnimPosRun*(float)runFactor();
			}
			// ROTATION //
			// Get the rotation for the current time in the animation (Rotation Null if animation has no rotation).
			CQuat currentAnimRot;
			if(!EAM->interpolate(animId(MOVE), animOffsetMOV, currentAnimRot))
				currentAnimRot = CQuat::Identity;
			else
			{
				// If the animation is a rotation -> Do just a part of the animation.
				if(parent==0 && _CurrentState && _CurrentState->Rotation && _RotationFactor!=-1.0)
				{
					// Get the Rotation at the beginning of the animation.
					CQuat currentAnimRotStart;
					if(!EAM->interpolate(_PlayList->getAnimation(MOVE), 0.0, currentAnimRotStart))
						currentAnimRotStart = CQuat::Identity;

					double animLength = EAM->getAnimationLength(animId(MOVE));

					// Get the Rotation at the beginning of the animation.
					CQuat currentAnimRotEnd;
					if(!EAM->interpolate(_PlayList->getAnimation(MOVE), animLength, currentAnimRotEnd))
						currentAnimRotEnd = CQuat::Identity;

					// Get the angle done by the animation from the beginning
					CQuat rotStartTmp = currentAnimRotStart;
					rotStartTmp.invert();
					CQuat rotTmp =  rotStartTmp * currentAnimRot;
					float ang = rotTmp.getAngle();

					currentAnimRot = applyRotationFactor(currentAnimRot, (float)_RotationFactor, currentAnimRotStart, currentAnimRotEnd, (float)(animOffsetMOV/animLength));

					// Get the angle done once scaled.
					rotTmp =  rotStartTmp * currentAnimRot;
					CMatrix rotMat;
					rotMat.identity();
					rotMat.rotateZ(_CurrentState->RotFactor*(ang-rotTmp.getAngle()));

					// Apply the scaled rotation to the position.
					currentAnimPos = rotMat*currentAnimPos;
//// OLD ////
/*
					// Get the Rotation at the beginning of the animation.
					CQuat currentAnimRotStart;
					if(!EAM->interpolate(_PlayList->getAnimation(MOVE), 0.0, currentAnimRotStart))
						currentAnimRotStart = CQuat::Identity;

					// Find the closest quat.
//					currentAnimRotStart.makeClosest(currentAnimRot);

					// Get the angle done by the animation from the beginning
					CQuat rotStartTmp = currentAnimRotStart;
					rotStartTmp.invert();
					CQuat rotTmp =  rotStartTmp * currentAnimRot;
					float ang = rotTmp.getAngle();

					// Get the Rotation scaled.
					currentAnimRot = CQuat::slerp(currentAnimRotStart, currentAnimRot, (float)_RotationFactor);

					// Get the angle done once scaled.
					rotTmp =  rotStartTmp * currentAnimRot;
					CMatrix rotMat;
					rotMat.identity();
					rotMat.rotateZ(_CurrentState->RotFactor*(ang-rotTmp.getAngle()));

					// Apply the scaled rotation to the position.
					currentAnimPos = rotMat*currentAnimPos;
*/
//// FIN OLD ////
				}
			}
			// Blend Walk/Run
			if(runFactor() > 0.0)
			{
				// Get the rotation for the current time in the animation (Rotation Null if animation has no rotation).
				CQuat currentAnimRotRun;
				if(!EAM->interpolate(animId(MOVE_BLEND_OUT), animOffsetBLE, currentAnimRotRun))
					currentAnimRotRun = CQuat::Identity;
				currentAnimRotRun.makeClosest(currentAnimRot);
				currentAnimRot = CQuat::slerp(currentAnimRot, currentAnimRotRun, (float)runFactor());
			}

			// Animation Matrix
			CMatrix AnimMatrixRot;
			AnimMatrixRot.identity();
			AnimMatrixRot.setRot(currentAnimRot);

			// Rotation 180 degrees Matrix
			CMatrix rot180;
			rot180.identity();
			if(parent == 0)
				rot180.rotateZ((float)Pi);

			// Logical entity Matrix.
			CMatrix current;
			if(parent == 0)
				current = _DirMatrix;
			else
				current.identity();

			// Convert the anim position in a world position.
			currentAnimPos = (current*rot180)*currentAnimPos;

			rot180 *= AnimMatrixRot;
			current *= rot180;


			// Get the rotation for the current time in the animation (Rotation Null if animation has no rotation).
			if(ClientCfg.BlendFrameNumber && _BlendRemaining > 0)
			{
				CQuat tmpQuat;
				_OldRotQuat.makeClosest(current.getRot());
				tmpQuat = CQuat::slerp(current.getRot(), _OldRotQuat, ((float)_BlendRemaining/(float)(ClientCfg.BlendFrameNumber+1)));
				current.setRot(tmpQuat);
				// 1 more frame played.
				_BlendRemaining--;
			}


			// Compute the position for the instance.
			CVectorD tmpPos;
			if(parent == 0)
			{
				tmpPos = pos();
				tmpPos += currentAnimPos;
			}
			// If the entity is on a mount, just adjust the position with the animation.
			else
				tmpPos = currentAnimPos;
			// Set the skeleton position and rotation.
			if(!_Skeleton.empty())
			{
				_Skeleton.setRotQuat(current.getRot());
				_Skeleton.setPos(tmpPos);
			}
			// Only Instances with no skeleton (objects).
			else if(!_Instances.empty() && !_Instances[0].Current.empty())
			{
				_Instances[0].Current.setRotQuat(current.getRot());
				_Instances[0].Current.setPos(tmpPos);
			}
			// Set the instance position and rotation.
			else if(!_Instance.empty())
			{
				_Instance.setRotQuat(current.getRot());
				_Instance.setPos(tmpPos);
			}
			else
			{
				static bool once = false;

				if (!once)
				{
					nlwarning("CH::updtDisp:%d: no instance nor skeleton. Sheet Id '%d(%s)'.", _Slot, _SheetId.asInt(), _SheetId.toString().c_str());
					once = true;
				}
			}
		}
		// Else Keep the lastest correct display.
		else
		{
			H_AUTO ( RZ_Client_Entity_CL_Update_Display_Unknown_Anim )

			// Rotation 90 degrees Matrix
			CMatrix rot90;
			rot90.identity();
			if(parent == 0)
				rot90.rotateZ((float)(Pi/2.0));

			// Logical entity Matrix.
			CMatrix current;
			if(parent == 0)
				current = _DirMatrix;
			//			else
			//				current.identity();

			current *= rot90;

			// Changes the skeleton position.
			if(!_Skeleton.empty())
			{
				_Skeleton.setRotQuat(current.getRot());
				if(parent == 0)
					_Skeleton.setPos(pos());
//				else
//					_Skeleton.setPos(currentAnimPos);
			}
			// Only Instances with no skeleton (objects).
			else if(!_Instances.empty() && !_Instances[0].Current.empty())
			{
				_Instances[0].Current.setRotQuat(current.getRot());
				if(parent == 0)
					_Instances[0].Current.setPos(pos());
			}
		}
	}
	else
	{
		// Changes the skeleton position.
		if(!_Skeleton.empty())
		{
			_Skeleton.setPos(pos());
		}
		// Only Instances with no skeleton (objects).
		else if(!_Instances.empty() && !_Instances[0].Current.empty())
		{
			// Logical entity Matrix.
			CMatrix current;
			if(parent == 0)
				current = _DirMatrix;

			_Instances[0].Current.setRotQuat(current.getRot());
			_Instances[0].Current.setPos(pos());
		}
		// Changes the instance position.
		else if(!_Instance.empty())
		{
			_Instance.setPos(pos());
		}
	}

	if(!ClientCfg.Light)
	{
		// update texture Async Loading
		updateAsyncTexture();
		// update lod Texture
		updateLodTexture();

	}

	// Update the children display.
	std::list<CEntityCL *>::iterator it = _Children.begin();
	while(it != _Children.end())
	{
		// Update the display for the child
		(*it)->updateDisplay(this);
		// Next Child.
		++it;
	}
}// updateDisplay //


//---------------------------------------------------
// getHeadPos :
// 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.
//---------------------------------------------------
bool CCharacterCL::getHeadPos(NLMISC::CVector &headPos)
{
	// if never computed (eg: clipped or lod)
	if(!_HeadOffsetComputed)
	{
		// force compute the bone
		if(_HeadBoneId != -1 && !_Skeleton.empty())
		{
			_Skeleton.forceComputeBone(_HeadBoneId);
			UBone headBone=_Skeleton.getBone(_HeadBoneId);
			const CMatrix &headMat = headBone.getLastWorldMatrixComputed();
			_HeadOffset = headMat.getPos()-pos();
		}
		_HeadOffsetComputed= true;
	}

	// return the pos with the last head offset computed
	headPos = pos()+_HeadOffset;

	return true;
}// getHeadPos //

//---------------------------------------------------
// updateHeadDirection :
// Update the head Direction.
//---------------------------------------------------
void CCharacterCL::updateHeadDirection(CEntityCL *target)
{
	// Does the entity got a target to track with the head ?
	// No head targeting if the target slot is the same as the entity slot
	if(_TargetSlot!=CLFECOMMON::INVALID_SLOT && _TargetSlot!=_Slot)
	{
		// Is the target allocated.
		if(target != 0)
		{
			// Do not orientate the head to the target if too far.
			CVectorD vectDist = target->pos() - pos();
			if((fabs(vectDist.x) + fabs(vectDist.y)) <= ClientCfg.MaxHeadTargetDist && vectDist != CVectorD::Null)
			{
				// Do not orientate the head to the target if behind.
				vectDist.normalize();
				if(fabs(angleBetween2Vect(dir(), vectDist)) < Pi/3.0)
				{
					CVector targetheadPos;
					if(target->getHeadPos(targetheadPos))
					{
						_TargetAnimCtrl.Mode = CTargetAnimCtrl::TargetMode;
						_TargetAnimCtrl.WorldTarget = targetheadPos;
						return;
					}
				}
			}
		}
	}

	_TargetAnimCtrl.Mode = CTargetAnimCtrl::DirectionMode;
	CMatrix frontMat;
	frontMat.setRot(CVector::I, front(), CVector::K, true);
	frontMat.normalize(CMatrix::YZX);
	_TargetAnimCtrl.CurrentWorldDirection = frontMat.getRot();
}// updateHeadDirection //


//---------------------------------------------------
// displayName :
// Display the entity name.
//---------------------------------------------------
void CCharacterCL::displayName()
{
	// There is no Context -> Cannot display a name.
	if(TextContext == 0)
		return;

	NLMISC::CVector namePos;
	// There is a skeleton.
	if(!_Skeleton.empty() && !ClientCfg.Light)
	{
		// Only if the skeleton is visible.
		if(!isVisible())
			return;
		// Do not display the name in LoD.
		if(_Skeleton.isDisplayedAsLodCharacter())
			return;
		// If the entity was not displayed last frame (clipped) -> do not display the name.
		if(!_Skeleton.getLastClippedState())
			return;

		// Is there a Bone for the Name ?
		if(_NameBoneId != -1)
			namePos = _Skeleton.getBone(_NameBoneId).getLastWorldMatrixComputed().getPos();
		// No Bone for the name -> Draw it at a default position.
		else
			namePos = pos() + CVector(0.f, 0.f, 2.0f);
	}
	// If there is no skeleton -> compute a position for the name.
	else
	{
		namePos = pos() + CVector(0.f, 0.f, 2.0f);
	}

	// Create the matrix and set the orientation according to the camera.
	CMatrix matrix;
	matrix.identity();
	matrix.setRot(MainCam.getRotQuat());
	matrix.setPos(namePos);

	CVector distPos = MainCam.getPos()-pos();
	float scale = distPos.norm();

	// don't display too far names
	if (ClientCfg.Light && scale > 20)
		return;

	if(scale <= 1.0f)
		scale = 1.0f;
	else if(scale > ClientCfg.ConstNameSizeDist)
		scale = ClientCfg.ConstNameSizeDist;
	// Too Far to display a name.
	else if(scale > ClientCfg.MaxNameDist)
		return;
	// Compute the final scale.
	matrix.scale(ClientCfg.NameScale*scale);

	// Draw the name.
	drawName(matrix);
}// displayName //

//---------------------------------------------------
// drawName :
// Draw the name.
//---------------------------------------------------
void CCharacterCL::drawName(const NLMISC::CMatrix &mat)	// virtual
{
	const ucstring &ucname = getEntityName();
	if(!getEntityName().empty())
	{
		// If there is no extended name, just display the name
		if(_NameEx.empty())
			TextContext->render3D(mat, ucname);
		// If there is an extended name, display the extended name at the name place and the name above.
		else
		{
			// Display the Extended Name at right place.
			TextContext->render3D(mat, _NameEx);
			// Compute the position for the Name.
			CMatrix mat2;
			mat2.identity();
			mat2.setRot(MainCam.getRotQuat());
			CVector v = mat.getPos()+mat.getK().normed()*ClientCfg.NamePos*mat.getScaleUniform();
			mat2.setPos(v);
			mat2.scale(mat.getScaleUniform());
			// Diaplay the name.
			TextContext->render3D(mat2, ucname);
		}
	}
	// Name from Sheet
	else
	{
		if(_Sheet != 0)
		{
			const ucstring name(STRING_MANAGER::CStringManagerClient::getCreatureLocalizedName(_Sheet->Id));
			if (name.find(ucstring("<NotExist:")) != 0)
				TextContext->render3D(mat, name);
		}
	}
}// drawName //


//---------------------------------------------------
// displayModifiers :
// Display the Hp Bar
//---------------------------------------------------
void CCharacterCL::displayModifiers()	// virtual
{
	// if none, no op
	if(	_HPDisplayed.empty())
		return;

	// **** get the name pos
	NLMISC::CVectorD namePos;
	if(!getNamePos(namePos))
		namePos = pos() + CVector(0.f, 0.f, 2.0f);
	// remove but keep the Z to the ground
	float	currentDeltaZ= float(namePos.z - pos().z);
	CVector	 groundPos= namePos;
	groundPos.z-= currentDeltaZ;


	// **** compute the scale
	float	dist = (MainCam.getPos()-pos()).norm();
	float	scale= 1.f;
	if(dist > ClientCfg.MaxNameDist)
		return;
	if ( dist < ClientCfg.ConstNameSizeDist )
		scale = 1.0f;
	else
		scale = ClientCfg.ConstNameSizeDist / dist;


	// **** Display HP modifiers.
	CInterfaceManager	*pIM= CInterfaceManager::getInstance();
	std::list<HPMD>::iterator itTmp;
	std::list<HPMD>::iterator it = _HPDisplayed.begin();
	while(it != _HPDisplayed.end())
	{
		HPMD &mod = *it;
		//
		const	float totalDuration= 3.f;
		const	float noFadeDuration= 1.f;
		const	float fadeDuration= totalDuration-noFadeDuration;
		if(TimeInSec > (mod.Time+totalDuration))
		{
			itTmp = it;
			++it;
			_HPDisplayed.erase(itTmp);
		}
		else if (TimeInSec >= mod.Time)
		{
			ucstring hpModifier;
			if (mod.Text.empty())
				hpModifier = ucstring(toString("%d", mod.Value));
			else
				hpModifier = mod.Text;
			double t = TimeInSec-mod.Time;
			// for character, keep the deltaZ the first time it is displayed, and apply the same each frame
			// (avoid Z movement of the flying text because of animation)
			if(mod.DeltaZ==-FLT_MAX)
				mod.DeltaZ= currentDeltaZ;
			// Compute the position for the Modifier.
			float	dynT= sqrtf((float)t/totalDuration);		// a sqrt just so it looks much more "jumpy"
			CVector		pos= groundPos + CVector(0.0f, 0.0f, mod.DeltaZ + dynT*1.f);
			// fade
			if(t<noFadeDuration)
				mod.Color.A= 255;
			else
				mod.Color.A= 255-(uint8)((t-noFadeDuration)*255.0/fadeDuration);

			// Display the hp modifier. display with a X offset according if user or not, for more readability
			sint	deltaX= -pIM->FlyingTextManager.getOffsetXForCharacter();
			if(UserEntity && UserEntity->slot()==slot())
				deltaX*= -1;
			pIM->FlyingTextManager.addFlyingText(&mod, hpModifier, pos, mod.Color, scale, deltaX);

			// Next
			++it;
		}
		else
		{
			// Next
			++it;
		}
	}
}// displayModifiers //


//---------------------------------------------------
// drawPath :
// Draw Pathes
//---------------------------------------------------
void CCharacterCL::drawPath()	// virtual
{
	// Pivot
	CLineColor line;
	CVector pl0 = pos();
	CVector pl1 = pos()+CVector(0.f, 0.f, 2.f);
	line = CLine(pl0, pl1);
	line.Color0 = CRGBA(150,0,255);
	line.Color1 = CRGBA(150,0,255);
	Driver->drawLine(line, GenericMat);

	line = CLine(_PositionLimiter, _PositionLimiter+CVector(0.f, 0.f, 2.f));
	line.Color0 = CRGBA(255,64,128);
	line.Color1 = CRGBA(255,64,128);
	Driver->drawLine(line, GenericMat);

	CVector p0 = pos();
	p0.z += 1.f;

	// Draw Front
	line = CLine(p0, p0+front());
	line.Color0 = CRGBA(0,255,0);
	line.Color1 = CRGBA(0,255,0);
	Driver->drawLine(line, GenericMat);

	// Draw Direction
	line = CLine(p0, p0+dir());
	line.Color0 = CRGBA(255,255,0);
	line.Color1 = CRGBA(255,255,0);
	Driver->drawLine(line, GenericMat);

	// Go to the First Stage.
	CStageSet::TStageSet::iterator it = _Stages._StageSet.begin();
	// Compute the distance over all Stages.
	while(it != _Stages._StageSet.end())
	{
		// Compute Distance.
		CVectorD stagePos;
		if((*it).second.getPos(stagePos))
		{
			CVector p1 = stagePos;
			CVector p2 = p0;
			p2.z = (float)stagePos.z;
			p2 = p2 + (stagePos-p2).normed();

			getCollisionEntity()->snapToGround(p1);
			p1.z += 0.05f;
			getCollisionEntity()->snapToGround(p2);
			p2.z += 0.03f;

			line = CLine(p0, p2);
			line.Color0 = CRGBA(0,0,255);
			line.Color1 = CRGBA(0,0,255);
			Driver->drawLine(line, GenericMat);

			p1.z += 0.03f;
			line = CLine(p0, p1);
			line.Color0 = CRGBA(255,0,0);
			line.Color1 = CRGBA(255,0,0);
			Driver->drawLine(line, GenericMat);

			p0 = p1;
		}

		// Next Stage.
		++it;
	}
}// drawPath //


//---------------------------------------------------
// drawBox :
// Draw the selection Box.
//---------------------------------------------------
void CCharacterCL::drawBox()	// virtual
{
	if(!ClientCfg.Light)
		::drawBox(_Aabbox.getMin(), _Aabbox.getMax(), CRGBA(0,250,0));

	// Draw the PACS box (adjust the color according to the PACS valid or not).
	NLMISC::CAABBox PACSBox = _Aabbox;
	CVector halfSize = PACSBox.getHalfSize();
	halfSize.x = 0; halfSize.y = 0;
	PACSBox.setCenter(_FinalPacsPos+halfSize);
	UGlobalPosition gPos;
	if(_Primitive)
		_Primitive->getGlobalPosition(gPos, dynamicWI);
	::drawBox(PACSBox.getMin(), PACSBox.getMax(), ((gPos.InstanceId == -1) && (T1%1000)>500)?CRGBA(255,0,0):CRGBA(0,250,250));

	if(!ClientCfg.Light)
	{
		::drawBox(selectBox().getMin(), selectBox().getMax(), CRGBA(250,250,0));
		// Draw the clip Sphere
		CVector clipPos = _Aabbox.getCenter();
		clipPos.z+= _ClipDeltaZ - _Aabbox.getHalfSize().z;	// _ClipDeltaZ is relative to pos on ground
		::drawSphere(clipPos, _ClipRadius, CRGBA(0,0,250));
	}
}// drawBox //

//---------------------------------------------------
// selectBox :
// Return the selection box.
//---------------------------------------------------
const NLMISC::CAABBox &CCharacterCL::selectBox()	// virtual
{
	// recompute the selection box?
	if(_LastSelectBoxComputeTime<T1)
	{
		_LastSelectBoxComputeTime=T1;
		bool	found= false;

		// if skeleton, compute aabox from precise skeleton method
		if(!_Skeleton.empty())
		{
			// Don't compute if in LOD form (else flick because sometimes valid because of shadow animation)
			if(!_Skeleton.isDisplayedAsLodCharacter() &&
				_Skeleton.computeRenderedBBoxWithBoneSphere(_SelectBox))
				found= true;
		}
		// else compute from static bot object
		else
		{
			UInstance	inst;
			// try with _Instances array first
			if(!_Instances.empty())
				inst= _Instances[0].Current;
			// Fallback to _Instance (??)
			if(inst.empty())
				inst= _Instance;

			// if static instance found
			if(!inst.empty())
			{
				CAABBox		bbox;
				inst.getShapeAABBox(bbox);
				// if supported (ie bbox not null)
				if(bbox.getHalfSize()!=CVector::Null)
				{
					// Transform bbox to world
					_SelectBox= CAABBox::transformAABBox(inst.getLastWorldMatrixComputed(), bbox);
					found= true;
				}
			}
		}

		// if not found, fallback to default bbox
		if(!found)
			_SelectBox = _Aabbox;
	}

	// Return the selection box.
	return _SelectBox;
}// selectBox //


//---------------------------------------------------
// updateAttachedFXListForSlotRemoved :
//---------------------------------------------------
void CCharacterCL::updateAttachedFXListForSlotRemoved(std::list<CAttachedFX::TSmartPtr> &fxList, const CLFECOMMON::TCLEntityId &slotRemoved)
{
	std::list<CAttachedFX::TSmartPtr>::iterator it = fxList.begin();
	while (it != fxList.end())
	{
		std::list<CAttachedFX::TSmartPtr>::iterator tmpIt = it;
		++ it;
		if ((*tmpIt)->StickMode &&
			((*tmpIt)->StickMode == CFXStickMode::OrientedTowardTargeter ||
			 (*tmpIt)->StickMode == CFXStickMode::UserBoneOrientedTowardTargeter ||
			 (*tmpIt)->StickMode == CFXStickMode::UserBoneRay
			)
		   )
		{
			if ((*tmpIt)->TargeterInfo.Slot == slotRemoved)
			{
				fxList.erase(tmpIt);
			}
		}
	}
}

//---------------------------------------------------
// slotRemoved :
// To Inform about an entity removed (to remove from selection for example).
// This will remove the entity from the target.
// \param slot : Slot of the entity that will be removed.
//---------------------------------------------------
void CCharacterCL::slotRemoved(const CLFECOMMON::TCLEntityId &slotRemoved)
{
	// If the target is the entity that will be removed -> no target
	if(_TargetSlot == slotRemoved)
		_TargetSlot = CLFECOMMON::INVALID_SLOT;
	// invalidate targeter slots in anim fxs
	updateAttachedFXListForSlotRemoved(_AttachedFXListForCurrentAnim, slotRemoved);
	updateAttachedFXListForSlotRemoved(_AttachedFXListToRemove, slotRemoved);
}// slotRemoved //

//---------------------------------------------------
// nbStage :
// Return number of stage remaining.
//---------------------------------------------------
uint CCharacterCL::nbStage()
{
	return (uint)_Stages._StageSet.size();
}// nbStage //


//---------------------------------------------------
// attackRadius :
// Method to return the attack radius of an entity (take the scale into account).
//---------------------------------------------------
double CCharacterCL::attackRadius() const
{
	return _Sheet->DistToFront * getScale();
}// attackRadius //

//---------------------------------------------------
// getAttackerPos :
// 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.
// \todo : GUIGUI precalculate entity matrix
//---------------------------------------------------
CVectorD CCharacterCL::getAttackerPos(double ang, double dist) const
{
	// Compute the local angle
	ang = computeShortestAngle(atan2(front().y, front().x), ang);
	ang += Pi;
	if(ang > Pi)
		ang -= 2*Pi;

	// Compute the local position.
	CVectorD p;
	float distToSide, distToFront, distToBack;
	bool useComplexShape = false;
	if (useComplexShape) // Keep this code for when AIS become complex shape aware
	{
		distToSide = _Sheet->DistToSide;
		distToFront = _Sheet->DistToFront;
		distToBack = _Sheet->DistToBack;
	}
	else // use round shape here
	{
		distToSide = _Sheet->ColRadius;
		distToFront = _Sheet->ColRadius;
		distToBack = _Sheet->ColRadius;
	}
	p.x = getScale()*distToSide*sin(-ang) + dist*sin(-ang);	// or: pos.x = _Sheet->DistToSide*cos(ang) + dist*cos(ang); but 0 should be right side.
	p.y = dist*cos(ang);
	if(fabs(ang) <= Pi/2.0)
		p.y += getScale()*distToFront * cos(ang);
	else
		p.y += getScale()*distToBack  * cos(ang);
	p.z = 0.0;


	// Compute the world position.
	// Create the target matrix.
	CVector vj = front();
	vj.z = 0;
	CVector vk(0,0,1);
	CVector vi = vj^vk;
	CMatrix bodyBase;
	bodyBase.setRot(vi,vj,vk,true);
	bodyBase.setPos(pos());

	// Get the destination in the world.
	return bodyBase * p;
}// getAttackerPos //

//---------------------------------------------------
// isPlacedToFight :
// Return true if the opponent is well placed.
//---------------------------------------------------
bool CCharacterCL::isPlacedToFight(const NLMISC::CVectorD &posAtk, const NLMISC::CVector &dirAtk, double attackerRadius) const	// virtual
{
	NLMISC::CVectorD vDist = pos()-posAtk;
	if(vDist != NLMISC::CVectorD::Null)
	{
		// Attacker Distance
		const double distToAttacker = vDist.norm();
		// Get the Ideal Position
		vDist.normalize();
		CVectorD rightPos = getAttackerPos(atan2(vDist.y, vDist.x), attackerRadius);
		// Vector from the Ideal Position
		NLMISC::CVectorD vDist2 = pos()-rightPos;
		// Check the Distance.
		if(distToAttacker <= vDist2.norm()+ClientCfg.FightAreaSize)
		{
			// Check the orientation.
			NLMISC::CVector vAng = dirAtk;
			vAng.z = 0.0f;
			vDist.z = 0.0;
			return (fabs(angleBetween2Vect(vAng, vDist)) <=  NLMISC::Pi/3.0);
		}
	}
	// User is on the target, do not check dist or angle
	else
		return true;
	// Something wrong
	return false;
//	NLMISC::CVectorD vDist = pos()-posAtk;
//	const double dist = vDist.norm();
//	double radius;
//	// Get current entity radius
//	if(_Primitive)
//		radius = _Primitive->getRadius();
//	else
//		radius = 0.0;
//	// Attack is possible if not too close or too far.
//	if(dist>=radius && dist<=(radius+ClientCfg.FightAreaSize))
//	{
//		// Check Angle
//		NLMISC::CVector vAng = dirAtk;
//		vAng.z = 0.0f;
//		vDist.z = 0.0;
//		return (fabs(angleBetween2Vect(vAng, vDist)) <=  NLMISC::Pi/3.0);
//	}
//	return false;
}// isPlacedToFight //


//---------------------------------------------------
// \param pos : result given in this variable. Only valid if return 'true'.
// \return bool : 'true' if the 'pos' has been filled.
//---------------------------------------------------
bool CCharacterCL::getNamePos(CVectorD &pos) // virtual
{
	// If there is no skeleton -> cannot display the name.
	if(_Skeleton.empty())
		return false;

	// If the entity was not displayed last frame (clipped) -> do not display the name.
	if(!_Skeleton.getLastClippedState())
		return false;

	if(_NameBoneId == -1)
		return false;

	// Take x and y in pos() else we a have a frame late.
	pos.x = this->pos().x;
	pos.y = this->pos().y;

	float namePosZ;
	if (ClientCfg.StaticNameHeight)
		namePosZ = getNamePosZ();
	else
		namePosZ = 0.f;

	// use bone position if no name position is given
	if (namePosZ == 0.f)
	{
		// if displayed as lod, the NameId bone may not be computed
		float skeletonZ = _Skeleton.getLastWorldMatrixComputed().getPos().z;
		if(_Skeleton.isDisplayedAsLodCharacter())
		{
			// if never computed
			if(_NameCLodDeltaZ==NameCLodDeltaZNotComputed)
			{
				_Skeleton.forceComputeBone(_NameBoneId);
				float	boneZ= _Skeleton.getBone(_NameBoneId).getLastWorldMatrixComputed().getPos().z;
				_NameCLodDeltaZ= boneZ - skeletonZ;
			}
			pos.z= skeletonZ + _NameCLodDeltaZ;
		}
		else
		{
			float	boneZ= _Skeleton.getBone(_NameBoneId).getLastWorldMatrixComputed().getPos().z;
			pos.z = boneZ;
			// update delta Z, for when enter in CLod form
			_NameCLodDeltaZ= boneZ - skeletonZ;
		}

		// reset name pos history
		if (_NamePosHistory.isInitialized())
		{
			_NamePosHistory.LastNamePosZ = 0.f;
			_NamePosHistory.LastBonePosZ = 0.f;
		}

		return true;
	}

	const float baseZ = float( this->pos().z );

	// if displayed as lod, skip smooth transition stuff
	if (_Skeleton.isDisplayedAsLodCharacter())
	{
		pos.z = baseZ + namePosZ;

		// reset name pos history
		if (_NamePosHistory.isInitialized())
		{
			_NamePosHistory.LastNamePosZ = 0.f;
			_NamePosHistory.LastBonePosZ = 0.f;
		}

		return true;
	}

	const float boneZ = _Skeleton.getBone(_NameBoneId).getLastWorldMatrixComputed().getPos().z;

	float deltaNamePosZ;
	float deltaBonePosZ;
	if (_NamePosHistory.isInitialized())
	{
		deltaNamePosZ = namePosZ - _NamePosHistory.LastNamePosZ;
		deltaBonePosZ = (boneZ - baseZ) - _NamePosHistory.LastBonePosZ;
	}
	else
	{
		deltaNamePosZ = 0.f;
		deltaBonePosZ = 0.f;
	}

	if (deltaNamePosZ != 0.f)
	{
		// generate a smooth transition following the bone movement
		if (deltaBonePosZ != 0.f && (deltaBonePosZ > 0.f) == (deltaNamePosZ > 0.f))
		{
			namePosZ = _NamePosHistory.LastNamePosZ + deltaBonePosZ;
		}
		else
		{
			const float defaultSpeed = 1.f; // in meters per sec.
			float deltaZ = defaultSpeed * DT;
			if (deltaNamePosZ < 0.f)
				deltaZ = -deltaZ;

			if ( fabs(deltaZ) < fabs(deltaNamePosZ) )
				namePosZ = _NamePosHistory.LastNamePosZ + deltaZ;
		}
	}

	pos.z = baseZ + namePosZ;

	// update history
	_NamePosHistory.LastNamePosZ = namePosZ;
	_NamePosHistory.LastBonePosZ = boneZ - baseZ;

	return true;
}// getNamePos //

//---------------------------------------------------
// Return name position on Z axis defined in sheet
//---------------------------------------------------
float CCharacterCL::getNamePosZ() const
{
	if (!_Sheet)
		return 0.f;

	float namePosZ;
	switch (_ModeWanted)
	{
	case MBEHAV::DEATH:
	case MBEHAV::SIT:
	case MBEHAV::REST:
		namePosZ = _Sheet->NamePosZLow;
		break;

	case MBEHAV::MOUNT_NORMAL:
	case MBEHAV::MOUNT_SWIM:
		namePosZ = _Sheet->NamePosZHigh;
		break;

	default:
		namePosZ = _Sheet->NamePosZNormal;
		break;
	}

	if (namePosZ == 0.f)
		namePosZ = _Sheet->NamePosZNormal;

	return namePosZ * getScale();
}// getNamePosZ //

//---------------------------------------------------
// \param pos : result given in this variable. Only valid if return 'true'.
// \return bool : 'true' if the 'pos' has been filled.
//---------------------------------------------------
bool CCharacterCL::getChestPos(CVectorD &pos) const	// virtual
{
	// If there is no skeleton -> cannot display the Chest.
	if(_Skeleton.empty())
		return false;

	// If the entity was not displayed last frame (clipped) -> do not display the Chest.
	if(!_Skeleton.getLastClippedState())
		return false;

	if(_ChestBoneId == -1)
		return false;

	// Take x and y in pos() else we a have a frame late.
	pos.x = this->pos().x;
	pos.y = this->pos().y;
	pos.z = _Skeleton.getBone(_ChestBoneId).getLastWorldMatrixComputed().getPos().z;
	return true;
}// getChestPos //


//---------------------------------------------------
// getSheetScale :
// Return the entity sheet scale. (return 1.0 if there is any problem).
//---------------------------------------------------
float CCharacterCL::getSheetScale() const	// virtual
{
	if(!_Sheet)
		return 1.f;
	else
		return _Sheet->Scale;

} // getSheetScale //


//---------------------------------------------------
// getColRadius :
// Return the entity collision radius. (return 0.5 if there is any problem).
//---------------------------------------------------
float CCharacterCL::getSheetColRadius() const 
{
	if(!_Sheet) 
		return 0.5f;
	else
		return _Sheet->ColRadius;
}
	

//---------------------------------------------------
// getScale :
// Return the entity scale. (return 1.0 if there is any problem).
//---------------------------------------------------
float CCharacterCL::getScale() const	// virtual
{
	switch( _OwnerPeople )
	{
		case MOUNT_PEOPLE::Fyros : return getSheetScale() * ClientCfg.FyrosScale * _CustomScale;
		case MOUNT_PEOPLE::Matis : return getSheetScale() * ClientCfg.MatisScale * _CustomScale;
		case MOUNT_PEOPLE::Tryker : return getSheetScale() * ClientCfg.TrykerScale * _CustomScale;
		case MOUNT_PEOPLE::Zorai : return getSheetScale() * ClientCfg.ZoraiScale * _CustomScale;
		default:
			return getSheetScale() * _CustomScale;
	}
}// getScale //





///////////
// DEBUG //
///////////
//---------------------------------------------------
// currentAnimationName :
// Return the current animation name.
//---------------------------------------------------
const std::string &CCharacterCL::currentAnimationName() const
{
	if(_PlayList)
	{
		uint idCurrentAnimation = _PlayList->getAnimation(MOVE);
		if(idCurrentAnimation != UPlayList::empty)
			if(EAM && EAM->getAnimationSet())
				return EAM->getAnimationSet()->getAnimationName(idCurrentAnimation);
	}

	// No animation yet.
	return CCharacterCL::_EmptyString;
}// currentAnimationName //

//---------------------------------------------------
// currentAnimationSetName :
// Return the current animation set name.
//---------------------------------------------------
std::string CCharacterCL::currentAnimationSetName(TAnimationType animType) const
{
	if( animType < animTypeCount )
	{
		if( uint(animType) < _CurrentAnimSet.size() )
		{
			if( _CurrentAnimSet[animType] )
			{
				return _CurrentAnimSet[animType]->getSheetName();
			}
		}
	}
	return CCharacterCL::_EmptyString;
}// currentAnimationSetName //

/////////////
// PRIVATE //
//---------------------------------------------------
// shapeFromItem :
// 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 CCharacterCL::shapeFromItem(const CItemSheet &itemSheet) const
{
	if(_Gender == GSGENDER::female && !itemSheet.getShapeFemale().empty())
		return itemSheet.getShapeFemale();
	else
		return itemSheet.getShape();
}// shapeFromItem //


//---------------------------------------------------
// createItemInstance :
// Create the instance from an item
//---------------------------------------------------
uint32 CCharacterCL::createItemInstance(const CItemSheet &itemSheet, uint32 instIdx, SLOTTYPE::EVisualSlot visualSlot, const string &bindBone, sint8 texture, sint color)
{
	uint32 idx = CEntityCL::BadIndex;
	// Get the right shape according to the gender of the character.
	const string &shape = shapeFromItem(itemSheet);

	// Check the shape.
	if(!shape.empty())
	{
		// Check the item need a shape.
		if(shape != "none.shape")
		{
			UInstance	instance;
			// Get the instance
			idx = addColoredInstance(shape, bindBone, texture, instIdx, color);
			SInstanceCL *pInst = idx2Inst(idx);
			nlassert( (pInst == NULL) || (pInst != NULL && !pInst->Loading.empty()) );
			if (pInst != NULL)
				instance = pInst->Loading;
			// Check the shape creation has been is well done.
			if(!instance.empty())
			{
				// Create the FX associated to the item in a given visual slot.
				_Items[visualSlot].initFXs(visualSlot, instance);
			}
			else
				nlwarning("CH:createItemInstance: cannot create the instance for the shape '%s'.", shape.c_str());
		}
	}
	else
		nlwarning("CH:createItemInstance: the item has no shape.");

	return idx;
}// createItemInstance //


//-----------------------------------------------
// setAlive :
// Method to Flag the character as alive and do everything needed.
//-----------------------------------------------
void CCharacterCL::setAlive()	// virtual
{
}// setAlive //



//---------------------------------------------------
// displayDebug :
// Display Debug Information.
//---------------------------------------------------
ADD_METHOD(void CCharacterCL::displayDebug(float x, float &y, float lineStep))	// virtual
	CInterfaceManager *IM = CInterfaceManager::getInstance ();

	CEntityCL::displayDebug(x, y, lineStep);
	// Mode Wanted
	// Display the Target Mode.
	TextContext->printfAt(x, y, "Mode Wanted: %d(%s)", (sint)_ModeWanted, MBEHAV::modeToString(_ModeWanted).c_str());
	y += lineStep;
	// Stage Remaining
	TextContext->printfAt(x, y, "Stages remaining: %d", _Stages._StageSet.size());
	y += lineStep;
	// Current Automaton
	TextContext->printfAt(x, y, "Automaton: %s", _CurrentAutomaton.c_str());
	y += lineStep;
	// Current Speed
	TextContext->printfAt(x, y, "Speed: %f (_DestTime(%f) - _LastFrameTime(%f)) = %f", speed(), _DestTime, _LastFrameTime, _DestTime-_LastFrameTime);
	y += lineStep;
	// Display the Run Factor.
	TextContext->printfAt(x, y, "(Walk)Run Factor: %f", runFactor());
	y += lineStep;
	// Display the current animation name(id)(offset)(nbloop) pour le channel MOVE.
	TextContext->printfAt(x, y, "Current Animation: %s(%u)(%f)(%u loops)", animId(MOVE)==-1?"[NONE]":currentAnimationName().c_str(), animId(MOVE), animOffset(MOVE), _NbLoopAnim);
	y += lineStep;
	// First Pos
	if(_First_Pos)
		TextContext->printfAt(x, y, "No Position Received", _First_Pos);
	else
		TextContext->printfAt(x, y, "At least 1 Position Received", _First_Pos);
	y += lineStep;
	// Primitive Ptr
	TextContext->printfAt(x, y, "Prim Ptr: %p", _Primitive);
	y += lineStep;
	// Primitive Position
	if(_Primitive)
	{
		CVectorD primFinalPos = _Primitive->getFinalPosition(dynamicWI);
		TextContext->printfAt(x, y, "Prim Pos: %f %f %f", primFinalPos.x, primFinalPos.y, primFinalPos.z);
		y += lineStep;
	}
	// Skeleton Ptr
	TextContext->printfAt(x, y, "Skel Ptr: %p", _Skeleton);
	y += lineStep;
	// Animset Ptr
	TextContext->printfAt(x, y, "AnimSet Ptr: %p", _CurrentAnimSet[MOVE]);
	y += lineStep;
	// Current State Ptr
	TextContext->printfAt(x, y, "State Ptr: %p", _CurrentState);
	y += lineStep;
	// Display the target mount and rider.
	TextContext->printfAt(x, y, "Mount: %3u(Theoretical: %3u) Rider: %3u(Theoretical: %3u)", mount(), _TheoreticalMount, rider(), _TheoreticalRider);
	y += lineStep;
	// VPA
	sint64 prop = IM->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->getValue64();
	if(isPlayer() || isUser())
	{
		SPropVisualA visualA = *(SPropVisualA *)(&prop);
		TextContext->printfAt(x, y, "VPA: %"NL_I64"X : Chest(%d,%d) Legs(%d,%d) Arms(%d,%d) Hat(%d,%d) RH(%d) LH(%d)", prop,
			(uint)visualA.PropertySubData.JacketModel,	(uint)visualA.PropertySubData.JacketColor,
			(uint)visualA.PropertySubData.TrouserModel,	(uint)visualA.PropertySubData.TrouserColor,
			(uint)visualA.PropertySubData.ArmModel,		(uint)visualA.PropertySubData.ArmColor,
			(uint)visualA.PropertySubData.HatModel,		(uint)visualA.PropertySubData.HatColor,
			(uint)visualA.PropertySubData.WeaponRightHand,
			(uint)visualA.PropertySubData.WeaponLeftHand);
	}
	else
		TextContext->printfAt(x, y, "VPA: %"NL_I64"X", prop);
	y += lineStep;
	// VPB
	prop = IM->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPB))->getValue64();
	if(isPlayer() || isUser())
	{
		SPropVisualB visualB = *(SPropVisualB *)(&prop);
		TextContext->printfAt(x, y, "VPB: %"NL_I64"X : Hands(%d,%d) Feet(%d,%d).", prop,
			(uint)visualB.PropertySubData.HandsModel,	(uint)visualB.PropertySubData.HandsColor,
			(uint)visualB.PropertySubData.FeetModel,	(uint)visualB.PropertySubData.FeetColor);
	}
	else
		TextContext->printfAt(x, y, "VPB: %"NL_I64"X", prop);
	y += lineStep;
	// VPC
	prop = IM->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPC))->getValue64();
	if(isPlayer() || isUser())
	{
		SPropVisualC visualC = *(SPropVisualC *)(&prop);
		TextContext->printfAt(x, y, "VPC: %"NL_I64"X : EyesColor(%d) Tattoo(%d).", prop, visualC.PropertySubData.EyesColor, visualC.PropertySubData.Tattoo);
	}
	else
		TextContext->printfAt(x, y, "VPC: %"NL_I64"X", prop);
	y += lineStep;
}// displayDebug //



//-----------------------------------------------
// displayDebugPropertyStages
//-----------------------------------------------
void CCharacterCL::displayDebugPropertyStages(float x, float &y, float lineStep)
{
	CStageSet::TStageSet::iterator	it= _Stages._StageSet.begin();
	for(;it!=_Stages._StageSet.end();it++)
	{
		CStage &stage= it->second;
		uint32	gc= it->first % 100;
		// build the string of props present in this stage
		string	strProps;
		for(uint i=0;i<CLFECOMMON::NB_VISUAL_PROPERTIES;i++)
		{
			if(i!=CLFECOMMON::PROPERTY_POSY && i!=CLFECOMMON::PROPERTY_POSZ && stage.isPresent(i))
				strProps+= string(CLFECOMMON::getPropShortText(i)) + " ";
		}
		TextContext->printfAt(x, y, "%02d %s", gc, strProps.c_str());
		y += lineStep;
	}
}


//---------------------------------------------------
// readWrite :
// Read/Write Variables from/to the stream.
//---------------------------------------------------
void CCharacterCL::readWrite(class NLMISC::IStream &f) throw(NLMISC::EStream)
{
	CEntityCL::readWrite(f);

	// PUBLIC

	// PROTECTED
	f.serial(_Stages);
//	std::vector<CAnimation::TAnimId>			_Animations;
//	std::vector<NLSOUND::TSoundAnimId>			_SoundId;
//	NLSOUND::CSoundContext						_SoundContext;
//	std::vector<double>							_AnimationsTimeOffset;
//	std::vector<CAnimationState::TAnimStateId>	_AnimationsStateKey;
//	const CAnimationSet							*_CurrentAnimSet;
	f.serial(_LastFrameTime);
	f.serial(_LodCharacterAnimEnabled);
	f.serial(_LodCharacterAnimTimeOffset);
//	uint										_LodCharacterMasterAnimSlot;
	f.serial(_CharacterScalePos);
	f.serial(_FirstPos);
	f.serial(_FirstTime);
	f.serial(_DistToFirst);
	f.serial(_DestPos);
	f.serial(_DestTime);
	f.serial(_DistToDest);
	f.serial(_OldPos);
	f.serial(_OldPosTime);
//	GSGENDER::EGender							_Gender;
//	sint										_NameBoneId;
//	NL3D::UTransform							_NameTransform;
//	std::vector<CItemSheet *>					_Items;
	f.serial(_HeadIdx);
	f.serial(_FaceIdx);
//	sint	_HeadBoneId;
	f.serial(_RotationFactor);
	f.serial(_DirEndAnim);
	f.serial(_RotAngle);
	f.serial(_CurrentAutomaton);
//	const CAutomatonStateSheet					*_CurrentState;
//	MBEHAV::EMode								_ModeWanted;
//	sint										_BlendRemaining;
	f.serial(_OldAutomaton);
	f.serial(_OldRotQuat);
	f.serial(_CustomScalePos);
//	TTime										_NextBlinkTime;
	f.serial(_NbLoopAnim);
//	std::vector<CFXStruct *>					_FXs;
//	std::list<UParticleSystemInstance>			_CurrentAnimFXList;
//	std::list<UParticleSystemInstance>			_RemoveAnimFXList;
//	NL3D::UParticleSystemInstance				_CurrentAnimFX;
	f.serial(_RightFXActivated);
	f.serial(_LeftFXActivated);
//	sint										_IndexRightFX;
//	sint										_IndexLeftFX;
	f.serial(_Mount);
	f.serial(_Rider);
	f.serial(_IsThereAMode);
	f.serial(_HairColor);
	f.serial(_EyesColor);
	f.serial(_HairIndex);
	f.serial(_LookRdy);
	f.serial(_Speed);
	f.serial(_RunFactor);

	// PRIVATE
//	uint32						_RHandInstIdx;
//	uint32						_LHandInstIdx;
}// readWrite //

//---------------------------------------------------
// load :
// To call after a read from a stream to re-initialize the entity.
//---------------------------------------------------
void CCharacterCL::load()	// virtual
{
	CInterfaceManager *IM = CInterfaceManager::getInstance ();

	// If the entity should be in the world already
	if(_First_Pos == false)
	{
		// Insert the primitive into the world.
		if(_Primitive)
			_Primitive->insertInWorldImage(dynamicWI);
		// Insert the entity into PACS
		pacsPos(pos());
	}

	if(_LookRdy)
	{
		_LookRdy = false;
		// Visual properties A
		_HeadIdx = CEntityCL::BadIndex;
		sint64 prop = IM->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->getValue64();
		updateVisualPropertyVpa(0, prop);
	}
}// load //

//---------------------------------------------------
// buildPlaylist :
//---------------------------------------------------
void CCharacterCL::buildPlaylist()
{
	computeAnimSet();
	// Release the old animation playlist.
	if(_PlayList)
	{
		EAM->deletePlayList(_PlayList);
		_PlayList = 0;
	}
	// Create the new animation playlist.
	_PlayList = EAM->createPlayList();
	if(!_PlayList)
	{
		nlwarning("Cannot create a playlist for the entity.");
		return;
	}
	// Register the skeleton to the playlist.
	_PlayList->registerTransform(_Skeleton);
	// Animation should not move alone.
	uint posChannel = EAM->getAnimationSet()->getChannelIdByName("pos");
	if(posChannel != NL3D::UAnimationSet::NotFound)
		_PlayList->enableChannel(posChannel, false);
	else
		nlwarning("Channel 'pos' not found.");
	// Animation should not rotate alone.
	uint rotquatChannel = EAM->getAnimationSet()->getChannelIdByName("rotquat");
	if(rotquatChannel != NL3D::UAnimationSet::NotFound)
		_PlayList->enableChannel(rotquatChannel, false);
	else
		nlwarning("Channel 'rotquat' not found.");
	// Initialize the new playlist.
	// MOVE Channel
	_PlayList->setSpeedFactor	(MOVE, 1.f);
	_PlayList->setWrapMode		(MOVE, NL3D::UPlayList::Clamp);
	// ACTION Channel
	_PlayList->setAnimation     (ACTION, NL3D::UPlayList::empty);
	_PlayList->setSpeedFactor	(ACTION, 1.f);
	_PlayList->setWrapMode		(ACTION, NL3D::UPlayList::Clamp);
	// Compute the current animation state.
	_CurrentState = EAM->mState(_CurrentAutomaton, animState(MOVE));
	if(_CurrentState == 0)
	{
		_PlayList->setAnimation(MOVE, NL3D::UPlayList::empty);
		return;
	}
	// Get the right animation state and choose an animation.
	{
		// Get the animation state
		const CAnimationState *animationState = 0;
		if(animState(MOVE) == CAnimationStateSheet::Emote)
			animationState = _CurrentAnimSet[MOVE]->getAnimationState(_SubStateKey);
		else
			animationState = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
		if(animationState)
		{
			// Choose the animation
			animIndex(MOVE, animationState->chooseAnim(_AnimJobSpecialisation, people(), getGender(), 0.0));
			// Should the objects in hands be displayed ?
			_ObjectsVisible = animationState->areObjectsVisible();
		}
	}
	// Set animation
	_PlayList->setAnimation(MOVE, animId(MOVE));
}// buildPlaylist //

//--------------//
// ENTITY INFOS //
//--------------//
//-----------------------------------------------
// getSpeed :
// Return the entity speed
//-----------------------------------------------
double CCharacterCL::getSpeed() const	// virtual
{
	return speed();
}// getSpeed //

//-----------------------------------------------
// dist2FirstPos :
// Set the Distance from the current entity position to the First Position.
//-----------------------------------------------
void CCharacterCL::dist2FirstPos(double d2FP)
{
	CHECK((d2FP == INVALID_DIST) || (d2FP == 0.0) || (d2FP >= ClientCfg.DestThreshold));
	_DistToFirst = d2FP;
}// dist2FirstPos //
//-----------------------------------------------
// dist2FirstPos :
// Return the Distance from the current entity position to the First Position.
//-----------------------------------------------
double CCharacterCL::dist2FirstPos() const
{
	CHECK((_DistToFirst == INVALID_DIST) || (_DistToFirst == 0.0) || (_DistToFirst >= ClientCfg.DestThreshold));
	return _DistToFirst;
}// dist2FirstPos //

//-----------------------------------------------
// dist2Dest :
// Set the Distance from the current entity position to the Destination.
//-----------------------------------------------
void CCharacterCL::dist2Dest(double d2D)
{
	CHECK((d2D == INVALID_DIST) || (d2D == 0.0) || (d2D >= ClientCfg.DestThreshold));
	_DistToDest = d2D;
}// dist2Dest //

//-----------------------------------------------
// dist2Dest :
// Return the Distance from the current entity position to the Destination.
//-----------------------------------------------
double CCharacterCL::dist2Dest() const
{
	CHECK((_DistToDest == INVALID_DIST) || (_DistToDest == 0.0) || (_DistToDest >= ClientCfg.DestThreshold));
	return _DistToDest;
}// dist2Dest //

//-----------------------------------------------
// speed :
// Set the Entity Current Speed.
//-----------------------------------------------
void CCharacterCL::speed(double s)
{
	CHECK((s == -1.0) || (s == 0.0) || ((s >= 0.001) && (s <= 1000.0)));
	_Speed = s;
}// speed //

//-----------------------------------------------
// speed :
// Return the Entity Current Speed.
//-----------------------------------------------
double CCharacterCL::speed() const	// virtual
{
	CHECK((_Speed == -1.0) || (_Speed == 0.0) || ((_Speed >= 0.001) && (_Speed <= 1000.0)));
	return _Speed;
}// getSpeed //

//-----------------------------------------------
// Build the in scene interface
//-----------------------------------------------
void CCharacterCL::buildInSceneInterface ()
{
	// Delete previous interface
	releaseInSceneInterfaces();

	_InSceneUserInterface = CGroupInSceneUserInfo::build (this);

	// parent
	CEntityCL::buildInSceneInterface();
}

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

void CCharacterCL::setBubble (CGroupInSceneBubble *bubble)
{
	if (_CurrentBubble != NULL)
	{
		CGroupInSceneBubble	*old = _CurrentBubble;
		_CurrentBubble = NULL;
		old->unlink();
	}
	nlassert (_CurrentBubble == NULL);
	_CurrentBubble = bubble;
}

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

//-----------------------------------------------
// runFactor :
// Set the Factor between Walk & Run
//-----------------------------------------------
void CCharacterCL::runFactor(double factor)
{
	CHECK((factor >= 0.0) && (factor <= 1.0));
	CHECK((factor == 0.0) || (animState(MOVE) == CAnimationStateSheet::Walk));
	_RunFactor = factor;
}// runFactor //

//-----------------------------------------------
// runFactor :
// Get the Factor between Walk & Run
//-----------------------------------------------
double CCharacterCL::runFactor() const
{
	CHECK((_RunFactor >= 0.0) && (_RunFactor <= 1.0));
	CHECK((_RunFactor == 0.0) || (animState(MOVE) == CAnimationStateSheet::Walk));
	return _RunFactor;
}// runFactor //

//-----------------------------------------------
// animOffset :
// Set the animation time offset for an animation channel.
//-----------------------------------------------
void CCharacterCL::animOffset(TAnimationType channel, double timeOffset)
{
	if(ClientCfg.Light)
		return;
	// Check the channel
	CHECK((uint)channel < _AnimOffset.size());
	// Check Animation Time Offset is greater or equal to 0.
	CHECK(timeOffset >= 0.0);
	// Check the animation time offset is not greater to the animation length.
	CHECK(timeOffset <= EAM->getAnimationLength(animId(channel)));
	// Set the Value
	_AnimOffset[channel] = timeOffset;
}// animOffset //

//-----------------------------------------------
// animOffset :
// Return the animation time offset for an animation channel.
//-----------------------------------------------
double CCharacterCL::animOffset(TAnimationType channel) const
{
	if(ClientCfg.Light)
		return 0.0;
	// Check the channel
	CHECK((uint)channel < _AnimOffset.size());
	// Check Animation Time Offset is greater or equal to 0.
	CHECK(_AnimOffset[channel] >= 0.0);
	// Check the animation time offset is not greater to the animation length.
	CHECK(_AnimOffset[channel] <= EAM->getAnimationLength(animId(channel)));
	// Return the Value
	return _AnimOffset[channel];
}// animOffset //

//---------------------------------------------------
// animationStateKey :
// Set the animation state key.
// \todo GUIGUI : a remplacer par animState directement.
//---------------------------------------------------
bool CCharacterCL::animationStateKey(TAnimationType channel, TAnimStateId value)
{
	// Is the new key valid ?
	if(value == CAnimationStateSheet::UnknownState)
	{
		nlwarning("CH::animationStateKey: Char '%d': new state key is Null.", _Slot);
		return false;
	}
	// Set the new key.
	animState(channel, value);
	// Debug Animation for the selection
	if(VerboseAnimSelection && _Slot == UserEntity->selection())
		nlinfo("CH:animationStateKey:%d: state '%s'.", _Slot, CAnimationState::getAnimationStateName(value).c_str());
	//
	return true;
}// animationStateKey //

//-----------------------------------------------
// animState :
// Set the Animation 'State' for an animation channel.
//-----------------------------------------------
void CCharacterCL::animState(TAnimationType channel, TAnimStateId state)
{
	// Check the channel
	CHECK((uint)channel < _AnimState.size());
	// Set the new State
	_AnimState[channel] = state;
	// Reset the Run Factor when the state change.
	runFactor(0.0);
}// animState //

//-----------------------------------------------
// animState :
// Get the Animation 'State' for an animation channel.
//-----------------------------------------------
TAnimStateId CCharacterCL::animState(TAnimationType channel) const
{
	// Check the channel
	CHECK((uint)channel < _AnimState.size());
	// Return the Animation State
	return _AnimState[channel];
}// animState //

//-----------------------------------------------
// animIndex :
// Set the Animation 'Index' in the 'State' for an animation channel.
//-----------------------------------------------
void CCharacterCL::animIndex(TAnimationType channel, CAnimation::TAnimId index)
{
	// Check the channel
	CHECK((uint)channel < _AnimState.size());
	// Set the animation index in the state
	_AnimIndex[channel] = index;
	// Set the animation Id
	// If the current animation Index is not a valid one, return empty
	if(_AnimIndex[channel] == CAnimation::UnknownAnim)
		animId(channel, NL3D::UPlayList::empty);
	else
	{
		// Check the AnimSet needed to get the animation Id.
		CHECK(_CurrentAnimSet[channel]);
		// Get the Pointer on the animation state, if Null, return empty
		const CAnimationState *animStatePtr = _CurrentAnimSet[channel]->getAnimationState( (animState(channel)==CAnimationStateSheet::Emote)?_SubStateKey:animState(channel));
		if(animStatePtr == 0)
			animId(channel, NL3D::UPlayList::empty);
		else
		{
			// Get the Animation Pointer, if Null, return Empty
			const CAnimation *anim = animStatePtr->getAnimation(animIndex(channel));
			if(anim == 0)
				animId(channel, NL3D::UPlayList::empty);
			// Return The Animation ID
			else
				animId(channel, anim->id());
		}
	}
}// animIndex //

//-----------------------------------------------
// animIndex :
// Get the Animation 'Index' in the 'State' for an animation channel.
//-----------------------------------------------
CAnimation::TAnimId CCharacterCL::animIndex(TAnimationType channel) const
{
	// Check the channel
	CHECK((uint)channel < _AnimState.size());
	// Return the Animation Index in the State
	return _AnimIndex[channel];
}//animIndex //

//-----------------------------------------------
// animId :
// Set the Animation 'Id' among all the animations for an animation channel.
//-----------------------------------------------
void CCharacterCL::animId(TAnimationType channel, uint id)
{
	// Check the channel
	CHECK((uint)channel < _AnimId.size());
	// Set the Id
	_AnimId[channel] = id;
}// animId //

//-----------------------------------------------
// animId :
// Get the Animation 'Id' among all the animations for an animation channel.
//-----------------------------------------------
uint CCharacterCL::animId(TAnimationType channel) const
{
	// Check the channel
	CHECK((uint)channel < _AnimId.size());
	// Get the Id
	return _AnimId[channel];
}// animId //



//-----------------------------------------------
// Align the given FX so that it is oriented like that entity
//-----------------------------------------------
void CCharacterCL::alignFX(UParticleSystemInstance instance, float scale /* = 1.f */, const NLMISC::CVector &localOffset /*= NLMISC::CVector::Null*/) const
{
	// copy matrix from parent
	CMatrix fxMatrix;
	fxMatrix.identity();
	buildAlignMatrix(fxMatrix);
	alignFX(instance, fxMatrix, scale, localOffset);
}


void CCharacterCL::alignFX(UParticleSystemInstance instance, const CMatrix &matrix, float scale /*=1.f*/, const NLMISC::CVector &localOffset /*=NLMISC::CVector::Null*/) const
{
	if(instance.empty())
		return;
	CMatrix fxMatrix = matrix;
	if (scale != 1.f) fxMatrix.scale(scale);
	fxMatrix.setPos(fxMatrix.getPos() + fxMatrix.mulVector(localOffset));
	instance.setTransformMode(NL3D::UTransform::DirectMatrix);
	instance.setMatrix(fxMatrix);
	if(!_Skeleton.empty())
	{
		instance.setClusterSystem(_Skeleton.getClusterSystem());
	}
}


//------------------------------------------------------------
// build a matrix aligned on that entity (includes dir & pos)
//------------------------------------------------------------
void CCharacterCL::buildAlignMatrix(NLMISC::CMatrix &dest) const
{
	// if not in clod, pelvis bone has been computed -> use it to get the current orientation
	// use the dir matrix otherwise
	/*CVector forward;
	if (pelvisBone() != -1 && _Skeleton)
	{
		if (_Skeleton.isBoneComputed(pelvisBone()))
		{
			// the direction is given by the y axis
			NL3D::UBone pelvisBone = _Skeleton.getBone(pelvisBone());
			forward = pelvisBone->getMatrix().getJ();
			forward.z = 0.f; // project onto XY plane
			forward.normalize();
		}
		else
		{
			// must be in clod -> use the direction
			forward = _Front;
		}
	}
	else
	{
		// bone not found, use the direction
		forward = _Front;
	}
	dest.setRot(- forward, forward ^ CVector::K, CVector::K);
	*/
	dest.setRot(CVector::K ^ _Front, - _Front, CVector::K);
	dest.setPos(pos());
}


//-----------------------------------------------
// attachFXInternal
//-----------------------------------------------
void	CCharacterCL::attachFXInternal(const CAttachedFX::TSmartPtr fx, TAttachedFXList targetList)
{
	if (!fx) return;
	switch(targetList)
	{
		case FXListToRemove:
			fx->TimeOutDate += TimeInSec; // in remove list timeout date is absolute
			_AttachedFXListToRemove.push_front(fx);
		break;
		case FXListCurrentAnim:
			_AttachedFXListForCurrentAnim.push_front(fx);
		break;
		case FXListAuto:
		{
			if (fx->AniFX->Sheet)
			{
				switch(fx->AniFX->Sheet->RepeatMode)
				{
					case CAnimationFXSheet::Respawn:
						fx->TimeOutDate += TimeInSec; // in remove list timeout date is absolute
						_AttachedFXListToRemove.push_front(fx);
					break;
					default:
						_AttachedFXListForCurrentAnim.push_front(fx);
					break;
				}
			}
			else
			{
				fx->TimeOutDate += TimeInSec; // in remove list timeout date is absolute
				_AttachedFXListToRemove.push_front(fx);
			}
		}
		break;
		default:
			nlassert(0);
		break;
	}
}

//-----------------------------------------------
// attachFX
//-----------------------------------------------
void	CCharacterCL::attachFX(const CAttachedFX::TSmartPtr fx)
{
	attachFXInternal(fx, FXListToRemove);
}





// ***********************************************************************************************************************
void CCharacterCL::setAuraFX(uint index, const CAnimationFX *sheet)
{
	nlassert(index < MaxNumAura);
	// no-op if same aura
	if (_AuraFX[index] && _AuraFX[index]->AniFX == sheet) return;

	if (sheet == NULL)
	{
		// if there's already an aura attached, and if it is not already shutting down
		if (_AuraFX[index] && _AuraFX[index]->TimeOutDate == 0.f)
		{
			_AuraFX[index]->TimeOutDate = TimeInSec + AURA_SHUTDOWN_TIME;
		}
	}
	else
	{
		// remove previous aura
		_AuraFX[index] = NULL;
		CAttachedFX::TSmartPtr fx = new CAttachedFX;
		CAttachedFX::CBuildInfo bi;
		bi.Sheet = sheet;
		bi.TimeOut =  0.f;
		fx->create(*this, bi, CAttachedFX::CTargeterInfo());
		if (!fx->FX.empty())
		{
			_AuraFX[index] = fx;
		}
	}
}

// ***********************************************************************************************************************
void CCharacterCL::setLinkFX(const CAnimationFX *fx, const CAnimationFX *dispell)
{
	// no-op if same link
	if (_LinkFX && _LinkFX->AniFX == fx) return;
	if (_LinkFX)
	{
		if (dispell)
		{
			CAttachedFX::TSmartPtr fx = new CAttachedFX;
			CAttachedFX::CBuildInfo bi;
			bi.Sheet = dispell;
			fx->create(*this, bi, CAttachedFX::CTargeterInfo());
			attachFX(fx);
		}
	}
	_LinkFX = NULL;
	if (!fx) return;
	CAttachedFX::TSmartPtr linkFX = new CAttachedFX;
	CAttachedFX::CBuildInfo bi;
	bi.Sheet = fx;
	linkFX->create(*this, bi, CAttachedFX::CTargeterInfo());
	if (!linkFX->FX.empty())
	{
		_LinkFX = linkFX;
	}
}



// ***********************************************************************************************************************
void CCharacterCL::startItemAttackFXs(bool activateTrails, uint intensity)
{
	uint numItems = (uint)_Items.size();
	forceEvalAnim(); // force to eval bones at least once when fx are created
	for(uint k = 0; k < numItems; ++k)
	{
		_Items[k].startAttackFX(_Skeleton, intensity, (SLOTTYPE::EVisualSlot) k, activateTrails);
	}
}

// ***********************************************************************************************************************
void CCharacterCL::stopItemAttackFXs()
{
	uint numItems = (uint)_Items.size();
	for(uint k = 0; k < numItems; ++k)
	{
		if (_Items[k].Sheet)
		{
			_Items[k].stopAttackFX();
		}
	}
}


//-----------------------------------------------
// isNeutral :
//-----------------------------------------------
bool CCharacterCL::isNeutral() const
{
	return !isEnemy();
}

//-----------------------------------------------
// isFriend :
//-----------------------------------------------
bool CCharacterCL::isFriend () const
{
	return !isEnemy();
}

//-----------------------------------------------
// isEnemy :
//-----------------------------------------------
bool CCharacterCL::isEnemy () const
{
	// Suppose enemy if attackable
	if( properties().attackable() )
	{
		return true;
	}

	return isAnOutpostEnemy();
}


//-----------------------------------------------
// isAlly :
//-----------------------------------------------
bool CCharacterCL::isAlly () const
{
	return this->isAnOutpostAlly();
}


//-----------------------------------------------
// applyVisualFX
//-----------------------------------------------
void CCharacterCL::applyVisualFX(sint64 prop)
{
	CVisualFX vfx;
	vfx.unpack(prop);
	const CAnimationFX *auraFX = NULL;
	if (vfx.Aura != 0)
	{
		auraFX = CAttackListManager::getInstance().getAuras().getFX(vfx.Aura);
	}
	setAuraFX(0, auraFX);
	const CAnimationFX *auraReceiptFX = NULL;
	if (vfx.AuraReceipt)
	{
		auraReceiptFX = CAttackListManager::getInstance().getAuras().getFX(0);
	}
	setAuraFX(1, auraReceiptFX);
	const CAnimationFX *linkFX = NULL;
	if (vfx.Link != 0)
	{
		linkFX = CAttackListManager::getInstance().getLinks().getFX(vfx.Link);
	}
	const CAnimationFX *dispellFX = NULL;
	dispellFX = CAttackListManager::getInstance().getLinks().getFX(0);
	setLinkFX(linkFX, dispellFX);
}

// *********************************************************************************************
const char *CCharacterCL::getBoneNameFromBodyPart(BODY::TBodyPart part, BODY::TSide side) const
{
	if (!_Sheet) return CEntityCL::getBoneNameFromBodyPart(part, side);
	return _Sheet->BodyToBone.getBoneName(part, side);
}


// *********************************************************************************************
const CItemSheet *CCharacterCL::getRightHandItemSheet() const
{
	if (_RHandInstIdx == CEntityCL::BadIndex) return NULL;
	return _Items[_RHandInstIdx].Sheet;
}

// *********************************************************************************************
const CItemSheet *CCharacterCL::getLeftHandItemSheet() const
{
	if (_LHandInstIdx == CEntityCL::BadIndex) return NULL;
	return _Items[_LHandInstIdx].Sheet;
}

// ***************************************************************************
void	CCharacterCL::resetAllSoundAnimId()
{
	for(uint i=0;i<_SoundId.size();i++)
	{
		_SoundId[i]= CSoundAnimationNoId;
	}
}


/////////////////////////////
// CCharacterCL::CWornItem //
/////////////////////////////


// ***********************************************************************************************************************
void CCharacterCL::CWornItem::startAttackFX(NL3D::USkeleton skeleton, uint intensity, SLOTTYPE::EVisualSlot visualSlot, bool activateTrail)
{
	if (intensity < 1 || intensity > 5) return;
	// activate trail
	if (activateTrail && !Trail.empty())
	{
		Trail.start();
	}
	// create the attack fx
	if (Sheet)
	{
		const CItemFXSheet &fxSheet = Sheet->FX;
		std::string shapeName = fxSheet.getAttackFX();
		if (!shapeName.empty())
		{
			const char *stickPoint = NULL;
			if(!skeleton.empty())
			{
				switch(visualSlot)
				{
					case SLOTTYPE::RIGHT_HAND_SLOT:
						if( Sheet->ItemType != ITEM_TYPE::MAGICIAN_STAFF )
							stickPoint = "box_arme";
					break;
					case SLOTTYPE::LEFT_HAND_SLOT:
						if(Sheet && Sheet->getAnimSet()=="s")
							stickPoint = "Box_bouclier";
						else
							stickPoint = "box_arme_gauche";
					break;
					default:
					break;
				}
			}
			if (stickPoint)
			{
				sint boneId = skeleton.getBoneIdByName(std::string(stickPoint));
				if (boneId != -1)
				{
					NL3D::UInstance instance = Scene->createInstance(shapeName);
					if (!instance.empty())
					{
						instance.show();
						if (skeleton.getVisibility() == UTransform::Hide)
						{
							// force to compute the bone at least once
							skeleton.forceComputeBone(boneId);
						}
						UParticleSystemInstance atk;
						atk.cast (instance);
						if (!atk.empty())
						{
							// set the user params
							static const float up[5][4] =
							{
								{ 0.f, 0.f, 0.f, 0.f},
								{ 1.f, 0.f, 0.f, 0.f},
								{ 1.f, 1.f, 0.f, 0.f},
								{ 1.f, 1.f, 1.f, 0.f},
								{ 1.f, 1.f, 1.f, 1.f}
							};
							for(uint k = 0; k < 4; ++k)
							{
								atk.setUserParam(k, up[intensity - 1][k]);
							}
							atk.setTransformMode(UTransform::RotEuler);
							atk.setPos(fxSheet.AttackFXOffset);
							const float degreeToRad = (float) Pi / 180.f;
							atk.setRotEuler(fxSheet.AttackFXRot.x * degreeToRad, fxSheet.AttackFXRot.y * degreeToRad, fxSheet.AttackFXRot.z * degreeToRad);
							skeleton.stickObject(atk, boneId);
							// delegate mng of this object lifetime to the fx manager
							FXMngr.fx2remove(atk);
						}
						else
						{
							Scene->deleteInstance(atk);
						}
					}
				}
			}
		}
	}
}

// ***********************************************************************************************************************
void CCharacterCL::CWornItem::stopAttackFX()
{
	if (!Trail.empty()) Trail.stop();
}

// ***********************************************************************************************************************
void CCharacterCL::CWornItem::initFXs(SLOTTYPE::EVisualSlot /* visualSlot */, NL3D::UInstance parent)
{
	releaseFXs();
	if (!Sheet) return;
	// create trail fx
	const CItemFXSheet &sheet = Sheet->FX;
	std::string shapeName = sheet.getTrail();
	if (!shapeName.empty())
	{
		Trail = Scene->createInstance(shapeName);
		if (Trail.empty())
		{
			nlwarning("Cannot create instance %s", shapeName.c_str());
			return;
		}
		// Initialize the remanence. Must substract the object matrix since parent(parent)
		CMatrix mat = parent.getMatrix();
		mat.invert();
		mat *= Trail.getMatrix();
		Trail.setTransformMode(UTransformable::DirectMatrix);
		Trail.setMatrix(mat);
		// Initialize instance.
		Trail.parent(parent);
	}
}

// ***********************************************************************************************************************
void CCharacterCL::CWornItem::enableAdvantageFX(NL3D::UInstance parent)
{
	if (!Sheet) return;

	bool enabled = Sheet->HasFx;

	if ((enabled && !AdvantageFX.empty()) || (!enabled && AdvantageFX.empty()))
		return; // state did not change
	if (!enabled)
	{
		// well, it is unlikely that player will loses its ability to master an item after he gained it, but manage the case anyway.
		if (!AdvantageFX.removeByID('STOP') && !AdvantageFX.removeByID('main'))
		{
			AdvantageFX.activateEmitters(false);
		}
		FXMngr.fx2remove(AdvantageFX);
		AdvantageFX = NULL;
	}
	else
	{
		std::string shapeName = Sheet->FX.getAdvantageFX();
		if (!shapeName.empty())
		{
			NL3D::UInstance fx = Scene->createInstance(shapeName);
			if (fx.empty()) return;
			AdvantageFX.cast (fx);
			if (AdvantageFX.empty())
			{
				Scene->deleteInstance(fx);
				return;
			}
			CMatrix mat = parent.getMatrix();
			mat.invert();
			mat *= AdvantageFX.getMatrix();
			AdvantageFX.setTransformMode(UTransformable::DirectMatrix);
			AdvantageFX.setMatrix(mat);
			AdvantageFX.parent(parent);
		}
	}
}

// ***********************************************************************************************************************
void CCharacterCL::CWornItem::releaseFXs()
{
	if (Scene)
	{
		if (!Trail.empty())
			Scene->deleteInstance(Trail);
		if (!AdvantageFX.empty())
			Scene->deleteInstance(AdvantageFX);
	}
}

// ***********************************************************************************************************************
void CCharacterCL::CWornItem::setTrailSize(uint size)
{
	if (Trail.empty()) return;
	if (!Sheet) return;
	clamp(size, (uint) 0, (uint) 15);
	if (size == 0)
	{
		Trail.setSliceTime(0.f);
	}
	else
	{
		float ratio = (size - 1) / 15.f;
		Trail.setSliceTime(ratio * Sheet->FX.TrailMaxSliceTime + (1.f - ratio) *  Sheet->FX.TrailMinSliceTime);
	}
}


// ***********************************************************************************************************************
const CAttack *CCharacterCL::getAttack(const CAttackIDSheet &id) const
{
	if (!_Sheet) return NULL;
	return getAttack(id, _Sheet->AttackLists);
}

// ***********************************************************************************************************************
const CAttack *CCharacterCL::getAttack(const CAttackIDSheet &id, const std::vector<NLMISC::TSStringId> &attackList) const
{
	for(std::vector<NLMISC::TSStringId>::const_reverse_iterator it = attackList.rbegin(); it != attackList.rend(); ++it)
	{
		const CAttackList *al = CAttackListManager::getInstance().getAttackList(ClientSheetsStrings.get(*it));
		if (al)
		{
			const CAttack *attk = al->getAttackFromID(id);
			if (attk) return attk;
		}
	}
	return NULL;
}


// ***********************************************************************************************************************
void CCharacterCL::initStaticFX()
{
	_StaticFX = NULL;
	if (ClientCfg.Light) return;
	std::string staticFX = _Sheet->getStaticFX();
	if (!staticFX.empty())
	{
		CEntitySheet *sheet = SheetMngr.get(NLMISC::CSheetId(staticFX));
		if (sheet)
		{
			if (sheet->Type == CEntitySheet::ANIMATION_FX)
			{
				CAnimationFXSheet *afs = NLMISC::safe_cast<CAnimationFXSheet *>(sheet);
				_StaticFX = new CStaticFX;
				_StaticFX->AF.init(afs, EAM ? EAM->getAnimationSet() : NULL);
				_StaticFX->FX = new CAttachedFX;
				CAttachedFX::CBuildInfo bi;
				bi.Sheet = &_StaticFX->AF;
				_StaticFX->FX->create(*this, bi, CAttachedFX::CTargeterInfo());
				if (_StaticFX->FX->FX.empty())
				{
					_StaticFX = NULL;
					return;
				}

			}
		}
		else
		{
			nlwarning("Static fx %s not found", staticFX.c_str());
		}
	}
}

// ***************************************************************************
EGSPD::CPeople::TPeople CCharacterCL::people() const
{
	if(_Sheet)
		return _Sheet->Race;
	else
		return EGSPD::CPeople::Unknown;
}

// ***************************************************************************
void CCharacterCL::setPeople(EGSPD::CPeople::TPeople /* people */)
{
}

// ***************************************************************************

#if !FINAL_VERSION

// temp : begin cast of projectile (start begin anim and loop anim)
NLMISC_COMMAND(beginCast, "Start spell cast", "<spell_id> <strenght> [<mode> <caster slot> <behaviour>]")
{
	if (args.size() < 2) return false;
	if (args.size() > 5) return false;
	uint casterSlot = 0;
	if (args.size() >= 4)
	{
		fromString(args[3], casterSlot);
	}
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(casterSlot));
	if (!ch) return false;
	CBehaviourContext bc;
	// TODO : the type of missile is contained in the spell id
	if (args.size() >= 5)
	{
		sint missileType;
		fromString(args[4], missileType);
		bc.Behav.Behaviour = (MBEHAV::EBehaviour) (MBEHAV::CAST_OFF + missileType);
	}
	else
	{
		bc.Behav.Behaviour = MBEHAV::CAST_OFF;
	}
	//
	uint16 spellId;
	fromString(args[0], spellId);	// spell id is unused
	bc.Behav.Spell.SpellId = spellId;
	//bc.Behav.Spell.Resist = false;
	uint16 spellIntensity;
	fromString(args[1], spellIntensity);
	bc.Behav.Spell.SpellIntensity = spellIntensity;
	if (args.size() == 3)
	{
		uint16 spellMode;
		fromString(args[2], spellMode);
		bc.Behav.Spell.SpellMode = spellMode;
	}
	else
	{
		bc.Behav.Spell.SpellMode = MAGICFX::Bomb; // 'bomb' is the default
	}
	ch->applyBehaviour(bc);
	return true;
}

// temp : test fail of a cast
NLMISC_COMMAND(failCast, "Simulate failure of a spell cast", "<spell_id> <strenght> [<mode>]")
{
	if (args.size() < 2) return false;
	if (args.size() > 3) return false;
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(0));
	if (!ch) return false;
	CBehaviourContext bc;
	// TODO : the type of missile is contained in the spell id
	bc.Behav.Behaviour = MBEHAV::CAST_OFF_FAIL;
	//
	uint16 spellId;
	fromString(args[0], spellId);	// spell id is unused
	bc.Behav.Spell.SpellId = spellId;
	//bc.Behav.Spell.Resist = false;
	uint16 spellIntensity;
	fromString(args[1], spellIntensity);
	bc.Behav.Spell.SpellIntensity = spellIntensity;
	if (args.size() == 3)
	{
		uint16 spellMode;
		fromString(args[2], spellMode);
		bc.Behav.Spell.SpellMode = spellMode;
	}
	else
	{
		bc.Behav.Spell.SpellMode = MAGICFX::Bomb; // 'bomb' is the default
	}
	ch->applyBehaviour(bc);
	return true;
}

// temp to test cast of a projectile on another entity
NLMISC_COMMAND(projectile, "Cast a projectile on another entity", "<spellID> <strenght> [<mode> <target entity> <resist> <source entity>]" )
{
	if (args.size() < 2) return false;
	if (args.size() > 6) return false;
	uint8 casterSlot = 0;
	if (args.size() > 5)
	{
		fromString(args[5], casterSlot);
	}
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(casterSlot));
	if (!ch) return false;
	// create a new behaviour to apply to the user
	CBehaviourContext bc;
	uint16 spellId, spellIntensity;
	fromString(args[0], spellId);
	bc.Behav.Spell.SpellId = spellId;
	fromString(args[1], spellIntensity);
	bc.Behav.Spell.SpellIntensity = spellIntensity;
	// TODO : the type of missile is contained in the spell id
	bc.Behav.Behaviour = MBEHAV::CAST_OFF_SUCCESS;
	//
	if (args.size() > 2)
	{
		uint16 spellMode;
		fromString(args[2], spellMode);
		bc.Behav.Spell.SpellMode = spellMode;
	}
	else
	{
		bc.Behav.Spell.SpellMode = MAGICFX::Bomb; // 'bomb' is the default
	}
	if (args.size() > 3)
	{
		uint targetSlot;
		fromString(args[3], targetSlot);
		if (targetSlot >= CLFECOMMON::INVALID_SLOT) return false;
		CEntityCL *target = EntitiesMngr.entity(targetSlot);
		if (!target) return false;
		double dist = (target->pos() - ch->pos()).norm();
		bool resist = false;
		if (args.size() > 4) fromString(args[4], resist);
		bc.Targets.Targets.push_back(CMultiTarget::CTarget(targetSlot, resist, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
	}
	bc.BehavTime = TimeInSec;
	ch->applyBehaviour(bc);
	return true;
}

NLMISC_COMMAND(mtProjectile, "Cast a projectile on one or several entities", "<caster> <spellID> <strenght> <mode> <target0> [<target n>]*" )
{
	if (args.size() < 5) return false;
	uint8 casterSlot;
	fromString(args[0], casterSlot);
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(casterSlot));
	if (!ch) return false;
	// create a new behaviour to apply to the user
	CBehaviourContext bc;
	uint16 spellId, spellIntensity, spellMode;

	fromString(args[1], spellId);
	bc.Behav.Spell.SpellId = spellId;

	fromString(args[2], spellIntensity);
	bc.Behav.Spell.SpellIntensity = spellIntensity;

	fromString(args[3], spellMode);
	bc.Behav.Spell.SpellMode = spellMode;
	// get targets and their dist depending on the mode
	switch(bc.Behav.Spell.SpellMode)
	{
		case MAGICFX::Bomb:
		{
			uint mainTargetSlot;
			fromString(args[4], mainTargetSlot);
			if (mainTargetSlot >= CLFECOMMON::INVALID_SLOT) return false;
			CEntityCL *mainTarget = EntitiesMngr.entity(mainTargetSlot);
			if (mainTarget)
			{
				double dist = (mainTarget->pos() - ch->pos()).norm();
				bc.Targets.Targets.push_back(CMultiTarget::CTarget(mainTargetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
				for(sint k = 1; k < (sint) (args.size() - 4); ++k)
				{
					uint secondaryTargetSlot;
					fromString(args[4 + k], secondaryTargetSlot);
					if (secondaryTargetSlot >= CLFECOMMON::INVALID_SLOT) return false;
					CEntityCL *secondaryTarget = EntitiesMngr.entity(secondaryTargetSlot);
					if (secondaryTarget)
					{
						dist = (secondaryTarget->pos() - mainTarget->pos()).norm();
						bc.Targets.Targets.push_back(CMultiTarget::CTarget(secondaryTargetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
					}
				}
			}
		}
		break;
		case MAGICFX::Spray:
		{
			for(sint k = 0; k < (sint) (args.size() - 4); ++k)
			{
				uint targetSlot;
				fromString(args[4 + k], targetSlot);
				if (targetSlot >= CLFECOMMON::INVALID_SLOT) return false;
				CEntityCL *target = EntitiesMngr.entity(targetSlot);
				if (target)
				{
					double dist = (target->pos() - ch->pos()).norm();
					bc.Targets.Targets.push_back(CMultiTarget::CTarget(targetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
				}
			}
		}
		break;
		case MAGICFX::Chain:
		{
			CEntityCL *startSlot = ch;
			for(sint k = 0; k < (sint) (args.size() - 4); ++k)
			{
				uint targetSlot;
				fromString(args[4 + k], targetSlot);
				if (targetSlot >= CLFECOMMON::INVALID_SLOT) return false;
				CEntityCL *target = EntitiesMngr.entity(targetSlot);
				if (target)
				{
					double dist = (target->pos() - startSlot->pos()).norm();
					bc.Targets.Targets.push_back(CMultiTarget::CTarget(targetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
					startSlot = target;
				}
			}
		}
		break;
	}
	bc.BehavTime = TimeInSec;
	// TODO : the type of missile is contained in the spell id
	bc.Behav.Behaviour = MBEHAV::CAST_OFF_SUCCESS;
	//
	ch->applyBehaviour(bc);
	return true;
}

// temp to test cast of multitarget projectile on another entity
NLMISC_COMMAND(aura, "enable / disable aura on an entity", "<slot> <aura>")
{
	if (args.size() != 2) return false;
	uint slot;
	fromString(args[0], slot);
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(slot));
	if (!ch) return false;
	const CAnimationFX *fx = NULL;
	sint auraIndex;
	fromString(args[1], auraIndex);
	if (auraIndex != -1)
	{
		fx = CAttackListManager::getInstance().getAuras().getFX(auraIndex);
		if (!fx) return false;
	}
	ch->setAuraFX(0, fx);
	return true;
}

NLMISC_COMMAND(link, "enable / disable link on an entity", "<slot> <link>")
{
	if (args.size() != 2) return false;
	uint slot;
	fromString(args[0], slot);
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(slot));
	if (!ch) return false;
	const CAnimationFX *link = NULL;
	sint linkIndex;
	fromString(args[1], linkIndex);
	if (linkIndex != -1)
	{
		link = CAttackListManager::getInstance().getLinks().getFX(linkIndex + 1);
		if (!link) return false;
	}
	const CAnimationFX *linkBreak = CAttackListManager::getInstance().getLinks().getFX(0);
	if (!linkBreak) return false;
	ch->setLinkFX(link, linkBreak);
	return true;
}

NLMISC_COMMAND(auraReceipt, "enable / disable aura receipt on an entity", "<slot> <aura> <0=on/1=off>")
{
	if (args.size() != 2) return false;
	uint slot;
	fromString(args[0], slot);
	CCharacterCL *ch = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(slot));
	if (!ch) return false;
	const CAnimationFX *fx = NULL;
	bool enableAura;
	fromString(args[1], enableAura);
	if (enableAura)
	{
		fx = CAttackListManager::getInstance().getAuras().getFX(0); // 0 is special for aura receipt
		if (!fx) return false;
	}
	ch->setAuraFX(1, fx);
	return true;
}

////////////////////////////
// test for melee weapons //
////////////////////////////

// these are helpers (the same can be done with /vp, or altLook)
NLMISC_COMMAND(weapon, "change the weapon in hand", "<slot> <hand> <weapon>")
{
	if (args.size() != 3) return false;
	CInterfaceManager *im = CInterfaceManager::getInstance();
	uint slot;
	fromString(args[0], slot);
	CCDBNodeLeaf *propA = im->getDbProp(toString("SERVER:Entities:E%d:P%d", (int) slot, (int) PROPERTY_VPA), false);
	if (!propA) return false;
	sint64 valueA = propA->getValue64();

	CCDBNodeLeaf *propB = im->getDbProp(toString("SERVER:Entities:E%d:P%d", (int) slot, (int) PROPERTY_VPB), false);
	if (!propB) return false;
	sint64 valueB = propB->getValue64();

	uint hand;
	fromString(args[1], hand);

	// the VP is dependent of Entity actual type
	if(dynamic_cast<CPlayerCL*>(EntitiesMngr.entity(slot)))
	{
		SPropVisualA vpa = (SPropVisualA &) valueA;
		SPropVisualB vpb = (SPropVisualB &) valueB;
		if (hand == 0)
		{
			uint16 weaponRightHand;
			fromString(args[2], weaponRightHand);
			vpa.PropertySubData.WeaponRightHand = weaponRightHand;
			vpb.PropertySubData.RTrail = 1;
		}
		else
		{
			uint16 weaponLeftHand;
			fromString(args[2], weaponLeftHand);
			vpa.PropertySubData.WeaponLeftHand = weaponLeftHand;
			vpb.PropertySubData.LTrail = 1;
		}
		propA->setValue64((sint64) vpa.PropertyA);
		propB->setValue64((sint64) vpb.PropertyB);
	}
	// CharacterCL: use a SAltLook
	else
	{
		SAltLookProp vpalt = (SAltLookProp&) valueA;
		if (hand == 0)
		{
			uint16 weaponRightHand;
			fromString(args[2], weaponRightHand);
			vpalt.Element.WeaponRightHand = weaponRightHand;
			vpalt.Element.RTrail = 1;
		}
		else
		{
			uint16 weaponLeftHand;
			fromString(args[2], weaponLeftHand);
			vpalt.Element.WeaponLeftHand = weaponLeftHand;
			vpalt.Element.LTrail = 1;
		}
		propA->setValue64((sint64) vpalt.Summary);
	}

	// Force to update property
	EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPA);
	EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPB);

	// display name of weapon sheet

	return true;
}

NLMISC_COMMAND(advantageFX, "turn on / off the advantage fx for an item in hand", "<slot> <hand> <on = 1/ off = 0>")
{
	if (args.size() != 3) return false;
	CInterfaceManager *im = CInterfaceManager::getInstance();
	uint slot;
	fromString(args[0], slot);

	/*
	CCDBNodeLeaf *prop = im->getDbProp(toString("SERVER:Entities:E%d:P%d", (int) slot, (int) PROPERTY_VPA), false);
	if (!prop) return false;
	sint64 value = prop->getValue64();
	uint hand;
	fromString(args[1], hand);
	// the VP is dependent of Entity actual type
	if(dynamic_cast<CPlayerCL*>(EntitiesMngr.entity(slot)))
	{
		SPropVisualA vpa = (SPropVisualA &) value;
		if (hand == 0)
		{
			fromString(args[2], vpa.PropertySubData.RWeaponFX);
		}
		else
		{
			fromString(args[2], vpa.PropertySubData.LWeaponFX);
		}
		prop->setValue64((sint64) vpa.PropertyA);
	}
	// CharacterCL: use a SAltLook
	else
	{
		SAltLookProp vpa = (SAltLookProp&) value;
		if (hand == 0)
		{
			fromString(args[2], vpa.Element.RWeaponFX);
		}
		else
		{
			fromString(args[2], vpa.Element.LWeaponFX);
		}
		prop->setValue64((sint64) vpa.Summary);
	}
	*/

	// Force to update property
	EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPA);

	return true;
}

NLMISC_COMMAND(trailLength, "set length of trail for one weapon in hand", "<slot> <hand> <power = 0..15>")
{
	if (args.size() != 3) return false;
	CInterfaceManager *im = CInterfaceManager::getInstance();
	uint slot;
	fromString(args[0], slot);

	CCDBNodeLeaf *propA = im->getDbProp(toString("SERVER:Entities:E%d:P%d", (int) slot, (int) PROPERTY_VPA), false);
	if (!propA) return false;
	sint64 valueA = propA->getValue64();

	CCDBNodeLeaf *propB = im->getDbProp(toString("SERVER:Entities:E%d:P%d", (int) slot, (int) PROPERTY_VPB), false);
	if (!propB) return false;
	sint64 valueB = propB->getValue64();

	uint hand;
	fromString(args[1], hand);

	// the VP is dependent of Entity actual type
	if(dynamic_cast<CPlayerCL*>(EntitiesMngr.entity(slot)))
	{
		SPropVisualA vpa = (SPropVisualA &) valueA;
		SPropVisualB vpb = (SPropVisualB &) valueB;
		if (hand == 0)
		{
			uint16 rTrail;
			fromString(args[2], rTrail);
			vpb.PropertySubData.RTrail = rTrail;
			propB->setValue64((sint64) vpb.PropertyB);
		}
		else
		{
			uint16 lTrail;
			fromString(args[2], lTrail);
			vpb.PropertySubData.LTrail = lTrail / 2;
			propB->setValue64((sint64) vpb.PropertyB);
		}
	}
	else
	{
		SAltLookProp vpalt = (SAltLookProp &) valueA;
		if (hand == 0)
		{
			uint16 rTrail;
			fromString(args[2], rTrail);
			vpalt.Element.RTrail = rTrail;
		}
		else
		{
			uint16 lTrail;
			fromString(args[2], lTrail);
			vpalt.Element.LTrail = lTrail / 2;
		}
		propA->setValue64((sint64) vpalt.Summary);
	}

	// Force to update property
	EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPA);
	EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPB);

	return true;
}


// simulate an attack behaviour for the given slot
NLMISC_COMMAND(attack, "simulate an attack", "<slot> <intensity> <hit_type> <localisation> <dmg_type> <damage_shield_power> <damage_shield_id>")
{
	if (args.size() < 2) return false;
	if (args.size() > 7) return false;
	CBehaviourContext bc;
	bc.Behav.Behaviour = MBEHAV::DEFAULT_ATTACK;
	bc.Behav.Combat.ActionDuration = 0;
	uint16 impactIntensity;
	fromString(args[1], impactIntensity);
	bc.Behav.Combat.ImpactIntensity = impactIntensity;
	bc.Behav.Combat.HitType = HITTYPE::Hit;
	bc.Behav.Combat.Localisation = BODY::HHead;
	bc.Behav.Combat2.DamageType = 0;
	if (args.size() > 2)
	{
		uint16 hitType;
		fromString(args[2], hitType);
		bc.Behav.Combat.HitType = hitType + 1;
	}
	if (args.size() > 3)
	{
		uint16 localisation;
		fromString(args[3], localisation);
		bc.Behav.Combat.Localisation = localisation;
	}
	if (args.size() > 4)
	{
		uint16 damageType;
		fromString(args[4], damageType);
		bc.Behav.Combat2.DamageType = damageType;
	}
	uint dsPower = 0;
	uint dsType = 0;
	if (args.size() > 5)
	{
		fromString(args[5], dsPower);
	}
	if (args.size() > 6)
	{
		fromString(args[6], dsType);
	}

	uint slot;
	fromString(args[0], slot);
	CCharacterCL *entity = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(slot));
	if (!entity) return false;
	// push current slection as main target
	CMultiTarget::CTarget target;
	target.TargetSlot = UserEntity->selection();
	target.Info = dsPower | (dsType << 3);
	bc.Targets.Targets.push_back(target);
	bc.BehavTime = TimeInSec;
	bc.Behav.DeltaHP = -20;
	entity->applyBehaviour(bc);
	return true;
}

// simulate a range attack from the current slor to the current selection
NLMISC_COMMAND(rangeAttack, "simulate a range attack", "<slot> [intensity] [localisation] [range_weapon_type_if_unequipped]")
{
	if (args.size() < 1) return false;
	if (args.size() > 4) return false;
	uint slot;
	fromString(args[0], slot);
	CCharacterCL *entity = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(slot));
	if (!entity) return false;
	const CItemSheet *weaponSheet = entity->getRightHandItemSheet();
	CBehaviourContext bc;
	if (!weaponSheet || weaponSheet->Family != ITEMFAMILY::RANGE_WEAPON)
	{
		//
		uint16 weaponType = 0;
		if (args.size() > 3)
		{
			fromString(args[3], weaponType);
		}
		bc.Behav.Range.WeaponType = weaponType;
	}
	else
	{
		bc.Behav.Range.WeaponType = weaponSheet->RangeWeapon.RangeWeaponType;
	}
	bc.Behav.Behaviour = MBEHAV::RANGE_ATTACK;
	bc.Behav.Range.ImpactIntensity = 1;
	bc.Behav.Range.Localisation = BODY::HHead;
	bc.BehavTime = TimeInSec;
	if (args.size() > 1)
	{
		uint16 impactIntensity;
		fromString(args[1], impactIntensity);
		bc.Behav.Range.ImpactIntensity = impactIntensity;
	}
	if (args.size() > 2)
	{
		uint16 localisation;
		fromString(args[2], localisation);
		bc.Behav.Range.Localisation = localisation;
	}
	// if not a generic range weapon, add a single target (this is the current selection)
	uint8 targetSlot = UserEntity->targetSlot();
	if (targetSlot >= CLFECOMMON::INVALID_SLOT) return false;
	CEntityCL *target = EntitiesMngr.entity(targetSlot);
	if (!target) return false;
	double dist = (target->pos() - entity->pos()).norm();
	bc.Targets.Targets.push_back(CMultiTarget::CTarget(targetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
	bc.Behav.DeltaHP = -10;
	entity->applyBehaviour(bc);
	return true;
}


// simulate a creature attack
NLMISC_COMMAND(creatureAttack, "simulate a creature attack (2 attaques per creature)", "<casterSlot> <targetSlot> [attk=0/1] [magicIntensity] [physicalIntensity] [localisation] [damageType] [hitType] [resist=1/0]")
{
	if (args.size() < 2) return false;
	if (args.size() > 9) return false;
	CBehaviourContext bc;
	bc.Behav.Behaviour = MBEHAV::CREATURE_ATTACK_0;
	if (args.size() > 2)
	{
		uint attk;
		fromString(args[2], attk);
		bc.Behav.Behaviour = attk == 0 ? MBEHAV::CREATURE_ATTACK_0 : MBEHAV::CREATURE_ATTACK_1;
	}
	uint8 casterSlot;
	fromString(args[0], casterSlot);
	CCharacterCL *caster = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(casterSlot));
	if (!caster) return false;
	uint8 targetSlot;
	fromString(args[1], targetSlot);
	CCharacterCL *target = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(targetSlot));
	if (!target) return false;
	double dist = (target->pos() - caster->pos()).norm();
	bool resist = false;
	if (args.size() > 8)
	{
		fromString(args[8], resist);
	}
	bc.Targets.Targets.push_back(CMultiTarget::CTarget(targetSlot, false, (uint8) ceilf((float) (dist /  MULTI_TARGET_DISTANCE_UNIT))));
	bc.Behav.CreatureAttack.ActionDuration = 0;
	uint magicImpactIntensity = 1;
	if (args.size() > 3)
	{
		fromString(args[3], magicImpactIntensity);
	}
	bc.Behav.CreatureAttack.MagicImpactIntensity = magicImpactIntensity;
	uint physicalImpactIntensity = 0;
	if (args.size() > 4)
	{
		fromString(args[4], physicalImpactIntensity);
	}
	bc.Behav.CreatureAttack.ImpactIntensity = physicalImpactIntensity;
	BODY::TBodyPart localisation = BODY::HHead;
	if (args.size() > 5)
	{
		sint tmp;
		fromString(args[5], tmp);
		localisation = (BODY::TBodyPart) tmp;
	}
	bc.Behav.CreatureAttack.Localisation = localisation;
	DMGTYPE::EDamageType dmgType = DMGTYPE::BLUNT;
	if (args.size() > 6)
	{
		sint tmp;
		fromString(args[6], tmp);
		dmgType = (DMGTYPE::EDamageType) tmp;
	}
	bc.Behav.CreatureAttack2.DamageType = dmgType;
	HITTYPE::THitType hitType = HITTYPE::Hit;
	if (args.size() > 7)
	{
		sint tmp;
		fromString(args[7], tmp);
		hitType = (HITTYPE::THitType) tmp;
	}
	bc.Behav.CreatureAttack2.HitType = hitType;
	bc.BehavTime = TimeInSec;
	bc.Behav.DeltaHP = -15;
	caster->applyBehaviour(bc);
	return true;
}

NLMISC_COMMAND(setNamePosZ, "", "<low/high/normal> <value>")
{
	if (args.size() != 2) return false;

	CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
	if (!target)
		return true;

	float *namePosZ = NULL;
	string sheetName, skelName;
	if (target->Type == CEntityCL::Player)
	{
		CPlayerCL *playerTarget = dynamic_cast<CPlayerCL*>(target);
		if (playerTarget)
		{
			CRaceStatsSheet *sheet = const_cast<CRaceStatsSheet*>(playerTarget->playerSheet());
			if (sheet)
			{
				if (toLower(args[0]) == "low")
					namePosZ = &sheet->GenderInfos[playerTarget->getGender()].NamePosZLow;
				else if (toLower(args[0]) == "normal")
					namePosZ = &sheet->GenderInfos[playerTarget->getGender()].NamePosZNormal;
				else if (toLower(args[0]) == "high")
					namePosZ = &sheet->GenderInfos[playerTarget->getGender()].NamePosZHigh;

				sheetName = sheet->Id.toString();
				skelName = sheet->GenderInfos[playerTarget->getGender()].Skelfilename;
			}
		}
	}
	else
	{
		CCharacterCL *creatureTarget = dynamic_cast<CCharacterCL*>(target);
		if (creatureTarget)
		{
			CCharacterSheet *sheet = const_cast<CCharacterSheet*>(creatureTarget->getSheet());
			if (sheet)
			{
				if (toLower(args[0]) == "low")
					namePosZ = &sheet->NamePosZLow;
				else if (toLower(args[0]) == "normal")
					namePosZ = &sheet->NamePosZNormal;
				else if (toLower(args[0]) == "high")
					namePosZ = &sheet->NamePosZHigh;

				sheetName = sheet->Id.toString();
				skelName = sheet->getSkelFilename();
			}
		}
	}

	if (namePosZ)
	{
		fromString(args[1], *namePosZ);
		nlinfo("NAMEPOSZ: sheet: %s, skel: %s, NamePosZ%s = %g", sheetName.c_str(), skelName.c_str(), args[0].c_str(), *namePosZ);
	}

	return true;
}

NLMISC_COMMAND(setMyNamePosZ, "", "<low/high/normal> <value>")
{
	if (args.size() != 2) return false;

	float *namePosZ = NULL;
	string sheetName, skelName;
	CRaceStatsSheet *sheet = const_cast<CRaceStatsSheet*>(UserEntity->playerSheet());
	if (sheet)
	{
		if (toLower(args[0]) == "low")
			namePosZ = &sheet->GenderInfos[UserEntity->getGender()].NamePosZLow;
		else if (toLower(args[0]) == "normal")
			namePosZ = &sheet->GenderInfos[UserEntity->getGender()].NamePosZNormal;
		else if (toLower(args[0]) == "high")
			namePosZ = &sheet->GenderInfos[UserEntity->getGender()].NamePosZHigh;

		sheetName = sheet->Id.toString();
		skelName = sheet->GenderInfos[UserEntity->getGender()].Skelfilename;
	}

	if (namePosZ)
	{
		fromString(args[1], *namePosZ);
		nlinfo("NAMEPOSZ: sheet: %s, skel: %s, NamePosZ%s = %g", sheetName.c_str(), skelName.c_str(), args[0].c_str(), *namePosZ);
	}

	return true;
}


NLMISC_COMMAND(pvpMode, "modify pvp mode", "[<pvp mode> <state>]")
{
	if (args.size() != 0 && args.size() != 2) return false;

	CInterfaceManager *IM = CInterfaceManager::getInstance();

	CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
	if (!target)
	{
		IM->displaySystemInfo(toString("<pvpMode> no target"));
		return false;
	}
	if (target->Type != CEntityCL::Player && target->Type != CEntityCL::User)
	{
		IM->displaySystemInfo(toString("<pvpMode> target is not a player"));
		return false;
	}
	CPlayerCL *playerTarget = dynamic_cast<CPlayerCL*>(target);
	if (!playerTarget)
		return false;

	if( args.size() == 0 )
	{
		uint8 pvpMode = playerTarget->getPvpMode();
		string str;
		if( pvpMode&PVP_MODE::PvpDuel )
			str+="duel ";
		if( pvpMode&PVP_MODE::PvpChallenge)
			str+="challenge ";
		if( pvpMode&PVP_MODE::PvpZoneFree)
			str+="free ";
		if( pvpMode&PVP_MODE::PvpZoneFaction)
			str+="zone_faction ";
		if( pvpMode&PVP_MODE::PvpZoneGuild)
			str+="zone_guild ";
		if( pvpMode&PVP_MODE::PvpZoneOutpost)
			str+="outpost ";
		if( pvpMode&PVP_MODE::PvpFaction)
			str+="faction ";
		if( pvpMode&PVP_MODE::PvpFactionFlagged)
			str+="faction_flagged ";
		IM->displaySystemInfo(ucstring(str));
		nlinfo("<pvpMode> %s",str.c_str());
	}
	else
	{
		PVP_MODE::TPVPMode pvpMode = PVP_MODE::fromString(args[0]);
		bool state;
		fromString(args[1], state);
		if( state )
		{
			uint8 currentPVPMode = playerTarget->getPvpMode();
			currentPVPMode |= pvpMode;
			playerTarget->setPvpMode(currentPVPMode);
			IM->displaySystemInfo(toString("<pvpMode> adding pvp mode %s",args[0].c_str()));
		}
		else
		{
			uint8 currentPVPMode = playerTarget->getPvpMode();
			currentPVPMode &= ~pvpMode;
			playerTarget->setPvpMode(currentPVPMode);
			IM->displaySystemInfo(toString("<pvpMode> removing pvp mode %s",args[0].c_str()));
		}
	}
	playerTarget->buildInSceneInterface();
	return true;
}


NLMISC_COMMAND(pvpClan, "modify pvp clan", "<pvp clan>")
{
	if (args.size() != 1) return false;

	CInterfaceManager *IM = CInterfaceManager::getInstance();

	CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
	if (!target)
	{
		IM->displaySystemInfo(toString("<pvpClan> no target"));
		return false;
	}
	if (target->Type != CEntityCL::Player && target->Type != CEntityCL::User)
	{
		IM->displaySystemInfo(toString("<pvpMode> target is not a player"));
		return false;
	}
	CPlayerCL *playerTarget = dynamic_cast<CPlayerCL*>(target);
	if (!playerTarget)
		return false;

	PVP_CLAN::TPVPClan clan = PVP_CLAN::fromString(args[0]);
	playerTarget->setPvpClan(clan);
	playerTarget->buildInSceneInterface();

	return true;
}

#endif // !FINAL_VERSION

#include "r2/editor.h"

//---------------------------------------------------
// setDead :
// Method to Flag the character as dead and do everything needed.
//---------------------------------------------------
void CCharacterCL::setDead()	// virtual
{
	// If the entity dead is the user -> switch to dead mode.
	if(_Slot == UserEntity->slot())
		UserControls.mode(CUserControls::DeathMode);

	// If the entity killed was the current user target, we update context cursor
	if(_Slot == UserEntity->selection())
	{
		bool nextContextSelected = false;
		// Quartering
		if (!R2::getEditor().isDMing())
		{
			if(_Properties.harvestable())
				nextContextSelected = ContextCur.context("QUARTER");
			// Loot
			else if(_Properties.lootable())
				nextContextSelected = ContextCur.context("LOOT");
			// Pick Up
			else if(_Properties.liftable())
				nextContextSelected = ContextCur.context("PICKUP");
			if( !nextContextSelected )
				ContextCur.context("STAND BY");
		}
	}

	// The character now won't be an obstacle anymore
	_Primitive->setOcclusionMask(MaskColNone);
}// setDead //