ryzom-core/code/ryzom/client/src/player_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/>.




/////////////
// INCLUDE //
/////////////
#include "stdpch.h"
// Misc
#include "nel/misc/time_nl.h"
// Client.
#include "player_cl.h"
#include "ingame_database_manager.h"
#include "net_manager.h"
#include "time_client.h"
#include "entity_animation_manager.h"
#include "sheet_manager.h"
#include "color_slot_manager.h"
#include "debug_client.h"
#include "gabarit.h"
#include "interface_v3/interface_manager.h"
#include "misc.h"
#include "pacs_client.h"
#include "motion/user_controls.h"
#include "client_cfg.h"
#include "user_entity.h"
#include "faction_war_manager.h"
// Client Sheets
#include "client_sheets/player_sheet.h"
// 3D
#include "nel/3d/u_scene.h"
#include "nel/3d/u_instance_material.h"
#include "nel/3d/u_play_list.h"
#include "nel/3d/u_bone.h"
#include "nel/3d/u_particle_system_instance.h"
#include "nel/3d/u_point_light.h"
// game share
#include "game_share/player_visual_properties.h"
#include "game_share/gender.h"
#include "game_share/bot_chat_types.h"


///////////
// USING //
///////////
using namespace NLMISC;
using namespace NL3D;
using namespace NLPACS;
using namespace std;


////////////
// EXTERN //
////////////
extern UScene					*Scene;
extern CEntityAnimationManager	*EAM;
extern UTextContext				*TextContext;
extern UCamera					MainCam;


//-----------------------------------------------
// CPlayerCL :
// Constructor.
//-----------------------------------------------
CPlayerCL::CPlayerCL()
: CCharacterCL()
{
	Type = Player;

	// Resize _Instances to the number of visual slots.
	_Instances.resize(SLOTTYPE::NB_SLOT);

	// No sheet pointed.
	_Sheet			= 0;
	_PlayerSheet	= 0;

	// Some default colors.
	_HairColor = 0;
	_EyesColor = 0;

	// Not enough informations to display the player.
	_WaitForAppearance = true;

	_PlayerCLAsyncTextureLoading= false;

	// Light Off and not allocated
	_LightOn = false;
}// CPlayerCL //


//-----------------------------------------------
// ~CPlayerCL :
// Destructor.
//-----------------------------------------------
CPlayerCL::~CPlayerCL()
{
	// No more sheet pointed.
	_PlayerSheet	= NULL;

	// Remove the light
	if(!_Light.empty())
	{
		if(Scene)
			Scene->deletePointLight(_Light);
	}
}

//---------------------------------------------------
// getScale :
// Return the entity scale. (return 1.0 if there is any problem).
//---------------------------------------------------
float CPlayerCL::getScale() const	// virtual
{
	// Default Scale.
	return _CharacterScalePos;
}// getScale //



//-----------------------------------------------
// getGroundFX :
// retrieve ground fxs for the entity depending on the ground
//-----------------------------------------------
const std::vector<CGroundFXSheet> *CPlayerCL::getGroundFX() const
{
	switch (getGender())
	{
		case 0: return &(_PlayerSheet->GenderInfos[0].GroundFX);
		case 1: return &(_PlayerSheet->GenderInfos[1].GroundFX);
		default: break;
	}
	return NULL;
}


//-----------------------------------------------
// isNeutral :
// Return true if this entity is a neutral entity(pvp or not)
//-----------------------------------------------
bool CPlayerCL::isNeutral() const
{
	return (!isEnemy() && !isAlly());
}


//-----------------------------------------------
// isFriend :
// Return true if this entity is a user's friend.
//-----------------------------------------------
bool CPlayerCL::isFriend () const
{
	return isNeutral() || isNeutralPVP() || isAlly();
}


//-----------------------------------------------
// isEnemy :
// true if at least enemy in on pvp mode
//-----------------------------------------------
bool CPlayerCL::isEnemy () const
{
	// if one of 2 players is not in pvp they can't be enemies
	if( UserEntity->getPvpMode() == PVP_MODE::None ||
		getPvpMode() == PVP_MODE::None )
	{
		return false;
	}

	// Outpost
	if ( isAnOutpostEnemy() )
	{
		return true;
	}

	// Challenge
	if( getPvpMode()&PVP_MODE::PvpChallenge &&
		UserEntity->getPvpMode()&PVP_MODE::PvpChallenge )
	{
		if( !isInTeam() )
			return true;
	}

	// Zone Free
	if( getPvpMode()&PVP_MODE::PvpZoneFree &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneFree )
	{
		if( !isInTeam() && !isInGuild() )
			return true;
	}

	// Zone Guild
	if( getPvpMode()&PVP_MODE::PvpZoneGuild &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneGuild )
	{
		if( !isInTeam() && !isInGuild() )
			return true;
	}

	// Zone Faction
	if( getPvpMode()&PVP_MODE::PvpZoneFaction &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneFaction )
	{
		if (getPvpClan() != UserEntity->getPvpClan())
			return true;
	}

	// Duel
	if( getPvpMode()&PVP_MODE::PvpDuel &&
		UserEntity->getPvpMode()&PVP_MODE::PvpDuel )
	{
		return true; // TODO
	}

	// Faction
	if( getPvpMode()&PVP_MODE::PvpFactionFlagged &&
		(UserEntity->getPvpMode()&PVP_MODE::PvpFaction || UserEntity->getPvpMode()&PVP_MODE::PvpFactionFlagged) )
	{
		if( CFactionWarManager::getInstance()->areFactionsInWar(getPvpClan(),UserEntity->getPvpClan()) )
		{
			return true;
		}
	}

	return false;

} // isEnemy //


