aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-14 03:09:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/client/src/user_entity.cpp
mattraykowski aa261f28a4 merging gui editor repo.
2013-02-14 09:53:06 -06:00

4463 lines
126 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/////////////
// INCLUDE //
/////////////
#include "stdpch.h"
// Misc.
#include "nel/misc/vectord.h"
#include "nel/misc/matrix.h"
#include "nel/misc/quat.h"
// 3D Interface.
#include "nel/3d/u_scene.h"
#include "nel/3d/u_visual_collision_manager.h"
#include "nel/3d/viewport.h"
#include "nel/3d/u_bone.h"
#include "nel/3d/u_instance_material.h"
#include "nel/3d/u_play_list.h"
#include "nel/3d/u_point_light.h"
#include "nel/3d/u_particle_system_instance.h"
#include "nel/3d/u_camera.h"
// Pacs Interface
#include "nel/pacs/u_global_position.h"
// Client.
#include "user_entity.h"
#include "motion/user_controls.h"
#include "pacs_client.h"
#include "net_manager.h"
#include "time_client.h"
#include "entity_animation_manager.h"
#include "sheet_manager.h"
#include "sound_manager.h"
#include "interface_v3/interface_manager.h"
#include "entities.h"
#include "debug_client.h"
#include "misc.h"
#include "interface_v3/bot_chat_manager.h"
#include "fx_manager.h"
#include "main_loop.h"
#include "interface_v3/group_in_scene_bubble.h"
#include "interface_v3/inventory_manager.h"
#include "nel/gui/group_html.h"
#include "interface_v3/people_interraction.h"
#include "init_main_loop.h"
#include "view.h"
#include "interface_v3/sphrase_manager.h"
#include "interface_v3/sbrick_manager.h"
#include "interface_v3/action_phrase_faber.h"
#include "interface_v3/bar_manager.h"
#include "interface_v3/skill_manager.h"
#include "far_tp.h"
#include "npc_icon.h"
// game share
#include "game_share/slot_types.h"
#include "game_share/player_visual_properties.h"
#include "game_share/mode_and_behaviour.h"
#include "game_share/inventories.h"
#include "game_share/animal_type.h"
#include "game_share/bot_chat_types.h"
// Sound animation
#include "nel/sound/sound_anim_manager.h"
#include "nel/sound/sound_animation.h"
#include "nel/sound/sound_anim_marker.h"
// r2
#include "r2/editor.h"
///////////
// USING //
///////////
using namespace NLMISC;
using namespace NLPACS;
using namespace std;
using NL3D::UScene;
using NL3D::UVisualCollisionManager;
using NL3D::UTextContext;
////////////
// EXTERN //
////////////
extern UScene *Scene;
extern UVisualCollisionManager *CollisionManager;
extern CEntityAnimationManager *EAM;
extern UTextContext *TextContext;
extern NL3D::UCamera MainCam;
// Context help
extern void contextHelp (const std::string &help);
extern void beastOrder (const std::string &orderStr, const std::string &beastIndexStr, bool confirmFree = true);
// Out game received position
NLMISC::CVectorD UserEntityInitPos;
NLMISC::CVector UserEntityInitFront;
CUserEntity *UserEntity = NULL;
uint32 CharFirstConnectedTime = 0;
uint32 CharPlayedTime = 0;
const double MaxExtractionDistance = 1.0f;
////////////
// GLOBAL //
////////////
// Hierarchical timer
H_AUTO_DECL ( RZ_Client_Update_Sound )
//////////////
// FUNCTION //
//////////////
//string chooseRandom( const vector<string>& sounds, uint32& previousIndex );
//-----------------------------------------------
// CUserEntity :
// Constructor.
//-----------------------------------------------
CUserEntity::CUserEntity()
: CPlayerCL()
{
Type = User;
_Run = false;
_RunWhenAble = false;
_WalkVelocity = 1.0f;
_RunVelocity = 2.0f;
_CurrentVelocity = _WalkVelocity;
_FrontVelocity = 0.0f;
_LateralVelocity = 0.0f;
// \todo GUIGUI : do it more generic.
_First_Pos = false;
// No selection, trader, interlocutor at the beginning.
_Selection = CLFECOMMON::INVALID_SLOT;
_Trader = CLFECOMMON::INVALID_SLOT;
_Interlocutor = CLFECOMMON::INVALID_SLOT;
// Not selectable at the beginning.
_Selectable = false;
// Your are not on a mount at the beginning.
_OnMount = false;
_AnimAttackOn = false;
_ViewMode = FirstPV;
_PermanentDeath = false;
_FollowMode = false;
_CheckPrimitive = 0;
// The user is not in collision with someone else.
_ColOn = false;
// Collisions are not removed.
_ColRemoved = false;
// No Move To at the beginning.
_MoveToSlot = CLFECOMMON::INVALID_SLOT;
_MoveToAction= CUserEntity::None;
_MoveToDist= 0.0;
_MoveToColStartTime= 0;
_FollowForceHeadPitch= false;
_ForceLookSlot= CLFECOMMON::INVALID_SLOT;
_LastExecuteCombatSlot= CLFECOMMON::INVALID_SLOT;
_R2CharMode= R2::TCharMode::Player;
}// CUserEntity //
//-----------------------------------------------
// ~CUserEntity :
// Destructor.
//-----------------------------------------------
CUserEntity::~CUserEntity()
{
// Remove observers
_SpeedFactor.release();
_MountHunger.release();
_MountSpeeds.release();
CInterfaceManager *pIM = CInterfaceManager::getInstance();
{
CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:IS_INVISIBLE", false);
if (node)
{
ICDBNode::CTextId textId;
node->removeObserver(&_InvisibleObs, textId);
}
}
for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
{
CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
if(node)
{
ICDBNode::CTextId textId;
node->removeObserver(_SkillPointObs+i, textId);
}
}
for( uint i=0; i<_FamesObs.size(); ++i )
{
uint32 factionIndex = _FamesObs[i]->FactionIndex;
uint32 fameIndexInDatabase = CStaticFames::getInstance().getDatabaseIndex(factionIndex);
string sDBPath = toString("SERVER:FAME:PLAYER%d:VALUE",fameIndexInDatabase);
CCDBNodeLeaf * node = NLGUI::CDBManager::getInstance()->getDbProp(sDBPath, false);
if(node)
{
ICDBNode::CTextId textId;
node->removeObserver(_FamesObs[i], textId);
}
}
contReset(_FamesObs);
CNPCIconCache::getInstance().removeObservers();
// Remove the Primitive used for check (because ~CEntityCL() will call CEntityCL::removePrimitive(), not CUserEntity::removePrimitive())
removeCheckPrimitive();
CNPCIconCache::release();
}// ~CUserEntity //
//-----------------------------------------------
// initProperties :
// Initialize properties of the entity (according to the class).
//-----------------------------------------------
void CUserEntity::initProperties()
{
properties().selectable(true);
}// initProperties //
//-----------------------------------------------
// build :
// Build the entity from a sheet.
//-----------------------------------------------
bool CUserEntity::build(const CEntitySheet *sheet) // virtual
{
// Init received position
pos(UserEntityInitPos);
front(UserEntityInitFront);
dir(front());
setHeadPitch(0);
// Cast the sheet in the right type.
_PlayerSheet = dynamic_cast<const CRaceStatsSheet *>(sheet);
if(_PlayerSheet == 0)
{
pushDebugStr("User Sheet is not a valid '.race_stats'.");
return false;
}
else
pushInfoStr("User Sheet is a valid '.race_stats'.");
// 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.");
}
}
disableFollow();
// Walk/Run ?
if(ClientCfg.RunAtTheBeginning != _Run)
switchVelocity();
// Set the up of the user.
up(CVector(0,0,1));
// Init User infos.
eyesHeight(ClientCfg.EyesHeight);
walkVelocity(ClientCfg.Walk);
runVelocity(ClientCfg.Run);
// Compute the first automaton.
_CurrentAutomaton = automatonType() + "_normal.automaton";
// Build the PACS Primitive.
if(initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::Slide, (UMovePrimitive::TTrigger)(UMovePrimitive::OverlapTrigger | UMovePrimitive::EnterTrigger), MaskColPlayer, MaskColPlayer | MaskColNpc | MaskColDoor))
_Primitive->insertInWorldImage(dynamicWI);
// Compute the element to be able to snap the entity to the ground.
computeCollisionEntity();
// Initialize properties of the client.
initProperties();
// Initialize the observer for the speed factor and mount stuff
_SpeedFactor.init();
_MountHunger.init();
_MountSpeeds.init();
// Create the user playlist
createPlayList();
// Initialize the internal time.
_LastFrameTime = ((double)T1) * 0.001;
// Set the gender in local mode.
if(ClientCfg.Local)
{
_Mode = MBEHAV::NORMAL;
_ModeWanted = MBEHAV::NORMAL;
_Gender = ClientCfg.Sex;
SPropVisualA visualA = buildPropVisualA(_PlayerSheet->GenderInfos[_Gender]);
SPropVisualB visualB = buildPropVisualB(_PlayerSheet->GenderInfos[_Gender]);
SPropVisualC visualC;
visualA.PropertySubData.Sex = _Gender;
visualC.PropertyC = 0;
visualC.PropertySubData.CharacterHeight = 0;
visualC.PropertySubData.ArmsWidth = 7;
visualC.PropertySubData.LegsWidth = 7;
visualC.PropertySubData.TorsoWidth = 7;
visualC.PropertySubData.BreastSize = 7;
// Set the Database
sint64 *prop = (sint64 *)&visualA;
NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->setValue64(*prop); // Set the database
prop = (sint64 *)&visualB;
NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPB))->setValue64(*prop); // Set the database
prop = (sint64 *)&visualC;
NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPC))->setValue64(*prop); // Set the database
// Apply Changes.
updateVisualProperty(0, CLFECOMMON::PROPERTY_VPA);
}
// \todo GUIGUI Retrieve the player's appearence during the avatar selection.
// Get Visual Properties From the character selection window.
else
{
}
// Rebuild interface
buildInSceneInterface ();
// Add observer on invisible property
CInterfaceManager *pIM = CInterfaceManager::getInstance();
{
CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:IS_INVISIBLE", false);
if (node)
{
ICDBNode::CTextId textId;
node->addObserver(&_InvisibleObs, textId);
}
}
// Add an observer on skill points
for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
{
_SkillPointObs[i].SpType= i;
CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
if(node)
{
ICDBNode::CTextId textId;
node->addObserver(_SkillPointObs+i, textId);
}
}
// Add an observer on Fames
for( uint i=(uint)PVP_CLAN::BeginClans; i<=(uint)PVP_CLAN::EndClans; ++i )
{
uint32 factionIndex = PVP_CLAN::getFactionIndex((PVP_CLAN::TPVPClan)i);
uint32 fameIndexInDatabase = CStaticFames::getInstance().getDatabaseIndex(factionIndex);
string sDBPath = toString("SERVER:FAME:PLAYER%d:VALUE",fameIndexInDatabase);
CFameObserver * fameObs = new CFameObserver();
if( fameObs )
{
fameObs->FactionIndex = factionIndex;
CCDBNodeLeaf * node = NLGUI::CDBManager::getInstance()->getDbProp(sDBPath, false);
if(node)
{
ICDBNode::CTextId textId;
node->addObserver(fameObs, textId);
}
_FamesObs.push_back(fameObs);
}
}
// Add an observer on Mission Journal
CNPCIconCache::getInstance().addObservers();
// Initialize the camera distance.
View.cameraDistance(ClientCfg.CameraDistance);
// char and account time properties
CSkillManager *pSM = CSkillManager::getInstance();
if( pSM )
{
pSM->tryToUnblockTitleFromCharOldness( CharFirstConnectedTime );
pSM->tryToUnblockTitleFromCharPlayedTime( CharPlayedTime );
}
// Entity created.
return true;
}// build //
//-----------------------------------------------
// eyesHeight :
// \todo GUIGUI : do it better in mount mode
//-----------------------------------------------
float CUserEntity::eyesHeight()
{
if(!_OnMount)
return _EyesHeight * _CharacterScalePos;
else
return _EyesHeight * _CharacterScalePos;
}// eyesHeight //
/////////////////////////////////////////////////
/////////////////////////////////////////////////
/////////////// VISUAL PROPERTIES ///////////////
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//-----------------------------------------------
// updateVisualPropertyPos :
// Update Entity Position.
//-----------------------------------------------
void CUserEntity::updateVisualPropertyPos(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, const NLMISC::TGameCycle &/* pI */)
{
}// updateVisualPropertyPos //
//-----------------------------------------------
// updateVisualPropertyOrient :
// Update Entity Orientation.
//-----------------------------------------------
void CUserEntity::updateVisualPropertyOrient(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */)
{
}// updateVisualPropertyOrient //
void CUserEntity::updateVisualPropertyTargetList(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, uint /* listIndex */)
{
}
void CUserEntity::updateVisualPropertyVisualFX(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
applyVisualFX(prop);
}
//-----------------------------------------------
// updateVisualPropertyBehaviour :
// Update Entity Behaviour.
//-----------------------------------------------
void CUserEntity::updateVisualPropertyBehaviour(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
// Compute the behaviour.
CBehaviourContext bc;
bc.Behav = MBEHAV::CBehaviour(prop);
bc.BehavTime = TimeInSec;
if(VerboseAnimUser)
{
nlinfo("UE::updateVPBeha: '%d(%s)'.", (sint)bc.Behav.Behaviour, MBEHAV::behaviourToString(bc.Behav.Behaviour).c_str());
}
CCDBNodeLeaf *targetList0 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_0));
CCDBNodeLeaf *targetList1 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_1));
CCDBNodeLeaf *targetList2 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_1));
CCDBNodeLeaf *targetList3 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_1));
if (targetList0 && targetList1 && targetList2 && targetList3)
{
uint64 vp[4] =
{
(uint64) targetList0->getValue64(),
(uint64) targetList1->getValue64(),
(uint64) targetList2->getValue64(),
(uint64) targetList3->getValue64()
};
bc.Targets.unpack(vp, 4);
}
applyBehaviour(bc);
}// updateVisualPropertyBehaviour //
//-----------------------------------------------
// updateVisualPropertyName :
// Update Entity Name.
//-----------------------------------------------
void CUserEntity::updateVisualPropertyName(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
uint32 oldNameId = _NameId;
CPlayerCL::updateVisualPropertyName(gameCycle, prop);
// Name changed ?
/* if (oldNameId != _NameId)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CInterfaceElement *element = CWidgetManager::getInstance()->getElementFromId("ui:interface:mailbox:content:html");
if (element)
{
CGroupHTML *html = dynamic_cast<CGroupHTML*>(element);
if (html)
html->browse("home");
}
}
*/
}// updateVisualPropertyName //
//-----------------------------------------------
// updateVisualPropertyTarget :
// Update Entity Target.
//-----------------------------------------------
void CUserEntity::updateVisualPropertyTarget(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */)
{
// Don't override the Player Target, cause client side entirely => no lag.
//targetSlot((CLFECOMMON::TCLEntityId)prop);
}// updateVisualPropertyTarget //
//-----------------------------------------------
// updateVisualPropertyMode :
// New mode received -> immediately change the mode for the user.
// \warning Read the position or orientation from the database when reading the mode (no more updated in updateVisualPropertyPos and updateVisualPropertyOrient).
//-----------------------------------------------
void CUserEntity::updateVisualPropertyMode(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
{
// Combat Float Check
if((MBEHAV::EMode)prop == MBEHAV::COMBAT_FLOAT)
{
nlwarning("UE:updateVPMode: the user should never have the COMBAT_FLOAT mode.");
return;
}
// New Mode Received.
_TheoreticalMode = (MBEHAV::EMode)prop;
// Change the user mode.
mode(_TheoreticalMode);
}// updateVisualPropertyMode //
//-----------------------------------------------
// updateVisualPropertyVpa :
// Update Entity Visual Property A
//-----------------------------------------------
void CUserEntity::updateVisualPropertyVpa(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyVpa(gameCycle, prop);
// Special for user: Disable Character Lod, because always want it at full rez.
if(!_Skeleton.empty())
{
_Skeleton.setLodCharacterShape(-1);
}
updateVisualDisplay();
}// updateVisualPropertyVpa //
//-----------------------------------------------
// updateVisualPropertyVpb :
// Update Entity Visual Property B
//-----------------------------------------------
void CUserEntity::updateVisualPropertyVpb(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyVpb(gameCycle, prop);
updateVisualDisplay();
}// updateVisualPropertyVpb //
//-----------------------------------------------
// updateVisualPropertyVpc :
// Update Entity Visual Property C
//-----------------------------------------------
void CUserEntity::updateVisualPropertyVpc(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyVpc(gameCycle, prop);
updateVisualDisplay();
}// updateVisualPropertyVpc //
//-----------------------------------------------
// updateVisualPropertyEntityMounted :
// Update Entity Mount
//-----------------------------------------------
void CUserEntity::updateVisualPropertyEntityMounted(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
if(isFighting())
CPlayerCL::updateVisualPropertyEntityMounted(gameCycle, prop);
else
_Mount = (CLFECOMMON::TCLEntityId)prop;
}// updateVisualPropertyEntityMounted //
//-----------------------------------------------
// updateVisualPropertyRiderEntity :
// Update Entity Rider
//-----------------------------------------------
void CUserEntity::updateVisualPropertyRiderEntity(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
if(isFighting())
CPlayerCL::updateVisualPropertyRiderEntity(gameCycle, prop);
else
_Rider = (CLFECOMMON::TCLEntityId)prop;
}// updateVisualPropertyRiderEntity //
//-----------------------------------------------
//-----------------------------------------------
void CUserEntity::updateVisualPropertyPvpMode(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyPvpMode(gameCycle, prop);
// Additionaly, inform interface of the change
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// For PVP ZoneFaction
CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_MODE");
if(pDB)
{
sint32 val= pDB->getValue32();
pDB->setValue32(val+1);
}
// For Any PVP change
pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
if(pDB)
{
sint32 val= pDB->getValue32();
pDB->setValue32(val+1);
}
}
//-----------------------------------------------
//-----------------------------------------------
void CUserEntity::updateVisualPropertyOutpostInfos(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyOutpostInfos(gameCycle, prop);
// For Any PVP change
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
if(pDB)
{
sint32 val= pDB->getValue32();
pDB->setValue32(val+1);
}
}
//-----------------------------------------------
//-----------------------------------------------
void CUserEntity::updateVisualPropertyPvpClan(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
{
CPlayerCL::updateVisualPropertyPvpClan(gameCycle, prop);
// For Any PVP change
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
if(pDB)
{
sint32 val= pDB->getValue32();
pDB->setValue32(val+1);
}
}
/////////////////////////////////////////////////
/////////////////////////////////////////////////
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//-----------------------------------------------
// mode :
// Method called to change the mode (Combat/Mount/etc.).
// \todo GUIGUI : apply stage in combat modes instead of just removing them.
// \todo GUIGUI : go or teleport the player to the mode position (see how to manage it).
//-----------------------------------------------
bool CUserEntity::mode(MBEHAV::EMode m)
{
if(Verbose & VerboseAnim)
nlinfo("UE::mode: old mode '%s(%d)' new mode '%s(%d)'.", MBEHAV::modeToString(_Mode).c_str(), _Mode, MBEHAV::modeToString(m).c_str(), m);
// Nothing to do if the mode is the same as the previous one.
if(m == _Mode)
return true;
// Release the old Mode.
switch(_Mode)
{
// Leave COMBAT Mode
case MBEHAV::COMBAT:
case MBEHAV::COMBAT_FLOAT:
{
// If there are some stage not complete -> remove them
if(_Stages._StageSet.size() != 0)
_Stages._StageSet.clear();
}
break;
// Leave MOUNTED Mode
case MBEHAV::MOUNT_NORMAL:
case MBEHAV::MOUNT_SWIM:
{
if ( m == MBEHAV::REST )
{
// can't go afk while mounting
return false;
}
// if changing mode for another mount mode, do nothing
if (m != MBEHAV::MOUNT_NORMAL && m != MBEHAV::MOUNT_SWIM)
{
// Display the mount again.
CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
if(mount)
{
// Set the mount.
mount->rider(CLFECOMMON::INVALID_SLOT);
mount->_Stages._StageSet.clear();
mount->setMode(MBEHAV::NORMAL);
mount->computeAutomaton();
mount->computeAnimSet();
mount->setAnim(CAnimationStateSheet::Idle);
if(mount->getPrimitive())
mount->getPrimitive()->setOcclusionMask(MaskColNpc); // the mount is an npc
mount->_ForbidClipping = false;
}
//
_Mount = CLFECOMMON::INVALID_SLOT;
// Restore the user Primitive
if(_Primitive)
{
_Primitive->setRadius( std::min(0.5f, (float)(RYZOM_ENTITY_SIZE_MAX/2)) );
_Primitive->setHeight(2);
}
_OnMount = false;
// Shift the player position (not to stand inside the mount)
CVectorD unmountShift;
unmountShift.sphericToCartesian(1.0, frontYaw() + NLMISC::Pi/2, 0);
pacsPos(pos() + unmountShift);
// Restore running if necessary
if (!_Run && _RunWhenAble)
{
switchVelocity();
}
}
if (_Mode == MBEHAV::MOUNT_SWIM && ( m == MBEHAV::COMBAT || m == MBEHAV::COMBAT_FLOAT))
{
//TODO : display "you can't fight while swimming"
return true;
}
}
break;
// Leave DEATH Mode
case MBEHAV::DEATH:
// Restaure the last view.
viewMode(viewMode());
break;
case MBEHAV::SWIM:
if( m == MBEHAV::COMBAT || m == MBEHAV::COMBAT_FLOAT)
{
//TODO : display "you can't fight while swimming"
return true;
}
break;
default:
nlwarning("Invalid behaviour change.");
}
// Reset Parent, unless we stay in mount mode
if ((_Mode != MBEHAV::MOUNT_SWIM && _Mode != MBEHAV::MOUNT_NORMAL)
|| (m != MBEHAV::MOUNT_SWIM && m != MBEHAV::MOUNT_NORMAL)
)
{
parent(CLFECOMMON::INVALID_SLOT);
}
// Change the Mode for the user ( if user sits down or stands up we wait in order to play the sit/stand transition anim)
if( m != MBEHAV::SIT && _Mode != MBEHAV::SIT )
_Mode = m;
_ModeWanted = m;
// Initialize the new Mode.
switch(m)
{
// Combat mode
case MBEHAV::COMBAT:
case MBEHAV::COMBAT_FLOAT:
{
// Compute the angle
const string propName = toString("SERVER:Entities:E%d:P%d", _Slot, CLFECOMMON::PROPERTY_ORIENTATION);
sint64 ang = NLGUI::CDBManager::getInstance()->getDbProp(propName)->getValue64();
_TargetAngle = *(float *)(&ang);
// Initialize controls for the combat.
UserControls.startCombat();
// Context help
contextHelp ("action_bar");
}
break;
// Mount Normal or mount swim
case MBEHAV::MOUNT_NORMAL:
{
CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(parent()));
if(mount)
{
mount->_Stages.removePosWithNoMode();
dir(mount->dir());
}
}
case MBEHAV::MOUNT_SWIM:
{
// Hide the mount unless we come from another mounted mode
if (_Mode != MBEHAV::MOUNT_SWIM && _Mode != MBEHAV::MOUNT_NORMAL)
{
if(_Mount != CLFECOMMON::INVALID_SLOT) // if _Mount is still invalid, the following code will be done in updatePos()
{
setOnMount();
}
}
// refresh target
UserEntity->selection(_Selection);
}
break;
// Dead mode.
case MBEHAV::DEATH:
setDead();
if(isSwimming())
_Mode = MBEHAV::SWIM_DEATH;
break;
// Normal or Default mode.
case MBEHAV::NORMAL:
_CurrentBehaviour.Behaviour = MBEHAV::IDLE;
default:
//
setAlive();
viewMode(viewMode());
break;
}
bool doSetAnim = true;
// if user sits down or stands up we set transition anim before changing animset
if( m == MBEHAV::SIT )
{
setAnim(CAnimationStateSheet::SitMode);
_Mode = m;
doSetAnim = false;
}
else
if( _Mode == MBEHAV::SIT && m!=MBEHAV::DEATH )
{
setAnim(CAnimationStateSheet::SitEnd);
_Mode = m;
doSetAnim = false;
}
// Show/Hide all or parts of the body.
updateVisualDisplay();
if( ClientCfg.AutomaticCamera )
{
// Set the direction as the front.
dir(front());
}
// Compute the current automaton
computeAutomaton();
// Update the animation set according to the mode.
computeAnimSet();
if( doSetAnim )
{
// Animset changed -> update current animation
setAnim(CAnimationStateSheet::Idle);
}
// Changing the mode well done.
return true;
}// mode //
/*
* Mount the mount in _Mount
*/
void CUserEntity::setOnMount()
{
CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
if(mount)
{
// Update primitives for the mount and the rider.
if(_Primitive && mount->getPrimitive())
{
_Primitive->setRadius( std::min(mount->getPrimitive()->getRadius(), (float)(RYZOM_ENTITY_SIZE_MAX/2)) );
_Primitive->setHeight(mount->getPrimitive()->getHeight());
mount->getPrimitive()->setOcclusionMask(MaskColNone); // Remove collisions.
}
// Now on a mount
_OnMount = true;
// Link the mount and the user.
parent(_Mount);
// Refresh the View Mode
viewMode(viewMode());
// Close the crafting window if open
closeFaberCastWindow();
// Keep run in mind
_RunWhenAble = _Run;
mount->_ForbidClipping = true;
}
}
//-----------------------------------------------
// getVelocity :
// compute and return the entity velocity
//-----------------------------------------------
CVector CUserEntity::getVelocity() const
{
static const CVector lateral(0,0,1);
static CVector velocity;
velocity = front() * _FrontVelocity + ( lateral ^ front()) * _LateralVelocity;
velocity.normalize();
// User is Dead
if(isDead())
{
velocity *= 0.0;
}
// User is sitting
else if(isSit())
{
velocity *= 0.0;
}
// User is swimming
else if(isSwimming())
{
// We are a Ring DM so speed up a litle
// Forward Run or Walk
if(_FrontVelocity > 0.0f)
{
if(_Run)
velocity *= 3.0;
else
velocity *= 1.0;
}
// Lateral or Backward Walk
else
velocity *= 1.0;
if (_R2CharMode == R2::TCharMode::Editer || _R2CharMode == R2::TCharMode::Dm)
{
velocity *= (float(ClientCfg.DmRun) / 6.0f); // velocity max = max run / 2
}
}
else if(isRiding())
{
// Forward Run or Walk
if(_FrontVelocity > 0.0f)
{
if(_Run)
velocity *= getMountRunVelocity();
else
velocity *= getMountWalkVelocity();
}
// Lateral or Backward Walk (currently, not used)
else
velocity *= 0.66f;//getMountWalkVelocity();
}
else
{
// Forward Run or Walk
if(_FrontVelocity > 0.0f)
velocity *= currentVelocity();
// Lateral or Backward Walk
else
velocity *= _WalkVelocity;
}
return velocity;
}// getVelocity //
//-----------------------------------------------
// speed :
// Return the Entity Current Speed.
//-----------------------------------------------
double CUserEntity::speed() const // virtual
{
return CPlayerCL::speed();
// return (double)getVelocity().norm();
}// speed //
//-----------------------------------------------
// applyMotion :
// Apply the motion to the entity.
//-----------------------------------------------
void CUserEntity::applyMotion(CEntityCL *target)
{
// default each frame
_ForceLookSlot= CLFECOMMON::INVALID_SLOT;
bool lastHasMoved = _HasMoved;
_HasMoved = false;
// Remove Positions in stages
_Stages.removePosWithNoMode();
// Remove Positions in stages for the mount.
CCharacterCL *mount = 0;
if(parent() != CLFECOMMON::INVALID_SLOT)
{
mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(parent()));
if(mount)
mount->_Stages.removePosWithNoMode();
}
// NO PRIMITIVE -> NO MOVE
if(_Primitive == 0)
return;
// BAD CONNECTION -> NO MOVE
if(NetMngr.getConnectionQuality() == false)
return;
// MS per TICK <=0 -> NO MOVE
if(NetMngr.getMsPerTick() <= 0)
return;
// Compute Speed Vector
NLMISC::CVectorD speed;
if(_MoveToSlot != CLFECOMMON::INVALID_SLOT)
{
// Check the Target.
if(target == 0 || target == this)
return;
// Compute the vector between the user and the target.
CVectorD dir2targ = target->pos() - pos();
dir2targ.z = 0.0;
if(dir2targ == CVectorD::Null)
dir2targ = front();
const double angToTarget = atan2(dir2targ.y, dir2targ.x);
CVectorD aimingPos = target->getAttackerPos(angToTarget, attackRadius() + ClientCfg.AttackDist);
// Aiming Position
CVectorD dirToAimingPos = aimingPos-pos();
dirToAimingPos.z = 0.0;
const double distToAimingPos = dirToAimingPos.norm();
// Decide if the target is reached or not
bool targetReached= false;
if(distToAimingPos > 0.5)
{
// Because of Tryker Counter, may increase the Threshold, when the player is stalled
if(distToAimingPos<_MoveToDist)
{
// If the player is stalled too much time, abort the move and launch the action
float actualSpeed= float((_Position - _LastFramePos).norm() / DT);
// if player effectively runs twice slower, start colision timer
if( actualSpeed*2 < getMaxSpeed() )
{
if(!_MoveToColStartTime)
_MoveToColStartTime= T1;
}
// else ok, reset colision timer
else
_MoveToColStartTime= 0;
// if too much time stalled, stop run.
if(_MoveToColStartTime && (T1 - _MoveToColStartTime >= ClientCfg.MoveToTimeToStopStall) )
targetReached= true;
}
else
_MoveToColStartTime= 0;
}
else
targetReached= true;
// If the target is reached
if(targetReached)
{
// stop and execute action
speed = CVectorD::Null;
moveToAction(target);
}
// else continue follow
else
{
// Look at the entity. delay it after pacs evalCollision(), for correct orientation
_ForceLookSlot= target->slot();
// but still estimate now an approximative front (may be used between now and applyForceLook())
forceLookEntity(dir2targ, false);
// Normalize
dirToAimingPos.normalize();
// Set the Velocity Direction
speed = dirToAimingPos*distToAimingPos;
speed /= DT;
if(speed.norm() > getMaxSpeed())
speed = dirToAimingPos*getMaxSpeed();
}
}
else if(follow())
{
// Check the Target.
if(target == 0 || target == this)
return;
// If the target is moving, orientate the user to the target.
// if(target->hasMoved())
{
// Compute the vector between the user and the target.
CVectorD dir2targ = target->pos() - pos();
dir2targ.z = 0.0;
if(dir2targ != CVectorD::Null)
{
// Look at the entity. delay it after pacs evalCollision(), for correct orientation
_ForceLookSlot= target->slot();
// but still estimate now an approximative front (may be used between now and applyForceLook())
forceLookEntity(dir2targ, false);
}
}
// Compute the angle in the world to attack the target.
const double angToTarget = frontYaw();
// Get the best position to attack the target with the given angle.
const CVectorD aimingPos = target->getAttackerPos(angToTarget, attackRadius() + ClientCfg.AttackDist);
// Aiming Position
CVectorD dirToAimingPos = aimingPos-pos();
dirToAimingPos.z = 0.0;
const double distToAimingPos = dirToAimingPos.norm();
// If the User was not moving and the distance to re-move is not enough big, stay idle
if(lastHasMoved
|| (isFighting() && distToAimingPos >= 0.5)
|| (!isFighting() && distToAimingPos >= 3.0))
{
dirToAimingPos.normalize();
// User is in combat mode -> follow as close as possible.
if(isFighting())
{
// Target is moving
if(target->hasMoved())
{
// Get closer if too far.
if(distToAimingPos >= 0.2)
{
// Set the Velocity Direction
speed = dirToAimingPos*distToAimingPos;
speed /= DT;
if(speed.norm() > getMaxSpeed())
speed = dirToAimingPos*getMaxSpeed();
}
else
{
// Try to have the same speed as the target.
if(target->getSpeed() > getMaxSpeed())
speed = target->dir()* ((float)getMaxSpeed());
else
speed = target->dir()* ((float)target->getSpeed());
}
}
// Target is not moving.
else
{
// Get closer if too far.
if(distToAimingPos >= 0.1)
{
// Set the Velocity Direction
speed = dirToAimingPos*distToAimingPos;
speed /= DT;
if(speed.norm() > getMaxSpeed())
speed = dirToAimingPos*getMaxSpeed();
}
else
speed = CVectorD::Null;
}
}
// User is not in combat mode -> follow not so close.
else
{
// Too far, get closer as fast as possible
if(distToAimingPos >= 3.0)
{
// Set the Velocity Direction
speed = dirToAimingPos*distToAimingPos;
speed /= DT;
if(speed.norm() > getMaxSpeed())
speed = dirToAimingPos*getMaxSpeed();
}
// Just far enough, adjust the user speed to the target
else if(target->hasMoved() && distToAimingPos >= 1.0)
{
// Try to have the same speed as the target.
if(target->getSpeed() > getMaxSpeed())
speed = target->dir()* ((float)getMaxSpeed());
else
speed = target->dir()* ((float)target->getSpeed());
}
// Too close, Stop
else
speed = CVectorD::Null;
}
}
// User was stop and the next pos is to close to begin to move.
else
speed = CVectorD::Null;
}
else
speed = getVelocity()*_SpeedFactor.getValue();
// SPEED VECTOR NULL -> NO MOVE
if(speed == CVectorD::Null)
return;
// First Person View
if(UserControls.isInternalView())
{
// If the server is slow, the client move slower too (only needed in FPV).
double modif = (100.0f/(float)NetMngr.getMsPerTick());
// don't increase speed
clamp(modif, 0.0, 1.0);
speed *= modif;
// Move
_HasMoved = true;
_Primitive->move(speed, dynamicWI);
if(mount && mount->getPrimitive())
mount->getPrimitive()->move(speed, dynamicWI);
}
// Third Person View
else
{
speed += pos();
sint64 x = (sint64)((sint32)(speed.x * 1000.0));
sint64 y = (sint64)((sint32)(speed.y * 1000.0));
sint64 z = (sint64)((sint32)(speed.z * 1000.0));
const uint time = 10; // = 1sec because the speed is in Meter per Sec.
_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSX, x, 0);
_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSY, y);
_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSZ, z);
// Move the Mount
if(mount)
{
mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSX, x, 0);
mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSY, y);
mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSZ, z);
}
}
}// applyMotion //
//---------------------------------------------------
//---------------------------------------------------
void CUserEntity::applyForceLook()
{
if(_ForceLookSlot!=CLFECOMMON::INVALID_SLOT)
{
CEntityCL *target= EntitiesMngr.entity(_ForceLookSlot);
if(target && target!=this)
{
// Compute the vector between the user and the target.
CVectorD dir2targ = target->pos() - pos();
dir2targ.z = 0.0;
if(dir2targ == CVectorD::Null)
dir2targ = front();
// Look at the entity
forceLookEntity(dir2targ, true);
}
}
}
//---------------------------------------------------
// updatePosCombatFloatChanged :
//---------------------------------------------------
void CUserEntity::updatePosCombatFloatChanged(CEntityCL * /* target */) // virtual
{
if(viewMode() == FirstPV)
{
pos(_FirstPos);
}
}// updatePosCombatFloatChanged //
//-----------------------------------------------
// forceIndoorFPV //
// Return true if the user is indoor and the CFG want to force the FPV Indoor.
//-----------------------------------------------
bool CUserEntity::forceIndoorFPV()
{
return (ClientCfg.ForceIndoorFPV && indoor());
}// forceIndoorFPV //
//-----------------------------------------------
// enableFollow :
//-----------------------------------------------
void CUserEntity::disableFollow()
{
if (_FollowMode==false)
return;
_FollowMode = false;
// Send the message to the server.
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("TARGET:NO_FOLLOW", out))
NetMngr.push(out);
else
nlwarning("UE:follow: unknown message named 'TARGET:NO_FOLLOW'.");
}// follow //
//-----------------------------------------------
// enableFollow :
//-----------------------------------------------
void CUserEntity::enableFollow(bool resetCameraRot)
{
if (_FollowMode == true)
return;
if( _Mode == MBEHAV::DEATH )
return;
_FollowMode = true;
// Send the message to the server.
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("TARGET:FOLLOW", out))
NetMngr.push(out);
else
nlwarning("UE:follow: unknown message named 'TARGET:FOLLOW'.");
// Disable any autowalk (else when follow re-disabled, it will effect, which is weird)
UserControls.autowalkState(false);
// disable afk mode
setAFK(false);
// if want to reset camera rotation
if(resetCameraRot)
startForceLookEntity(targetSlot());
}// follow //
//-----------------------------------------------
// resetAnyMoveTo
//-----------------------------------------------
void CUserEntity::resetAnyMoveTo()
{
// if we cancel a MoveToPhrase action, MUST dec the action counter, and hide the Action Icon
if(_MoveToAction==CUserEntity::CombatPhrase || _MoveToAction==CUserEntity::ExtractRM)
{
// the clientExecute has not been called in case of "ExtractRM autoFind"
bool autoFindExtractRM= _MoveToAction==CUserEntity::ExtractRM && _MoveToPhraseMemoryLine == std::numeric_limits<uint>::max();
if(!autoFindExtractRM)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
pPM->cancelClientExecute(_MoveToPhraseCyclic);
}
}
// reset to no moveTo
_MoveToSlot = CLFECOMMON::INVALID_SLOT;
_MoveToAction = CUserEntity::None;
_MoveToDist = 0.0;
_MoveToColStartTime= 0;
}
//-----------------------------------------------
// moveToCheckStartDist :
// Check if the user is not already well placed.
//-----------------------------------------------
void CUserEntity::moveToCheckStartDist(CLFECOMMON::TCLEntityId slot, double dist, TMoveToAction /* action */)
{
if(_MoveToSlot != CLFECOMMON::INVALID_SLOT)
{
// Start a new Force Look entity
startForceLookEntity(_MoveToSlot);
// Disable any autowalk (else when moveTo re-disabled, it will effect, which is weird)
UserControls.autowalkState(false);
// disable afk mode
setAFK(false);
// if sufficiently near, launch the action
CEntityCL *target = EntitiesMngr.entity(slot);
if(target)
{
CVectorD dir2targ = target->pos() - pos();
dir2targ.z = 0.0;
if((dir2targ==CVectorD::Null) || (dir2targ.norm() < dist))
{
moveToAction(target);
}
}
}
}// moveToCheckStartDist //
//-----------------------------------------------
// moveTo :
// Method to move to someone else.
//-----------------------------------------------
void CUserEntity::moveTo(CLFECOMMON::TCLEntityId slot, double dist, TMoveToAction action)
{
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = action;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}// moveTo //
//-----------------------------------------------
// moveToMission :
// Method to move to someone else for a mission. NB: if prec action was a CombatPhrase action, action counter are decremented
//-----------------------------------------------
void CUserEntity::moveToMission(CLFECOMMON::TCLEntityId slot, double dist, uint32 id)
{
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = CUserEntity::Mission;
_MoveToMissionId = id;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}// moveToMission //
//-----------------------------------------------
// moveToMissionRing :
// Method to move to someone else for a ring mission. NB: if prec action was a CombatPhrase action, action counter are decremented
//-----------------------------------------------
void CUserEntity::moveToMissionRing(CLFECOMMON::TCLEntityId slot, double dist, uint32 id)
{
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = CUserEntity::MissionRing;
_MoveToMissionId = id;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}// moveToMissionRing //
//-----------------------------------------------
// moveTo :
// Method to move to someone else.
//-----------------------------------------------
void CUserEntity::moveToCombatPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool phraseCyclic)
{
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = CUserEntity::CombatPhrase;
_MoveToPhraseMemoryLine= phraseMemoryLine;
_MoveToPhraseMemorySlot= phraseMemorySlot;
_MoveToPhraseCyclic= phraseCyclic;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}
//-----------------------------------------------
// Method to move to someone else, for foraging extraction
// The caller MUST call after CSPhraseManager::clientExecute(), to increment action counter
//-----------------------------------------------
void CUserEntity::moveToExtractionPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool cyclic)
{
// Test if forage tool in hand, otherwise auto-equip with it
bool validForageToolInHand = false;
CInventoryManager * inv = CInventoryManager::getInstance();
if ( !inv )
{
return;
}
uint32 rightHandSheet = inv->getRightHandItemSheet();
if ( rightHandSheet )
{
validForageToolInHand = inv->isForageToolItem( rightHandSheet );
}
if ( !validForageToolInHand )
{
// Find a forage tool in the bag
uint i;
for ( i=0; i<MAX_BAGINV_ENTRIES; ++i )
{
uint32 itemSheet = inv->getBagItem(i).getSheetID();
if ( itemSheet && inv->isForageToolItem(itemSheet) )
{
break;
}
}
if ( i != MAX_BAGINV_ENTRIES && ClientCfg.AutoEquipTool )
{
// remember last used weapon(s)
rememberWeaponsInHand();
// Clear hands
inv->unequip( "LOCAL:INVENTORY:HAND:1" );
inv->unequip( "LOCAL:INVENTORY:HAND:0" );
// Equip hands
string bagPath = toString( "LOCAL:INVENTORY:BAG:%u", i );
inv->equip( bagPath, "LOCAL:INVENTORY:HAND:0" );
}
else
{
// No forage tool in bag
CInterfaceManager::getInstance()->displaySystemInfo( CI18N::get("uiForageToolMissing"), "CHK" );
return;
}
}
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = CUserEntity::ExtractRM;
_MoveToPhraseMemoryLine= phraseMemoryLine;
_MoveToPhraseMemorySlot= phraseMemorySlot;
_MoveToPhraseCyclic= cyclic;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}
//-----------------------------------------------
// Method to begin a spire construction
// The caller MUST call after CSPhraseManager::clientExecute(), to increment action counter
//-----------------------------------------------
void CUserEntity::moveToTotemBuildingPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool cyclic)
{
resetAnyMoveTo();
// setup new state
_MoveToSlot = slot;
_MoveToDist = dist;
_MoveToAction = CUserEntity::BuildTotem;
_MoveToPhraseMemoryLine= phraseMemoryLine;
_MoveToPhraseMemorySlot= phraseMemorySlot;
_MoveToPhraseCyclic= cyclic;
moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
}
//-----------------------------------------------
// moveToAction :
// Launch the Action Once the Move is done.
// \param CEntityCL * : pointer on the destination entity.
// \warning entity pointer must be valid(allocated).
//-----------------------------------------------
void CUserEntity::moveToAction(CEntityCL *ent)
{
// Check entity pointer
nlassert(ent);
UserControls.needReleaseForward();
// Get the interface instance.
CInterfaceManager *IM = CInterfaceManager::getInstance();
switch(_MoveToAction)
{
// Attack
case CUserEntity::Attack:
UserEntity->attack();
break;
// Quartering
case CUserEntity::Quarter:
if((ent->properties()).harvestable())
CAHManager::getInstance()->runActionHandler("context_quartering", 0);
break;
// Loot
case CUserEntity::Loot:
if((ent->properties()).lootable())
CAHManager::getInstance()->runActionHandler("context_loot", 0);
break;
// Pick Up
case CUserEntity::PickUp:
nlwarning("UE:checkMoveTo: not yet implemented");
break;
case CUserEntity::ExtractRM:
extractRM();
break;
// Trade Item
case CUserEntity::TradeItem:
CAHManager::getInstance()->runActionHandler("context_trade_item", 0);
break;
// Trade Phrase
case CUserEntity::TradePhrase:
CAHManager::getInstance()->runActionHandler("context_trade_phrase", 0);
break;
// Trade Pact
case CUserEntity::TradePact:
CAHManager::getInstance()->runActionHandler("context_trade_pact", 0);
break;
// Mission
case CUserEntity::Mission:
{
string param = toString("id=%d", _MoveToMissionId);
CAHManager::getInstance()->runActionHandler("mission_option", 0, param);
}
break;
// Dynamic Mission
case CUserEntity::DynamicMission:
CAHManager::getInstance()->runActionHandler("context_dynamic_mission", 0);
break;
// Static Mission
case CUserEntity::StaticMission:
CAHManager::getInstance()->runActionHandler("context_choose_mission", 0);
break;
// Mission
case CUserEntity::MissionRing:
{
string param = toString("id=%d", _MoveToMissionId);
CAHManager::getInstance()->runActionHandler("mission_ring", 0, param);
}
break;
// Create Guild
case CUserEntity::CreateGuild:
CAHManager::getInstance()->runActionHandler("context_create_guild", 0);
break;
// News
case CUserEntity::News:
CAHManager::getInstance()->runActionHandler("context_talk", 0);
break;
// Trade Teleport
case CUserEntity::TradeTeleport:
CAHManager::getInstance()->runActionHandler("context_trade_teleport", 0);
break;
// Trade Faction items
case CUserEntity::TradeFaction:
CAHManager::getInstance()->runActionHandler("context_trade_faction", 0);
break;
// Trade Cosmetic
case CUserEntity::TradeCosmetic:
CAHManager::getInstance()->runActionHandler("context_trade_cosmetic", 0);
break;
// Talk
case CUserEntity::Talk:
nlwarning("UE:checkMoveTo: not yet implemented");
break;
// CombatPhrase
case CUserEntity::CombatPhrase:
UserEntity->attackWithPhrase();
break;
// Mount
case CUserEntity::Mount:
{
string orderStr = "mount";
string beastIndexStr = "@UI:GCM_BEAST_SELECTED";
bool confirmFree = true;
beastOrder(orderStr,beastIndexStr,confirmFree);
break;
}
// WebPage
case CUserEntity::WebPage:
CAHManager::getInstance()->runActionHandler("context_web_page", 0);
break;
// Outpost
case CUserEntity::Outpost:
CLuaManager::getInstance().executeLuaScript("game:outpostBCOpenStateWindow()", 0);
break;
// BuildTotem
case CUserEntity::BuildTotem:
buildTotem();
break;
default:
break;
}
// Move To Done.
resetAnyMoveTo();
}// moveToAction //
//-----------------------------------------------
// sendToServer :
// Send the position and orientation to the server.
//-----------------------------------------------
bool CUserEntity::sendToServer(CBitMemStream &out)
{
if(GenericMsgHeaderMngr.pushNameToStream("POSITION", out))
{
// Backup the position sent.
if (_Primitive) _Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
// Send Position & Orientation
CPositionMsg positionMsg;
positionMsg.X = (sint32)(pos().x * 1000);
positionMsg.Y = (sint32)(pos().y * 1000);
positionMsg.Z = (sint32)(pos().z * 1000);
positionMsg.Heading = frontYaw();
out.serial(positionMsg);
return true;
}
else
{
nlwarning("UE:sendToServer: unknown message named 'POSITION'.");
return false;
}
}// sendToServer //
//-----------------------------------------------
// msgForCombatPos :
// Fill the msg to know if the user is well placed to fight.
//-----------------------------------------------
bool CUserEntity::msgForCombatPos(NLMISC::CBitMemStream &out)
{
static bool wellPosition = false;
bool wellP = false;
// if(isFighting())
{
// Is the user well Placed
CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
if(target)
wellP = target->isPlacedToFight(UserEntity->pos(), front(), attackRadius() + ClientCfg.AttackDist);
}
// If different from the last time
if(wellPosition != wellP)
{
wellPosition = wellP;
// Send state to server.
if(GenericMsgHeaderMngr.pushNameToStream("COMBAT:VALIDATE_MELEE", out))
{
uint8 flag = wellP?1:0;
out.serial(flag);
return true;
}
else
nlwarning("UE:msgForCombatPos: unknown message named 'COMBAT:TOGGLE_COMBAT_FLOAT_MODE'.");
}
// Do not send the msg.
return false;
}// msgForCombatPos //
//-----------------------------------------------
// checkPos :
// Check the User Position according to the server code.
// \todo GUIGUI : put checks on GPos
// \todo GUIGUI : refact the check primitive when creating a PACS again
//-----------------------------------------------
void CUserEntity::checkPos()
{
if(PACS && _Primitive)
{
// Is in water ?
if(GR)
{
UGlobalPosition gPos;
_Primitive->getGlobalPosition(gPos, dynamicWI);
float waterHeight;
if(GR->isWaterPosition(gPos, waterHeight))
{
if(isSwimming() == false)
{
// Player is Dead set the right mode (swim and dead)
if(isDead())
mode(MBEHAV::SWIM_DEATH);
else
{
// Do not swim when in combat mode.
if(isFighting())
{
_HasMoved = false;
pacsPos(_LastPositionValidated, _LastGPosValidated);
}
// \todo GUIGUI : if the move was cancelled, do not switch to swimming mode.
else if (isRiding())
{
mode(MBEHAV::MOUNT_SWIM);
// also change mounted entity mode
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);
}
}
}
}
else
{
if(isSwimming())
{
if(isDead())
{
mode(MBEHAV::DEATH);
}
else if (isRiding())
{
mode(MBEHAV::MOUNT_NORMAL);
// also change mounted entity mode
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);
}
}
}
}
// Create the Primitive used to check if the move will be accepted by the server
if(_CheckPrimitive == 0)
{
_Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
_Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
_CheckPrimitive = PACS->addNonCollisionablePrimitive(_Primitive);
_CheckPrimitive->setOcclusionMask(MaskColNone); // Collide with nothing
_CheckPrimitive->setCollisionMask(MaskColNone); // Collide with nothing
_LastPositionValidated = pos();
}
if(_CheckPrimitive)
{
_CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
CVectorD speed = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
_CheckPrimitive->move(speed, dynamicWI);
if(PACS->evalNCPrimitiveCollision(1.0, _CheckPrimitive, dynamicWI) == false)
nlwarning("UE:checkPos: _CheckPrimitive is a collisionable primitive !!!");
CVectorD vectDist = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
if(vectDist.norm() > 0.001)
{
// The server will not be able to reproduce this move, restoring the last one.
_HasMoved = false;
pacsPos(_LastPositionValidated,_LastGPosValidated);
}
else
{
_LastPositionValidated = _Primitive->getFinalPosition(dynamicWI);
_Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
}
}
}
}// checkPos //
//-----------------------------------------------
// testPacsPos :
// test the move from posToTest to current pos
//-----------------------------------------------
bool CUserEntity::testPacsPos( CVectorD& posToTest )
{
if(PACS && _Primitive && _CheckPrimitive)
{
_CheckPrimitive->setGlobalPosition(posToTest, dynamicWI);
CVectorD speed = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
_CheckPrimitive->move(speed, dynamicWI);
if(PACS->evalNCPrimitiveCollision(1.0, _CheckPrimitive, dynamicWI) == false)
nlwarning("UE:testPacsPos: _CheckPrimitive is a collisionable primitive !!!");
CVectorD vectDist = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
if(vectDist.norm() > 0.001)
{
return false;
}
else
return true;
}
return false;
} // testPacsPos //
//-----------------------------------------------
// tp :
// Teleport the player (remove selection, re-init checkPos, etc.).
//-----------------------------------------------
void CUserEntity::tp(const CVectorD &dest)
{
// Remove the selection.
UserEntity->selection(CLFECOMMON::INVALID_SLOT);
// Update PACS
pacsPos(dest);
// Update the primitive useful to check the user position.
_LastPositionValidated = dest;
// Get the Global position
if(_Primitive)
{
// this is the last PACS position validated too
_Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
// consider this is the last position sent to server (since actually received!)
_Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
// Set the new position of the 'check' primitive
if(_CheckPrimitive)
_CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
}
else
nlwarning("UE:tp: the entity has a Null primitive.");
// Return to interface mode.
viewMode(UserEntity->viewMode());
// User well oriented.
dir(UserEntity->front());
// Set Normal Mode after a teleport.
mode(MBEHAV::NORMAL);
// Set animation with idle.
setAnim(CAnimationStateSheet::Idle);
}// tp //
//-----------------------------------------------
// correctPos :
// Teleport the player to correct his position.
//-----------------------------------------------
void CUserEntity::correctPos(const NLMISC::CVectorD &dest)
{
nlinfo("UE:correctPos: new user position %f %f %f", dest.x, dest.y, dest.z);
// Change the user poisition.
UserEntity->pacsPos(dest);
// Update the primitive useful to check the user position.
_LastPositionValidated = dest;
// Get the Global position
if(_Primitive)
{
// this is the last PACS position validated too
_Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
// consider this is the last position sent to server (since actually received!)
_Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
// Set the new position of the 'check' primitive
if(_CheckPrimitive)
_CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
}
else
nlwarning("UE:correctPos: the entity has a Null primitive.");
// Correct the pos of the mount, if riding
if ( isRiding() )
{
if ( _Mount < EntitiesMngr.entities().size() )
{
CEntityCL *mount = EntitiesMngr.entities()[_Mount];
if ( mount )
mount->pacsPos( dest );
}
}
}// correctPos //
/*
* Check if the mount is able to run, and force walking mode if not
* (if the player clicked on run, set back to walk).
*/
void CUserEntity::checkMountAbleToRun()
{
if ( isRiding() )
{
if ( running() )
{
// Make the mount walk if she's hungry
if ( ! _MountHunger.canRun() )
switchVelocity( false );
}
else
{
// Make the mount run if she's not hungry anymore
if ( _RunWhenAble && _MountHunger.canRun() )
switchVelocity( false );
}
}
}
//-----------------------------------------------
// Update the position of the entity after the motion.
// \param t : Time for the position of the entity after the motion.
// \param target : pointer on the current target.
//-----------------------------------------------
void CUserEntity::updatePos(const TTime &t, CEntityCL *target)
{
// Update Mount if mounting (if _Mount was still not valid when mode received)
if((_Mount != CLFECOMMON::INVALID_SLOT && isRiding()) && _OnMount==false)
{
setOnMount();
}
// External view are managed like other entities.
if(!UserControls.isInternalView())
{
// Update position according to the animations.
CPlayerCL::updatePos(t, target);
_LastFrameTime = t*0.001;
// Set The FPV when indoor.
if(forceIndoorFPV())
viewMode(FirstPV, false);
return;
}
/*
else
{
// update anim state at least (needed when a spell is cast to play the cast fx at the right time, because they may be visible)
updateAnimationState();
}*/
// Compute the Time Step.
double frameTimeRemaining = computeTimeStep(((double)t)*0.001);
// Do not update animation if Client Light
if (!ClientCfg.Light)
{
// Attack Animation.
if(_AnimAttackOn)
{
if(animIndex(MOVE) != ::CAnimation::UnknownAnim)
{
if(animOffset(MOVE) >= EAM->getAnimationLength(animId(MOVE)))
{
_AnimAttackOn = false;
updateVisualDisplay();
}
}
}
// Increase the time in the current animation.
double previousTimeOffset = animOffset(MOVE);
double offset = previousTimeOffset + frameTimeRemaining;
// Check Anim length
double animLength = EAM->getAnimationLength(animId(MOVE));
if(offset > animLength)
animOffset(MOVE, animLength);
else
animOffset(MOVE, offset);
// Manage Events that could be created by the animation (like sound).
animEventsProcessing(previousTimeOffset, animOffset(MOVE));
}
// Get the right pos from PACS.
if(_Primitive && GR)
{
UGlobalPosition gPos;
_Primitive->getGlobalPosition(gPos, dynamicWI);
// Set the new current pos.
pos(GR->getGlobalPosition(gPos));
}
// Set the direction.
if( ClientCfg.AutomaticCamera )
{
//dir(front());
}
// Reset the TPV when outdoor if needed.
if(_Primitive && GR)
{
UGlobalPosition gPos;
_Primitive->getGlobalPosition(gPos, dynamicWI);
if(!GR->isInterior(gPos))
if(!ClientCfg.FPV)
viewMode(ThirdPV, false);
}
// Current time is now the entity time too.
_LastFrameTime = t*0.001;
}// updatePos //
//-----------------------------------------------
// updateDisplay :
// Update the PACS position after the evalCollision. The entity position is set too. This is fast.
// If the entity position is too far from its PACS position, setGlobalPosition is called.
// After this call, the position.z is valid.
//-----------------------------------------------
void CUserEntity::pacsFinalizeMove() // virtual
{
if(_Primitive == 0)
return;
// Get the global position
_FinalPacsPos = _Primitive->getFinalPosition(dynamicWI);
// Get the global position
UGlobalPosition gPos;
_Primitive->getGlobalPosition(gPos, dynamicWI);
if(gPos.InstanceId != -1)
{
pos(_FinalPacsPos);
if(_Mount != CLFECOMMON::INVALID_SLOT)
{
CEntityCL *mount = EntitiesMngr.entity(_Mount);
if(mount)
mount->pacsPos(pos());
}
}
else
_SetGlobalPositionDone = false;
}// pacsFinalizeMove //
//-----------------------------------------------
// applyBehaviour :
// Apply the behaviour for the user.
//-----------------------------------------------
void CUserEntity::applyBehaviour(const CBehaviourContext &behaviourContext) // virtual
{
const MBEHAV::CBehaviour &behaviour = behaviourContext.Behav;
// Special code for the First Person View
if((viewMode() == FirstPV) && behaviour.isCombat())
{
// Backup the current behaviour.
_CurrentBehaviour = behaviourContext.Behav;
dir(front());
// check if self-target
bool selfSpell = false;
if (behaviourContext.Targets.Targets.size() == 1)
{
if (behaviourContext.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;
}
// Default target hit dates
static vector<double> targetHitDates;
targetHitDates.clear();
targetHitDates.resize(behaviourContext.Targets.Targets.size(), TimeInSec);
// cast projectiles/impact linked to behaviour
updateCurrentAttack();
if (isCurrentBehaviourAttackEnd())
{
// In First Person (don't care), use a default animation => will choose a default delay of 0.5
performCurrentAttackEnd(behaviourContext, selfSpell && isOffensif,
targetHitDates, CAnimationStateSheet::UnknownState);
}
//
_RightFXActivated = false;
_LeftFXActivated = false;
if(EAM)
{
animState (MOVE, CAnimationStateSheet::FirstPersonAttack);
animIndex (MOVE, CAnimation::UnknownAnim);
animOffset(MOVE, 0.0);
_CurrentState = EAM->mState(_CurrentAutomaton, animState(MOVE));
if(_CurrentState && _CurrentAnimSet[MOVE])
{
const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
if(animStatePtr)
{
animIndex(MOVE, animStatePtr->chooseAnim(_AnimJobSpecialisation, people(), getGender(), 0.0));
if(animIndex(MOVE) != CAnimation::UnknownAnim)
{
if(_PlayList)
{
_PlayList->setAnimation (MOVE, animId(MOVE));
_PlayList->setTimeOrigin (MOVE, ryzomGetLocalTime ()*0.001);//_LastFrameTime);
_AnimAttackOn = true;
updateVisualDisplay();
}
}
}
}
}
// Start FX to play at the animation beginning like trails.
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);
}
// DeltaHP
applyBehaviourFlyingHPs(behaviourContext, behaviour, targetHitDates);
}
// In third person view (or camera mode), play the same way than for the others.
else
CPlayerCL::applyBehaviour(behaviourContext);
}// applyBehaviour //
//---------------------------------------------------
// setDead :
// Method to Flag the character as dead and do everything needed.
//---------------------------------------------------
void CUserEntity::setDead() // virtual
{
// User is dead -> NO FOLLOW
disableFollow();
// Remove the selection.
UserEntity->selection(CLFECOMMON::INVALID_SLOT);
// Death Mode Control and view.
UserControls.mode(CUserControls::DeathMode);
// Play the FX for the death
NL3D::UParticleSystemInstance deathFX = FXMngr.instantFX(ClientCfg.DeadFXName);
if(!deathFX.empty())
deathFX.setPos(selectBox().getCenter());
// Last teleport is a death
// get player's kami fame
CInterfaceManager *pIM = CInterfaceManager::getInstance();
sint8 kamiFame = 0;
uint kamiFameIndex = CStaticFames::getInstance().getFactionIndex("kami");
if (pIM && kamiFameIndex != CStaticFames::INVALID_FACTION_INDEX)
{
CCDBNodeLeaf *pLeafKamiFame = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:FAME:PLAYER%d:VALUE", kamiFameIndex - 1), false);
if (pLeafKamiFame != NULL)
kamiFame = pLeafKamiFame->getValue8();
}
// get player's karavan fame
sint8 karavanFame = 0;
uint karavanFameIndex = CStaticFames::getInstance().getFactionIndex("karavan");
if (pIM && karavanFameIndex != CStaticFames::INVALID_FACTION_INDEX)
{
CCDBNodeLeaf *pLeafKaravanFame = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:FAME:PLAYER%d:VALUE", karavanFameIndex - 1), false);
if (pLeafKaravanFame != NULL)
karavanFame = pLeafKaravanFame->getValue8();
}
// set loading background depending on player's faction fame
if (kamiFame > karavanFame)
LoadingBackground = ResurectKamiBackground;
else
LoadingBackground = ResurectKaravanBackground;
// disable or enable shadowing
updateCastShadowMap();
// enable death warning popup
//CInterfaceManager * pIM = CInterfaceManager::getInstance();
if( pIM )
{
CAHManager::getInstance()->runActionHandler("set",NULL,"dblink=UI:VARIABLES:DEATH_WARNING_WANTED|value=1");
}
}// setDead //
//-----------------------------------------------
// skillUp :
// Skill Up
//-----------------------------------------------
void CUserEntity::skillUp()
{
// Play the FX for the death
NL3D::UParticleSystemInstance skillUpFX = FXMngr.instantFX(ClientCfg.SkillUpFXName);
skillUpFX.setClusterSystem(getClusterSystem());
if(!skillUpFX.empty())
skillUpFX.setPos(pos());
}// skillUp //
//-----------------------------------------------
// startColTimer :
// After a few time, if the user is still in collision with someone else, remove collisions with other entitites.
//-----------------------------------------------
void CUserEntity::startColTimer()
{
if(_ColOn)
{
if(_ColRemoved==false)
{
if((T1-_ColStartTime) > ClientCfg.TimeToRemoveCol)
{
EntitiesMngr.removeColUserOther();
_ColRemoved = true;
}
}
}
else
{
_ColOn = true;
_ColStartTime = T1;
}
}// startColTimer //
//-----------------------------------------------
// stopColTimer :
// Called when the user is no more in collision with another entity.
//-----------------------------------------------
void CUserEntity::stopColTimer()
{
// Restore collisions.
if(_ColRemoved)
{
EntitiesMngr.restoreColUserOther();
_ColRemoved = false;
}
_ColOn = false;
}// stopColTimer //
//-----------------------------------------------
// getMaxSpeed
// Return the current max speed for the entity in meter per sec
// The method return a max according to the speed factor (given by the server)
// It's also return a value according to the landscape (water)
// Also managed mounts
//-----------------------------------------------
double CUserEntity::getMaxSpeed() const // virtual
{
// Max Defined speed according to the current factor (slow, or speed increased)
double maxSpeed = _SpeedFactor.getValue();
// User is Dead
if(isDead())
{
maxSpeed *= 0.0;
}
// User is sitting
else if(isSit())
{
maxSpeed *= 0.0;
}
// User is swimming
else if(isSwimming())
{
// We are a Ring DM so speed up a litle
if (_R2CharMode == R2::TCharMode::Editer || _R2CharMode == R2::TCharMode::Dm)
{
maxSpeed *= ClientCfg.DmRun / 2;
}
else
{
// Run
maxSpeed *= 3.0;
}
}
else if(isRiding())
{
// Run if mount not hungry, otherwise, use walk velocity
if (_MountHunger.canRun())
maxSpeed *= (double)getMountRunVelocity();
else
maxSpeed *= (double)getMountWalkVelocity();
}
else
{
// Run
maxSpeed *= runVelocity();
}
// Return the current max
return maxSpeed;
// return ClientCfg.Run * _SpeedFactor.getValue();
}// getMaxSpeed //
//-----------------------------------------------
// snapToGround :
// Snap the user to the ground.
//-----------------------------------------------
void CUserEntity::snapToGround()
{
CEntityCL::snapToGround();
updateSound (ryzomGetLocalTime ());
}// // snapToGround //
//-----------------------------------------------
// updateSound :
//-----------------------------------------------
void CUserEntity::updateSound(const TTime &time)
{
H_AUTO_USE ( RZ_Client_Update_Sound );
// no sound manager, no need to update sound
if (SoundMngr == 0)
return;
SoundMngr->setListenerPos(pos());
const CMatrix &camMat = MainCam.getMatrix();
SoundMngr->setListenerOrientation(camMat.getJ(), camMat.getK());
if (ClientCfg.Light)
return;
// step sound of self : refind the sound animations associated to the walk and run animation
static bool computeAnim = true;
static bool lastMode = false;
static TTime previousTime = 0;
static TTime stepTime = 0;
static bool leftRight = false;
static NLSOUND::CSoundAnimMarker *leftStep = 0;
static NLSOUND::CSoundAnimMarker *rightStep = 0;
// TODO : Remove when bug corrected:
if (_Gender == GSGENDER::unknown)
{
nlwarning("CUserEntity::updateSound : The gender is unknown, forcing it to male");
_Gender = GSGENDER::male;
}
// force recompute of anim if walk/run change.
computeAnim = computeAnim || (lastMode != _Run);
// Check the sound animation to find the time between to step
if(computeAnim && SoundMngr && _CurrentAnimSet[MOVE] != 0) // && _SoundId[MOVE] != NLSOUND::CSoundAnimationNoId)
{
lastMode = _Run;
TAnimStateId mode = _Run ? CAnimationStateSheet::Run : CAnimationStateSheet::Walk;
const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState (mode);
if (animStatePtr)
{
::CAnimation::TAnimId animId = animStatePtr->chooseAnim (_AnimJobSpecialisation, people(), getGender(), 0);
if (animId != ::CAnimation::UnknownAnim)
{
const ::CAnimation *anim = animStatePtr->getAnimation (animId);
if(anim)
{
// Select the sound ID
_SoundId[MOVE] = anim->soundId();
if (_SoundId[MOVE] != NLSOUND::CSoundAnimationNoId)
{
// retrieve the anim
NLSOUND::CSoundAnimManager *mgr = NLSOUND::CSoundAnimManager::instance();
string name = mgr->idToName(_SoundId[MOVE]);
if (!name.empty())
{
NLSOUND::CSoundAnimation *sanim = mgr->findAnimation(name);
if (sanim->countMarkers() != 2)
{
static set<string> warnOnce;
if (warnOnce.find(sanim->getName()) == warnOnce.end())
{
nlwarning("Sound animation '%s' has not 2 markers, not a biped ? (Display Once)", sanim->getName().c_str());
warnOnce.insert(sanim->getName());
}
}
else
{
stepTime = TTime((sanim->getMarker(1)->getTime() - sanim->getMarker(0)->getTime()) * 1000);
rightStep = sanim->getMarker(0);
leftStep = sanim->getMarker(1);
computeAnim = false;
}
}
}
}
}
}
}
if( SoundMngr && _Mode == MBEHAV::NORMAL)
{
if (!getVelocity().isNull())
{
if (stepTime > 0 && time-previousTime>=stepTime)
{
previousTime = time;
// set the sound 1 meter below listener
_SoundContext.Position = pos() + CVector(0,0,-1);
_SoundContext.RelativeGain = SoundMngr->getUserEntitySoundLevel();;
uint32 matId= getGroundType();
//nldebug("Current material = %u", matId);
_SoundContext.Args[0] = matId;
if (leftRight)
{
if (leftStep)
// TODO : find the correct cluster
leftStep->play(SoundMngr->getMixer(), NULL, _SoundContext);
}
else
{
if (rightStep)
// TODO : find the correct cluster
rightStep->play(SoundMngr->getMixer(), NULL, _SoundContext);
// recompute a new sound anim
computeAnim = true;
}
leftRight = !leftRight;
}
}
else
{
// resets the counter
previousTime = 0;
}
}
}// updateSound //
//-----------------------------------------------
// rotate :
// rotate the body on the left or right (front changes).
//-----------------------------------------------
void CUserEntity::rotate(float ang)
{
// Rotate the body.
CMatrix m;
m.identity();
m.rotateZ(ang);
front(m * front().normed());
}// rotate //
//-----------------------------------------------
// rotHeadVertically :
// rotate the head vertically.
//-----------------------------------------------
void CUserEntity::rotHeadVertically(float ang)
{
setHeadPitch(_HeadPitch+ang);
}// rotHeadVertically //
//-----------------------------------------------
// setHeadPitch(double hp)
//-----------------------------------------------
void CUserEntity::setHeadPitch(double hp)
{
_HeadPitch= hp;
const double bound= Pi/2 - 0.01; // epsilon to avoid gimbal lock
clamp(_HeadPitch, -bound, bound);
}
//---------------------------------------------------
// 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 CUserEntity::slotRemoved(const CLFECOMMON::TCLEntityId &slot)
{
// parent call
CPlayerCL::slotRemoved(slot);
// reset also selection
if(selection() == slot)
selection(CLFECOMMON::INVALID_SLOT);
}// slotRemoved //
//---------------------------------------------------
// selection :
// Change the entity selected.
// \param slot : slot now selected (CLFECOMMON::INVALID_SLOT for an empty selection).
// \warning Can be different from the entity targeted (in combat mode for example).
//---------------------------------------------------
void CUserEntity::selection(const CLFECOMMON::TCLEntityId &slot) // virtual
{
//allows reselection in Ring client: even if the selected slots is equal to the selection,
//the client must send the messages.
if ((_Selection == slot) && !ClientCfg.R2EDEnabled)
return;
// The selection will be the entity to watch
WatchedEntitySlot = slot;
disableFollow();
// Send the entity selected to the server.
NetMngr.pushTarget(slot);
// Target the slot on client, don't wait NetWork response
targetSlot(slot);
_TargetSlotNoLag= slot;
if (ClientCfg.R2EDEnabled)
{
R2::getEditor().inGameSelection(slot);
}
// Change the current selection so un color the current selection.
CEntityCL *sel = EntitiesMngr.entity(_Selection);
if(sel != NULL)
sel->visualSelectionStop(); // Blink off == restore to normal
// Set the entity selected
_Selection = slot;
// Update visual selection and interface
if ( sel && sel->isForageSource() )
sel->buildInSceneInterface(); // remove focus on previous selected source
sel = EntitiesMngr.entity(_Selection);
if(sel != NULL)
{
sel->visualSelectionStart();
if ( sel->isForageSource() )
sel->buildInSceneInterface(); // set focus on new selected source
}
// **** Update Target interface
//get the new target slot and set it in the database
CInterfaceManager *pIM = CInterfaceManager::getInstance();
NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:TARGET:SLOT")->setValue64(slot);
// Get the new target UID, and set in Database
uint tgtSlot= _Selection;
uint32 tgtEntityId= CLFECOMMON::INVALID_CLIENT_DATASET_INDEX;
CEntityCL *entity = NULL;
if (tgtSlot!=CLFECOMMON::INVALID_SLOT)
{
entity = EntitiesMngr.entity(tgtSlot);
if (entity)
tgtEntityId= entity->dataSetId();
}
// Set the User Target
CCDBNodeLeaf *prop = NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:TARGET:UID", false);
if(prop)
prop->setValue32(tgtEntityId);
// Bar Manager. Update now the Target View (so it takes VP if data available or 0... but result is immediate)
CBarManager::getInstance()->setLocalTarget(tgtEntityId);
// **** Update DB for InGameMenu
// clear the entries for mission option
for(uint k = 0; k < NUM_MISSION_OPTIONS; ++k)
{
CCDBNodeLeaf *missionOption = NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:TITLE", (int) k), false);
if (missionOption)
{
missionOption->setValue32(0);
}
CCDBNodeLeaf *playerGiftNeeded = NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:PLAYER_GIFT_NEEDED", (int) k), false);
if (playerGiftNeeded)
{
playerGiftNeeded->setValue32(0);
}
//
missionOption = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:TITLE", (int) k), false);
if (missionOption)
{
missionOption->setValue32(0);
}
playerGiftNeeded = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:PLAYER_GIFT_NEEDED", (int) k), false);
if (playerGiftNeeded)
{
playerGiftNeeded->setValue32(0);
}
}
/* TODO ULU : Add RP tags */
// update pvp tags
if ((tgtSlot!=CLFECOMMON::INVALID_SLOT) && entity)
{
CPlayerCL *pPlayer = dynamic_cast<CPlayerCL*>(entity);
if (pPlayer)
{
/*// Pvp Mode
CViewBitmap * tagMode = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:pvp_tags:mode"));
if (tagMode)
{
if (pPlayer->getPvpMode()&PVP_MODE::PvpFaction)
tagMode->setTexture("pvp_orange.tga");
else if (pPlayer->getPvpMode()&PVP_MODE::PvpFactionFlagged)
tagMode->setTexture("pvp_red.tga");
else
tagMode->setTexture("alpha_10.tga");
}
*/
/*// Pvp available actions (attack, heal, both)
CViewBitmap * tagMode = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:pvp_tags:actions"));
if (tagMode)
{
if (pPlayer->getPvpMode()&PVP_MODE::PvpFaction)
tag->setTexture("pvp_orange.tga");
else if (pPlayer->getPvpMode()&PVP_MODE::PvpFactionFlagged)
tag->setTexture("pvp_red.tga");
else
tag->setTexture("alpha_10.tga");
}*/
}
}
// clear web page
prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:WEB_PAGE_URL", false);
if(prop) prop->setValue32(0);
prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:WEB_PAGE_TITLE", false);
if(prop) prop->setValue32(0);
// clear mission ring
for(uint k = 0; k < BOTCHATTYPE::MaxR2MissionEntryDatabase; ++k)
{
prop= NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSION_RING:%d:TITLE", k), false);
if(prop) prop->setValue32(0);
}
// clear programs
prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:PROGRAMMES", false);
if(prop) prop->setValue32(0);
prop= NLGUI::CDBManager::getInstance()->getDbProp("SERVER:TARGET:CONTEXT_MENU:PROGRAMMES");
if(prop) prop->setValue32(0);
// increment db counter for context menu
pIM->incLocalSyncActionCounter();
}// selection //
//---------------------------------------------------
// moveToAttack :
// Method to place the user to attack the target and attack.
//---------------------------------------------------
void CUserEntity::moveToAttack()
{
// **** For clarity, try to launch a "default attack" found in the memory bar instead of an "anonymous" action
CSPhraseManager *pPM= CSPhraseManager::getInstance();
uint32 memLine, memSlot;
CEntityCL *target= EntitiesMngr.entity(selection());
CInventoryManager *inv = CInventoryManager::getInstance();
// auto-equip with valid weapon
if( ClientCfg.AutoEquipTool )
{
if(inv)
{
// if no valid weapons in had -> auto-equip with last used weapons
bool validWeaponInHand = true;
uint32 rightHandSheet = inv->getRightHandItemSheet();
if(rightHandSheet)
{
validWeaponInHand = inv->isMeleeWeaponItem(rightHandSheet) || inv->isRangeWeaponItem(rightHandSheet);
}
if( !validWeaponInHand )
{
autoEquipWithLastUsedWeapons();
}
// remember last used weapon(s)
rememberWeaponsInHand();
}
}
if(target && pPM->findDefaultAttack(memLine, memSlot))
{
// launch instead a phrase execution with this phrase
executeCombatWithPhrase(target, memLine, memSlot, true);
}
// **** Else launch an anonymous "default attack"
else
{
// melee or range?
bool melee = true;
if(inv)
{
uint32 rightHandSheet = inv->getRightHandItemSheet();
if(rightHandSheet)
melee = inv->isMeleeWeaponItem(rightHandSheet);
}
// Move to target if melee weapon
if(melee)
moveTo(selection(), 2.0, CUserEntity::Attack);
// Just attack if range weapon.
else
attack();
}
}// moveToAttack //
//---------------------------------------------------
// attack :
// Method to attack the target.
//---------------------------------------------------
void CUserEntity::attack()
{
// execute the default attack
CSPhraseManager *pPM= CSPhraseManager::getInstance();
pPM->executeDefaultAttack();
bool melee = true;
CInventoryManager *inv = CInventoryManager::getInstance();
if(inv)
{
uint32 rightHandSheet = inv->getRightHandItemSheet();
if(rightHandSheet)
melee = inv->isMeleeWeaponItem(rightHandSheet);
}
// If option ON, follow when attacking.
if(ClientCfg.FollowOnAtk)
{
// Follow only if attacking with a melee weapon
if(melee)
// enable, but don't reset camera rotation
enableFollow(false);
}
}// attack //
//---------------------------------------------------
// attack :
// Method to attack the target, with a special phrase
//---------------------------------------------------
void CUserEntity::attackWithPhrase()
{
if( !canEngageCombat() )
return;
CSPhraseManager *pPM= CSPhraseManager::getInstance();
// validate the execution on server
pPM->sendExecuteToServer(_MoveToPhraseMemoryLine, _MoveToPhraseMemorySlot, _MoveToPhraseCyclic);
// If the Attack is a "Next", and not a cycle, do a default attack
if(!_MoveToPhraseCyclic)
pPM->executeDefaultAttack();
// If option ON, follow when attacking.
if(ClientCfg.FollowOnAtk)
{
bool melee = true;
CInventoryManager *inv = CInventoryManager::getInstance();
if(inv)
{
uint32 rightHandSheet = inv->getRightHandItemSheet();
if(rightHandSheet)
melee = inv->isMeleeWeaponItem(rightHandSheet);
}
// Follow only if attacking with a melee weapon
if(melee)
// enable, but don't reset camera rotation
enableFollow(false);
}
// Because sendExecuteToServer() has been called, must NOT cancelClientExecute() at resetAnyMoveTo()
_MoveToAction= CUserEntity::None;
}
//-----------------------------------------------
// assist :
// your current target become the target of your current one.
//-----------------------------------------------
void CUserEntity::assist()
{
assist(targetSlot());
}// assist //
//-----------------------------------------------
void CUserEntity::assist(uint slot)
{
// Check the current target
if(slot == CLFECOMMON::INVALID_SLOT || slot == _Slot)
return;
// Check the target
CEntityCL *target = EntitiesMngr.entity(slot);
if(target == 0)
return;
// Check the new slot.
CLFECOMMON::TCLEntityId newSlot = target->targetSlot();
if(newSlot == CLFECOMMON::INVALID_SLOT || newSlot == _Slot)
return;
// Select the new target.
selection(newSlot);
}
//---------------------------------------------------
// disengage :
// Method to disengage the target.
//---------------------------------------------------
void CUserEntity::disengage()
{
// Set the database in local.
if(ClientCfg.Local)
{
IngameDbMngr.setProp("Entities:E0:P" + toString(CLFECOMMON::PROPERTY_MODE), MBEHAV::NORMAL); // Mode
IngameDbMngr.setProp("Entities:E0:P" + toString(CLFECOMMON::PROPERTY_TARGET_ID), _Selection); // Target
UserEntity->updateVisualProperty(0, CLFECOMMON::PROPERTY_MODE);
UserEntity->updateVisualProperty(0, CLFECOMMON::PROPERTY_TARGET_ID);
return;
}
// Disengage MSG.
const string msgName = "COMBAT:DISENGAGE";
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
NetMngr.push(out);
else
nlwarning("UE::disengage: unknown message named '%s'.", msgName.c_str());
// Change the current mode.
mode(MBEHAV::NORMAL);
}// disengage //
//-----------------------------------------------
// sit :
// Ask for the client to sit/stand ('true' to sit).
//-----------------------------------------------
bool CUserEntity::sit(bool s)
{
bool ok= false;
// SIT
if(s)
{
if(canSit() == true)
{
// disable afk mode
setAFK(false);
// Sit MSG.
if(mode(MBEHAV::SIT))
{
// autowalk disabled
UserControls.autowalkState(false);
const string msgName = "COMMAND:SIT";
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
{
out.serial(s);
NetMngr.push(out);
}
else
nlwarning("UE:sit: unknown message named '%s'.", msgName.c_str());
// mode changed
ok= true;
// display sit msg
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgUserIsSitting");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
}
}
}
// STAND
else
{
if(_Mode == MBEHAV::SIT)
{
if(mode(MBEHAV::NORMAL))
{
const string msgName = "COMMAND:SIT";
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
{
out.serial(s);
NetMngr.push(out);
}
else
nlwarning("UE:sit: unknown message named '%s'.", msgName.c_str());
// mode changed
ok= true;
// display stand msg
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgUserIsStanding");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
}
}
}
// if mode changed, Write to the UI database, to update views
if(ok)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:PLAYER_STAND", false);
if(node)
node->setValue32(_Mode != MBEHAV::SIT);
}
// mode changed
return ok;
}// sit //
//-----------------------------------------------
// canSit :
// Return true if the user can sit.
//-----------------------------------------------
bool CUserEntity::canSit() const
{
// If the user is not already sitting or is on a mount
if(!isSit() && (!isRiding()) && !isDead() && !isSwimming())
{
return true;
}
else
return false;
}// canSit //
//-----------------------------------------------
// setAFK
//-----------------------------------------------
void CUserEntity::setAFK(bool b, string afkTxt)
{
if( isAFK() == b ) return;
if (b)
{
if( isDead() || isRiding() || moveTo() || follow() )
return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
//sint64 start = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TSTART")->getValue64();
//sint64 end = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TEND")->getValue64();
//sint64 type = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TYPE")->getValue64();
//sint64 num = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_NUMBER")->getValue64();
if( pIM )
{
if( NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TYPE")->getValue64() != 0 )
return;
}
if( !isSit() && !isSwimming() )
{
if( !mode(MBEHAV::REST) )
return;
}
}
else
{
if( !isSit() && !isSwimming() )
{
if (isDead())
return;
else
mode(MBEHAV::NORMAL);
}
}
// send afk state
string msgName = "COMMAND:AFK";
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
{
out.serial(b);
NetMngr.push(out);
}
else
nlwarning("CUserEntity:setAFK: unknown message named '%s'.", msgName.c_str());
// custom afk txt
ucstring ucstr;
ucstr.fromUtf8( afkTxt );
CBitMemStream outTxt;
msgName = "STRING:AFK_TXT";
if( GenericMsgHeaderMngr.pushNameToStream(msgName,outTxt) )
{
outTxt.serial( ucstr );
NetMngr.push( outTxt );
}
else
{
nlwarning("CUserEntity:setAFK: unknown message named '%s'.", msgName.c_str());
}
}// setAFK //
//-----------------------------------------------
// rollDice
//-----------------------------------------------
void CUserEntity::rollDice(sint16 min, sint16 max)
{
const string msgName = "COMMAND:RANDOM";
CBitMemStream out;
if (GenericMsgHeaderMngr.pushNameToStream(msgName, out))
{
out.serial(min);
out.serial(max);
NetMngr.push(out);
}
else
nlwarning("CUserEntity:rollDice: unknown message named '%s'.", msgName.c_str());
}// rollDice //
//---------------------------------------------------
// canEngageCombat :
// return true if user can engage melee combat, else return false and display system msg
//---------------------------------------------------
bool CUserEntity::canEngageCombat()
{
if( isSit() )
{
// display "you can't fight while sitting" message)
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgCantFightSit");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
return false;
}
if( isSwimming() )
{
// display "you can't fight while swiming" message)
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgCantFightSwim");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
return false;
}
if ( isRiding() )
{
// display "you can't fight while swimming" message)
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgCantFightRide");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
return false;
}
return true;
} // canEngageCombat //
//---------------------------------------------------
// viewMode :
// Change the View (First/Third Person View).
//---------------------------------------------------
void CUserEntity::viewMode(CUserEntity::TView viewMode, bool changeView)
{
switch(viewMode)
{
// First Person View
case FirstPV:
if(changeView)
ClientCfg.FPV = true;
if(_Mount != CLFECOMMON::INVALID_SLOT)
{
CEntityCL *mount = EntitiesMngr.entity(_Mount);
if(mount)
mount->displayable(false);
}
// Change Controls.
if( isRiding() )
{
bool autoWalk = UserControls.autowalkState();
UserControls.mode(CUserControls::MountMode);
if( autoWalk )
UserControls.autowalkState( true );
}
else
UserControls.mode(CUserControls::InterfaceMode);
break;
// Third Person View
case ThirdPV:
if(changeView)
ClientCfg.FPV = false;
if(_Mount != CLFECOMMON::INVALID_SLOT)
{
CEntityCL *mount = EntitiesMngr.entity(_Mount);
if(mount)
mount->displayable(true);
}
// Change Controls.
UserControls.mode(CUserControls::ThirdMode);
break;
// Unknown
default:
nlwarning("UE:viewMode: Unknown View Asked '%d'.", (sint)viewMode);
return;
}
// Change the current View like asked.
_ViewMode = viewMode;
// disable or enable shadowing
updateCastShadowMap();
}// viewMode //
//-----------------------------------------------
// toggleCamera :
// Toggle Camera (First/Third Person)
//-----------------------------------------------
void CUserEntity::toggleCamera()
{
// You cannot change the camera view when dead.
if(isDead())
return;
// Only if not inside a building.
if(!UserEntity->forceIndoorFPV())
{
// Leave the 1st Person Mode -> Enter the 3rd Person View Mode
if (UserEntity->viewMode() == CUserEntity::FirstPV)
UserEntity->viewMode(CUserEntity::ThirdPV);
// Leave the 3rd Person Mode -> Enter the 1st Person View Mode
else
UserEntity->viewMode(CUserEntity::FirstPV);
}
}// toggleCamera //
//---------------------------------------------------
// getScale :
// Return the entity scale. (return 1.0 if there is any problem).
// \todo GUIGUI : do we have to take care of the user's race kwnowing it can favour him ?
//---------------------------------------------------
float CUserEntity::getScale() const // virtual
{
// Default Scale.
return 1.0f;
}// getScale //
//---------------------------------------------------
// removeCheckPrimitive :
// Remove the check primitive
//---------------------------------------------------
void CUserEntity::removeCheckPrimitive()
{
if(PACS && _CheckPrimitive)
PACS->removePrimitive(_CheckPrimitive);
_CheckPrimitive = 0;
}
//---------------------------------------------------
// removePrimitive :
// Remove the primitive
//---------------------------------------------------
void CUserEntity::removePrimitive() // virtual (will not be called by ~CEntityCL())
{
// Remove the Primitive used for check
removeCheckPrimitive();
// Remove the other primitive
CPlayerCL::removePrimitive();
}// removePrimitive //
//---------------------------------------------------
// computePrimitive :
// Create a primitive for the entity.
//---------------------------------------------------
void CUserEntity::computePrimitive() // virtual
{
// Initialize the primitive.
if(initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::Slide, (UMovePrimitive::TTrigger)(UMovePrimitive::OverlapTrigger | UMovePrimitive::EnterTrigger), MaskColPlayer, MaskColPlayer | MaskColNpc | MaskColDoor))
_Primitive->insertInWorldImage(dynamicWI);
// Set the position.
pacsPos(pos());
}// computePrimitive //
//---------------------------------------------------
// isBusy :
// Return if the user is already busy (combat/bo chat/loot/ etc.).
//---------------------------------------------------
bool CUserEntity::isBusy() const
{
CInterfaceManager *IM = CInterfaceManager::getInstance ();
// Check Trade.
// TODO : put the right DB entry !
CCDBNodeLeaf *nod = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:INVENTORY:EXCHANGE:BEGUN", false);
if(nod)
{
if(nod->getValueBool())
return true;
}
// else
// nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:EXCHANGE:BEGUN'.");
/*
// Check Loot
static const uint nbSlot = 4;
uint i;
for(i=0; i<nbSlot; ++i)
{
nod = NLGUI::CDBManager::getInstance()->getDbProp(NLMISC::toString("SERVER:INVENTORY:%d:%d:SHEET", INVENTORIES::pickup, i), false);
if(nod)
{
if(nod->getValue32() != 0)
return true;
}
else
nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:%d:%d:SHEET'.", INVENTORIES::pickup, i);
}
// Check Harvest
for(i=0; i<nbSlot; ++i)
{
nod = NLGUI::CDBManager::getInstance()->getDbProp(NLMISC::toString("SERVER:INVENTORY:%d:%d:SHEET", INVENTORIES::harvest, i), false);
if(nod)
{
if(nod->getValue32() != 0)
return true;
}
else
nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:%d:%d:SHEET'.", INVENTORIES::harvest, i);
}
*/
// Check Bot chat.
CBotChatPage * currPage = CBotChatManager::getInstance()->getCurrPage();
if( currPage!= NULL )
{
return true;
}
// Not Busy
return false;
}// isBusy //
//---------------------------------------------------
// updateVisualDisplay :
// Show/Hide all or parts of the user body.
// todo GUIGUI : it's bad for the _Face to be a separated instance
//---------------------------------------------------
void CUserEntity::updateVisualDisplay()
{
// We need a skeleton.
if(_Skeleton.empty())
return;
// 1st person View
if(UserControls.isInternalView() || View.forceFirstPersonView())
{
// Hide the mount
CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
if(mount)
mount->displayable(false);
// Hide all user body parts.
for(uint i=0; i<_Instances.size(); ++i)
if(!_Instances[i].Current.empty())
{
_Instances[i].Current.hide();
_Instances[i].hideStaticFXs();
}
// Hide the face
if(!_Face.Current.empty())
_Face.Current.hide();
// We want to display weapons in 1st person view when attacking.
if(modeWithHiddenItems() == false)
{
if( _Mode == MBEHAV::COMBAT_FLOAT || _Mode == MBEHAV::COMBAT )
{
if( _ObjectsVisible )
{
// Show just Few parts
if(!_Instances[SLOTTYPE::HANDS_SLOT].Current.empty())
{
_Instances[SLOTTYPE::HANDS_SLOT].Current.show();
_Instances[SLOTTYPE::HANDS_SLOT].showStaticFXs();
}
if(!_Instances[SLOTTYPE::ARMS_SLOT].Current.empty())
{
_Instances[SLOTTYPE::ARMS_SLOT].Current.show();
_Instances[SLOTTYPE::ARMS_SLOT].showStaticFXs();
}
if(!_Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current.empty())
{
_Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current.show();
_Instances[SLOTTYPE::RIGHT_HAND_SLOT].showStaticFXs();
}
if(!_Instances[SLOTTYPE::LEFT_HAND_SLOT].Current.empty())
{
_Instances[SLOTTYPE::LEFT_HAND_SLOT].Current.show();
_Instances[SLOTTYPE::LEFT_HAND_SLOT].showStaticFXs();
}
}
}
}
}
else
{
// Show the mount
CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
if(mount)
{
mount->displayable(true);
showOrHideBodyParts( objectsVisible() );
}
// Show the face
/*
if(!_Face.Current.empty())
_Face.Current.show();
*/
}
}// updateVisualDisplay //
//---------------------------------------------------
// light:
// Show/Hide the user light.
//---------------------------------------------------
void CUserEntity::light()
{
// Create the light
if(_Light.empty())
{
// Check there is a skeleton and a bone to stick the light before to create it.
if(!_Skeleton.empty() && _NameBoneId!=-1)
{
_Light = Scene->createPointLight();
if(!_Light.empty())
{
// front of the player
_Light.setPos(0.f,0.3f,0.f);
// Setup the light
_Light.setupAttenuation(12.0f, 20.0f);
// Attach the light
_Skeleton.stickObject(_Light, _NameBoneId);
// The player light is the only one who can interact with Lightmapped objects
_Light.setInfluenceLightMap(true);
// TestYoyo
/*
NL3D::UInstance inst;
inst= Scene->createInstance("box.shape");
if(!inst.empty())
{
inst.setScale(0.2f, 0.2f, 0.2f);
inst.parent(_Light);
}
*/
}
}
else
nlwarning("UE:light: there is no skeleton or Name Bone to stick the light.");
}
// Turn On/Off the Light
_LightOn = !_LightOn;
if(!_Light.empty())
{
if(_LightOn)
_Light.show();
else
_Light.hide();
}
}// light //
//---------------------------------------------------
// CSpeedFactor::init :
// Initialize the Observer for the Speed Factor.
//---------------------------------------------------
void CUserEntity::CSpeedFactor::init()
{
_Value = 1.0f; // Default speed factor is 1.
CInterfaceManager *IM = CInterfaceManager::getInstance ();
CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:SPEED_FACTOR", false);
if(pNodeLeaf)
{
/* if(!pNodeLeaf->addToLeaves(this))
nlwarning("UE:SP:init: cannot add the observer");*/
ICDBNode::CTextId textId;
pNodeLeaf->addObserver(this, textId);
if ( pNodeLeaf->getValue64() != 0 )
_Value = ((float)pNodeLeaf->getValue64())/100.0f; // may have been received before
}
else
nlwarning("UE:SP:init: 'SERVER:USER:SPEED_FACTOR' does not exist.");
}// CSpeedFactor::init //
//---------------------------------------------------
// CMountHunger::init :
//---------------------------------------------------
void CUserEntity::CMountHunger::init()
{}
//---------------------------------------------------
// CMountSpeeds::init :
//---------------------------------------------------
void CUserEntity::CMountSpeeds::init()
{
CInterfaceManager *IM = CInterfaceManager::getInstance ();
CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_WALK_SPEED", false );
BOMB_IF( ! pNodeLeaf, "MOUNT_WALK_SPEED not found", return );
if(pNodeLeaf)
{
ICDBNode::CTextId textId;
pNodeLeaf->addObserver(this, textId);
_WalkSpeed = ((float)pNodeLeaf->getValue32()) / 1000.0f; // may have been received before
}
pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_RUN_SPEED", false );
BOMB_IF( ! pNodeLeaf, "MOUNT_RUN_SPEED not found", return );
if(pNodeLeaf)
{
ICDBNode::CTextId textId;
pNodeLeaf->addObserver(this, textId);
_RunSpeed = ((float)pNodeLeaf->getValue32()) / 1000.0f; // may have been received before
}
}
//---------------------------------------------------
void CUserEntity::CSpeedFactor::release()
{
CInterfaceManager *IM = CInterfaceManager::getInstance ();
CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:SPEED_FACTOR", false);
if(pNodeLeaf)
{
/* if(!pNodeLeaf->addToLeaves(this))
nlwarning("UE:SP:init: cannot add the observer");*/
ICDBNode::CTextId textId;
pNodeLeaf->removeObserver(this, textId);
}
else
nlwarning("UE:SP:init: 'SERVER:USER:SPEED_FACTOR' does not exist.");
}// CSpeedFactor::init //
void CUserEntity::CMountHunger::release()
{}
void CUserEntity::CMountSpeeds::release()
{
CInterfaceManager *IM = CInterfaceManager::getInstance ();
CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_WALK_SPEED", false );
BOMB_IF( ! pNodeLeaf, "MOUNT_WALK_SPEED not found", return );
if(pNodeLeaf)
{
ICDBNode::CTextId textId;
pNodeLeaf->removeObserver(this, textId);
}
pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_RUN_SPEED", false );
BOMB_IF( ! pNodeLeaf, "MOUNT_RUN_SPEED not found", return );
if(pNodeLeaf)
{
ICDBNode::CTextId textId;
pNodeLeaf->removeObserver(this, textId);
}
}
//---------------------------------------------------
// CSpeedFactor::update :
// Callback called to update the speed factor.
//---------------------------------------------------
void CUserEntity::CSpeedFactor::update(ICDBNode *node) // virtual
{
CCDBNodeLeaf *leaf = safe_cast<CCDBNodeLeaf *>(node);
_Value = ((float)leaf->getValue64())/100.0f;
//nlinfo("SpeedFactor changed to %f / %"NL_I64"u", _Value, leaf->getValue64());
// clamp the value (2.0 is the egg item or the level 6 speed up power up, nothing should be faster)
if(_Value > 2.0f)
{
//nlwarning("HACK: you try to change the speed factor to %f", _Value);
//nlstop;
//_Value = 2.0f;
}
}// CSpeedFactor::update //
/*
* Return true if the mount can run. Precondition: UserEntity->isRiding().
*/
bool CUserEntity::CMountHunger::canRun() const
{
CEntityCL *mountEntity = UserEntity->getMountEntity();
if ( ! mountEntity )
return false;
// Find the mount's db leaf and check hunger
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CCDBNodeBranch *animalsNode = safe_cast<CCDBNodeBranch*>(NLGUI::CDBManager::getInstance()->getDB()->getNode( ICDBNode::CTextId( "SERVER:PACK_ANIMAL" ), false ));
BOMB_IF( ! animalsNode, "! animalsNode", return false; );
uint nbAnimals = (uint)animalsNode->getNbNodes();
for ( uint i=0; i!=nbAnimals; ++i )
{
ICDBNode *beastNode = animalsNode->getNode( i );
CCDBNodeLeaf *uidLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "UID" ) ));
if ( ((CLFECOMMON::TClientDataSetIndex)uidLeaf->getValue32()) == mountEntity->dataSetId() )
{
CCDBNodeLeaf *hungerLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "HUNGER" ) ));
return (hungerLeaf->getValue32() != (sint)ANIMAL_TYPE::DbHungryValue);
}
}
return false;
}
//---------------------------------------------------
// CMountSpeeds::update :
// Callback called to update the mount speed.
//---------------------------------------------------
void CUserEntity::CMountSpeeds::update(ICDBNode * /* node */) // virtual
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
_WalkSpeed = ((float)(NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:MOUNT_WALK_SPEED")->getValue32())) / 1000.0f;
_RunSpeed = ((float)(NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:MOUNT_RUN_SPEED")->getValue32())) / 1000.0f;
}
/*
* Return the mount entity if the user is riding, otherwise NULL
*/
CEntityCL* CUserEntity::getMountEntity()
{
if ( _Mount < EntitiesMngr.entities().size() )
{
return EntitiesMngr.entities()[_Mount];
}
return NULL;
}
/*
* Return the DB entry for the specified user's animal (NULL if not found)
*/
CCDBNodeBranch *CUserEntity::getBeastDBEntry( CLFECOMMON::TClientDataSetIndex uid )
{
// Find animal entry corresponding to datasetId
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CCDBNodeBranch *animalsNode = safe_cast<CCDBNodeBranch*>(NLGUI::CDBManager::getInstance()->getDB()->getNode( ICDBNode::CTextId( "SERVER:PACK_ANIMAL" ), false ));
BOMB_IF( ! animalsNode, "! animalsNode", return NULL );
uint nbAnimals = (uint)animalsNode->getNbNodes();
for ( uint i=0; i!=nbAnimals; ++i )
{
ICDBNode *beastNode = animalsNode->getNode( i );
CCDBNodeLeaf *pNodeLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "UID" ) ));
if ( pNodeLeaf && (pNodeLeaf->getValue32() == (sint32)uid) )
return (CCDBNodeBranch*)beastNode;
}
return NULL;
}
//---------------------------------------------------
// displayDebug :
// Display Debug Information.
//---------------------------------------------------
void CUserEntity::displayDebug(float x, float &y, float lineStep) // virtual
{
CPlayerCL::displayDebug(x, y, lineStep);
}// displayDebug //
//---------------------------------------------------
// displayModifiers :
// Display dmg/heal numbers above the head.
//---------------------------------------------------
void CUserEntity::displayModifiers() // virtual
{
if(!UserControls.isInternalView())
CPlayerCL::displayModifiers();
}// displayModifiers //
//---------------------------------------------------
// isVisible :
// Return 'true' is the entity is displayed.
//---------------------------------------------------
bool CUserEntity::isVisible() const // virtual
{
return !UserControls.isInternalView();
}// isVisible //
//---------------------------------------------------
// readWrite :
// Read/Write Variables from/to the stream.
//---------------------------------------------------
void CUserEntity::readWrite(class NLMISC::IStream &f) throw(NLMISC::EStream)
{
CPlayerCL::readWrite(f);
// PROTECTED
f.serial(_SpeedFactor);
f.serial(_FrontVelocity);
f.serial(_LateralVelocity);
CVector dummyHead;
f.serial(dummyHead);
f.serial(_HeadPitch);
f.serial(_EyesHeight);
f.serial(_Run);
f.serial(_WalkVelocity);
f.serial(_RunVelocity);
f.serial(_CurrentVelocity);
f.serial(_Selection);
f.serial(_Trader);
f.serial(_Interlocutor);
f.serial(_Selectable);
// PRIVATE
f.serial(_OnMount);
f.serial(_AnimAttackOn);
// f.serialEnum(_ViewMode);
}// readWrite //
//---------------------------------------------------
// load :
// To call after a read from a stream to re-initialize the entity.
//---------------------------------------------------
void CUserEntity::load() // virtual
{
CInterfaceManager *IM = CInterfaceManager::getInstance ();
// Insert the user into PACS at his saved position
pacsPos(pos());
// update
if(!_WaitForAppearance)
{
// Visual properties A
sint64 prop = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->getValue64();
updateVisualPropertyVpa(0, prop); // Vpa udapte vpb and vpc too.
}
}// load //
//---------------------------------------------------
void CUserEntity::CInvisibleObserver::update(ICDBNode* node)
{
UserEntity->buildInSceneInterface();
}
//---------------------------------------------------
void CUserEntity::CSkillPointsObserver::update(ICDBNode* node )
{
if (FarTP.isFarTPInProgress() || IngameDbMngr.initInProgress()) // prevent from displaying at the beginning of a FarTP (due to RESET_BANK or CDB resetData())
return;
CInterfaceManager *pIM = CInterfaceManager::getInstance ();
CCDBNodeLeaf *leaf = dynamic_cast<CCDBNodeLeaf*>(node);
if (leaf)
{
sint32 oldValue = leaf->getOldValue32();
if (oldValue != 0)
{
sint delta = leaf->getValue32()-oldValue;
string deltaStr = toString("%+d", delta);
// get the sp title
ucstring spTitle;
spTitle= CI18N::get(toString("uiSkillPointsBold%d",SpType));
// run the popup
CAHManager::getInstance()->runActionHandler("message_popup", NULL, "text1="+deltaStr+"|text0="+spTitle.toUtf8());
// Context help
contextHelp ("skill_point");
}
}
}
//---------------------------------------------------
// CFameObserver::update
//---------------------------------------------------
void CUserEntity::CFameObserver::update(ICDBNode* node )
{
CSkillManager *pSM = CSkillManager::getInstance();
CCDBNodeLeaf *leaf = dynamic_cast<CCDBNodeLeaf*>(node);
if (leaf)
{
sint32 fameValue = leaf->getValue32();
pSM->tryToUnblockTitleFromMinFames( FactionIndex, fameValue );
pSM->tryToUnblockTitleFromMaxFames( FactionIndex, fameValue );
}
}
//---------------------------------------------------
void CUserEntity::makeTransparent(bool t)
{
CPlayerCL::makeTransparent(t);
uint32 opaMin= getOpacityMin();
uint8 opacity = (uint8)(opaMin + (255-opaMin) * (1.0 - _TranspFactor));
getFace()->makeInstanceTransparent(opacity, (uint8)opaMin);
}// makeTransparent //
//---------------------------------------------------
void CUserEntity::setDiffuse(bool onOff, NLMISC::CRGBA diffuse)
{
CPlayerCL::setDiffuse(onOff, diffuse);
getFace()->setDiffuse(onOff, diffuse);
}
// Helper for CUserEntity::extractRM()
bool findExtractionActionInMemory( CSPhraseManager *pm, CSBrickManager *bm, uint memoryLine, uint& index )
{
uint x;
for ( x=0; x!=PHRASE_MAX_MEMORY_SLOT; ++x )
{
uint32 phraseSlot = pm->getMemorizedPhrase( memoryLine, x );
const CSPhraseCom& phraseCom = pm->getPhrase( phraseSlot );
if ( ! phraseCom.empty() )
{
CSBrickSheet *brickSheet = bm->getBrick( phraseCom.Bricks[0] );
if ( brickSheet->isForageExtraction() && (!brickSheet->MandatoryFamilies.empty()) ) // assumes care root bricks have not mandatories
{
index = x;
return true;
}
}
}
return false;
}
//---------------------------------------------------
void CUserEntity::extractRM()
{
CSPhraseManager *pm = CSPhraseManager::getInstance();
uint index;
uint memoryLine;
bool autoFindPhrase = (_MoveToPhraseMemoryLine == std::numeric_limits<uint>::max());
if ( ! autoFindPhrase )
{
// Use clicked phrase
memoryLine = _MoveToPhraseMemoryLine;
index = _MoveToPhraseMemorySlot;
}
else
{
// Find the first extraction phrase in the memory bar
CSBrickManager *bm = CSBrickManager::getInstance();
memoryLine = pm->getSelectedMemoryLineDB();
if ( ! findExtractionActionInMemory( pm, bm, memoryLine, index ) )
{
// Search in other memory bar lines (because the auto-equip does not set the current line at once)
memoryLine = std::numeric_limits<uint>::max();
uint nbLines = pm->getNbMemoryLines();
for ( uint j=0; j!=nbLines; ++j )
{
if ( j == memoryLine )
continue;
if ( findExtractionActionInMemory( pm, bm, j, index ) )
{
memoryLine = j;
break;
}
}
}
}
if ( memoryLine != std::numeric_limits<uint>::max() )
{
// Open the forage (but not for care actions). Necessary for the case of redoing an extraction after a Drop All on the same source.
uint32 phraseId = pm->getMemorizedPhrase( memoryLine, index );
if ( phraseId != 0 )
{
const CSPhraseCom& phraseCom = pm->getPhrase( phraseId );
if ( ! phraseCom.empty() )
{
CSBrickSheet *rootBrick = CSBrickManager::getInstance()->getBrick( phraseCom.Bricks[0] );
if ( rootBrick )
{
if ( rootBrick->IndexInFamily == 1 ) // only extracting actions
CTempInvManager::getInstance()->open( TEMP_INV_MODE::Forage );
}
}
}
// Cast the extraction. if autoFindPhrase, clientExecute() not already called.
if ( autoFindPhrase )
{
// decide now if cyclic or not
_MoveToPhraseCyclic= true;
if(pm->avoidCyclicForPhrase(pm->getMemorizedPhrase(memoryLine, index)))
_MoveToPhraseCyclic= false;
// execute on client now
pm->clientExecute( memoryLine, index, _MoveToPhraseCyclic);
}
// execute on server
pm->sendExecuteToServer( memoryLine, index, _MoveToPhraseCyclic );
// Because sendExecuteToServer() has been called, must NOT cancelClientExecute() at resetAnyMoveTo()
_MoveToAction= CUserEntity::None;
}
else
{
CInterfaceManager::getInstance()->displaySystemInfo( CI18N::get("uiExtractionPhraseMissing"), "CHK" );
return;
}
}
// ***************************************************************************
bool CUserEntity::canCastShadowMap() const
{
if(!CCharacterCL::canCastShadowMap())
return false;
// don't cast shadow in first person, but in death mode (third person actually...)
return viewMode() != FirstPV || UserControls.mode() == CUserControls::DeathMode;
}
// ***************************************************************************
void CUserEntity::forceLookEntity(const NLMISC::CVectorD &dir2targIn, bool updateHeadPitch, bool /* start */)
{
CVectorD dir2targ= dir2targIn;
float frontYawBefore = 0.f;
float frontYawAfter;
// Third person: bkup current yaw
if(viewMode()==ThirdPV)
{
frontYawBefore = frontYaw();
}
// **** Look at the entity
dir2targ.normalize();
front(dir2targ, false, false);
// **** FirstPerson
if(viewMode() == FirstPV)
{
if(updateHeadPitch && _FollowForceHeadPitch)
{
// rotate the head to the target
CEntityCL *target = EntitiesMngr.entity(targetSlot());
if(target)
{
// Both Z must be correct
snapToGround();
target->snapToGround();
// don't update to the real head position each frame (else jitter too much cause of target anim)
CVector targetPos= target->pos() + CVector(0,0,_FollowHeadOffset);
// then look at this target
CVector dirToTarget = targetPos - (pos()+CVector(0,0, UserEntity->eyesHeight()));
if((dirToTarget.x != 0.0f) || (dirToTarget.y!=0.0f))
{
dirToTarget.normalize();
setHeadPitch(atan2(dirToTarget.z, sqrt(sqr(dirToTarget.x)+sqr(dirToTarget.y))));
}
// TestYoyo
/*if(ClientCfg.Fly!=0.f)
{
nlinfo("Uy: %.3f. Hp: %.3f. UPos:(%.3f,%.3f,%.3f). TPos:(%.3f,%.3f,%.3f)",
UserEntity->frontYaw(), UserEntity->getHeadPitch(), pos().x, pos().y, pos().z,
targetPos.x, targetPos.y, targetPos.z);
static float uy=0.f;
static float hp=0.f;
if( fabs(fmod(UserEntity->frontYaw()-uy, 2*Pi))>ClientCfg.Fly ||
fabs(fmod(UserEntity->getHeadPitch()-hp, 2*Pi))>ClientCfg.Fly )
{
nlinfo("YOYOBREAK: ^^^^^^^^^^");
}
uy=UserEntity->frontYaw();
hp=UserEntity->getHeadPitch();
}*/
}
}
}
// **** Third person
else if(viewMode()==ThirdPV)
{
// keep the current effective yaw. ONLY if no SmoothResetCameraYaw forced
if(!UserControls.isResetSmoothCDYForced())
{
frontYawAfter = frontYaw();
float deltaYaw= frontYawAfter - frontYawBefore;
// compensate rotation (NB: it stops also any SmoothReset)
UserControls.appendCameraDeltaYaw(-deltaYaw);
}
}
// when looking to an entity, if automatic camera, center the view on it.
if( ClientCfg.AutomaticCamera /*&& start*/ )
{
UserControls.resetSmoothCameraDeltaYaw();
}
}
// ***************************************************************************
void CUserEntity::startForceLookEntity(CLFECOMMON::TCLEntityId slot)
{
// Start a new follow: force head pitch to follow by default
_FollowForceHeadPitch= true;
// if a follow is started in first person, reset CameraYaw
if(viewMode()==FirstPV)
UserControls.resetCameraDeltaYaw();
// reorient now (important else may have a time shift because of resetCameraDeltaYaw above)
CEntityCL *target = EntitiesMngr.entity(slot);
if(target)
{
/* For complex reason, the target may not be still snapped on the ground. snap it now
- this is because in common case, entities are snap only if they are visible (for speed up)
=> depends on camera
- but in this case, the camera depends on real entity position (headPitch in first person)
*/
target->snapToGround();
// For FirstPerson targeting. Get the current target head offset
_FollowHeadOffset= 0.f;
CVector headPos;
if(target->getHeadPos(headPos))
{
_FollowHeadOffset= headPos.z - float(target->pos().z);
}
// Look at the entity
CVectorD dir2targ = target->pos() - pos();
dir2targ.z = 0.0;
if(dir2targ!=CVectorD::Null)
{
forceLookEntity(dir2targ, true, true);
}
}
}
// ***************************************************************************
void CUserEntity::stopForceHeadPitchInFollow()
{
_FollowForceHeadPitch= false;
}
// ***************************************************************************
void CUserEntity::switchVelocity(bool userRequest)
{
if (ClientCfg.R2EDEnabled && R2::getEditor().getMode() == R2::CEditor::EditionMode)
{
// when in the R2 editor, force to run all the time
_Run = true;
}
else
{
_Run = !_Run;
}
_CurrentVelocity = _Run ? runVelocity() : walkVelocity();
if (userRequest)
{
_RunWhenAble = _Run;
}
// display message : your are running, you are walking
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg;
if( _Run )
msg = CI18N::get("msgUserIsRunning");
else
msg = CI18N::get("msgUserIsWalking");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
// Write to the UI database, to update views
CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:PLAYER_RUNNING", false);
if(node)
node->setValue32(_Run);
}
//-----------------------------------------------
// autoEquipWithLastUsedWeapons
//
//-----------------------------------------------
void CUserEntity::autoEquipWithLastUsedWeapons()
{
CInventoryManager *inv = CInventoryManager::getInstance();
if ( !inv )
{
return;
}
// Clear hands
inv->unequip( "LOCAL:INVENTORY:HAND:1" );
inv->unequip( "LOCAL:INVENTORY:HAND:0" );
uint ir,il;
// Equip right hand
if( _PreviousRightHandItem.Sheet != 0 )
{
// find item in bag with same properties than last used one in right hand
for ( ir=0; ir<MAX_BAGINV_ENTRIES; ++ir )
{
if( _PreviousRightHandItem.Sheet == inv->getBagItem(ir).getSheetID() &&
_PreviousRightHandItem.Quality == inv->getBagItem(ir).getQuality() &&
_PreviousRightHandItem.Weight == inv->getBagItem(ir).getWeight() &&
_PreviousRightHandItem.NameId == inv->getBagItem(ir).getNameId() )
{
break;
}
}
if ( ir != MAX_BAGINV_ENTRIES )
{
// Equip right hand
string bagPath = toString( "LOCAL:INVENTORY:BAG:%u", ir );
inv->equip( bagPath, "LOCAL:INVENTORY:HAND:0" );
// Equip left hand if needed
if( _PreviousLeftHandItem.Sheet != 0 )
{
for ( il=0; il<MAX_BAGINV_ENTRIES; ++il )
{
if( il != ir &&
_PreviousLeftHandItem.Sheet == inv->getBagItem(il).getSheetID() &&
_PreviousLeftHandItem.Quality == inv->getBagItem(il).getQuality() &&
_PreviousLeftHandItem.Weight == inv->getBagItem(il).getWeight() &&
_PreviousLeftHandItem.NameId == inv->getBagItem(il).getNameId() )
{
break;
}
}
if ( il != MAX_BAGINV_ENTRIES )
{
bagPath = toString( "LOCAL:INVENTORY:BAG:%u", il );
inv->equip( bagPath, "LOCAL:INVENTORY:HAND:1" );
}
}
return;
}
}
// TODO : choose the best one
}
// ***************************************************************************
void CUserEntity::executeCombatWithPhrase(CEntityCL *target, uint32 memoryLine, uint32 memoryIndex, bool cyclic)
{
nlassert(target);
CSPhraseManager *pPM= CSPhraseManager::getInstance();
// is a melee combat?
bool meleeCombat = false;
// empty hand => yes!
meleeCombat= true;
uint32 rightHandSheet = getInventory().getRightHandItemSheet();
if(rightHandSheet)
meleeCombat = getInventory().isMeleeWeaponItem(rightHandSheet);
// If melee combat, and if the user entity is not well placed for fight, or if it has changed his target
if( meleeCombat &&
(
!target->isPlacedToFight(pos(), front(), attackRadius() + ClientCfg.AttackDist) ||
target->slot()!=_LastExecuteCombatSlot
)
)
{
_LastExecuteCombatSlot= target->slot();
// Cancel any follow
disableFollow();
// Launch the moveToCombatPhrase, canceling any old action client execution.
// NB: this will also force him to look at the entity
moveToCombatPhrase(target->slot(), 2.0, memoryLine, memoryIndex, cyclic);
// And after (order is important), start the phrase execution on client
pPM->clientExecute(memoryLine, memoryIndex, cyclic);
}
else
{
// Cancel any moveTo(), because don't want to continue reaching the prec entity
// VERY important if previous MoveTo was a SPhrase MoveTo (because cancelClientExecute() must be called)
resetAnyMoveTo();
// start client execution: NB: start client execution even if it
pPM->clientExecute(memoryLine, memoryIndex, cyclic);
// inform Server of phrase cast
pPM->sendExecuteToServer(memoryLine, memoryIndex, cyclic);
if( !meleeCombat && !cyclic )
{
pPM->executeDefaultAttack();
}
}
}
// ***************************************************************************
void CUserEntity::beginCast(const MBEHAV::CBehaviour &behaviour)
{
if(viewMode()==ThirdPV)
{
// backup front yaw
float frontYawBefore = frontYaw();
// begin cast
CCharacterCL::beginCast( behaviour );
// compensate the front change using a camera move
float frontYawAfter = frontYaw();
float deltaYaw= frontYawAfter - frontYawBefore;
UserControls.appendCameraDeltaYaw(-deltaYaw);
// if automatic camera, center the view behind the user
if( ClientCfg.AutomaticCamera )
{
UserControls.resetSmoothCameraDeltaYaw();
}
}
else
{
// in first person mode, reset the delta yaw
UserControls.resetCameraDeltaYaw();
CCharacterCL::beginCast( behaviour );
}
}
// ***************************************************************************
void CUserEntity::updatePreCollision(const NLMISC::TTime &time, CEntityCL *target)
{
CPlayerCL::updatePreCollision(time, target);
// test each frame if the mode has changed
if(SoundMngr)
{
string deadMusic= "death.ogg";
// Play/stop music if comes from or goes to dead
bool isDead= _Mode==MBEHAV::DEATH || _Mode==MBEHAV::SWIM_DEATH;
// must start music?
if( isDead && SoundMngr->getEventMusicPlayed()!=deadMusic )
{
SoundMngr->playEventMusic(deadMusic, 0, true);
}
// must end music?
if( !isDead && SoundMngr->getEventMusicPlayed()==deadMusic )
{
SoundMngr->stopEventMusic(deadMusic, CSoundManager::LoadingMusicXFade);
}
}
}
// ***************************************************************************
void CUserEntity::buildTotem()
{
const string msgName = "TOTEM:BUILD";
CBitMemStream out;
if( GenericMsgHeaderMngr.pushNameToStream( msgName, out ) )
{
NetMngr.push( out );
nlinfo( "sending TOTEM:build message to server" );
}
}
// ***************************************************************************
void CUserEntity::setR2CharMode(R2::TCharMode mode)
{
if (mode == R2::TCharMode::Editer || mode == R2::TCharMode::Dm)
{
_R2CharMode= mode;
walkVelocity(ClientCfg.DmWalk);
runVelocity(ClientCfg.DmRun);
View.setCameraDistanceMaxForDm();
CEntityCL *user = EntitiesMngr.entity(0);
NLPACS::UMovePrimitive* prim = user?user->getPrimitive():0;
if (prim)
{
prim->setObstacle(false);
}
}
else if (mode == R2::TCharMode::Player || mode == R2::TCharMode::Tester)
{
_R2CharMode= mode;
walkVelocity(ClientCfg.Walk);
runVelocity(ClientCfg.Run);
View.setCameraDistanceMaxForPlayer();
CEntityCL *user = EntitiesMngr.entity(0);
NLPACS::UMovePrimitive* prim = user?user->getPrimitive():0;
if (prim)
{
prim->setObstacle(true);
}
}
else
{
nlwarning("R2Ed: Error Char Mode not handled %u", (uint32)mode.getValue());
}
}
bool CUserEntity::isInNpcControl() const
{
CInterfaceManager* pIM = CInterfaceManager::getInstance();
CCDBNodeLeaf *sheet = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:SHEET", false);
return sheet && NLMISC::CSheetId(sheet->getValue32())!=NLMISC::CSheetId::Unknown;
}
void CUserEntity::updateNpcContolSpeed()
{
CInterfaceManager* pIM = CInterfaceManager::getInstance();
CCDBNodeLeaf *sheet = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:SHEET", false);
CCDBNodeLeaf *walk = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:WALK", false);
CCDBNodeLeaf *run = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:RUN", false);
if (!sheet || !walk || !run)
{
return;
}
static NLMISC::CSheetId oldSheet = NLMISC::CSheetId::Unknown;
static float oldRun=0.f;
static float oldWalk=0.f;
NLMISC::CSheetId sheetId(sheet->getValue32());
float newRun = float(run->getValue32()) / 1000.0f;
float newWalk = float(walk->getValue32()) / 1000.0f;
if (sheetId == oldSheet && oldRun == newRun && oldWalk == newWalk )
{
return;
}
oldSheet = sheetId;
oldRun = newRun;
oldWalk = newWalk;
if (sheetId != NLMISC::CSheetId::Unknown)
{
walkVelocity(newWalk);
runVelocity(newRun);
}
else
{
setR2CharMode(_R2CharMode);
}
}
//-----------------------------------------------
// cancelAllPhrases
//-----------------------------------------------
void CUserEntity::cancelAllPhrases()
{
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("PHRASE:CANCEL_ALL", out))
{
NetMngr.push(out);
}
else
{
nlwarning("<CUserEntity::cancelAllPhrases> unknown message name '%s'", "PHRASE:CANCEL_ALL");
}
}
//-----------------------------------------------
// canChangeFront
//-----------------------------------------------
bool CUserEntity::canChangeFront()
{
return !(_CurrentBehaviour.Behaviour == MBEHAV::EXTRACTING
|| (_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK && _Mode==MBEHAV::COMBAT && !UserControls.isMoving())
|| (_CurrentBehaviour.Behaviour >= MBEHAV::MAGIC_CASTING_BEHAVIOUR_BEGIN && _CurrentBehaviour.Behaviour <= MBEHAV::MAGIC_CASTING_BEHAVIOUR_END));
}
//-----------------------------------------------
// rememberWeaponsInHand
//
//-----------------------------------------------
void CUserEntity::rememberWeaponsInHand()
{
CInventoryManager * inv = CInventoryManager::getInstance();
if( !inv )
{
return;
}
// keep right hand item
CItemImage * rightItemImg = inv->getHandItem(0);
if( rightItemImg )
{
if( inv->isMeleeWeaponItem(rightItemImg->getSheetID()) || inv->isRangeWeaponItem(rightItemImg->getSheetID()) )
{
_PreviousRightHandItem = CItemSnapshot(*rightItemImg);
// keep left hand item too (could be ammo, second weapon, etc ..)
CItemImage * leftItemImg = inv->getHandItem(1);
if( leftItemImg )
{
_PreviousLeftHandItem = CItemSnapshot(*leftItemImg);
}
else
{
_PreviousLeftHandItem = CItemSnapshot();
}
}
}
}
//-----------------------------------------------
// snapshot of a CItemImage
//
//-----------------------------------------------
CUserEntity::CItemSnapshot::CItemSnapshot( const CItemImage& i )
{
Sheet = i.getSheetID();
Quality = i.getQuality();
Quantity = i.getQuantity();
UserColor = i.getUserColor();
Price = i.getPrice();
Weight = i.getWeight();
NameId = i.getNameId();
InfoVersion = i.getInfoVersion();
}
sint CUserEntity::getLevel() const
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
sint level = -1;
for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
{
CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
if(node)
{
level = std::max(level, (sint) node->getValue32());
}
}
return level;
}
//-----------------------------------------------
// interlocutor
//-----------------------------------------------
void CUserEntity::interlocutor( const CLFECOMMON::TCLEntityId &slot)
{
CLFECOMMON::TCLEntityId prevInterlocutor = _Interlocutor;
_Interlocutor = slot;
// Refresh (hide or unhide) the icon for the interlocutor NPC
if (prevInterlocutor != CLFECOMMON::INVALID_SLOT)
EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(prevInterlocutor);
if (_Interlocutor != CLFECOMMON::INVALID_SLOT)
EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(_Interlocutor);
}
//-----------------------------------------------
// trader
//-----------------------------------------------
void CUserEntity::trader(const CLFECOMMON::TCLEntityId &slot)
{
CLFECOMMON::TCLEntityId prevTrader = _Trader;
_Trader = slot;
// Refresh (hide or unhide) the icon for the trader NPC
if (prevTrader != CLFECOMMON::INVALID_SLOT)
EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(prevTrader);
if (_Trader != CLFECOMMON::INVALID_SLOT)
EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(_Trader);
}
Reference in a new issue View git blame Copy permalink