//-----------------------------------------------
// isAlly :
// true if at least ally in one pvp mode
//-----------------------------------------------
bool CPlayerCL::isAlly() const
{
	// if one of 2 players is not in pvp they can't be enemies
	if( UserEntity->getPvpMode() == PVP_MODE::None ||
		getPvpMode() == PVP_MODE::None )
	{
		return false;
	}

	// Outpost
	if ( isAnOutpostAlly() )
	{
		return true;
	}

	// Challenge
	if( getPvpMode()&PVP_MODE::PvpChallenge &&
		UserEntity->getPvpMode()&PVP_MODE::PvpChallenge )
	{
		if( isInTeam() )
			return true;
	}

	// Zone Free
	if( getPvpMode()&PVP_MODE::PvpZoneFree &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneFree )
	{
		if( isInTeam() || isInGuild() )
			return true;
	}

	// Zone Guild
	if( getPvpMode()&PVP_MODE::PvpZoneGuild &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneGuild )
	{
		if( isInTeam() || isInGuild() )
			return true;
	}

	// Zone Faction
	if( getPvpMode()&PVP_MODE::PvpZoneFaction &&
		UserEntity->getPvpMode()&PVP_MODE::PvpZoneFaction )
	{
		if (getPvpClan() == UserEntity->getPvpClan())
			return true;
	}

	// Faction
	if( getPvpMode()&PVP_MODE::PvpFactionFlagged &&
		(UserEntity->getPvpMode()&PVP_MODE::PvpFaction || UserEntity->getPvpMode()&PVP_MODE::PvpFactionFlagged))
	{
		if( getPvpClan()!=PVP_CLAN::Neutral && UserEntity->getPvpClan()!=PVP_CLAN::Neutral )
		{
			if( getPvpClan()==UserEntity->getPvpClan() )
			{
				return true;
			}
		}
	}

	return false;

} // isAlly //


//-----------------------------------------------
// isNeutralPVP :
//-----------------------------------------------
bool CPlayerCL::isNeutralPVP() const
{
	// if player is not in pvp they can't be neutral pvp
	if( getPvpMode() == PVP_MODE::None )
	{
		return false;
	}

	// Outpost
	if ( getOutpostId() != 0 )
	{
		if( UserEntity->getOutpostId() != getOutpostId() )
		{
			return true;
		}
	}

	// Challenge
	if( getPvpMode()&PVP_MODE::PvpChallenge &&
		!(UserEntity->getPvpMode()&PVP_MODE::PvpChallenge) )
	{
		return true;
	}

	// Zone Free
	if( getPvpMode()&PVP_MODE::PvpZoneFree &&
		!(UserEntity->getPvpMode()&PVP_MODE::PvpZoneFree) )
	{
		return true;
	}

	// Zone Guild
	if( getPvpMode()&PVP_MODE::PvpZoneGuild &&
		!(UserEntity->getPvpMode()&PVP_MODE::PvpZoneGuild) )
	{
		return true;
	}

	// Zone Faction
	if( getPvpMode()&PVP_MODE::PvpZoneFaction &&
		!(UserEntity->getPvpMode()&PVP_MODE::PvpZoneFaction) )
	{
		return true;
	}

	// Duel
	if( getPvpMode()&PVP_MODE::PvpDuel &&
		!(UserEntity->getPvpMode()&PVP_MODE::PvpDuel) )
	{
		return true;
	}

	// Faction
	if( getPvpMode()&PVP_MODE::PvpFactionFlagged )
	{
		// if only target is in faction pvp
		if( !(UserEntity->getPvpMode()&PVP_MODE::PvpFaction || UserEntity->getPvpMode()&PVP_MODE::PvpFactionFlagged) )
		{
			return true;
		}
		// else if factions not in war
		if( CFactionWarManager::getInstance()->areFactionsInWar(getPvpClan(),UserEntity->getPvpClan())==false )
		{
			return true;
		}
	}

	return false;
}


//-----------------------------------------------
// build :
// Build the entity from a sheet.
//-----------------------------------------------
bool CPlayerCL::build(const CEntitySheet *sheet)	// virtual
{
	// Cast the sheet in the right type.
	_PlayerSheet = dynamic_cast<const CRaceStatsSheet *>(sheet);
	if(_PlayerSheet==0)
	{
		pushDebugStr(NLMISC::toString("Player '%d' sheet is not a '.race_stats' -> BIG PROBLEM.", _Slot));
		return false;
	}
	else
		pushInfoStr(NLMISC::toString("Player '%d' sheet is valid.", _Slot));
	// 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.");
		}
	}

	// Compute the first automaton.
	_CurrentAutomaton = automatonType() + "_normal.automaton";

	// Initialize the player look.
	init3d();
	// Compute the primitive
	initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::DoNothing, UMovePrimitive::NotATrigger, MaskColPlayer, MaskColNone);
	// Create the collision entity (used to snap the entity to the ground).
	computeCollisionEntity();

	// Initialize properties of the client.
	initProperties();
	// Entity Created.
	return true;
}// build //

//-----------------------------------------------
// automatonType :
// Return the automaton type of the entity (homin, creature, etc.)
//-----------------------------------------------
std::string CPlayerCL::automatonType() const	// virtual
{
	return _PlayerSheet->Automaton;
}// automatonType //


//-----------------------------------------------
// init3d :
// Initialize the graphic for the player.
//-----------------------------------------------
void CPlayerCL::init3d()
{
	createPlayList();
	// Initialize the internal time.
	_LastFrameTime = ((double)T1) * 0.001;
}// init3d //


//-----------------------------------------------
// initProperties :
// Initialize properties of the entity (according to the class).
//-----------------------------------------------
void CPlayerCL::initProperties()
{
	properties().selectable(true);
	properties().attackable(false);
	properties().givable(true);
	properties().invitable(true);
	properties().canExchangeItem(true);
}// initProperties //


//-----------------------------------------------
// equip :
// Set the equipmenent worn.
//-----------------------------------------------
void CPlayerCL::equip(SLOTTYPE::EVisualSlot slot, const std::string &shapeName, const CItemSheet *item)
{
	// Check slot.
	if(slot == SLOTTYPE::HIDDEN_SLOT || slot >= SLOTTYPE::NB_SLOT)
	{
		nlwarning("CCharacterCL::equip : slot %d is not valid.", (uint)slot);
		return;
	}

	uint s = (uint)slot;

	// If exactly the same than before -> return

	if (!_Instances[s].Loading.empty())
	{
		if ((_Instances[s].LoadingName == shapeName) && (_Instances[s].FXItemSheet == item))
			return;
	}
	else if (!_Instances[s].Current.empty())
	{
		if ((_Instances[s].CurrentName == shapeName) && (_Instances[s].FXItemSheet == item))
			return;
	}



	// Attach to the skeleton.
	string stickPoint;
	if(!_Skeleton.empty())
	{
		switch(slot)
		{
			case SLOTTYPE::RIGHT_HAND_SLOT:
				if( item && item->ItemType != ITEM_TYPE::MAGICIAN_STAFF )
					stickPoint = "box_arme";
			break;

			case SLOTTYPE::LEFT_HAND_SLOT:
				if(_Items[slot].Sheet && _Items[slot].Sheet->getAnimSet()=="s")
					stickPoint = "Box_bouclier";
				else
					stickPoint = "box_arme_gauche";
			break;

			default:
			break;
		}
	}

	/* If the object is sticked (ie not a skin), decide to delete the Current instance. Why? because the animation
		is changed according to the equiped item.

		Hence, For example, if a sword would be changed for a gun, then the new gun animation would take place,
		while Keeping the old sword shape. BAD.
	*/
	if(!stickPoint.empty())
		_Instances[s].createLoading(string(), stickPoint);

	// Create the instance.
	if(item)
		_Instances[s].createLoading(shapeName, stickPoint, item->MapVariant);
	else
		_Instances[s].createLoading(shapeName, stickPoint);

	// If shapeName is empty, only clear the slot
	if(shapeName.empty())
	{
		_Items[slot].release();
		return;
	}

	if(!_Instances[s].Loading.empty())
	{
		_Instances[s].FXItemSheet = item;

		_Items[slot].initFXs(slot, _Instances[s].Loading);
	}
	else
		nlwarning("PL::equip(1):%d: cannot create the instance '%s'.", _Slot, shapeName.c_str());

	if ((slot != SLOTTYPE::RIGHT_HAND_SLOT) && (slot != SLOTTYPE::LEFT_HAND_SLOT))
		applyColorSlot(_Instances[s], skin(), 0, _HairColor, _EyesColor);

}// equip //

//-----------------------------------------------
// equip :
// Compute the equipmenent worn.
//-----------------------------------------------
void CPlayerCL::equip(SLOTTYPE::EVisualSlot slot, uint index, uint color)
{
	// Get the sheet according to the visual slot
	_Items[slot].Sheet = SheetMngr.getItem(slot, index);
	if(_Items[slot].Sheet)
	{
		const CItemSheet *item = _Items[slot].Sheet;

		// If the gender is a female get the right shape.
		if(_Gender == GSGENDER::female)
			equip(slot, item->getShapeFemale(), item);
		// Else get the default shape.
		else
			equip(slot, item->getShape(), item);

		// Check there is a shape.
		UInstance pInst = _Instances[slot].createLoadingFromCurrent();
		if(!pInst.empty())
		{
			// Set the right texture variation (quality).
			pInst.selectTextureSet((uint)item->MapVariant);
			_Instances[slot].TextureSet = item->MapVariant;

			// If Hair, color is for the head slot.
			if(slot == SLOTTYPE::HEAD_SLOT && item->Family != ITEMFAMILY::ARMOR)
				applyColorSlot(_Instances[slot], skin(), 0, color, _EyesColor);
			else
			{
				// Set the User Color.
				if(item->Color == -1)
					applyColorSlot(_Instances[slot], skin(), color, _HairColor, _EyesColor);
				// Set the Item Color.
				else if(item->Color != -2)
					applyColorSlot(_Instances[slot], skin(), item->Color, _HairColor, _EyesColor);
				// Else let the default color.
				else
					applyColorSlot(_Instances[slot], skin(), 0, _HairColor, _EyesColor);
			}
		}
	}
	// Default equipment.
	else
	{
		nlwarning("PL:equip(2):%d: VS '%d' default equipement used.", _Slot, slot);
		sint idx = SheetMngr.getVSIndex(_PlayerSheet->GenderInfos[_Gender].Items[slot], slot);
		if(idx != -1)
		{
			if(SheetMngr.getItem(slot, (uint)idx))
			{
				// If the gender is a female get the right shape.
				if(_Gender == GSGENDER::female)
					equip(slot, SheetMngr.getItem(slot, (uint)idx)->getShapeFemale());
				// Else get the default shape.
				else
					equip(slot, SheetMngr.getItem(slot, (uint)idx)->getShape());
			}
		}
/*
		//
		switch(slot)
		{
		case SLOTTYPE::CHEST_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Chest.", _Slot);
			equip(slot, _DefaultChest);
			break;
		case SLOTTYPE::LEGS_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Legs.", _Slot);
			equip(slot, _DefaultLegs);
			break;
		case SLOTTYPE::ARMS_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Arms.", _Slot);
			equip(slot, _DefaultArms);
			break;
		case SLOTTYPE::HANDS_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Hands.", _Slot);
			equip(slot, _DefaultHands);
			break;
		case SLOTTYPE::FEET_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Feet.", _Slot);
			equip(slot, _DefaultFeet);
			break;
		case SLOTTYPE::HEAD_SLOT:
			nlwarning("PL::equip(2):%d: default equipement used for the Head.", _Slot);
			equip(slot, _DefaultHair);
			break;

		default:
			nlwarning("PL::equip(2):%d: default equipement used for an unknown slot.", _Slot);
			break;
		}
*/
	}
}// equip //

//-----------------------------------------------
// computeAnimSet :
// Compute the animation set to use according to weapons, mode and race.
//-----------------------------------------------
void CPlayerCL::computeAnimSet()
{
	// We need a valid Gender to compute the animset.
	if(_Gender >= 2)
	{
		nlwarning("PL:computeAnimSet:%d: not a male or a female (gender=%d).", _Slot, _Gender);
		return;
	}

	// Now computing the animset.
	// Do not count weapons if swimming.
	if(!::computeAnimSet(_CurrentAnimSet[MOVE], _Mode, _PlayerSheet->GenderInfos[_Gender].AnimSetBaseName, _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet, _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet, !modeWithHiddenItems()))
		nlwarning("PL:computeAnimSet:%d: pb when computing the animset.", _Slot);

}// computeAnimSet //


//-----------------------------------------------
// updateVisualPropertyVpa :
// Update the Visual Property A.
// \todo GUIGUI : utiliser l'enum gender.
//-----------------------------------------------
void CPlayerCL::updateVisualPropertyVpa(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	CInterfaceManager *IM = CInterfaceManager::getInstance ();

	// Player will now have enough informations to display the character.
	_WaitForAppearance = false;

	// Get the property.
	SPropVisualA visualA = *(SPropVisualA *)(&prop);

	// GENDER
	_Gender = (GSGENDER::EGender)(visualA.PropertySubData.Sex);
	if(_Gender!=GSGENDER::male && _Gender!=GSGENDER::female)
	{
		nlwarning("PL::updateVPVpa:%d: neither a male nor a female -> male selected.", _Slot);
		_Gender = GSGENDER::male;
	}

	// update title when gender changed
	const ucstring replacement(STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(_TitleRaw,_Gender == GSGENDER::female));
	if (!replacement.empty() || !ClientCfg.DebugStringManager)
	{
		// Get extended name
		_NameEx = replacement;
		_Title = replacement;

		// display the new title in player interface
		if (_Slot == 0)
		{
			CViewText *pVT = dynamic_cast<CViewText*>(IM->getElementFromId("ui:interface:player:header_opened:player_title"));
			if (pVT != NULL) pVT->setText(_Title);
		}

		// rebuild in scene interface
		buildInSceneInterface();
	}

	// Setup _CharacterScalePos
	_CharacterScalePos = _PlayerSheet->GenderInfos[_Gender].CharacterScalePos;

	// Check if skeleton has changed
	if (_CacheSkeletonShapeName != _PlayerSheet->GenderInfos[_Gender].Skelfilename)
	{
		_CacheSkeletonShapeName = _PlayerSheet->GenderInfos[_Gender].Skelfilename;

		// Clean the playlist.
		if(_PlayList)
			_PlayList->resetAllChannels();

		// We can now build the skeleton so do it now.
		skeleton(_CacheSkeletonShapeName);

		// Invalidate instances cache
		for (uint i = 0; i < _Instances.size(); ++i)
			_Instances[i].CurrentName = _Instances[i].LoadingName = "";
		_Face.CurrentName = _Face.LoadingName = "";
	}
	// Check the skeleton.
	if(skeleton() && !ClientCfg.Light)
	{
		// To re-link the skeleton to the mount if needed.
		parent(parent());
		// Set the skeleton scale.
		// \todo GUIGUI: mettre le scale aussi dans race_stats.
		// Setup Lod Character skeleton, if skeleton exist
		// Get Lod Character Id from the sheet.
		sint clodId= getLodCharacterId(*Scene, _PlayerSheet->GenderInfos[_Gender].LodCharacterName);
		if(clodId>=0)
		{
			// Setup Lod Character shape and distance
			skeleton()->setLodCharacterShape(clodId);
			skeleton()->setLodCharacterDistance(_PlayerSheet->GenderInfos[_Gender].LodCharacterDistance);
		}
		// Compute the
		computeSomeBoneId();

		// CHEST
		equip(SLOTTYPE::CHEST_SLOT, visualA.PropertySubData.JacketModel, visualA.PropertySubData.JacketColor);
		// LEGS
		equip(SLOTTYPE::LEGS_SLOT, visualA.PropertySubData.TrouserModel, visualA.PropertySubData.TrouserColor);
		// ARMS
		equip(SLOTTYPE::ARMS_SLOT, visualA.PropertySubData.ArmModel, visualA.PropertySubData.ArmColor);
		// HAT
		equip(SLOTTYPE::HEAD_SLOT, visualA.PropertySubData.HatModel, visualA.PropertySubData.HatColor);
		// OBJECT in the RIGHT HAND
		_Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet = SheetMngr.getItem(SLOTTYPE::RIGHT_HAND_SLOT, visualA.PropertySubData.WeaponRightHand);
		// Equip the weapon(object/tool).
		if(_Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet)
		{
			if(_Gender == GSGENDER::female)
				equip(SLOTTYPE::RIGHT_HAND_SLOT, _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet->getShapeFemale(), _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet);
			else
				equip(SLOTTYPE::RIGHT_HAND_SLOT, _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet->getShape(), _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet);

			NL3D::UInstance itemInstance = (!_Instances[SLOTTYPE::RIGHT_HAND_SLOT].Loading.empty()) ? _Instances[SLOTTYPE::RIGHT_HAND_SLOT].Loading : _Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current;
			if (!itemInstance.empty())
			{
				// update fxs
				_Items[SLOTTYPE::RIGHT_HAND_SLOT].enableAdvantageFX(itemInstance);
				if ( _CurrentBehaviour.Behaviour != MBEHAV::EXTRACTING )
					_Items[SLOTTYPE::RIGHT_HAND_SLOT].setTrailSize(0);
					//_Items[SLOTTYPE::RIGHT_HAND_SLOT].setTrailSize(visualA.PropertySubData.RTrail);
			}
		}
		else
		{
			// No Valid item in the right hand.
			equip(SLOTTYPE::RIGHT_HAND_SLOT, "");
		}

		// OBJECT in the LEFT HAND
		_Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet = SheetMngr.getItem(SLOTTYPE::LEFT_HAND_SLOT, visualA.PropertySubData.WeaponLeftHand);
		// Equip the weapon(object/tool).
		if(_Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet)
		{
			equip(SLOTTYPE::LEFT_HAND_SLOT, _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet->getShape(), _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet);
			NL3D::UInstance itemInstance = (!_Instances[SLOTTYPE::LEFT_HAND_SLOT].Loading.empty()) ? _Instances[SLOTTYPE::LEFT_HAND_SLOT].Loading : _Instances[SLOTTYPE::LEFT_HAND_SLOT].Current;
			if (!itemInstance.empty())
			{
				// update fxs
				_Items[SLOTTYPE::LEFT_HAND_SLOT].enableAdvantageFX(itemInstance);
				_Items[SLOTTYPE::LEFT_HAND_SLOT].setTrailSize(0);
				//_Items[SLOTTYPE::LEFT_HAND_SLOT].setTrailSize(2 * (uint) visualA.PropertySubData.LTrail);
			}
		}
		else
		{
			// No Valid item in the left hand.
			equip(SLOTTYPE::LEFT_HAND_SLOT, "");
		}
		// Create face
		// Only create a face when there is no Helmet
		if(_Items[SLOTTYPE::HEAD_SLOT].Sheet == 0 || _Items[SLOTTYPE::HEAD_SLOT].Sheet->Family != ITEMFAMILY::ARMOR)
		{
			CItemSheet *faceItem = getItem(_PlayerSheet->GenderInfos[_Gender], SLOTTYPE::FACE_SLOT);
			if (faceItem)
			{
				string sFaceName;

				if(_Gender == GSGENDER::female)
					sFaceName = faceItem->getShapeFemale();
				else
					sFaceName = faceItem->getShape();

				if (((!_Face.Loading.empty()) && (_Face.LoadingName != sFaceName)) ||
					((!_Face.Current.empty()) && (_Face.CurrentName != sFaceName)) ||
					(_Face.Current.empty()))
				{
					if (!_Face.Loading.empty())
					{
						Scene->deleteInstance(_Face.Loading);
						_Face.Loading = NULL;
						_Face.LoadingName = sFaceName;
					}
					_Face.Loading = Scene->createInstance(sFaceName);
					if (!_Face.Loading.empty())
					{
						_Face.LoadingName = sFaceName;
						if(!skeleton()->bindSkin(_Face.Loading))
							nlwarning("PL::updateVPVpa:%d: Cannot bind the face.", _Slot);
						_Face.Loading.hide();
						// set it async for texture
						_Face.Loading.enableAsyncTextureMode(true);
					}
					else
						nlwarning("PL::updateVPVpa:%d: Cannot create the face.", _Slot);
				}
				_Face.TextureSet = faceItem->MapVariant;
				applyColorSlot(_Face, skin(), 0, visualA.PropertySubData.HatColor, 0); // Set a default ruflaket color.
			}
			else
				nlwarning("PL::updateVPVpa:%d: Face Item '%s' does not exist.", _Slot,
					_PlayerSheet->GenderInfos[_Gender].Items[SLOTTYPE::FACE_SLOT].c_str());
		}
		else
		{
			// There is a helmet !
			if (!_Face.Loading.empty())
				Scene->deleteInstance(_Face.Loading);
			_Face.Loading = NULL;
			_Face.LoadingName = "";
			if (!_Face.Current.empty())
				Scene->deleteInstance(_Face.Current);
			_Face.Current = NULL;
			_Face.CurrentName = "";
		}
		// Now we have a skeleton, we can update VpB and VpC.
		sint64 vB, vC;
		string propName;
		propName = toString("SERVER:Entities:E%d:P%d", _Slot, CLFECOMMON::PROPERTY_VPB);
		vB = IM->getDbProp(propName)->getValue64();
		propName = toString("SERVER:Entities:E%d:P%d", _Slot, CLFECOMMON::PROPERTY_VPC);
		vC = IM->getDbProp(propName)->getValue64();
		updateVisualPropertyVpb(0, vB);
		updateVisualPropertyVpc(0, vC);

		// Attach The Light if there is one.
		if(!_Light.empty() && _NameBoneId!=-1)
			_Skeleton.stickObject(_Light, _NameBoneId);

		// Compute the new animation set to use (due to weapons).
		computeAnimSet();

		// Set the animation to idle.
		setAnim(CAnimationStateSheet::Idle);
	}
	// No skeleton
	else
		nlwarning("PL::updateVPVpa:%d: Skeleton not allocated.", _Slot);
}// updateVisualPropertyVpa //

//-----------------------------------------------
// updateVisualPropertyVpb :
// Update the Visual Property B.
//-----------------------------------------------
void CPlayerCL::updateVisualPropertyVpb(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	// Get the property.
	SPropVisualB visualB = *(SPropVisualB *)(&prop);

	if(_Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet)
	{
		NL3D::UInstance itemInstance = (!_Instances[SLOTTYPE::RIGHT_HAND_SLOT].Loading.empty()) ? _Instances[SLOTTYPE::RIGHT_HAND_SLOT].Loading : _Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current;
		if (!itemInstance.empty())
		{
			// update fxs
			if ( _CurrentBehaviour.Behaviour != MBEHAV::EXTRACTING )
				_Items[SLOTTYPE::RIGHT_HAND_SLOT].setTrailSize(visualB.PropertySubData.RTrail);
		}
	}

	if(_Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet)
	{
		NL3D::UInstance itemInstance = (!_Instances[SLOTTYPE::LEFT_HAND_SLOT].Loading.empty()) ? _Instances[SLOTTYPE::LEFT_HAND_SLOT].Loading : _Instances[SLOTTYPE::LEFT_HAND_SLOT].Current;
		if (!itemInstance.empty())
		{
			// update fxs
			_Items[SLOTTYPE::LEFT_HAND_SLOT].setTrailSize(2 * (uint) visualB.PropertySubData.LTrail);
		}
	}

	if(skeleton())
	{
		// HANDS
		equip(SLOTTYPE::HANDS_SLOT, visualB.PropertySubData.HandsModel, visualB.PropertySubData.HandsColor);
		// FEET
		equip(SLOTTYPE::FEET_SLOT, visualB.PropertySubData.FeetModel, visualB.PropertySubData.FeetColor);
	}
	else
		nlinfo("PL::updateVPVpb:%d: Prop Vpb received before prop Vpa.", _Slot);
}// updateVisualPropertyVpb //

//-----------------------------------------------
// updateVisualPropertyVpc :
// Update the Visual Property C.
// \todo GUIGUI : factoriser les tatouages avec la cr<63>ation de perso
//-----------------------------------------------
void CPlayerCL::updateVisualPropertyVpc(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
	if(skeleton())
	{
		// Get the property.
		SPropVisualC visualC = *(SPropVisualC *)(&prop);

		// EYES
		_EyesColor = visualC.PropertySubData.EyesColor;
		UInstance inst;

		// must recreate the face asynchronously (because of color change / makeup change)
		inst= _Face.createLoadingFromCurrent();

		// if exist
		if (!inst.empty())
		{
			// change eyes color only
			applyColorSlot(_Face, _Face.ACSkin, _Face.ACUser, _Face.ACHair, visualC.PropertySubData.EyesColor);

			// Tattoo
			makeUp(inst, visualC.PropertySubData.Tattoo);

			// Morph
			static const char *baseName = "visage_00";
			float MTmin, MTmax;

			const CGenderInfo *pGI = &_PlayerSheet->GenderInfos[_Gender];
			if (pGI == NULL)
				return;

			MTmin = pGI->BlendShapeMin[0];
			MTmax = pGI->BlendShapeMax[0];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(0), (float)(visualC.PropertySubData.MorphTarget1) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[1];
			MTmax = pGI->BlendShapeMax[1];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(1), (float)(visualC.PropertySubData.MorphTarget2) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[2];
			MTmax = pGI->BlendShapeMax[2];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(2), (float)(visualC.PropertySubData.MorphTarget3) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[3];
			MTmax = pGI->BlendShapeMax[3];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(3), (float)(visualC.PropertySubData.MorphTarget4) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[4];
			MTmax = pGI->BlendShapeMax[4];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(4), (float)(visualC.PropertySubData.MorphTarget5) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[5];
			MTmax = pGI->BlendShapeMax[5];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(5), (float)(visualC.PropertySubData.MorphTarget6) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[6];
			MTmax = pGI->BlendShapeMax[6];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(6), (float)(visualC.PropertySubData.MorphTarget7) / 7.f * (MTmax-MTmin) + MTmin, true);

			MTmin = pGI->BlendShapeMin[7];
			MTmax = pGI->BlendShapeMax[7];
			if (!ClientCfg.BlendShapePatched) { MTmin = 0.0f; MTmax = 100.0f; }
			inst.setBlendShapeFactor(baseName + toString(7), (float)(visualC.PropertySubData.MorphTarget8) / 7.f * (MTmax-MTmin) + MTmin, true);
		}

		// Set the Gabarit
		float characterHeight	= (float)((sint8)(visualC.PropertySubData.CharacterHeight)-7)/7.f;
		float torsoWidth		= (float)((sint8)(visualC.PropertySubData.TorsoWidth)-7)/7.f;
		float armsWidth			= (float)((sint8)(visualC.PropertySubData.ArmsWidth)-7)/7.f;
		float legsWidth			= (float)((sint8)(visualC.PropertySubData.LegsWidth)-7)/7.f;
		float breastSize		= (float)((sint8)(visualC.PropertySubData.BreastSize)-7)/7.f;
		float heightScale, baseHeightScale;
		//	TODO : manage breast size
		GabaritSet.applyGabarit(*skeleton(), _Gender, people(), characterHeight, torsoWidth, armsWidth, legsWidth, breastSize, &heightScale);
		baseHeightScale = GabaritSet.getRefHeightScale(_Gender, people());

		if(baseHeightScale != 0.f)
			_CustomScalePos = heightScale/baseHeightScale;
		else
		{
			_CustomScalePos = 1.f;
			nlwarning("PL::updateVPVpc:'%d': baseHeight == 0.", _Slot);
		}
	}
	else
		nlinfo("PL:updateVPVpc:'%d': Prop Vpc received before prop Vpa.", _Slot);
}// updateVisualPropertyVpc //

//-----------------------------------------------
//-----------------------------------------------
void CPlayerCL::updateVisualPropertyPvpMode(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
	CCharacterCL::updateVisualPropertyPvpMode(gameCycle, prop);
	// Additionaly, if i am the target, inform interface of the change
	if(isTarget())
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		CCDBNodeLeaf *pDB= pIM->getDbProp("UI:VARIABLES:USER:TRACK_TARGET_PVP_CHANGE_MODE");
		if(pDB)
		{
			sint32	val= pDB->getValue32();
			pDB->setValue32(val+1);
		}
	}
}


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

//-----------------------------------------------
// people :
// Return the People for the entity.
//-----------------------------------------------
EGSPD::CPeople::TPeople CPlayerCL::people()	const// virtual
{
	if(_PlayerSheet)
		return _PlayerSheet->People;
	else
		return EGSPD::CPeople::Unknown;
}// people //

//-----------------------------------------------
// people :
// Setup the People for the entity.
//-----------------------------------------------
void CPlayerCL::setPeople(EGSPD::CPeople::TPeople /* people */)
{
}// people //

//-----------------------------------------------
// drawName :
// Draw the name.
//-----------------------------------------------
void CPlayerCL::drawName(const NLMISC::CMatrix &mat)	// virtual
{
	// Draw the name.
	if(!getEntityName().empty())
		TextContext->render3D(mat, getEntityName());
}// drawName //


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

//-----------------------------------------------
// attackRadius :
// Method to return the attack radius of an entity (take the scale into account).
//-----------------------------------------------
double CPlayerCL::attackRadius() const	// virtual
{
	return 0.5;
}// attackRadius //

//-----------------------------------------------
// 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.
//-----------------------------------------------
CVectorD CPlayerCL::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;
	p.x = 0.5 * sin(-ang) + dist*sin(-ang);	// or: pos.x = _Sheet->DistToSide*cos(ang) + dist*cos(ang); but 0 should be right side.
	p.y = 0.5 * cos(ang)  + dist*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 //


///////////////
// 3D SYSTEM //
///////////////
//-----------------------------------------------
// updateAsyncTexture
//-----------------------------------------------
float	CPlayerCL::updateAsyncTexture()
{
	// Call parent.
	float	distToCam= CCharacterCL::updateAsyncTexture();

	// Check all instance to know if they need to start async load their textures
	if(!_Face.Loading.empty())
	{
		// dirty?
		if(_Face.Loading.isAsyncTextureDirty())
		{
			// reset instance state.
			_Face.Loading.setAsyncTextureDirty(false);
			// must start loading for this isntance
			_Face.Loading.startAsyncTextureLoading();
			// the entity is now currently loading.
			_PlayerCLAsyncTextureLoading= true;
			// The LodTexture need to be recomputed
			_LodTextureDirty= true;
		}
	}


	// Update Async Texture loading of all instances.
	if(_PlayerCLAsyncTextureLoading)
	{
		bool	allLoaded= true;
		// update loading for all instances.
		if(!_Face.Loading.empty())
		{
			// update async texture loading
			allLoaded= allLoaded && _Face.Loading.isAsyncTextureReady();
		}

		// if all are loaded, then End! don't need to check all instances every frame.
		if(allLoaded)
		{
			_PlayerCLAsyncTextureLoading= false;
			_Face.updateCurrentFromLoading(_Skeleton);
		}
	}


	// For LOD texture, must update the "texture distance"
	if(!_Face.Current.empty())
	{
		// update async texture loading
		_Face.Current.setAsyncTextureDistance(distToCam);
	}

	return distToCam;
}

//-----------------------------------------------
// updateLodTexture
//-----------------------------------------------
void	CPlayerCL::updateLodTexture()
{
	// if need to recompute, and if Async loading ended
	if( _LodTextureDirty && !_PlayerCLAsyncTextureLoading )
		// check parent and upadte lod
		CCharacterCL::updateLodTexture();
}

//-----------------------------------------------
// getMaxSpeed :
// Return the basic max speed for the entity in meter per sec
//-----------------------------------------------
double CPlayerCL::getMaxSpeed()	const// virtual
{
	return 6.0f;
}// getMaxSpeed //



//---------------------------------------------------
// displayDebug :
// Display Debug Informations.
//---------------------------------------------------
void CPlayerCL::displayDebug(float x, float &y, float lineStep)	// virtual
{
	CCharacterCL::displayDebug(x, y, lineStep);
}// displayDebug //






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

	// PUBLIC

	// PROTECTED
//	const CPlayerSheet		*_Sheet;
//	const CRaceStatsSheet	*_PlayerSheet;
//	NL3D::UInstance			_Face;
	f.serial(_DefaultChest);
	f.serial(_DefaultLegs);
	f.serial(_DefaultArms);
	f.serial(_DefaultHands);
	f.serial(_DefaultFeet);
	f.serial(_DefaultHair);
	f.serial(_HairColor);
	f.serial(_EyesColor);
	f.serial(_WaitForAppearance);
	f.serial(_PlayerCLAsyncTextureLoading);
	f.serial(_LightOn);
//	NL3D::UPointLight		_Light;

	// PRIVATE
}// readWrite //

//---------------------------------------------------
// load :
// To call after a read from a stream to re-initialize the entity.
//---------------------------------------------------
void CPlayerCL::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());
	}

	// update
	if(!_WaitForAppearance)
	{
		// Visual properties A
		sint64 prop = IM->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->getValue64();
		updateVisualPropertyVpa(0, prop);	// Vpa udapte vpb and vpc too.
	}
}// load //

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

//*********************************************************************************************
const CItemSheet *CPlayerCL::getRightHandItemSheet() const
{
	return _Items[SLOTTYPE::RIGHT_HAND_SLOT].Sheet;
}

//*********************************************************************************************
const CItemSheet *CPlayerCL::getLeftHandItemSheet() const
{
	return _Items[SLOTTYPE::LEFT_HAND_SLOT].Sheet;
}

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

//*********************************************************************************************
float CPlayerCL::getScaleRef() const
{
	float fyrosRefScale = GabaritSet.getRefHeightScale(0, EGSPD::CPeople::Fyros);
	if (fyrosRefScale == 0) return 1.f;
	return _CustomScalePos * (GabaritSet.getRefHeightScale(_Gender, people()) / fyrosRefScale);

}

//*********************************************************************************************
float CPlayerCL::getNamePosZ() const
{
	if (!_PlayerSheet)
		return 0.f;

	float namePosZ;
	switch (_ModeWanted)
	{
	case MBEHAV::DEATH:
	case MBEHAV::SIT:
		namePosZ = _PlayerSheet->GenderInfos[_Gender].NamePosZLow;
		break;

	case MBEHAV::MOUNT_NORMAL:
	case MBEHAV::MOUNT_SWIM:
		namePosZ = _PlayerSheet->GenderInfos[_Gender].NamePosZHigh;
		break;

	default:
		namePosZ = _PlayerSheet->GenderInfos[_Gender].NamePosZNormal;
		break;
	}

	return namePosZ * _CharacterScalePos * _CustomScalePos;
}

// ***************************************************************************
void CPlayerCL::doSetVisualSelectionBlink(bool bOnOff, NLMISC::CRGBA emitColor)
{
	// Do it on Face
	if(bOnOff)
		_Face.setEmissive(emitColor);
	else
		_Face.restoreEmissive();

	// and parent call
	CCharacterCL::doSetVisualSelectionBlink(bOnOff, emitColor);
}



//-----------------------------------------------
// computePrimitive :
// Create (or re-create) a primitive.
//-----------------------------------------------
void CPlayerCL::computePrimitive()
{
	// Initialize the primitive.
	initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::DoNothing, UMovePrimitive::NotATrigger, MaskColPlayer, MaskColNone);
	if(_Primitive)
		_Primitive->insertInWorldImage(dynamicWI);
	// Set the position.
	pacsPos(pos());
}// computePrimitive //