?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch '164-crash-on-patching-and-possibly-right-after-login' into main/gingo...
[ryzomcore.git] / ryzom / client / src / user_entity.cpp
blob9ec59f6fb117b3abdec50afa64e04e36defb3d03
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010-2020 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2013 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
6 // Copyright (C) 2013-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
7 //
8 // This program is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Affero General Public License as
10 // published by the Free Software Foundation, either version 3 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Affero General Public License for more details.
17 //
18 // You should have received a copy of the GNU Affero General Public License
19 // along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
22
23
24 /////////////
25 // INCLUDE //
26 /////////////
27 #include "stdpch.h"
28 // Misc.
29 #include "nel/misc/vectord.h"
30 #include "nel/misc/matrix.h"
31 #include "nel/misc/quat.h"
32 // 3D Interface.
33 #include "nel/3d/u_scene.h"
34 #include "nel/3d/u_visual_collision_manager.h"
35 #include "nel/3d/viewport.h"
36 #include "nel/3d/u_bone.h"
37 #include "nel/3d/u_instance_material.h"
38 #include "nel/3d/u_play_list.h"
39 #include "nel/3d/u_point_light.h"
40 #include "nel/3d/u_particle_system_instance.h"
41 #include "nel/3d/u_camera.h"
42 // Pacs Interface
43 #include "nel/pacs/u_global_position.h"
44 // Client.
45 #include "user_entity.h"
46 #include "motion/user_controls.h"
47 #include "pacs_client.h"
48 #include "net_manager.h"
49 #include "time_client.h"
50 #include "entity_animation_manager.h"
51 #include "sheet_manager.h"
52 #include "sound_manager.h"
53 #include "interface_v3/interface_manager.h"
54 #include "entities.h"
55 #include "debug_client.h"
56 #include "misc.h"
57 #include "interface_v3/bot_chat_manager.h"
58 #include "fx_manager.h"
59 #include "main_loop.h"
60 #include "interface_v3/group_in_scene_bubble.h"
61 #include "interface_v3/inventory_manager.h"
62 #include "nel/gui/group_html.h"
63 #include "interface_v3/people_interraction.h"
64 #include "init_main_loop.h"
65 #include "view.h"
66 #include "interface_v3/sphrase_manager.h"
67 #include "interface_v3/sbrick_manager.h"
68 #include "interface_v3/action_phrase_faber.h"
69 #include "interface_v3/bar_manager.h"
70 #include "interface_v3/skill_manager.h"
71 #include "far_tp.h"
72 #include "npc_icon.h"
73 // game share
74 #include "game_share/slot_types.h"
75 #include "game_share/player_visual_properties.h"
76 #include "game_share/mode_and_behaviour.h"
77 #include "game_share/inventories.h"
78 #include "game_share/animal_type.h"
79 #include "game_share/bot_chat_types.h"
80 // Sound animation
81 #include "nel/sound/sound_anim_manager.h"
82 #include "nel/sound/sound_animation.h"
83 #include "nel/sound/sound_anim_marker.h"
84 // r2
85 #include "r2/editor.h"
86
87 #ifdef DEBUG_NEW
88 #define new DEBUG_NEW
89 #endif
90
91 ///////////
92 // USING //
93 ///////////
94 using namespace NLMISC;
95 using namespace NLPACS;
96 using namespace std;
97 using NL3D::UScene;
98 using NL3D::UVisualCollisionManager;
99 using NL3D::UTextContext;
100
101
102 ////////////
103 // EXTERN //
104 ////////////
105 extern UScene *Scene;
106 extern UVisualCollisionManager *CollisionManager;
107 extern CEntityAnimationManager *EAM;
108 extern UTextContext *TextContext;
109 extern NL3D::UCamera MainCam;
110
111 // Context help
112 extern void contextHelp (const std::string &help);
113
114 extern void beastOrder (const std::string &orderStr, const std::string &beastIndexStr, bool confirmFree = true);
115
116 // Out game received position
117 NLMISC::CVectorD UserEntityInitPos;
118 NLMISC::CVector UserEntityInitFront;
119 CUserEntity *UserEntity = NULL;
120
121 uint32 CharFirstConnectedTime = 0;
122 uint32 CharPlayedTime = 0;
123
124 const double MaxExtractionDistance = 1.0f;
125
126 ////////////
127 // GLOBAL //
128 ////////////
129
130 // Hierarchical timer
131 H_AUTO_DECL ( RZ_Client_Update_Sound )
132
133 //////////////
134 // FUNCTION //
135 //////////////
136 //string chooseRandom( const vector<string>& sounds, uint32& previousIndex );
137
138 //-----------------------------------------------
139 // CUserEntity :
140 // Constructor.
141 //-----------------------------------------------
142 CUserEntity::CUserEntity()
143 : CPlayerCL()
144 {
145 Type = User;
146 _Run = false;
147 _RunWhenAble = false;
148 _WalkVelocity = 1.0f;
149 _RunVelocity = 2.0f;
150 _CurrentVelocity = _WalkVelocity;
151
152 _FrontVelocity = 0.0f;
153 _LateralVelocity = 0.0f;
154
155 _SpeedServerAdjust = 1.0f;
156
157 // \todo GUIGUI : do it more generic.
158 _First_Pos = false;
159
160 // No selection, trader, interlocutor at the beginning.
161 _Selection = CLFECOMMON::INVALID_SLOT;
162 _Trader = CLFECOMMON::INVALID_SLOT;
163 _Interlocutor = CLFECOMMON::INVALID_SLOT;
164
165 // Not selectable at the beginning.
166 _Selectable = false;
167
168 // Your are not on a mount at the beginning.
169 _OnMount = false;
170 _HiddenMount = CLFECOMMON::INVALID_SLOT;
171
172 _AnimAttackOn = false;
173
174 _ViewMode = FirstPV;
175 _PermanentDeath = false;
176 _FollowMode = false;
177
178 _CheckPrimitive = 0;
179 // The user is not in collision with someone else.
180 _ColOn = false;
181 // Collisions are not removed.
182 _ColRemoved = false;
183
184 // No Move To at the beginning.
185 _MoveToSlot = CLFECOMMON::INVALID_SLOT;
186 _MoveToAction= CUserEntity::None;
187 _MoveToDist= 0.0;
188 _MoveToColStartTime= 0;
189 _HeadPitch = Pi/2;
190 _FollowForceHeadPitch= false;
191
192 _ForceLookSlot= CLFECOMMON::INVALID_SLOT;
193 _LastExecuteCombatSlot= CLFECOMMON::INVALID_SLOT;
194
195 _R2CharMode= R2::TCharMode::Player;
196
197 _CameraMoves = NLMISC::CVector(0, 0, 0);
198 }// CUserEntity //
199
200
201 //-----------------------------------------------
202 // ~CUserEntity :
203 // Destructor.
204 //-----------------------------------------------
205 CUserEntity::~CUserEntity()
206 {
207 // Remove observers
208 _SpeedFactor.release();
209 _MountHunger.release();
210 _MountSpeeds.release();
211
212 CInterfaceManager *pIM = CInterfaceManager::getInstance();
213
214 {
215 CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:IS_INVISIBLE", false);
216 if (node)
217 {
218 ICDBNode::CTextId textId;
219 node->removeObserver(&_InvisibleObs, textId);
220 }
221 }
222
223 for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
224 {
225 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
226 if(node)
227 {
228 ICDBNode::CTextId textId;
229 node->removeObserver(_SkillPointObs+i, textId);
230 }
231 }
232
233 for( uint i=0; i<_FamesObs.size(); ++i )
234 {
235 uint32 factionIndex = _FamesObs[i]->FactionIndex;
236 uint32 fameIndexInDatabase = CStaticFames::getInstance().getDatabaseIndex(factionIndex);
237 string sDBPath = toString("SERVER:FAME:PLAYER%d:VALUE",fameIndexInDatabase);
238
239 CCDBNodeLeaf * node = NLGUI::CDBManager::getInstance()->getDbProp(sDBPath, false);
240 if(node)
241 {
242 ICDBNode::CTextId textId;
243 node->removeObserver(_FamesObs[i], textId);
244 }
245 }
246 contReset(_FamesObs);
247
248 CNPCIconCache::getInstance().removeObservers();
249
250 // Remove the Primitive used for check (because ~CEntityCL() will call CEntityCL::removePrimitive(), not CUserEntity::removePrimitive())
251 removeCheckPrimitive();
252
253 CNPCIconCache::release();
254
255 }// ~CUserEntity //
256
257 //-----------------------------------------------
258 // initProperties :
259 // Initialize properties of the entity (according to the class).
260 //-----------------------------------------------
261 void CUserEntity::initProperties()
262 {
263 properties().selectable(true);
264 }// initProperties //
265
266
267 //-----------------------------------------------
268 // build :
269 // Build the entity from a sheet.
270 //-----------------------------------------------
271 bool CUserEntity::build(const CEntitySheet *sheet) // virtual
272 {
273 // Init received position
274 pos(UserEntityInitPos);
275 front(UserEntityInitFront);
276 dir(front());
277 setHeadPitch(0);
278
279 // Cast the sheet in the right type.
280 _PlayerSheet = dynamic_cast<const CRaceStatsSheet *>(sheet);
281 if(_PlayerSheet == 0)
282 {
283 pushDebugStr("User Sheet is not a valid '.race_stats'.");
284 return false;
285 }
286 else
287 pushInfoStr("User Sheet is a valid '.race_stats'.");
288 // Get the DB Entry
289 if(IngameDbMngr.getNodePtr())
290 {
291 CCDBNodeBranch *nodeRoot = dynamic_cast<CCDBNodeBranch *>(IngameDbMngr.getNodePtr()->getNode(0));
292 if(nodeRoot)
293 {
294 _DBEntry = dynamic_cast<CCDBNodeBranch *>(nodeRoot->getNode(_Slot));
295 if(_DBEntry == 0)
296 pushDebugStr("Cannot get a pointer on the DB entry.");
297 }
298 }
299
300 disableFollow();
301 // Walk/Run ?
302 if(ClientCfg.RunAtTheBeginning != _Run)
303 switchVelocity();
304
305 // Set the up of the user.
306 up(CVector(0,0,1));
307
308 // Init User infos.
309 eyesHeight(ClientCfg.EyesHeight);
310 walkVelocity(ClientCfg.Walk);
311 runVelocity(ClientCfg.Run);
312
313 // Compute the first automaton.
314 _CurrentAutomaton = automatonType() + "_normal.automaton";
315
316 // Build the PACS Primitive.
317 if(initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::Slide, (UMovePrimitive::TTrigger)(UMovePrimitive::OverlapTrigger | UMovePrimitive::EnterTrigger), MaskColPlayer, MaskColPlayer | MaskColNpc | MaskColDoor))
318 _Primitive->insertInWorldImage(dynamicWI);
319
320 // Compute the element to be able to snap the entity to the ground.
321 computeCollisionEntity();
322
323 // Initialize properties of the client.
324 initProperties();
325
326 // Initialize the observer for the speed factor and mount stuff
327 _SpeedFactor.init();
328 _MountHunger.init();
329 _MountSpeeds.init();
330
331 // Create the user playlist
332 createPlayList();
333
334 // Initialize the internal time.
335 _LastFrameTime = ((double)T1) * 0.001;
336
337 // Set the gender in local mode.
338 if(ClientCfg.Local)
339 {
340 _Mode = MBEHAV::NORMAL;
341 _ModeWanted = MBEHAV::NORMAL;
342 _Gender = ClientCfg.Sex;
343 SPropVisualA visualA = buildPropVisualA(_PlayerSheet->GenderInfos[_Gender]);
344 SPropVisualB visualB = buildPropVisualB(_PlayerSheet->GenderInfos[_Gender]);
345 SPropVisualC visualC;
346 visualA.PropertySubData.Sex = _Gender;
347 visualC.PropertyC = 0;
348 visualC.PropertySubData.CharacterHeight = 0;
349 visualC.PropertySubData.ArmsWidth = 7;
350 visualC.PropertySubData.LegsWidth = 7;
351 visualC.PropertySubData.TorsoWidth = 7;
352 visualC.PropertySubData.BreastSize = 7;
353 // Set the Database
354 sint64 *prop = (sint64 *)&visualA;
355 NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->setValue64(*prop); // Set the database
356 prop = (sint64 *)&visualB;
357 NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPB))->setValue64(*prop); // Set the database
358 prop = (sint64 *)&visualC;
359 NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E0:P"+toString("%d", CLFECOMMON::PROPERTY_VPC))->setValue64(*prop); // Set the database
360 // Apply Changes.
361 updateVisualProperty(0, CLFECOMMON::PROPERTY_VPA);
362 }
363 // \todo GUIGUI Retrieve the player's appearence during the avatar selection.
364 // Get Visual Properties From the character selection window.
365 else
366 {
367 }
368
369 // Rebuild interface
370 buildInSceneInterface ();
371
372 // Add observer on invisible property
373 CInterfaceManager *pIM = CInterfaceManager::getInstance();
374 {
375 CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:IS_INVISIBLE", false);
376 if (node)
377 {
378 ICDBNode::CTextId textId;
379 node->addObserver(&_InvisibleObs, textId);
380 }
381 }
382
383 // Add an observer on skill points
384 for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
385 {
386 _SkillPointObs[i].SpType= i;
387 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
388 if(node)
389 {
390 ICDBNode::CTextId textId;
391 node->addObserver(_SkillPointObs+i, textId);
392 }
393 }
394
395 // Add an observer on Fames
396 for( uint i=(uint)PVP_CLAN::BeginClans; i<=(uint)PVP_CLAN::EndClans; ++i )
397 {
398 uint32 factionIndex = PVP_CLAN::getFactionIndex((PVP_CLAN::TPVPClan)i);
399 uint32 fameIndexInDatabase = CStaticFames::getInstance().getDatabaseIndex(factionIndex);
400 string sDBPath = toString("SERVER:FAME:PLAYER%d:VALUE",fameIndexInDatabase);
401
402 CFameObserver * fameObs = new CFameObserver();
403 if( fameObs )
404 {
405 fameObs->FactionIndex = factionIndex;
406 CCDBNodeLeaf * node = NLGUI::CDBManager::getInstance()->getDbProp(sDBPath, false);
407 if(node)
408 {
409 ICDBNode::CTextId textId;
410 node->addObserver(fameObs, textId);
411 }
412 _FamesObs.push_back(fameObs);
413 }
414 }
415
416 // Add an observer on Mission Journal
417 CNPCIconCache::getInstance().addObservers();
418
419 // Initialize the camera distance.
420 View.cameraDistance(ClientCfg.CameraDistance);
421
422 // char and account time properties
423 CSkillManager *pSM = CSkillManager::getInstance();
424 if( pSM )
425 {
426 pSM->tryToUnblockTitleFromCharOldness( CharFirstConnectedTime );
427 pSM->tryToUnblockTitleFromCharPlayedTime( CharPlayedTime );
428 }
429
430 // Entity created.
431 return true;
432 }// build //
433
434
435 //-----------------------------------------------
436 // eyesHeight :
437 // \todo GUIGUI : do it better in mount mode
438 //-----------------------------------------------
439 float CUserEntity::eyesHeight()
440 {
441 if(!_OnMount)
442 return _EyesHeight * _CharacterScalePos;
443 else
444 return _EyesHeight * _CharacterScalePos;
445 }// eyesHeight //
446
447
448 /////////////////////////////////////////////////
449 /////////////////////////////////////////////////
450 /////////////// VISUAL PROPERTIES ///////////////
451 /////////////////////////////////////////////////
452 /////////////////////////////////////////////////
453 //-----------------------------------------------
454 // updateVisualPropertyPos :
455 // Update Entity Position.
456 //-----------------------------------------------
457 void CUserEntity::updateVisualPropertyPos(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, const NLMISC::TGameCycle &/* pI */)
458 {
459 }// updateVisualPropertyPos //
460
461 //-----------------------------------------------
462 // updateVisualPropertyOrient :
463 // Update Entity Orientation.
464 //-----------------------------------------------
465 void CUserEntity::updateVisualPropertyOrient(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */)
466 {
467 }// updateVisualPropertyOrient //
468
469
470 void CUserEntity::updateVisualPropertyTargetList(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */, uint /* listIndex */)
471 {
472 }
473
474 void CUserEntity::updateVisualPropertyVisualFX(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
475 {
476 applyVisualFX(prop);
477 }
478
479 //-----------------------------------------------
480 // updateVisualPropertyBehaviour :
481 // Update Entity Behaviour.
482 //-----------------------------------------------
483 void CUserEntity::updateVisualPropertyBehaviour(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
484 {
485 // Compute the behaviour.
486 CBehaviourContext bc;
487 bc.Behav = MBEHAV::CBehaviour(prop);
488 bc.BehavTime = TimeInSec;
489 if(VerboseAnimUser)
490 {
491 nlinfo("UE::updateVPBeha: '%d(%s)'.", (sint)bc.Behav.Behaviour, MBEHAV::behaviourToString(bc.Behav.Behaviour).c_str());
492 }
493 CCDBNodeLeaf *targetList0 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_0));
494 CCDBNodeLeaf *targetList1 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_1));
495 CCDBNodeLeaf *targetList2 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_2));
496 CCDBNodeLeaf *targetList3 = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_TARGET_LIST_3));
497 if (targetList0 && targetList1 && targetList2 && targetList3)
498 {
499 uint64 vp[4] =
500 {
501 (uint64) targetList0->getValue64(),
502 (uint64) targetList1->getValue64(),
503 (uint64) targetList2->getValue64(),
504 (uint64) targetList3->getValue64()
505 };
506 bc.Targets.unpack(vp, 4);
507 }
508 applyBehaviour(bc);
509 }// updateVisualPropertyBehaviour //
510
511 //-----------------------------------------------
512 // updateVisualPropertyName :
513 // Update Entity Name.
514 //-----------------------------------------------
515 void CUserEntity::updateVisualPropertyName(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
516 {
517 uint32 oldNameId = _NameId;
518
519 CPlayerCL::updateVisualPropertyName(gameCycle, prop);
520
521 // Name changed ?
522 /* if (oldNameId != _NameId)
523 {
524 CInterfaceManager *pIM = CInterfaceManager::getInstance();
525 CInterfaceElement *element = CWidgetManager::getInstance()->getElementFromId("ui:interface:mailbox:content:html");
526 if (element)
527 {
528 CGroupHTML *html = dynamic_cast<CGroupHTML*>(element);
529 if (html)
530 html->browse("home");
531 }
532 }
533 */
534 }// updateVisualPropertyName //
535
536 //-----------------------------------------------
537 // updateVisualPropertyTarget :
538 // Update Entity Target.
539 //-----------------------------------------------
540 void CUserEntity::updateVisualPropertyTarget(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &/* prop */)
541 {
542 // Don't override the Player Target, cause client side entirely => no lag.
543 //targetSlot((CLFECOMMON::TCLEntityId)prop);
544 }// updateVisualPropertyTarget //
545
546 //-----------------------------------------------
547 // updateVisualPropertyMode :
548 // New mode received -> immediately change the mode for the user.
549 // \warning Read the position or orientation from the database when reading the mode (no more updated in updateVisualPropertyPos and updateVisualPropertyOrient).
550 //-----------------------------------------------
551 void CUserEntity::updateVisualPropertyMode(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop)
552 {
553 // Combat Float Check
554 if((MBEHAV::EMode)prop == MBEHAV::COMBAT_FLOAT)
555 {
556 nlwarning("UE:updateVPMode: the user should never have the COMBAT_FLOAT mode.");
557 return;
558 }
559 // New Mode Received.
560 _TheoreticalMode = (MBEHAV::EMode)prop;
561 // Change the user mode.
562 mode(_TheoreticalMode);
563 }// updateVisualPropertyMode //
564
565 //-----------------------------------------------
566 // updateVisualPropertyVpa :
567 // Update Entity Visual Property A
568 //-----------------------------------------------
569 void CUserEntity::updateVisualPropertyVpa(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
570 {
571 CPlayerCL::updateVisualPropertyVpa(gameCycle, prop);
572
573 // Special for user: Disable Character Lod, because always want it at full rez.
574 if(!_Skeleton.empty())
575 {
576 _Skeleton.setLodCharacterShape(-1);
577 }
578
579 updateVisualDisplay();
580 }// updateVisualPropertyVpa //
581
582 //-----------------------------------------------
583 // updateVisualPropertyVpb :
584 // Update Entity Visual Property B
585 //-----------------------------------------------
586 void CUserEntity::updateVisualPropertyVpb(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
587 {
588 CPlayerCL::updateVisualPropertyVpb(gameCycle, prop);
589 updateVisualDisplay();
590 }// updateVisualPropertyVpb //
591
592 //-----------------------------------------------
593 // updateVisualPropertyVpc :
594 // Update Entity Visual Property C
595 //-----------------------------------------------
596 void CUserEntity::updateVisualPropertyVpc(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
597 {
598 CPlayerCL::updateVisualPropertyVpc(gameCycle, prop);
599 updateVisualDisplay();
600 }// updateVisualPropertyVpc //
601
602 //-----------------------------------------------
603 // updateVisualPropertyEntityMounted :
604 // Update Entity Mount
605 //-----------------------------------------------
606 void CUserEntity::updateVisualPropertyEntityMounted(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
607 {
608 if(isFighting())
609 CPlayerCL::updateVisualPropertyEntityMounted(gameCycle, prop);
610 else
611 _Mount = (CLFECOMMON::TCLEntityId)prop;
612 }// updateVisualPropertyEntityMounted //
613
614 //-----------------------------------------------
615 // updateVisualPropertyRiderEntity :
616 // Update Entity Rider
617 //-----------------------------------------------
618 void CUserEntity::updateVisualPropertyRiderEntity(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
619 {
620 if(isFighting())
621 CPlayerCL::updateVisualPropertyRiderEntity(gameCycle, prop);
622 else
623 _Rider = (CLFECOMMON::TCLEntityId)prop;
624 }// updateVisualPropertyRiderEntity //
625
626 //-----------------------------------------------
627 //-----------------------------------------------
628 void CUserEntity::updateVisualPropertyPvpMode(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
629 {
630 CPlayerCL::updateVisualPropertyPvpMode(gameCycle, prop);
631 // Additionaly, inform interface of the change
632 CInterfaceManager *pIM= CInterfaceManager::getInstance();
633 // For PVP ZoneFaction
634 CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_MODE");
635 if(pDB)
636 {
637 sint32 val= pDB->getValue32();
638 pDB->setValue32(val+1);
639 }
640 // For Any PVP change
641 pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
642 if(pDB)
643 {
644 sint32 val= pDB->getValue32();
645 pDB->setValue32(val+1);
646 }
647 }
648
649 //-----------------------------------------------
650 //-----------------------------------------------
651 void CUserEntity::updateVisualPropertyOutpostInfos(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
652 {
653 CPlayerCL::updateVisualPropertyOutpostInfos(gameCycle, prop);
654 // For Any PVP change
655 CInterfaceManager *pIM= CInterfaceManager::getInstance();
656 CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
657 if(pDB)
658 {
659 sint32 val= pDB->getValue32();
660 pDB->setValue32(val+1);
661 }
662 }
663
664 //-----------------------------------------------
665 //-----------------------------------------------
666 void CUserEntity::updateVisualPropertyPvpClan(const NLMISC::TGameCycle &gameCycle, const sint64 &prop)
667 {
668 CPlayerCL::updateVisualPropertyPvpClan(gameCycle, prop);
669 // For Any PVP change
670 CInterfaceManager *pIM= CInterfaceManager::getInstance();
671 CCDBNodeLeaf *pDB= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:TRACK_PVP_CHANGE_ANY");
672 if(pDB)
673 {
674 sint32 val= pDB->getValue32();
675 pDB->setValue32(val+1);
676 }
677 }
678
679
680 /////////////////////////////////////////////////
681 /////////////////////////////////////////////////
682 /////////////////////////////////////////////////
683 /////////////////////////////////////////////////
684
685
686 //-----------------------------------------------
687 // mode :
688 // Method called to change the mode (Combat/Mount/etc.).
689 // \todo GUIGUI : apply stage in combat modes instead of just removing them.
690 // \todo GUIGUI : go or teleport the player to the mode position (see how to manage it).
691 //-----------------------------------------------
692 bool CUserEntity::mode(MBEHAV::EMode m)
693 {
694 if(Verbose & VerboseAnim)
695 nlinfo("UE::mode: old mode '%s(%d)' new mode '%s(%d)'.", MBEHAV::modeToString(_Mode).c_str(), _Mode, MBEHAV::modeToString(m).c_str(), m);
696 // Nothing to do if the mode is the same as the previous one.
697 if(m == _Mode)
698 return true;
699 // Release the old Mode.
700 switch(_Mode)
701 {
702 // Leave COMBAT Mode
703 case MBEHAV::COMBAT:
704 case MBEHAV::COMBAT_FLOAT:
705 {
706 // If there are some stage not complete -> remove them
707 if(_Stages._StageSet.size() != 0)
708 _Stages._StageSet.clear();
709 }
710 break;
711 // Leave MOUNTED Mode
712 case MBEHAV::MOUNT_NORMAL:
713 case MBEHAV::MOUNT_SWIM:
714 {
715 if ( m == MBEHAV::REST )
716 {
717 // can't go afk while mounting
718 return false;
719 }
720
721 // if changing mode for another mount mode, do nothing
722 if (m != MBEHAV::MOUNT_NORMAL && m != MBEHAV::MOUNT_SWIM)
723 {
724 // Display the mount again.
725 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
726 if(mount)
727 {
728 // Set the mount.
729 mount->rider(CLFECOMMON::INVALID_SLOT);
730 mount->_Stages._StageSet.clear();
731 mount->setMode(MBEHAV::NORMAL);
732 mount->computeAutomaton();
733 mount->computeAnimSet();
734 mount->setAnim(CAnimationStateSheet::Idle);
735 if(mount->getPrimitive())
736 mount->getPrimitive()->setOcclusionMask(MaskColNpc); // the mount is an npc
737 mount->_ForbidClipping = false;
738 }
739 //
740 _Mount = CLFECOMMON::INVALID_SLOT;
741 // Restore the user Primitive
742 if(_Primitive)
743 {
744 _Primitive->setRadius( std::min(0.5f, (float)(RYZOM_ENTITY_SIZE_MAX/2)) );
745 _Primitive->setHeight(2);
746 }
747 _OnMount = false;
748
749 // Shift the player position (not to stand inside the mount)
750 CVectorD unmountShift;
751 unmountShift.sphericToCartesian(1.0, frontYaw() + NLMISC::Pi/2, 0);
752 pacsPos(pos() + unmountShift);
753
754 // Restore running if necessary
755 if (!_Run && _RunWhenAble)
756 {
757 switchVelocity();
758 }
759 }
760
761 if (_Mode == MBEHAV::MOUNT_SWIM && ( m == MBEHAV::COMBAT || m == MBEHAV::COMBAT_FLOAT))
762 {
763 //TODO : display "you can't fight while swimming"
764 return true;
765 }
766 }
767 break;
768 // Leave DEATH Mode
769 case MBEHAV::DEATH:
770 // Restore the last view.
771 viewMode(viewMode());
772 break;
773 case MBEHAV::SWIM:
774 if( m == MBEHAV::COMBAT || m == MBEHAV::COMBAT_FLOAT)
775 {
776 //TODO : display "you can't fight while swimming"
777 return true;
778 }
779 break;
780 default:
781 nlwarning("Invalid behaviour change.");
782 }
783
784 // Reset Parent, unless we stay in mount mode
785 if ((_Mode != MBEHAV::MOUNT_SWIM && _Mode != MBEHAV::MOUNT_NORMAL)
786 || (m != MBEHAV::MOUNT_SWIM && m != MBEHAV::MOUNT_NORMAL)
787 )
788 {
789 parent(CLFECOMMON::INVALID_SLOT);
790 }
791
792 // Change the Mode for the user ( if user sits down or stands up we wait in order to play the sit/stand transition anim)
793 if( m != MBEHAV::SIT && _Mode != MBEHAV::SIT )
794 _Mode = m;
795 _ModeWanted = m;
796
797 // Initialize the new Mode.
798 switch(m)
799 {
800 // Combat mode
801 case MBEHAV::COMBAT:
802 case MBEHAV::COMBAT_FLOAT:
803 {
804 C64BitsParts rot;
805
806 // Compute the angle
807 const string propName = toString("SERVER:Entities:E%d:P%d", _Slot, CLFECOMMON::PROPERTY_ORIENTATION);
808 rot.i64[0] = NLGUI::CDBManager::getInstance()->getDbProp(propName)->getValue64();
809 _TargetAngle = rot.f[0];
810
811 // Initialize controls for the combat.
812 UserControls.startCombat();
813
814 // Context help
815 contextHelp ("action_bar");
816 }
817 break;
818
819 // Mount Normal or mount swim
820 case MBEHAV::MOUNT_NORMAL:
821 {
822 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(parent()));
823 if(mount)
824 {
825 mount->_Stages.removePosWithNoMode();
826 dir(mount->dir());
827 }
828 }
829 case MBEHAV::MOUNT_SWIM:
830 {
831 // Hide the mount unless we come from another mounted mode
832 if (_Mode != MBEHAV::MOUNT_SWIM && _Mode != MBEHAV::MOUNT_NORMAL)
833 {
834 if(_Mount != CLFECOMMON::INVALID_SLOT) // if _Mount is still invalid, the following code will be done in updatePos()
835 {
836 setOnMount();
837 }
838 }
839 // refresh target
840 UserEntity->selection(_Selection);
841 }
842 break;
843
844 // Dead mode.
845 case MBEHAV::DEATH:
846 setDead();
847 if(isSwimming())
848 _Mode = MBEHAV::SWIM_DEATH;
849 break;
850
851 // Normal or Default mode.
852 case MBEHAV::NORMAL:
853 _CurrentBehaviour.Behaviour = MBEHAV::IDLE;
854 default:
855 //
856 setAlive();
857 viewMode(viewMode());
858 break;
859 }
860
861 bool doSetAnim = true;
862 // if user sits down or stands up we set transition anim before changing animset
863 if( m == MBEHAV::SIT )
864 {
865 setAnim(CAnimationStateSheet::SitMode);
866 _Mode = m;
867 doSetAnim = false;
868 }
869 else
870 if( _Mode == MBEHAV::SIT && m!=MBEHAV::DEATH )
871 {
872 setAnim(CAnimationStateSheet::SitEnd);
873 _Mode = m;
874 doSetAnim = false;
875 }
876
877 // Show/Hide all or parts of the body.
878 updateVisualDisplay();
879 if( ClientCfg.AutomaticCamera )
880 {
881 // Set the direction as the front.
882 dir(front());
883 }
884 // Compute the current automaton
885 computeAutomaton();
886 // Update the animation set according to the mode.
887 computeAnimSet();
888
889 if( doSetAnim )
890 {
891 // Animset changed -> update current animation
892 setAnim(CAnimationStateSheet::Idle);
893 }
894
895 // Changing the mode well done.
896 return true;
897 }// mode //
898
899
900 /*
901 * Mount the mount in _Mount
902 */
903 void CUserEntity::setOnMount()
904 {
905 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
906 if(mount)
907 {
908 // Update primitives for the mount and the rider.
909 if(_Primitive && mount->getPrimitive())
910 {
911 _Primitive->setRadius( std::min(mount->getPrimitive()->getRadius(), (float)(RYZOM_ENTITY_SIZE_MAX/2)) );
912 _Primitive->setHeight(mount->getPrimitive()->getHeight());
913 mount->getPrimitive()->setOcclusionMask(MaskColNone); // Remove collisions.
914 }
915 // Now on a mount
916 _OnMount = true;
917 // Link the mount and the user.
918 parent(_Mount);
919 // Refresh the View Mode
920 viewMode(viewMode());
921 // Close the crafting window if open
922 closeFaberCastWindow();
923
924 // Keep run in mind
925 _RunWhenAble = _Run;
926
927 mount->_ForbidClipping = true;
928 }
929 }
930
931
932
933 //-----------------------------------------------
934 // getVelocity :
935 // compute and return the entity velocity
936 //-----------------------------------------------
937 CVector CUserEntity::getVelocity() const
938 {
939 static const CVector lateral(0,0,1);
940 static CVector velocity;
941 velocity = front() * _FrontVelocity + ( lateral ^ front()) * _LateralVelocity;
942 velocity.normalize();
943 // User is Dead
944 if(isDead())
945 {
946 velocity *= 0.0;
947 }
948 // User is sitting
949 else if(isSit())
950 {
951 velocity *= 0.0;
952 }
953 // User is swimming
954 else if(isSwimming())
955 {
956 // We are a Ring DM so speed up a litle
957
958
959 // Forward Run or Walk
960 if(_FrontVelocity > 0.0f)
961 {
962 if(_Run)
963 velocity *= 3.0;
964 else
965 velocity *= 1.0;
966 }
967 // Lateral or Backward Walk
968 else
969 velocity *= 1.0;
970
971 if (_R2CharMode == R2::TCharMode::Editer || _R2CharMode == R2::TCharMode::Dm)
972 {
973 velocity *= (float(ClientCfg.DmRun) / 6.0f); // velocity max = max run / 2
974 }
975
976 }
977 else if(isRiding())
978 {
979 // Forward Run or Walk
980 if(_FrontVelocity > 0.0f)
981 {
982 if(_Run)
983 velocity *= getMountRunVelocity();
984 else
985 velocity *= getMountWalkVelocity();
986 }
987 // Lateral or Backward Walk (currently, not used)
988 else
989 velocity *= 0.66f;//getMountWalkVelocity();
990 }
991 else
992 {
993 // Forward Run or Walk
994 if(_FrontVelocity > 0.0f)
995 velocity *= currentVelocity();
996 // Lateral or Backward Walk
997 else
998 velocity *= _WalkVelocity;
999 }
1000 return velocity;
1001 }// getVelocity //
1002
1003 //-----------------------------------------------
1004 // speed :
1005 // Return the Entity Current Speed.
1006 //-----------------------------------------------
1007 double CUserEntity::speed() const // virtual
1008 {
1009 return CPlayerCL::speed();
1010 // return (double)getVelocity().norm();
1011 }// speed //
1012
1013 //-----------------------------------------------
1014 // applyMotion :
1015 // Apply the motion to the entity.
1016 //-----------------------------------------------
1017 void CUserEntity::applyMotion(CEntityCL *target)
1018 {
1019 // default each frame
1020 _ForceLookSlot= CLFECOMMON::INVALID_SLOT;
1021
1022 bool lastHasMoved = _HasMoved;
1023 _HasMoved = false;
1024 // Remove Positions in stages
1025 _Stages.removePosWithNoMode();
1026 // Remove Positions in stages for the mount.
1027 CCharacterCL *mount = 0;
1028 if(parent() != CLFECOMMON::INVALID_SLOT)
1029 {
1030 mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(parent()));
1031 if(mount)
1032 mount->_Stages.removePosWithNoMode();
1033 }
1034 // NO PRIMITIVE -> NO MOVE
1035 if(_Primitive == 0)
1036 return;
1037 // BAD CONNECTION -> NO MOVE
1038 if(NetMngr.getConnectionQuality() == false)
1039 return;
1040 // MS per TICK <=0 -> NO MOVE
1041 if(NetMngr.getMsPerTick() <= 0)
1042 return;
1043 // Compute Speed Vector
1044 NLMISC::CVectorD speed;
1045 if(_MoveToSlot != CLFECOMMON::INVALID_SLOT)
1046 {
1047 // Check the Target.
1048 if(target == 0 || target == this)
1049 return;
1050 // Compute the vector between the user and the target.
1051 CVectorD dir2targ = target->pos() - pos();
1052 dir2targ.z = 0.0;
1053 if(dir2targ == CVectorD::Null)
1054 dir2targ = front();
1055 const double angToTarget = atan2(dir2targ.y, dir2targ.x);
1056 CVectorD aimingPos = target->getAttackerPos(angToTarget, attackRadius() + ClientCfg.AttackDist);
1057 // Aiming Position
1058 CVectorD dirToAimingPos = aimingPos-pos();
1059 dirToAimingPos.z = 0.0;
1060 const double distToAimingPos = dirToAimingPos.norm();
1061
1062 // Decide if the target is reached or not
1063 bool targetReached= false;
1064 if(distToAimingPos > 0.5)
1065 {
1066 // Because of Tryker Counter, may increase the Threshold, when the player is stalled
1067 if(distToAimingPos<_MoveToDist)
1068 {
1069 // If the player is stalled too much time, abort the move and launch the action
1070 float actualSpeed= float((_Position - _LastFramePos).norm() / DT);
1071
1072 // if player effectively runs twice slower, start colision timer
1073 if( actualSpeed*2 < getMaxSpeed() )
1074 {
1075 if(!_MoveToColStartTime)
1076 _MoveToColStartTime= T1;
1077 }
1078 // else ok, reset colision timer
1079 else
1080 _MoveToColStartTime= 0;
1081
1082 // if too much time stalled, stop run.
1083 if(_MoveToColStartTime && (T1 - _MoveToColStartTime >= ClientCfg.MoveToTimeToStopStall) )
1084 targetReached= true;
1085 }
1086 else
1087 _MoveToColStartTime= 0;
1088 }
1089 else
1090 targetReached= true;
1091
1092 // If the target is reached
1093 if(targetReached)
1094 {
1095 // stop and execute action
1096 speed = CVectorD::Null;
1097 moveToAction(target);
1098 }
1099 // else continue follow
1100 else
1101 {
1102 // Look at the entity. delay it after pacs evalCollision(), for correct orientation
1103 _ForceLookSlot= target->slot();
1104 // but still estimate now an approximative front (may be used between now and applyForceLook())
1105 forceLookEntity(dir2targ, false);
1106
1107 // Normalize
1108 dirToAimingPos.normalize();
1109 // Set the Velocity Direction
1110 speed = dirToAimingPos*distToAimingPos;
1111 speed /= DT;
1112 if(speed.norm() > getMaxSpeed())
1113 speed = dirToAimingPos*getMaxSpeed();
1114 }
1115 }
1116 else if(follow())
1117 {
1118 // Check the Target.
1119 if(target == 0 || target == this)
1120 return;
1121 // If the target is moving, orientate the user to the target.
1122 // if(target->hasMoved())
1123 {
1124 // Compute the vector between the user and the target.
1125 CVectorD dir2targ = target->pos() - pos();
1126 dir2targ.z = 0.0;
1127 if(dir2targ != CVectorD::Null)
1128 {
1129 // Look at the entity. delay it after pacs evalCollision(), for correct orientation
1130 _ForceLookSlot= target->slot();
1131 // but still estimate now an approximative front (may be used between now and applyForceLook())
1132 forceLookEntity(dir2targ, false);
1133 }
1134 }
1135 // Compute the angle in the world to attack the target.
1136 const double angToTarget = frontYaw();
1137 // Get the best position to attack the target with the given angle.
1138 const CVectorD aimingPos = target->getAttackerPos(angToTarget, attackRadius() + ClientCfg.AttackDist);
1139 // Aiming Position
1140 CVectorD dirToAimingPos = aimingPos-pos();
1141 dirToAimingPos.z = 0.0;
1142 const double distToAimingPos = dirToAimingPos.norm();
1143 // If the User was not moving and the distance to re-move is not enough big, stay idle
1144 if(lastHasMoved
1145 || (isFighting() && distToAimingPos >= 0.5)
1146 || (!isFighting() && distToAimingPos >= 3.0))
1147 {
1148 dirToAimingPos.normalize();
1149 // User is in combat mode -> follow as close as possible.
1150 if(isFighting())
1151 {
1152 // Target is moving
1153 if(target->hasMoved())
1154 {
1155 // Get closer if too far.
1156 if(distToAimingPos >= 0.2)
1157 {
1158 // Set the Velocity Direction
1159 speed = dirToAimingPos*distToAimingPos;
1160 speed /= DT;
1161 if(speed.norm() > getMaxSpeed())
1162 speed = dirToAimingPos*getMaxSpeed();
1163 }
1164 else
1165 {
1166 // Try to have the same speed as the target.
1167 if(target->getSpeed() > getMaxSpeed())
1168 speed = target->dir()* ((float)getMaxSpeed());
1169 else
1170 speed = target->dir()* ((float)target->getSpeed());
1171 }
1172 }
1173 // Target is not moving.
1174 else
1175 {
1176 // Get closer if too far.
1177 if(distToAimingPos >= 0.1)
1178 {
1179 // Set the Velocity Direction
1180 speed = dirToAimingPos*distToAimingPos;
1181 speed /= DT;
1182 if(speed.norm() > getMaxSpeed())
1183 speed = dirToAimingPos*getMaxSpeed();
1184 }
1185 else
1186 speed = CVectorD::Null;
1187 }
1188 }
1189 // User is not in combat mode -> follow not so close.
1190 else
1191 {
1192 // Too far, get closer as fast as possible
1193 if(distToAimingPos >= 3.0)
1194 {
1195 // Set the Velocity Direction
1196 speed = dirToAimingPos*distToAimingPos;
1197 speed /= DT;
1198 if(speed.norm() > getMaxSpeed())
1199 speed = dirToAimingPos*getMaxSpeed();
1200 }
1201 // Just far enough, adjust the user speed to the target
1202 else if(target->hasMoved() && distToAimingPos >= 1.0)
1203 {
1204 // Try to have the same speed as the target.
1205 if(target->getSpeed() > getMaxSpeed())
1206 speed = target->dir()* ((float)getMaxSpeed());
1207 else
1208 speed = target->dir()* ((float)target->getSpeed());
1209 }
1210 // Too close, Stop
1211 else
1212 speed = CVectorD::Null;
1213 }
1214 }
1215 // User was stop and the next pos is to close to begin to move.
1216 else
1217 speed = CVectorD::Null;
1218 }
1219 else
1220 {
1221 speed = getVelocity()*_SpeedFactor.getValue();
1222 _SpeedFactor.addFactorValue(0.005f);
1223 }
1224
1225 // SPEED VECTOR NULL -> NO MOVE
1226 if(speed == CVectorD::Null)
1227 return;
1228
1229 // First Person View
1230 if(UserControls.isInternalView())
1231 {
1232 // If the server is slow, the client move slower too (only needed in FPV).
1233 double modif = (100.0f/(float)NetMngr.getMsPerTick());
1234 // don't increase speed
1235 clamp(modif, 0.0, 1.0);
1236 speed *= modif;
1237 // Move
1238 _HasMoved = true;
1239 _Primitive->move(speed, dynamicWI);
1240 if(mount && mount->getPrimitive())
1241 mount->getPrimitive()->move(speed, dynamicWI);
1242 }
1243 // Third Person View
1244 else
1245 {
1246 double modif = (100.0f/(float)NetMngr.getMsPerTick());
1247 clamp(modif, 0.0, 1.0);
1248 speed *= modif;
1249 speed += pos();
1250 sint64 x = (sint64)((sint32)(speed.x * 1000.0));
1251 sint64 y = (sint64)((sint32)(speed.y * 1000.0));
1252 sint64 z = (sint64)((sint32)(speed.z * 1000.0));
1253 const uint time = 10; // = 1sec because the speed is in Meter per Sec.
1254 _Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSX, x, 0);
1255 _Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSY, y);
1256 _Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSZ, z);
1257 // Move the Mount
1258 if(mount)
1259 {
1260 mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSX, x, 0);
1261 mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSY, y);
1262 mount->_Stages.addStage(NetMngr.getCurrentClientTick()+time, CLFECOMMON::PROPERTY_POSZ, z);
1263 }
1264 }
1265
1266
1267 }// applyMotion //
1268
1269
1270 //---------------------------------------------------
1271 //---------------------------------------------------
1272 void CUserEntity::applyForceLook()
1273 {
1274 if(_ForceLookSlot!=CLFECOMMON::INVALID_SLOT)
1275 {
1276 CEntityCL *target= EntitiesMngr.entity(_ForceLookSlot);
1277 if(target && target!=this)
1278 {
1279 // Compute the vector between the user and the target.
1280 CVectorD dir2targ = target->pos() - pos();
1281 dir2targ.z = 0.0;
1282 if(dir2targ == CVectorD::Null)
1283 dir2targ = front();
1284 // Look at the entity
1285 forceLookEntity(dir2targ, true);
1286 }
1287 }
1288 }
1289
1290
1291 //---------------------------------------------------
1292 // updatePosCombatFloatChanged :
1293 //---------------------------------------------------
1294 void CUserEntity::updatePosCombatFloatChanged(CEntityCL * /* target */) // virtual
1295 {
1296 if(viewMode() == FirstPV)
1297 {
1298 pos(_FirstPos);
1299 }
1300 }// updatePosCombatFloatChanged //
1301
1302
1303 //-----------------------------------------------
1304 // forceIndoorFPV //
1305 // Return true if the user is indoor and the CFG want to force the FPV Indoor.
1306 //-----------------------------------------------
1307 bool CUserEntity::forceIndoorFPV()
1308 {
1309 return (ClientCfg.ForceIndoorFPV && indoor());
1310 }// forceIndoorFPV //
1311
1312
1313 //-----------------------------------------------
1314 // enableFollow :
1315 //-----------------------------------------------
1316 void CUserEntity::disableFollow()
1317 {
1318 if (_FollowMode==false)
1319 return;
1320
1321 _FollowMode = false;
1322
1323 // Send the message to the server.
1324 CBitMemStream out;
1325 if(GenericMsgHeaderMngr.pushNameToStream("TARGET:NO_FOLLOW", out))
1326 NetMngr.push(out);
1327 else
1328 nlwarning("UE:follow: unknown message named 'TARGET:NO_FOLLOW'.");
1329
1330 }// follow //
1331
1332
1333 //-----------------------------------------------
1334 // enableFollow :
1335 //-----------------------------------------------
1336 void CUserEntity::enableFollow(bool resetCameraRot)
1337 {
1338 if (_FollowMode == true)
1339 return;
1340
1341 if( _Mode == MBEHAV::DEATH )
1342 return;
1343
1344 _FollowMode = true;
1345
1346 // Send the message to the server.
1347 CBitMemStream out;
1348 if(GenericMsgHeaderMngr.pushNameToStream("TARGET:FOLLOW", out))
1349 NetMngr.push(out);
1350 else
1351 nlwarning("UE:follow: unknown message named 'TARGET:FOLLOW'.");
1352
1353 // Disable any autowalk (else when follow re-disabled, it will effect, which is weird)
1354 UserControls.autowalkState(false);
1355
1356 // disable afk mode
1357 setAFK(false);
1358
1359 // if want to reset camera rotation
1360 if(resetCameraRot)
1361 startForceLookEntity(targetSlot());
1362
1363 }// follow //
1364
1365
1366 //-----------------------------------------------
1367 // resetAnyMoveTo
1368 //-----------------------------------------------
1369 void CUserEntity::resetAnyMoveTo()
1370 {
1371 // if we cancel a MoveToPhrase action, MUST dec the action counter, and hide the Action Icon
1372 if(_MoveToAction==CUserEntity::CombatPhrase || _MoveToAction==CUserEntity::ExtractRM)
1373 {
1374 // the clientExecute has not been called in case of "ExtractRM autoFind"
1375 bool autoFindExtractRM= _MoveToAction==CUserEntity::ExtractRM && _MoveToPhraseMemoryLine == std::numeric_limits<uint>::max();
1376 if(!autoFindExtractRM)
1377 {
1378 CSPhraseManager *pPM= CSPhraseManager::getInstance();
1379 pPM->cancelClientExecute(_MoveToPhraseCyclic);
1380 }
1381 }
1382
1383 // reset to no moveTo
1384 _MoveToSlot = CLFECOMMON::INVALID_SLOT;
1385 _MoveToAction = CUserEntity::None;
1386 _MoveToDist = 0.0;
1387 _MoveToColStartTime= 0;
1388 }
1389
1390 //-----------------------------------------------
1391 // moveToCheckStartDist :
1392 // Check if the user is not already well placed.
1393 //-----------------------------------------------
1394 void CUserEntity::moveToCheckStartDist(CLFECOMMON::TCLEntityId slot, double dist, TMoveToAction /* action */)
1395 {
1396 if(_MoveToSlot != CLFECOMMON::INVALID_SLOT)
1397 {
1398 // Start a new Force Look entity
1399 startForceLookEntity(_MoveToSlot);
1400
1401 // Disable any autowalk (else when moveTo re-disabled, it will effect, which is weird)
1402 UserControls.autowalkState(false);
1403
1404 // disable afk mode
1405 setAFK(false);
1406
1407 // if sufficiently near, launch the action
1408 CEntityCL *target = EntitiesMngr.entity(slot);
1409 if(target)
1410 {
1411 CVectorD dir2targ = target->pos() - pos();
1412 dir2targ.z = 0.0;
1413 if((dir2targ==CVectorD::Null) || (dir2targ.norm() < dist))
1414 {
1415 moveToAction(target);
1416 }
1417 }
1418 }
1419 }// moveToCheckStartDist //
1420
1421 //-----------------------------------------------
1422 // moveTo :
1423 // Method to move to someone else.
1424 //-----------------------------------------------
1425 void CUserEntity::moveTo(CLFECOMMON::TCLEntityId slot, double dist, TMoveToAction action)
1426 {
1427 resetAnyMoveTo();
1428
1429 // setup new state
1430 _MoveToSlot = slot;
1431 _MoveToDist = dist;
1432 _MoveToAction = action;
1433
1434 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1435 }// moveTo //
1436
1437 //-----------------------------------------------
1438 // moveToMission :
1439 // Method to move to someone else for a mission. NB: if prec action was a CombatPhrase action, action counter are decremented
1440 //-----------------------------------------------
1441 void CUserEntity::moveToMission(CLFECOMMON::TCLEntityId slot, double dist, uint32 id)
1442 {
1443 resetAnyMoveTo();
1444
1445 // setup new state
1446 _MoveToSlot = slot;
1447 _MoveToDist = dist;
1448 _MoveToAction = CUserEntity::Mission;
1449 _MoveToMissionId = id;
1450
1451 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1452 }// moveToMission //
1453
1454 //-----------------------------------------------
1455 // moveToMissionRing :
1456 // Method to move to someone else for a ring mission. NB: if prec action was a CombatPhrase action, action counter are decremented
1457 //-----------------------------------------------
1458 void CUserEntity::moveToMissionRing(CLFECOMMON::TCLEntityId slot, double dist, uint32 id)
1459 {
1460 resetAnyMoveTo();
1461
1462 // setup new state
1463 _MoveToSlot = slot;
1464 _MoveToDist = dist;
1465 _MoveToAction = CUserEntity::MissionRing;
1466 _MoveToMissionId = id;
1467
1468 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1469 }// moveToMissionRing //
1470
1471 //-----------------------------------------------
1472 // moveTo :
1473 // Method to move to someone else.
1474 //-----------------------------------------------
1475 void CUserEntity::moveToCombatPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool phraseCyclic)
1476 {
1477 resetAnyMoveTo();
1478
1479 // setup new state
1480 _MoveToSlot = slot;
1481 _MoveToDist = dist;
1482 _MoveToAction = CUserEntity::CombatPhrase;
1483 _MoveToPhraseMemoryLine= phraseMemoryLine;
1484 _MoveToPhraseMemorySlot= phraseMemorySlot;
1485 _MoveToPhraseCyclic= phraseCyclic;
1486
1487 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1488 }
1489
1490 //-----------------------------------------------
1491 // Method to move to someone else, for foraging extraction
1492 // The caller MUST call after CSPhraseManager::clientExecute(), to increment action counter
1493 //-----------------------------------------------
1494 void CUserEntity::moveToExtractionPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool cyclic)
1495 {
1496 // Test if forage tool in hand, otherwise auto-equip with it
1497 bool validForageToolInHand = false;
1498 CInventoryManager * inv = CInventoryManager::getInstance();
1499 if ( !inv )
1500 {
1501 return;
1502 }
1503 uint32 rightHandSheet = inv->getRightHandItemSheet();
1504 if ( rightHandSheet )
1505 {
1506 validForageToolInHand = inv->isForageToolItem( rightHandSheet );
1507 }
1508 if ( !validForageToolInHand )
1509 {
1510 // Find a forage tool in the bag
1511 uint i;
1512 for ( i=0; i<MAX_BAGINV_ENTRIES; ++i )
1513 {
1514 uint32 itemSheet = inv->getBagItem(i).getSheetID();
1515 if ( itemSheet && inv->isForageToolItem(itemSheet) )
1516 {
1517 break;
1518 }
1519 }
1520 if ( i != MAX_BAGINV_ENTRIES && ClientCfg.AutoEquipTool )
1521 {
1522 // remember last used weapon(s)
1523 rememberWeaponsInHand();
1524
1525 // Clear hands
1526 inv->unequip( "LOCAL:INVENTORY:HAND:1" );
1527 inv->unequip( "LOCAL:INVENTORY:HAND:0" );
1528
1529 // Equip hands
1530 string bagPath = toString( "LOCAL:INVENTORY:BAG:%u", i );
1531 inv->equip( bagPath, "LOCAL:INVENTORY:HAND:0" );
1532 }
1533 else
1534 {
1535 // No forage tool in bag
1536 CInterfaceManager::getInstance()->displaySystemInfo( CI18N::get("uiForageToolMissing"), "CHK" );
1537 return;
1538 }
1539 }
1540
1541 resetAnyMoveTo();
1542
1543 // setup new state
1544 _MoveToSlot = slot;
1545 _MoveToDist = dist;
1546 _MoveToAction = CUserEntity::ExtractRM;
1547 _MoveToPhraseMemoryLine= phraseMemoryLine;
1548 _MoveToPhraseMemorySlot= phraseMemorySlot;
1549 _MoveToPhraseCyclic= cyclic;
1550
1551 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1552 }
1553
1554 //-----------------------------------------------
1555 // Method to begin a spire construction
1556 // The caller MUST call after CSPhraseManager::clientExecute(), to increment action counter
1557 //-----------------------------------------------
1558 void CUserEntity::moveToTotemBuildingPhrase(CLFECOMMON::TCLEntityId slot, double dist, uint phraseMemoryLine, uint phraseMemorySlot, bool cyclic)
1559 {
1560 resetAnyMoveTo();
1561
1562 // setup new state
1563 _MoveToSlot = slot;
1564 _MoveToDist = dist;
1565 _MoveToAction = CUserEntity::BuildTotem;
1566 _MoveToPhraseMemoryLine= phraseMemoryLine;
1567 _MoveToPhraseMemorySlot= phraseMemorySlot;
1568 _MoveToPhraseCyclic= cyclic;
1569
1570 moveToCheckStartDist(_MoveToSlot, _MoveToDist, _MoveToAction);
1571 }
1572
1573 //-----------------------------------------------
1574 // moveToAction :
1575 // Launch the Action Once the Move is done.
1576 // \param CEntityCL * : pointer on the destination entity.
1577 // \warning entity pointer must be valid(allocated).
1578 //-----------------------------------------------
1579 void CUserEntity::moveToAction(CEntityCL *ent)
1580 {
1581 // Check entity pointer
1582 nlassert(ent);
1583
1584 UserControls.needReleaseForward();
1585
1586 // Get the interface instance.
1587 CInterfaceManager *IM = CInterfaceManager::getInstance();
1588 switch(_MoveToAction)
1589 {
1590 // Attack
1591 case CUserEntity::Attack:
1592 UserEntity->attack();
1593 break;
1594 // Quartering
1595 case CUserEntity::Quarter:
1596 if((ent->properties()).harvestable())
1597 CAHManager::getInstance()->runActionHandler("context_quartering", 0);
1598 break;
1599 // Loot
1600 case CUserEntity::Loot:
1601 if((ent->properties()).lootable())
1602 CAHManager::getInstance()->runActionHandler("context_loot", 0);
1603 break;
1604 // Pick Up
1605 case CUserEntity::PickUp:
1606 nlwarning("UE:checkMoveTo: not yet implemented");
1607 break;
1608 case CUserEntity::ExtractRM:
1609 extractRM();
1610 break;
1611 // Trade Item
1612 case CUserEntity::TradeItem:
1613 CAHManager::getInstance()->runActionHandler("context_trade_item", 0);
1614 break;
1615 // Trade Phrase
1616 case CUserEntity::TradePhrase:
1617 CAHManager::getInstance()->runActionHandler("context_trade_phrase", 0);
1618 break;
1619 // Trade Pact
1620 case CUserEntity::TradePact:
1621 CAHManager::getInstance()->runActionHandler("context_trade_pact", 0);
1622 break;
1623 // Mission
1624 case CUserEntity::Mission:
1625 {
1626 string param = toString("id=%d", _MoveToMissionId);
1627 CAHManager::getInstance()->runActionHandler("open_mission_option", 0, param);
1628 }
1629 break;
1630 // Dynamic Mission
1631 case CUserEntity::DynamicMission:
1632 CAHManager::getInstance()->runActionHandler("context_dynamic_mission", 0);
1633 break;
1634 // Static Mission
1635 case CUserEntity::StaticMission:
1636 CAHManager::getInstance()->runActionHandler("context_choose_mission", 0);
1637 break;
1638 // Mission
1639 case CUserEntity::MissionRing:
1640 {
1641 string param = toString("id=%d", _MoveToMissionId);
1642 CAHManager::getInstance()->runActionHandler("mission_ring", 0, param);
1643 }
1644 break;
1645 // Create Guild
1646 case CUserEntity::CreateGuild:
1647 CAHManager::getInstance()->runActionHandler("context_create_guild", 0);
1648 break;
1649 // News
1650 case CUserEntity::News:
1651 CAHManager::getInstance()->runActionHandler("context_talk", 0);
1652 break;
1653 // Trade Teleport
1654 case CUserEntity::TradeTeleport:
1655 CAHManager::getInstance()->runActionHandler("context_trade_teleport", 0);
1656 break;
1657 // Trade Faction items
1658 case CUserEntity::TradeFaction:
1659 CAHManager::getInstance()->runActionHandler("context_trade_faction", 0);
1660 break;
1661 // Trade Cosmetic
1662 case CUserEntity::TradeCosmetic:
1663 CAHManager::getInstance()->runActionHandler("context_trade_cosmetic", 0);
1664 break;
1665 // Talk
1666 case CUserEntity::Talk:
1667 nlwarning("UE:checkMoveTo: not yet implemented");
1668 break;
1669 // CombatPhrase
1670 case CUserEntity::CombatPhrase:
1671 UserEntity->attackWithPhrase();
1672 break;
1673 // Mount
1674 case CUserEntity::Mount:
1675 {
1676 string orderStr = "mount";
1677 string beastIndexStr = "@UI:GCM_BEAST_SELECTED";
1678 bool confirmFree = true;
1679 beastOrder(orderStr,beastIndexStr,confirmFree);
1680 break;
1681 }
1682 // WebPage
1683 case CUserEntity::WebPage:
1684 CAHManager::getInstance()->runActionHandler("context_web_page", 0);
1685 break;
1686 // Outpost
1687 case CUserEntity::Outpost:
1688 CLuaManager::getInstance().executeLuaScript("game:outpostBCOpenStateWindow()", 0);
1689 break;
1690 // BuildTotem
1691 case CUserEntity::BuildTotem:
1692 buildTotem();
1693 break;
1694 // openArkUrl
1695 case CUserEntity::OpenArkUrl:
1696 CLuaManager::getInstance().executeLuaScript("getUI('ui:interface:web_transactions'):find('html'):browse(ArkTargetUrl)", 0);
1697 break;
1698 default:
1699 break;
1700 }
1701
1702 // Move To Done.
1703 resetAnyMoveTo();
1704 }// moveToAction //
1705
1706
1707 //-----------------------------------------------
1708 // sendToServer :
1709 // Send the position and orientation to the server.
1710 //-----------------------------------------------
1711 bool CUserEntity::sendToServer(CBitMemStream &out)
1712 {
1713 if(GenericMsgHeaderMngr.pushNameToStream("POSITION", out))
1714 {
1715 // Backup the position sent.
1716 if (_Primitive) _Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
1717 // Send Position & Orientation
1718 CPositionMsg positionMsg;
1719 positionMsg.X = (sint32)(pos().x * 1000);
1720 positionMsg.Y = (sint32)(pos().y * 1000);
1721 positionMsg.Z = (sint32)(pos().z * 1000);
1722 positionMsg.Heading = frontYaw();
1723 out.serial(positionMsg);
1724 return true;
1725 }
1726 else
1727 {
1728 nlwarning("UE:sendToServer: unknown message named 'POSITION'.");
1729 return false;
1730 }
1731 }// sendToServer //
1732
1733 //-----------------------------------------------
1734 // msgForCombatPos :
1735 // Fill the msg to know if the user is well placed to fight.
1736 //-----------------------------------------------
1737 bool CUserEntity::msgForCombatPos(NLMISC::CBitMemStream &out)
1738 {
1739 static bool wellPosition = false;
1740 bool wellP = false;
1741 // if(isFighting())
1742 {
1743 // Is the user well Placed
1744 CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
1745 if(target)
1746 wellP = target->isPlacedToFight(UserEntity->pos(), front(), attackRadius() + ClientCfg.AttackDist);
1747 }
1748 // If different from the last time
1749 if(wellPosition != wellP)
1750 {
1751 wellPosition = wellP;
1752 // Send state to server.
1753 if(GenericMsgHeaderMngr.pushNameToStream("COMBAT:VALIDATE_MELEE", out))
1754 {
1755 uint8 flag = wellP?1:0;
1756 out.serial(flag);
1757 return true;
1758 }
1759 else
1760 nlwarning("UE:msgForCombatPos: unknown message named 'COMBAT:TOGGLE_COMBAT_FLOAT_MODE'.");
1761 }
1762 // Do not send the msg.
1763 return false;
1764 }// msgForCombatPos //
1765
1766
1767 //-----------------------------------------------
1768 // checkPos :
1769 // Check the User Position according to the server code.
1770 // \todo GUIGUI : put checks on GPos
1771 // \todo GUIGUI : refact the check primitive when creating a PACS again
1772 //-----------------------------------------------
1773 void CUserEntity::checkPos()
1774 {
1775 if(PACS && _Primitive)
1776 {
1777 // Is in water ?
1778 if(GR)
1779 {
1780 UGlobalPosition gPos;
1781 _Primitive->getGlobalPosition(gPos, dynamicWI);
1782 float waterHeight;
1783 if(GR->isWaterPosition(gPos, waterHeight))
1784 {
1785 if(isSwimming() == false)
1786 {
1787 // Player is Dead set the right mode (swim and dead)
1788 if(isDead())
1789 mode(MBEHAV::SWIM_DEATH);
1790 else
1791 {
1792 // Do not swim when in combat mode.
1793 if(isFighting())
1794 {
1795 _HasMoved = false;
1796 pacsPos(_LastPositionValidated, _LastGPosValidated);
1797 }
1798 // \todo GUIGUI : if the move was cancelled, do not switch to swimming mode.
1799 else if (isRiding())
1800 {
1801 mode(MBEHAV::MOUNT_SWIM);
1802 // also change mounted entity mode
1803 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
1804 if(mount)
1805 {
1806 // Set the mount.
1807 mount->setMode(MBEHAV::MOUNT_SWIM);
1808 mount->computeAutomaton();
1809 mount->computeAnimSet();
1810 mount->setAnim(CAnimationStateSheet::Idle);
1811 }
1812 }
1813 else
1814 {
1815 mode(MBEHAV::SWIM);
1816 }
1817 }
1818 }
1819 }
1820 else
1821 {
1822 if(isSwimming())
1823 {
1824 if(isDead())
1825 {
1826 mode(MBEHAV::DEATH);
1827 }
1828 else if (isRiding())
1829 {
1830 mode(MBEHAV::MOUNT_NORMAL);
1831 // also change mounted entity mode
1832 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
1833 if(mount)
1834 {
1835 // Set the mount.
1836 mount->setMode(MBEHAV::MOUNT_NORMAL);
1837 mount->computeAutomaton();
1838 mount->computeAnimSet();
1839 mount->setAnim(CAnimationStateSheet::Idle);
1840 }
1841 }
1842 else
1843 {
1844 mode(MBEHAV::NORMAL);
1845 }
1846 }
1847 }
1848 }
1849
1850 // Create the Primitive used to check if the move will be accepted by the server
1851 if(_CheckPrimitive == 0)
1852 {
1853 _Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
1854 _Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
1855 _CheckPrimitive = PACS->addNonCollisionablePrimitive(_Primitive);
1856 _CheckPrimitive->setOcclusionMask(MaskColNone); // Collide with nothing
1857 _CheckPrimitive->setCollisionMask(MaskColNone); // Collide with nothing
1858 _LastPositionValidated = pos();
1859 }
1860 if(_CheckPrimitive)
1861 {
1862 _CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
1863 CVectorD speed = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
1864
1865 _CheckPrimitive->move(speed, dynamicWI);
1866 if(PACS->evalNCPrimitiveCollision(1.0, _CheckPrimitive, dynamicWI) == false)
1867 nlwarning("UE:checkPos: _CheckPrimitive is a collisionable primitive !!!");
1868
1869 CVectorD vectDist = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
1870 if(vectDist.norm() > 0.001)
1871 {
1872 // The server will not be able to reproduce this move, restoring the last one.
1873 _HasMoved = false;
1874 pacsPos(_LastPositionValidated,_LastGPosValidated);
1875 }
1876 else
1877 {
1878 _LastPositionValidated = _Primitive->getFinalPosition(dynamicWI);
1879 _Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
1880 }
1881 }
1882 }
1883 }// checkPos //
1884
1885
1886 //-----------------------------------------------
1887 // testPacsPos :
1888 // test the move from posToTest to current pos
1889 //-----------------------------------------------
1890 bool CUserEntity::testPacsPos( CVectorD& posToTest )
1891 {
1892 if(PACS && _Primitive && _CheckPrimitive)
1893 {
1894 _CheckPrimitive->setGlobalPosition(posToTest, dynamicWI);
1895 CVectorD speed = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
1896
1897 _CheckPrimitive->move(speed, dynamicWI);
1898 if(PACS->evalNCPrimitiveCollision(1.0, _CheckPrimitive, dynamicWI) == false)
1899 nlwarning("UE:testPacsPos: _CheckPrimitive is a collisionable primitive !!!");
1900
1901 CVectorD vectDist = _Primitive->getFinalPosition(dynamicWI) - _CheckPrimitive->getFinalPosition(dynamicWI);
1902 if(vectDist.norm() > 0.001)
1903 {
1904 return false;
1905 }
1906 else
1907 return true;
1908 }
1909 return false;
1910
1911 } // testPacsPos //
1912
1913
1914 //-----------------------------------------------
1915 // tp :
1916 // Teleport the player (remove selection, re-init checkPos, etc.).
1917 //-----------------------------------------------
1918 void CUserEntity::tp(const CVectorD &dest)
1919 {
1920 // Remove the selection.
1921 UserEntity->selection(CLFECOMMON::INVALID_SLOT);
1922 // Update PACS
1923 pacsPos(dest);
1924 // Update the primitive useful to check the user position.
1925 _LastPositionValidated = dest;
1926 // Get the Global position
1927 if(_Primitive)
1928 {
1929 // this is the last PACS position validated too
1930 _Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
1931 // consider this is the last position sent to server (since actually received!)
1932 _Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
1933 // Set the new position of the 'check' primitive
1934 if(_CheckPrimitive)
1935 _CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
1936 }
1937 else
1938 nlwarning("UE:tp: the entity has a Null primitive.");
1939 // Return to interface mode.
1940 viewMode(UserEntity->viewMode());
1941 // User well oriented.
1942 dir(UserEntity->front());
1943 // Set Normal Mode after a teleport.
1944 mode(MBEHAV::NORMAL);
1945 // Set animation with idle.
1946 setAnim(CAnimationStateSheet::Idle);
1947 }// tp //
1948
1949 //-----------------------------------------------
1950 // correctPos :
1951 // Teleport the player to correct his position.
1952 //-----------------------------------------------
1953 void CUserEntity::correctPos(const NLMISC::CVectorD &dest)
1954 {
1955 nlinfo("UE:correctPos: new user position %f %f %f", dest.x, dest.y, dest.z);
1956 // Change the user poisition.
1957 UserEntity->pacsPos(dest);
1958 // Update the primitive useful to check the user position.
1959 _LastPositionValidated = dest;
1960 // Get the Global position
1961 if(_Primitive)
1962 {
1963 // this is the last PACS position validated too
1964 _Primitive->getGlobalPosition(_LastGPosValidated, dynamicWI);
1965 // consider this is the last position sent to server (since actually received!)
1966 _Primitive->getGlobalPosition(_LastGPosSent, dynamicWI);
1967 // Set the new position of the 'check' primitive
1968 if(_CheckPrimitive)
1969 _CheckPrimitive->setGlobalPosition(_LastGPosSent, dynamicWI);
1970 }
1971 else
1972 nlwarning("UE:correctPos: the entity has a Null primitive.");
1973
1974 // Correct the pos of the mount, if riding
1975 if ( isRiding() )
1976 {
1977 if ( _Mount < EntitiesMngr.entities().size() )
1978 {
1979 CEntityCL *mount = EntitiesMngr.entities()[_Mount];
1980 if ( mount )
1981 mount->pacsPos( dest );
1982 }
1983 }
1984 }// correctPos //
1985
1986
1987 /*
1988 * Check if the mount is able to run, and force walking mode if not
1989 * (if the player clicked on run, set back to walk).
1990 */
1991 void CUserEntity::checkMountAbleToRun()
1992 {
1993 if ( isRiding() )
1994 {
1995 if ( running() )
1996 {
1997 // Make the mount walk if she's hungry
1998 if ( ! _MountHunger.canRun() )
1999 switchVelocity( false );
2000 }
2001 else
2002 {
2003 // Make the mount run if she's not hungry anymore
2004 if ( _RunWhenAble && _MountHunger.canRun() )
2005 switchVelocity( false );
2006 }
2007 }
2008 }
2009
2010
2011 //-----------------------------------------------
2012 // Update the position of the entity after the motion.
2013 // \param t : Time for the position of the entity after the motion.
2014 // \param target : pointer on the current target.
2015 //-----------------------------------------------
2016 void CUserEntity::updatePos(const TTime &t, CEntityCL *target)
2017 {
2018 // Update Mount if mounting (if _Mount was still not valid when mode received)
2019 if((_Mount != CLFECOMMON::INVALID_SLOT && isRiding()) && _OnMount==false)
2020 {
2021 setOnMount();
2022 }
2023 // External view are managed like other entities.
2024 if(!UserControls.isInternalView())
2025 {
2026 // Update position according to the animations.
2027 CPlayerCL::updatePos(t, target);
2028 _LastFrameTime = t*0.001;
2029 // Set The FPV when indoor.
2030 if(forceIndoorFPV())
2031 viewMode(FirstPV, false);
2032 return;
2033 }
2034 /*
2035 else
2036 {
2037 // 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)
2038 updateAnimationState();
2039 }*/
2040
2041 // Compute the Time Step.
2042 double frameTimeRemaining = computeTimeStep(((double)t)*0.001);
2043 // Do not update animation if Client Light
2044 if (!ClientCfg.Light)
2045 {
2046 // Attack Animation.
2047 if(_AnimAttackOn)
2048 {
2049 if(animIndex(MOVE) != ::CAnimation::UnknownAnim)
2050 {
2051 if(animOffset(MOVE) >= EAM->getAnimationLength(animId(MOVE)))
2052 {
2053 _AnimAttackOn = false;
2054 updateVisualDisplay();
2055 }
2056 }
2057 }
2058
2059 // Increase the time in the current animation.
2060 double previousTimeOffset = animOffset(MOVE);
2061 double offset = previousTimeOffset + frameTimeRemaining;
2062 // Check Anim length
2063 double animLength = EAM->getAnimationLength(animId(MOVE));
2064 if(offset > animLength)
2065 animOffset(MOVE, animLength);
2066 else
2067 animOffset(MOVE, offset);
2068 // Manage Events that could be created by the animation (like sound).
2069 animEventsProcessing(previousTimeOffset, animOffset(MOVE));
2070 }
2071 // Get the right pos from PACS.
2072 if(_Primitive && GR)
2073 {
2074 UGlobalPosition gPos;
2075 _Primitive->getGlobalPosition(gPos, dynamicWI);
2076
2077 // Set the new current pos.
2078 pos(GR->getGlobalPosition(gPos));
2079 }
2080 // Set the direction.
2081 if( ClientCfg.AutomaticCamera )
2082 {
2083 //dir(front());
2084 }
2085 // Reset the TPV when outdoor if needed.
2086 if(_Primitive && GR)
2087 {
2088 UGlobalPosition gPos;
2089 _Primitive->getGlobalPosition(gPos, dynamicWI);
2090 if(!GR->isInterior(gPos))
2091 if(!ClientCfg.FPV)
2092 viewMode(ThirdPV, false);
2093 }
2094 // Current time is now the entity time too.
2095 _LastFrameTime = t*0.001;
2096 }// updatePos //
2097
2098 //-----------------------------------------------
2099 // updateDisplay :
2100 // Update the PACS position after the evalCollision. The entity position is set too. This is fast.
2101 // If the entity position is too far from its PACS position, setGlobalPosition is called.
2102 // After this call, the position.z is valid.
2103 //-----------------------------------------------
2104 void CUserEntity::pacsFinalizeMove() // virtual
2105 {
2106 if(_Primitive == 0)
2107 return;
2108
2109 // Get the global position
2110 _FinalPacsPos = _Primitive->getFinalPosition(dynamicWI);
2111
2112 // Get the global position
2113 UGlobalPosition gPos;
2114 _Primitive->getGlobalPosition(gPos, dynamicWI);
2115 if(gPos.InstanceId != -1)
2116 {
2117 pos(_FinalPacsPos);
2118 if(_Mount != CLFECOMMON::INVALID_SLOT)
2119 {
2120 CEntityCL *mount = EntitiesMngr.entity(_Mount);
2121 if(mount)
2122 mount->pacsPos(pos());
2123 }
2124 }
2125 else
2126 _SetGlobalPositionDone = false;
2127 }// pacsFinalizeMove //
2128
2129
2130 //-----------------------------------------------
2131 // applyBehaviour :
2132 // Apply the behaviour for the user.
2133 //-----------------------------------------------
2134 void CUserEntity::applyBehaviour(const CBehaviourContext &behaviourContext) // virtual
2135 {
2136 const MBEHAV::CBehaviour &behaviour = behaviourContext.Behav;
2137 // Special code for the First Person View
2138 if((viewMode() == FirstPV) && behaviour.isCombat())
2139 {
2140 // Backup the current behaviour.
2141 _CurrentBehaviour = behaviourContext.Behav;
2142 dir(front());
2143
2144 // check if self-target
2145 bool selfSpell = false;
2146 if (behaviourContext.Targets.Targets.size() == 1)
2147 {
2148 if (behaviourContext.Targets.Targets[0].TargetSlot == 0)
2149 {
2150 selfSpell = true;
2151 }
2152 }
2153 bool isOffensif;
2154 switch(behaviour.Behaviour)
2155 {
2156 case MBEHAV::CAST_OFF:
2157 case MBEHAV::CAST_OFF_FAIL:
2158 case MBEHAV::CAST_OFF_SUCCESS:
2159 case MBEHAV::CAST_OFF_LINK:
2160 isOffensif = true;
2161 break;
2162 default:
2163 isOffensif = false;
2164 break;
2165 }
2166
2167 // Default target hit dates
2168 static vector<double> targetHitDates;
2169 targetHitDates.clear();
2170 targetHitDates.resize(behaviourContext.Targets.Targets.size(), TimeInSec);
2171
2172 // cast projectiles/impact linked to behaviour
2173 updateCurrentAttack();
2174 if (isCurrentBehaviourAttackEnd())
2175 {
2176 // In First Person (don't care), use a default animation => will choose a default delay of 0.5
2177 performCurrentAttackEnd(behaviourContext, selfSpell && isOffensif,
2178 targetHitDates, CAnimationStateSheet::UnknownState);
2179 }
2180 //
2181 _RightFXActivated = false;
2182 _LeftFXActivated = false;
2183 if(EAM)
2184 {
2185 animState (MOVE, CAnimationStateSheet::FirstPersonAttack);
2186 animIndex (MOVE, CAnimation::UnknownAnim);
2187 animOffset(MOVE, 0.0);
2188 _CurrentState = EAM->mState(_CurrentAutomaton, animState(MOVE));
2189 if(_CurrentState && _CurrentAnimSet[MOVE])
2190 {
2191 const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState(animState(MOVE));
2192 if(animStatePtr)
2193 {
2194 animIndex(MOVE, animStatePtr->chooseAnim(_AnimJobSpecialisation, people(), getGender(), 0.0));
2195 if(animIndex(MOVE) != CAnimation::UnknownAnim)
2196 {
2197 if(_PlayList)
2198 {
2199 _PlayList->setAnimation (MOVE, animId(MOVE));
2200 _PlayList->setTimeOrigin (MOVE, ryzomGetLocalTime ()*0.001);//_LastFrameTime);
2201 _AnimAttackOn = true;
2202 updateVisualDisplay();
2203 }
2204 }
2205 }
2206 }
2207 }
2208 // Start FX to play at the animation beginning like trails.
2209 if(_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK)
2210 {
2211 startItemAttackFXs(_CurrentBehaviour.Range.ImpactIntensity != 0, _CurrentBehaviour.Range.ImpactIntensity);
2212 }
2213 else
2214 {
2215 startItemAttackFXs(_CurrentBehaviour.Combat.ImpactIntensity != 0 && _CurrentBehaviour.Combat.HitType != HITTYPE::Failed, _CurrentBehaviour.Combat.ImpactIntensity);
2216 }
2217 // DeltaHP
2218 applyBehaviourFlyingHPs(behaviourContext, behaviour, targetHitDates);
2219 }
2220 // In third person view (or camera mode), play the same way than for the others.
2221 else
2222 CPlayerCL::applyBehaviour(behaviourContext);
2223 }// applyBehaviour //
2224
2225 //---------------------------------------------------
2226 // setDead :
2227 // Method to Flag the character as dead and do everything needed.
2228 //---------------------------------------------------
2229 void CUserEntity::setDead() // virtual
2230 {
2231 // User is dead -> NO FOLLOW
2232 disableFollow();
2233 // Remove the selection.
2234 UserEntity->selection(CLFECOMMON::INVALID_SLOT);
2235 // Death Mode Control and view.
2236 UserControls.mode(CUserControls::DeathMode);
2237 // Play the FX for the death
2238 NL3D::UParticleSystemInstance deathFX = FXMngr.instantFX(ClientCfg.DeadFXName);
2239 if(!deathFX.empty())
2240 deathFX.setPos(selectBox().getCenter());
2241
2242 // Last teleport is a death
2243
2244 // get player's kami fame
2245 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2246 sint8 kamiFame = 0;
2247 uint kamiFameIndex = CStaticFames::getInstance().getFactionIndex("kami");
2248 if (pIM && kamiFameIndex != CStaticFames::INVALID_FACTION_INDEX)
2249 {
2250 CCDBNodeLeaf *pLeafKamiFame = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:FAME:PLAYER%d:VALUE", kamiFameIndex - 1), false);
2251 if (pLeafKamiFame != NULL)
2252 kamiFame = pLeafKamiFame->getValue8();
2253 }
2254
2255 // get player's karavan fame
2256 sint8 karavanFame = 0;
2257 uint karavanFameIndex = CStaticFames::getInstance().getFactionIndex("karavan");
2258 if (pIM && karavanFameIndex != CStaticFames::INVALID_FACTION_INDEX)
2259 {
2260 CCDBNodeLeaf *pLeafKaravanFame = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:FAME:PLAYER%d:VALUE", karavanFameIndex - 1), false);
2261 if (pLeafKaravanFame != NULL)
2262 karavanFame = pLeafKaravanFame->getValue8();
2263 }
2264
2265 // set loading background depending on player's faction fame
2266 if (kamiFame > karavanFame)
2267 LoadingBackground = ResurectKamiBackground;
2268 else
2269 LoadingBackground = ResurectKaravanBackground;
2270
2271 // disable or enable shadowing
2272 updateCastShadowMap();
2273
2274 // enable death warning popup
2275 //CInterfaceManager * pIM = CInterfaceManager::getInstance();
2276 if( pIM )
2277 {
2278 CAHManager::getInstance()->runActionHandler("set",NULL,"dblink=UI:VARIABLES:DEATH_WARNING_WANTED|value=1");
2279 }
2280 }// setDead //
2281
2282 //-----------------------------------------------
2283 // skillUp :
2284 // Skill Up
2285 //-----------------------------------------------
2286 void CUserEntity::skillUp()
2287 {
2288 // Play the FX for the death
2289 NL3D::UParticleSystemInstance skillUpFX = FXMngr.instantFX(ClientCfg.SkillUpFXName);
2290 skillUpFX.setClusterSystem(getClusterSystem());
2291 if(!skillUpFX.empty())
2292 skillUpFX.setPos(pos());
2293 }// skillUp //
2294
2295 //-----------------------------------------------
2296 // startColTimer :
2297 // After a few time, if the user is still in collision with someone else, remove collisions with other entitites.
2298 //-----------------------------------------------
2299 void CUserEntity::startColTimer()
2300 {
2301 if(_ColOn)
2302 {
2303 if(_ColRemoved==false)
2304 {
2305 if((T1-_ColStartTime) > ClientCfg.TimeToRemoveCol)
2306 {
2307 EntitiesMngr.removeColUserOther();
2308 _ColRemoved = true;
2309 }
2310 }
2311 }
2312 else
2313 {
2314 _ColOn = true;
2315 _ColStartTime = T1;
2316 }
2317 }// startColTimer //
2318
2319 //-----------------------------------------------
2320 // stopColTimer :
2321 // Called when the user is no more in collision with another entity.
2322 //-----------------------------------------------
2323 void CUserEntity::stopColTimer()
2324 {
2325 // Restore collisions.
2326 if(_ColRemoved)
2327 {
2328 EntitiesMngr.restoreColUserOther();
2329 _ColRemoved = false;
2330 }
2331 _ColOn = false;
2332 }// stopColTimer //
2333
2334
2335
2336 //-----------------------------------------------
2337 // getMaxSpeed
2338 // Return the current max speed for the entity in meter per sec
2339 // The method return a max according to the speed factor (given by the server)
2340 // It's also return a value according to the landscape (water)
2341 // Also managed mounts
2342 //-----------------------------------------------
2343 double CUserEntity::getMaxSpeed() const // virtual
2344 {
2345 // Max Defined speed according to the current factor (slow, or speed increased)
2346 double maxSpeed = _SpeedFactor.getValue();
2347 // User is Dead
2348 if(isDead())
2349 {
2350 maxSpeed *= 0.0;
2351 }
2352 // User is sitting
2353 else if(isSit())
2354 {
2355 maxSpeed *= 0.0;
2356 }
2357 // User is swimming
2358 else if(isSwimming())
2359 {
2360
2361 // We are a Ring DM so speed up a litle
2362 if (_R2CharMode == R2::TCharMode::Editer || _R2CharMode == R2::TCharMode::Dm)
2363 {
2364 maxSpeed *= ClientCfg.DmRun / 2;
2365 }
2366 else
2367 {
2368 // Run
2369 maxSpeed *= 3.0;
2370 }
2371 }
2372 else if(isRiding())
2373 {
2374 // Run if mount not hungry, otherwise, use walk velocity
2375 if (_MountHunger.canRun())
2376 maxSpeed *= (double)getMountRunVelocity();
2377 else
2378 maxSpeed *= (double)getMountWalkVelocity();
2379 }
2380 else
2381 {
2382 // Run
2383 maxSpeed *= runVelocity();
2384 }
2385 // Return the current max
2386 return maxSpeed;
2387 // return ClientCfg.Run * _SpeedFactor.getValue();
2388 }// getMaxSpeed //
2389
2390
2391 //-----------------------------------------------
2392 // snapToGround :
2393 // Snap the user to the ground.
2394 //-----------------------------------------------
2395 void CUserEntity::snapToGround()
2396 {
2397 CEntityCL::snapToGround();
2398
2399 updateSound (ryzomGetLocalTime ());
2400 }// // snapToGround //
2401
2402
2403 //-----------------------------------------------
2404 // updateSound :
2405 //-----------------------------------------------
2406 void CUserEntity::updateSound(const TTime &time)
2407 {
2408 H_AUTO_USE ( RZ_Client_Update_Sound );
2409
2410 // no sound manager, no need to update sound
2411 if (SoundMngr == NULL)
2412 return;
2413
2414 if (!(StereoHMD && true)) // TODO: ClientCfg.Headphone
2415 {
2416 // NOTE: StereoHMD+Headphone impl in main_loop.cpp
2417 SoundMngr->setListenerPos(pos());
2418 const CMatrix &camMat = MainCam.getMatrix();
2419 SoundMngr->setListenerOrientation(camMat.getJ(), camMat.getK());
2420 }
2421
2422 if (ClientCfg.Light)
2423 return;
2424
2425 // step sound of self : refind the sound animations associated to the walk and run animation
2426
2427 static bool computeAnim = true;
2428 static bool lastMode = false;
2429 static TTime previousTime = 0;
2430 static TTime stepTime = 0;
2431 static bool leftRight = false;
2432 static NLSOUND::CSoundAnimMarker *leftStep = 0;
2433 static NLSOUND::CSoundAnimMarker *rightStep = 0;
2434
2435 // TODO : Remove when bug corrected:
2436 if (_Gender == GSGENDER::unknown)
2437 {
2438 nlwarning("CUserEntity::updateSound : The gender is unknown, forcing it to male");
2439 _Gender = GSGENDER::male;
2440 }
2441
2442 // force recompute of anim if walk/run change.
2443 computeAnim = computeAnim || (lastMode != _Run);
2444
2445 // Check the sound animation to find the time between to step
2446 if(computeAnim && SoundMngr && _CurrentAnimSet[MOVE] != 0) // && _SoundId[MOVE] != NLSOUND::CSoundAnimationNoId)
2447 {
2448 lastMode = _Run;
2449 TAnimStateId mode = _Run ? CAnimationStateSheet::Run : CAnimationStateSheet::Walk;
2450 const CAnimationState *animStatePtr = _CurrentAnimSet[MOVE]->getAnimationState (mode);
2451 if (animStatePtr)
2452 {
2453 ::CAnimation::TAnimId animId = animStatePtr->chooseAnim (_AnimJobSpecialisation, people(), getGender(), 0);
2454 if (animId != ::CAnimation::UnknownAnim)
2455 {
2456 const ::CAnimation *anim = animStatePtr->getAnimation (animId);
2457 if(anim)
2458 {
2459 // Select the sound ID
2460 _SoundId[MOVE] = anim->soundId();
2461
2462 if (_SoundId[MOVE] != NLSOUND::CSoundAnimationNoId)
2463 {
2464 // retrieve the anim
2465 NLSOUND::CSoundAnimManager *mgr = NLSOUND::CSoundAnimManager::instance();
2466
2467 string name = mgr->idToName(_SoundId[MOVE]);
2468
2469 if (!name.empty())
2470 {
2471 NLSOUND::CSoundAnimation *sanim = mgr->findAnimation(name);
2472 if (sanim->countMarkers() != 2)
2473 {
2474 static set<string> warnOnce;
2475 if (warnOnce.find(sanim->getName()) == warnOnce.end())
2476 {
2477 nlwarning("Sound animation '%s' has not 2 markers, not a biped ? (Display Once)", sanim->getName().c_str());
2478 warnOnce.insert(sanim->getName());
2479 }
2480 }
2481 else
2482 {
2483 stepTime = TTime((sanim->getMarker(1)->getTime() - sanim->getMarker(0)->getTime()) * 1000);
2484 rightStep = sanim->getMarker(0);
2485 leftStep = sanim->getMarker(1);
2486 computeAnim = false;
2487 }
2488 }
2489 }
2490 }
2491 }
2492 }
2493 }
2494
2495 if( SoundMngr && _Mode == MBEHAV::NORMAL)
2496 {
2497 if (!getVelocity().isNull())
2498 {
2499 if (stepTime > 0 && time-previousTime>=stepTime)
2500 {
2501 previousTime = time;
2502
2503 // set the sound 1 meter below listener
2504 _SoundContext.Position = pos() + CVector(0,0,-1);
2505 _SoundContext.RelativeGain = SoundMngr->getUserEntitySoundLevel();;
2506
2507 uint32 matId= getGroundType();
2508 //nldebug("Current material = %u", matId);
2509 _SoundContext.Args[0] = matId;
2510
2511 if (leftRight)
2512 {
2513 if (leftStep)
2514 // TODO : find the correct cluster
2515 leftStep->play(SoundMngr->getMixer(), NULL, _SoundContext);
2516 }
2517 else
2518 {
2519 if (rightStep)
2520 // TODO : find the correct cluster
2521 rightStep->play(SoundMngr->getMixer(), NULL, _SoundContext);
2522
2523 // recompute a new sound anim
2524 computeAnim = true;
2525 }
2526
2527 leftRight = !leftRight;
2528 }
2529 }
2530 else
2531 {
2532 // resets the counter
2533 previousTime = 0;
2534 }
2535 }
2536 }// updateSound //
2537
2538
2539 //-----------------------------------------------
2540 // rotate :
2541 // rotate the body on the left or right (front changes).
2542 //-----------------------------------------------
2543 void CUserEntity::rotate(float ang)
2544 {
2545 // Rotate the body.
2546 CMatrix m;
2547 m.identity();
2548 m.rotateZ(ang);
2549 front(m * front().normed());
2550 }// rotate //
2551
2552
2553 //-----------------------------------------------
2554 // rotHeadVertically :
2555 // rotate the head vertically.
2556 //-----------------------------------------------
2557 void CUserEntity::rotHeadVertically(float ang)
2558 {
2559 setHeadPitch(_HeadPitch+ang);
2560 }// rotHeadVertically //
2561
2562
2563 //-----------------------------------------------
2564 // setHeadPitch(double hp)
2565 //-----------------------------------------------
2566 void CUserEntity::setHeadPitch(double hp)
2567 {
2568 _HeadPitch = hp;
2569 // epsilon to avoid gimbal lock
2570 clamp(_HeadPitch, -Pi/2 + 0.01, Pi/2 - 0.5);
2571 }
2572
2573 //---------------------------------------------------
2574 // slotRemoved :
2575 // To Inform about an entity removed (to remove from selection for example).
2576 // This will remove the entity from the target.
2577 // \param slot : Slot of the entity that will be removed.
2578 //---------------------------------------------------
2579 void CUserEntity::slotRemoved(const CLFECOMMON::TCLEntityId &slot)
2580 {
2581 // parent call
2582 CPlayerCL::slotRemoved(slot);
2583
2584 // reset also selection
2585 if(selection() == slot)
2586 selection(CLFECOMMON::INVALID_SLOT);
2587 }// slotRemoved //
2588
2589 //---------------------------------------------------
2590 // selection :
2591 // Change the entity selected.
2592 // \param slot : slot now selected (CLFECOMMON::INVALID_SLOT for an empty selection).
2593 // \warning Can be different from the entity targeted (in combat mode for example).
2594 //---------------------------------------------------
2595 void CUserEntity::selection(const CLFECOMMON::TCLEntityId &slot) // virtual
2596 {
2597 //allows reselection in Ring client: even if the selected slots is equal to the selection,
2598 //the client must send the messages.
2599 if ((_Selection == slot) && !ClientCfg.R2EDEnabled)
2600 return;
2601
2602 // The selection will be the entity to watch
2603 WatchedEntitySlot = slot;
2604 disableFollow();
2605
2606 // Send the entity selected to the server.
2607 NetMngr.pushTarget(slot);
2608
2609
2610 // Target the slot on client, don't wait NetWork response
2611 targetSlot(slot);
2612 _TargetSlotNoLag= slot;
2613
2614 if (ClientCfg.R2EDEnabled)
2615 {
2616 R2::getEditor().inGameSelection(slot);
2617 }
2618
2619
2620 // Change the current selection so un color the current selection.
2621 CEntityCL *sel = EntitiesMngr.entity(_Selection);
2622 if(sel != NULL)
2623 sel->visualSelectionStop(); // Blink off == restore to normal
2624
2625 // Set the entity selected
2626 _Selection = slot;
2627
2628 // Update visual selection and interface
2629 if ( sel && sel->isForageSource() )
2630 sel->buildInSceneInterface(); // remove focus on previous selected source
2631 sel = EntitiesMngr.entity(_Selection);
2632 if(sel != NULL)
2633 {
2634 sel->visualSelectionStart();
2635 if ( sel->isForageSource() )
2636 sel->buildInSceneInterface(); // set focus on new selected source
2637 }
2638
2639
2640 // **** Update Target interface
2641 //get the new target slot and set it in the database
2642 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2643 NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:TARGET:SLOT")->setValue64(slot);
2644
2645 // Get the new target UID, and set in Database
2646 uint tgtSlot= _Selection;
2647 uint32 tgtEntityId= CLFECOMMON::INVALID_CLIENT_DATASET_INDEX;
2648 CEntityCL *entity = NULL;
2649 if (tgtSlot!=CLFECOMMON::INVALID_SLOT)
2650 {
2651 entity = EntitiesMngr.entity(tgtSlot);
2652 if (entity)
2653 tgtEntityId= entity->dataSetId();
2654 }
2655
2656 // Set the User Target
2657 CCDBNodeLeaf *prop = NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:TARGET:UID", false);
2658 if(prop)
2659 prop->setValue32(tgtEntityId);
2660
2661 // Bar Manager. Update now the Target View (so it takes VP if data available or 0... but result is immediate)
2662 CBarManager::getInstance()->setLocalTarget(tgtEntityId);
2663
2664 // **** Update DB for InGameMenu
2665 // clear the entries for mission option
2666 for(uint k = 0; k < NUM_MISSION_OPTIONS; ++k)
2667 {
2668 CCDBNodeLeaf *missionOption = NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:TITLE", (int) k), false);
2669 if (missionOption)
2670 {
2671 missionOption->setValue32(0);
2672 }
2673 CCDBNodeLeaf *playerGiftNeeded = NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:PLAYER_GIFT_NEEDED", (int) k), false);
2674 if (playerGiftNeeded)
2675 {
2676 playerGiftNeeded->setValue32(0);
2677 }
2678 }
2679 /* TODO ULU : Add RP tags */
2680
2681 // update pvp tags
2682 if ((tgtSlot!=CLFECOMMON::INVALID_SLOT) && entity)
2683 {
2684 CPlayerCL *pPlayer = dynamic_cast<CPlayerCL*>(entity);
2685
2686 if (pPlayer)
2687 {
2688 /*// Pvp Mode
2689 CViewBitmap * tagMode = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:pvp_tags:mode"));
2690 if (tagMode)
2691 {
2692 if (pPlayer->getPvpMode()&PVP_MODE::PvpFaction)
2693 tagMode->setTexture("pvp_orange.tga");
2694 else if (pPlayer->getPvpMode()&PVP_MODE::PvpFactionFlagged)
2695 tagMode->setTexture("pvp_red.tga");
2696 else
2697 tagMode->setTexture("alpha_10.tga");
2698 }
2699 */
2700 /*// Pvp available actions (attack, heal, both)
2701 CViewBitmap * tagMode = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:pvp_tags:actions"));
2702 if (tagMode)
2703 {
2704 if (pPlayer->getPvpMode()&PVP_MODE::PvpFaction)
2705 tag->setTexture("pvp_orange.tga");
2706 else if (pPlayer->getPvpMode()&PVP_MODE::PvpFactionFlagged)
2707 tag->setTexture("pvp_red.tga");
2708 else
2709 tag->setTexture("alpha_10.tga");
2710 }*/
2711
2712 }
2713 }
2714
2715 // clear web page
2716 prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:WEB_PAGE_URL", false);
2717 if(prop) prop->setValue32(0);
2718 prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:WEB_PAGE_TITLE", false);
2719 if(prop) prop->setValue32(0);
2720
2721 // clear mission ring
2722 for(uint k = 0; k < BOTCHATTYPE::MaxR2MissionEntryDatabase; ++k)
2723 {
2724 prop= NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSION_RING:%d:TITLE", k), false);
2725 if(prop) prop->setValue32(0);
2726 }
2727
2728 // clear programs
2729 prop= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:PROGRAMMES", false);
2730 if(prop) prop->setValue32(0);
2731 prop= NLGUI::CDBManager::getInstance()->getDbProp("SERVER:TARGET:CONTEXT_MENU:PROGRAMMES");
2732 if(prop) prop->setValue32(0);
2733 // increment db counter for context menu
2734 pIM->incLocalSyncActionCounter();
2735
2736 }// selection //
2737
2738 //---------------------------------------------------
2739 // moveToAttack :
2740 // Method to place the user to attack the target and attack.
2741 //---------------------------------------------------
2742 void CUserEntity::moveToAttack()
2743 {
2744 // **** For clarity, try to launch a "default attack" found in the memory bar instead of an "anonymous" action
2745 CSPhraseManager *pPM= CSPhraseManager::getInstance();
2746 uint32 memLine, memSlot;
2747 CEntityCL *target= EntitiesMngr.entity(selection());
2748
2749 CInventoryManager *inv = CInventoryManager::getInstance();
2750
2751 // auto-equip with valid weapon
2752 if( ClientCfg.AutoEquipTool )
2753 {
2754 if(inv)
2755 {
2756 // if no valid weapons in had -> auto-equip with last used weapons
2757 bool validWeaponInHand = true;
2758 uint32 rightHandSheet = inv->getRightHandItemSheet();
2759 if(rightHandSheet)
2760 {
2761 validWeaponInHand = inv->isMeleeWeaponItem(rightHandSheet) || inv->isRangeWeaponItem(rightHandSheet);
2762 }
2763 if( !validWeaponInHand )
2764 {
2765 autoEquipWithLastUsedWeapons();
2766 }
2767
2768 // remember last used weapon(s)
2769 rememberWeaponsInHand();
2770 }
2771 }
2772
2773 if(target && pPM->findDefaultAttack(memLine, memSlot))
2774 {
2775 // launch instead a phrase execution with this phrase
2776 executeCombatWithPhrase(target, memLine, memSlot, true);
2777 }
2778 // **** Else launch an anonymous "default attack"
2779 else
2780 {
2781 // melee or range?
2782 bool melee = true;
2783 if(inv)
2784 {
2785 uint32 rightHandSheet = inv->getRightHandItemSheet();
2786 if(rightHandSheet)
2787 melee = inv->isMeleeWeaponItem(rightHandSheet);
2788 }
2789
2790 // Move to target if melee weapon
2791 if(melee)
2792 moveTo(selection(), 2.0, CUserEntity::Attack);
2793 // Just attack if range weapon.
2794 else
2795 attack();
2796 }
2797 }// moveToAttack //
2798
2799 //---------------------------------------------------
2800 // attack :
2801 // Method to attack the target.
2802 //---------------------------------------------------
2803 void CUserEntity::attack()
2804 {
2805 // execute the default attack
2806 CSPhraseManager *pPM= CSPhraseManager::getInstance();
2807 pPM->executeDefaultAttack();
2808
2809 bool melee = true;
2810 CInventoryManager *inv = CInventoryManager::getInstance();
2811 if(inv)
2812 {
2813 uint32 rightHandSheet = inv->getRightHandItemSheet();
2814 if(rightHandSheet)
2815 melee = inv->isMeleeWeaponItem(rightHandSheet);
2816 }
2817
2818 // If option ON, follow when attacking.
2819 if(ClientCfg.FollowOnAtk)
2820 {
2821 // Follow only if attacking with a melee weapon
2822 if(melee)
2823 // enable, but don't reset camera rotation
2824 enableFollow(false);
2825 }
2826 }// attack //
2827
2828 //---------------------------------------------------
2829 // attack :
2830 // Method to attack the target, with a special phrase
2831 //---------------------------------------------------
2832 void CUserEntity::attackWithPhrase()
2833 {
2834 if( !canEngageCombat() )
2835 return;
2836
2837 CSPhraseManager *pPM= CSPhraseManager::getInstance();
2838
2839 // validate the execution on server
2840 pPM->sendExecuteToServer(_MoveToPhraseMemoryLine, _MoveToPhraseMemorySlot, _MoveToPhraseCyclic);
2841
2842 // If the Attack is a "Next", and not a cycle, do a default attack
2843 if(!_MoveToPhraseCyclic)
2844 pPM->executeDefaultAttack();
2845
2846 // If option ON, follow when attacking.
2847 if(ClientCfg.FollowOnAtk)
2848 {
2849 bool melee = true;
2850 CInventoryManager *inv = CInventoryManager::getInstance();
2851 if(inv)
2852 {
2853 uint32 rightHandSheet = inv->getRightHandItemSheet();
2854 if(rightHandSheet)
2855 melee = inv->isMeleeWeaponItem(rightHandSheet);
2856 }
2857 // Follow only if attacking with a melee weapon
2858 if(melee)
2859 // enable, but don't reset camera rotation
2860 enableFollow(false);
2861 }
2862
2863 // Because sendExecuteToServer() has been called, must NOT cancelClientExecute() at resetAnyMoveTo()
2864 _MoveToAction= CUserEntity::None;
2865 }
2866
2867 //-----------------------------------------------
2868 // assist :
2869 // your current target become the target of your current one.
2870 //-----------------------------------------------
2871 void CUserEntity::assist()
2872 {
2873 assist(targetSlot());
2874 }// assist //
2875
2876 //-----------------------------------------------
2877
2878 void CUserEntity::assist(uint slot)
2879 {
2880 // Check the current target
2881 if(slot == CLFECOMMON::INVALID_SLOT || slot == _Slot)
2882 return;
2883 // Check the target
2884 CEntityCL *target = EntitiesMngr.entity(slot);
2885 if(target == 0)
2886 return;
2887 // Check the new slot.
2888 CLFECOMMON::TCLEntityId newSlot = target->targetSlot();
2889 if(newSlot == CLFECOMMON::INVALID_SLOT || newSlot == _Slot)
2890 return;
2891 // Select the new target.
2892 selection(newSlot);
2893 }
2894
2895 //---------------------------------------------------
2896 // disengage :
2897 // Method to disengage the target.
2898 //---------------------------------------------------
2899 void CUserEntity::disengage()
2900 {
2901 // Set the database in local.
2902 if(ClientCfg.Local)
2903 {
2904 IngameDbMngr.setProp("Entities:E0:P" + toString(CLFECOMMON::PROPERTY_MODE), MBEHAV::NORMAL); // Mode
2905 IngameDbMngr.setProp("Entities:E0:P" + toString(CLFECOMMON::PROPERTY_TARGET_ID), _Selection); // Target
2906 UserEntity->updateVisualProperty(0, CLFECOMMON::PROPERTY_MODE);
2907 UserEntity->updateVisualProperty(0, CLFECOMMON::PROPERTY_TARGET_ID);
2908 return;
2909 }
2910
2911 // Disengage MSG.
2912 const string msgName = "COMBAT:DISENGAGE";
2913 CBitMemStream out;
2914 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
2915 NetMngr.push(out);
2916 else
2917 nlwarning("UE::disengage: unknown message named '%s'.", msgName.c_str());
2918
2919 // Change the current mode.
2920 mode(MBEHAV::NORMAL);
2921 }// disengage //
2922
2923 //-----------------------------------------------
2924 // sit :
2925 // Ask for the client to sit/stand ('true' to sit).
2926 //-----------------------------------------------
2927 bool CUserEntity::sit(bool s)
2928 {
2929 bool ok= false;
2930
2931 // SIT
2932 if(s)
2933 {
2934 if(canSit() == true)
2935 {
2936 // disable afk mode
2937 setAFK(false);
2938
2939 // Sit MSG.
2940 if(mode(MBEHAV::SIT))
2941 {
2942 // autowalk disabled
2943 UserControls.autowalkState(false);
2944
2945 static const string msgName = "COMMAND:SIT";
2946 CBitMemStream out;
2947 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
2948 {
2949 out.serial(s);
2950 NetMngr.push(out);
2951 }
2952 else
2953 nlwarning("UE:sit: unknown message named '%s'.", msgName.c_str());
2954
2955 // mode changed
2956 ok= true;
2957
2958 // display sit msg
2959 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2960 string msg = CI18N::get("msgUserIsSitting");
2961 string cat = getStringCategory(msg, msg);
2962 pIM->displaySystemInfo(msg, cat);
2963 }
2964 }
2965 }
2966 // STAND
2967 else
2968 {
2969 if(_Mode == MBEHAV::SIT)
2970 {
2971 if(mode(MBEHAV::NORMAL))
2972 {
2973 static const string msgName = "COMMAND:SIT";
2974 CBitMemStream out;
2975 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
2976 {
2977 out.serial(s);
2978 NetMngr.push(out);
2979 }
2980 else
2981 nlwarning("UE:sit: unknown message named '%s'.", msgName.c_str());
2982
2983 // mode changed
2984 ok= true;
2985
2986 // display stand msg
2987 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2988 string msg = CI18N::get("msgUserIsStanding");
2989 string cat = getStringCategory(msg, msg);
2990 pIM->displaySystemInfo(msg, cat);
2991 }
2992 }
2993 }
2994
2995 // if mode changed, Write to the UI database, to update views
2996 if(ok)
2997 {
2998 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2999 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:PLAYER_STAND", false);
3000 if(node)
3001 node->setValue32(_Mode != MBEHAV::SIT);
3002 }
3003
3004 // mode changed
3005 return ok;
3006 }// sit //
3007
3008 //-----------------------------------------------
3009 // canSit :
3010 // Return true if the user can sit.
3011 //-----------------------------------------------
3012 bool CUserEntity::canSit() const
3013 {
3014 // If the user is not already sitting or is on a mount
3015 if(!isSit() && (!isRiding()) && !isDead() && !isSwimming())
3016 {
3017 return true;
3018 }
3019 else
3020 return false;
3021 }// canSit //
3022
3023 //-----------------------------------------------
3024 // setAFK
3025 //-----------------------------------------------
3026 void CUserEntity::setAFK(bool b, string afkTxt)
3027 {
3028 if( isAFK() == b ) return;
3029
3030 if (b)
3031 {
3032 if( isDead() || isRiding() || moveTo() || follow() )
3033 return;
3034
3035 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3036 //sint64 start = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TSTART")->getValue64();
3037 //sint64 end = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TEND")->getValue64();
3038 //sint64 type = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TYPE")->getValue64();
3039 //sint64 num = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_NUMBER")->getValue64();
3040 if( pIM )
3041 {
3042 if( NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:ACT_TYPE")->getValue64() != 0 )
3043 return;
3044 }
3045
3046 if( !isSit() && !isSwimming() )
3047 {
3048 if( !mode(MBEHAV::REST) )
3049 return;
3050 }
3051 }
3052 else
3053 {
3054 if( !isSit() && !isSwimming() )
3055 {
3056 if (isDead())
3057 return;
3058 else
3059 mode(MBEHAV::NORMAL);
3060 }
3061 }
3062
3063 // send afk state
3064 static const string msgName = "COMMAND:AFK";
3065 CBitMemStream out;
3066 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
3067 {
3068 out.serial(b);
3069 NetMngr.push(out);
3070 }
3071 else
3072 nlwarning("CUserEntity:setAFK: unknown message named '%s'.", msgName.c_str());
3073
3074 // custom afk txt
3075 ucstring ucstr; // TODO: UTF-8 (serial)
3076 ucstr.fromUtf8( afkTxt );
3077 CBitMemStream outTxt;
3078 static const string msgNameTxt = "STRING:AFK_TXT";
3079 if( GenericMsgHeaderMngr.pushNameToStream(msgNameTxt,outTxt) )
3080 {
3081 outTxt.serial( ucstr );
3082 NetMngr.push( outTxt );
3083 }
3084 else
3085 {
3086 nlwarning("CUserEntity:setAFK: unknown message named '%s'.", msgNameTxt.c_str());
3087 }
3088
3089
3090 }// setAFK //
3091
3092 //-----------------------------------------------
3093 // rollDice
3094 //-----------------------------------------------
3095 void CUserEntity::rollDice(sint16 min, sint16 max, bool local)
3096 {
3097 if (local)
3098 {
3099 // no need to broadcast over network here
3100 static NLMISC::CRandom* dice = (NLMISC::CRandom*)NULL;
3101 if (!dice)
3102 {
3103 dice = new NLMISC::CRandom;
3104 dice->srand(CTickEventHandler::getGameCycle());
3105 }
3106 sint16 roll = min + (sint16)dice->rand(max-min);
3107
3108 string msg = CI18N::get("msgRollDiceLocal");
3109 strFindReplace(msg, "%min", toString(min));
3110 strFindReplace(msg, "%max", toString(max));
3111 strFindReplace(msg, "%roll", toString(roll));
3112
3113 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3114
3115 pIM->displaySystemInfo(msg, getStringCategory(msg, msg));
3116 return;
3117 }
3118 const string msgName = "COMMAND:RANDOM";
3119 CBitMemStream out;
3120 if (GenericMsgHeaderMngr.pushNameToStream(msgName, out))
3121 {
3122 out.serial(min);
3123 out.serial(max);
3124 NetMngr.push(out);
3125 }
3126 else
3127 nlwarning("CUserEntity:rollDice: unknown message named '%s'.", msgName.c_str());
3128 }// rollDice //
3129
3130 //---------------------------------------------------
3131 // canEngageCombat :
3132 // return true if user can engage melee combat, else return false and display system msg
3133 //---------------------------------------------------
3134 bool CUserEntity::canEngageCombat()
3135 {
3136 if( isSit() )
3137 {
3138 // display "you can't fight while sitting" message)
3139 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3140 string msg = CI18N::get("msgCantFightSit");
3141 string cat = getStringCategory(msg, msg);
3142 pIM->displaySystemInfo(msg, cat);
3143
3144 return false;
3145 }
3146
3147 if( isSwimming() )
3148 {
3149 // display "you can't fight while swiming" message)
3150 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3151 string msg = CI18N::get("msgCantFightSwim");
3152 string cat = getStringCategory(msg, msg);
3153 pIM->displaySystemInfo(msg, cat);
3154
3155 return false;
3156 }
3157
3158 if ( isRiding() )
3159 {
3160 // display "you can't fight while swimming" message)
3161 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3162 string msg = CI18N::get("msgCantFightRide");
3163 string cat = getStringCategory(msg, msg);
3164 pIM->displaySystemInfo(msg, cat);
3165
3166 return false;
3167 }
3168
3169 return true;
3170 } // canEngageCombat //
3171
3172
3173 //---------------------------------------------------
3174 // viewMode :
3175 // Change the View (First/Third Person View).
3176 //---------------------------------------------------
3177 void CUserEntity::viewMode(CUserEntity::TView viewMode, bool changeView)
3178 {
3179 switch(viewMode)
3180 {
3181 // First Person View
3182 case FirstPV:
3183 if(changeView)
3184 ClientCfg.FPV = true;
3185 if(_Mount != CLFECOMMON::INVALID_SLOT)
3186 {
3187 CEntityCL *mount = EntitiesMngr.entity(_Mount);
3188 if(mount)
3189 mount->displayable(false);
3190
3191 _HiddenMount = _Mount;
3192 }
3193 // Change Controls.
3194 if( isRiding() )
3195 {
3196 bool autoWalk = UserControls.autowalkState();
3197 UserControls.mode(CUserControls::MountMode);
3198 if( autoWalk )
3199 UserControls.autowalkState( true );
3200 }
3201 else
3202 UserControls.mode(CUserControls::InterfaceMode);
3203 break;
3204
3205 // Third Person View
3206 case ThirdPV:
3207 if(changeView)
3208 ClientCfg.FPV = false;
3209
3210 if(_HiddenMount != CLFECOMMON::INVALID_SLOT)
3211 {
3212 CEntityCL *mount = EntitiesMngr.entity(_HiddenMount);
3213 if(mount)
3214 mount->displayable(true);
3215
3216 _HiddenMount = CLFECOMMON::INVALID_SLOT;
3217 }
3218 // Change Controls.
3219 UserControls.mode(CUserControls::ThirdMode);
3220 break;
3221
3222 // Unknown
3223 default:
3224 nlwarning("UE:viewMode: Unknown View Asked '%d'.", (sint)viewMode);
3225 return;
3226 }
3227
3228 // Change the current View like asked.
3229 _ViewMode = viewMode;
3230
3231 // disable or enable shadowing
3232 updateCastShadowMap();
3233 }// viewMode //
3234
3235 //-----------------------------------------------
3236 // toggleCamera :
3237 // Toggle Camera (First/Third Person)
3238 //-----------------------------------------------
3239 void CUserEntity::toggleCamera()
3240 {
3241 // You cannot change the camera view when dead.
3242 if(isDead())
3243 return;
3244 // Only if not inside a building.
3245 if(!UserEntity->forceIndoorFPV())
3246 {
3247 // Leave the 1st Person Mode -> Enter the 3rd Person View Mode
3248 if (UserEntity->viewMode() == CUserEntity::FirstPV)
3249 UserEntity->viewMode(CUserEntity::ThirdPV);
3250 // Leave the 3rd Person Mode -> Enter the 1st Person View Mode
3251 else
3252 UserEntity->viewMode(CUserEntity::FirstPV);
3253 }
3254 }// toggleCamera //
3255
3256 //-----------------------------------------------
3257 // forceCameraFirstPerson :
3258 // Force Camera to First Person View
3259 //-----------------------------------------------
3260 void CUserEntity::forceCameraFirstPerson()
3261 {
3262 // You cannot change the camera view when dead.
3263 if(isDead())
3264 return;
3265 // Only if not inside a building.
3266 if(!UserEntity->forceIndoorFPV())
3267 {
3268 if (UserEntity->viewMode() != CUserEntity::FirstPV)
3269 //Enter the 1st Person View Mode
3270 UserEntity->viewMode(CUserEntity::FirstPV);
3271 }
3272 }// forceCameraFirstPerson //
3273
3274 //---------------------------------------------------
3275 // getScale :
3276 // Return the entity scale. (return 1.0 if there is any problem).
3277 // \todo GUIGUI : do we have to take care of the user's race kwnowing it can favour him ?
3278 //---------------------------------------------------
3279 float CUserEntity::getScale() const // virtual
3280 {
3281 // Default Scale.
3282 return 1.0f;
3283 }// getScale //
3284
3285 //---------------------------------------------------
3286 // removeCheckPrimitive :
3287 // Remove the check primitive
3288 //---------------------------------------------------
3289 void CUserEntity::removeCheckPrimitive()
3290 {
3291 if(PACS && _CheckPrimitive)
3292 PACS->removePrimitive(_CheckPrimitive);
3293 _CheckPrimitive = 0;
3294 }
3295
3296 //---------------------------------------------------
3297 // removePrimitive :
3298 // Remove the primitive
3299 //---------------------------------------------------
3300 void CUserEntity::removePrimitive() // virtual (will not be called by ~CEntityCL())
3301 {
3302 // Remove the Primitive used for check
3303 removeCheckPrimitive();
3304
3305 // Remove the other primitive
3306 CPlayerCL::removePrimitive();
3307 }// removePrimitive //
3308
3309 //---------------------------------------------------
3310 // computePrimitive :
3311 // Create a primitive for the entity.
3312 //---------------------------------------------------
3313 void CUserEntity::computePrimitive() // virtual
3314 {
3315 // Initialize the primitive.
3316 if(initPrimitive(0.5f, 2.0f, 0.0f, 0.0f, UMovePrimitive::Slide, (UMovePrimitive::TTrigger)(UMovePrimitive::OverlapTrigger | UMovePrimitive::EnterTrigger), MaskColPlayer, MaskColPlayer | MaskColNpc | MaskColDoor))
3317 _Primitive->insertInWorldImage(dynamicWI);
3318 // Set the position.
3319 pacsPos(pos());
3320 }// computePrimitive //
3321
3322
3323 //---------------------------------------------------
3324 // isBusy :
3325 // Return if the user is already busy (combat/bo chat/loot/ etc.).
3326 //---------------------------------------------------
3327 bool CUserEntity::isBusy() const
3328 {
3329 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3330 // Check Trade.
3331
3332 // TODO : put the right DB entry !
3333
3334 CCDBNodeLeaf *nod = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:INVENTORY:EXCHANGE:BEGUN", false);
3335 if(nod)
3336 {
3337 if(nod->getValueBool())
3338 return true;
3339 }
3340 // else
3341 // nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:EXCHANGE:BEGUN'.");
3342
3343 /*
3344 // Check Loot
3345 static const uint nbSlot = 4;
3346 uint i;
3347 for(i=0; i<nbSlot; ++i)
3348 {
3349 nod = NLGUI::CDBManager::getInstance()->getDbProp(NLMISC::toString("SERVER:INVENTORY:%d:%d:SHEET", INVENTORIES::pickup, i), false);
3350 if(nod)
3351 {
3352 if(nod->getValue32() != 0)
3353 return true;
3354 }
3355 else
3356 nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:%d:%d:SHEET'.", INVENTORIES::pickup, i);
3357 }
3358
3359 // Check Harvest
3360 for(i=0; i<nbSlot; ++i)
3361 {
3362 nod = NLGUI::CDBManager::getInstance()->getDbProp(NLMISC::toString("SERVER:INVENTORY:%d:%d:SHEET", INVENTORIES::harvest, i), false);
3363 if(nod)
3364 {
3365 if(nod->getValue32() != 0)
3366 return true;
3367 }
3368 else
3369 nlwarning("UE:isBusy: Cannot get the nod 'SERVER:INVENTORY:%d:%d:SHEET'.", INVENTORIES::harvest, i);
3370 }
3371 */
3372
3373 // Check Bot chat.
3374 CBotChatPage * currPage = CBotChatManager::getInstance()->getCurrPage();
3375 if( currPage!= NULL )
3376 {
3377 return true;
3378 }
3379
3380 // Not Busy
3381 return false;
3382 }// isBusy //
3383
3384
3385 //---------------------------------------------------
3386 // updateVisualDisplay :
3387 // Show/Hide all or parts of the user body.
3388 // todo GUIGUI : it's bad for the _Face to be a separated instance
3389 //---------------------------------------------------
3390 void CUserEntity::updateVisualDisplay()
3391 {
3392 // We need a skeleton.
3393 if(_Skeleton.empty())
3394 return;
3395
3396 // 1st person View
3397 if(UserControls.isInternalView() || View.forceFirstPersonView())
3398 {
3399 // Hide the mount
3400 if (_Mount != CLFECOMMON::INVALID_SLOT)
3401 {
3402 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
3403 if(mount)
3404 mount->displayable(false);
3405
3406 _HiddenMount = _Mount;
3407 }
3408 else if (_HiddenMount != CLFECOMMON::INVALID_SLOT)
3409 {
3410 // not on mount anymore, but still in FPV
3411 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_HiddenMount));
3412 if(mount)
3413 mount->displayable(true);
3414
3415 _HiddenMount = CLFECOMMON::INVALID_SLOT;
3416 }
3417
3418 // Hide all user body parts.
3419 for(uint i=0; i<_Instances.size(); ++i)
3420 if(!_Instances[i].Current.empty())
3421 {
3422 _Instances[i].Current.hide();
3423 _Instances[i].hideStaticFXs();
3424 }
3425 // Hide the face
3426 if(!_Face.Current.empty())
3427 _Face.Current.hide();
3428
3429 // We want to display weapons in 1st person view when attacking.
3430 if(modeWithHiddenItems() == false)
3431 {
3432 if( _Mode == MBEHAV::COMBAT_FLOAT || _Mode == MBEHAV::COMBAT )
3433 {
3434 if( _ObjectsVisible )
3435 {
3436 // Show just Few parts
3437 if(!_Instances[SLOTTYPE::HANDS_SLOT].Current.empty())
3438 {
3439 _Instances[SLOTTYPE::HANDS_SLOT].Current.show();
3440 _Instances[SLOTTYPE::HANDS_SLOT].showStaticFXs();
3441 }
3442 if(!_Instances[SLOTTYPE::ARMS_SLOT].Current.empty())
3443 {
3444 _Instances[SLOTTYPE::ARMS_SLOT].Current.show();
3445 _Instances[SLOTTYPE::ARMS_SLOT].showStaticFXs();
3446 }
3447 if(!_Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current.empty())
3448 {
3449 _Instances[SLOTTYPE::RIGHT_HAND_SLOT].Current.show();
3450 _Instances[SLOTTYPE::RIGHT_HAND_SLOT].showStaticFXs();
3451 }
3452 if(!_Instances[SLOTTYPE::LEFT_HAND_SLOT].Current.empty())
3453 {
3454 _Instances[SLOTTYPE::LEFT_HAND_SLOT].Current.show();
3455 _Instances[SLOTTYPE::LEFT_HAND_SLOT].showStaticFXs();
3456 }
3457 }
3458 }
3459 }
3460 }
3461 else
3462 {
3463 // Show the mount
3464 CCharacterCL *mount = dynamic_cast<CCharacterCL *>(EntitiesMngr.entity(_Mount));
3465 if(mount)
3466 {
3467 mount->displayable(true);
3468
3469 showOrHideBodyParts( objectsVisible() );
3470 }
3471
3472 // Show the face
3473 /*
3474 if(!_Face.Current.empty())
3475 _Face.Current.show();
3476 */
3477 }
3478 }// updateVisualDisplay //
3479
3480 void CUserEntity::lightOn()
3481 {
3482 _LightOn = false;
3483 light();
3484 }
3485
3486 //---------------------------------------------------
3487 // light:
3488 // Show/Hide the user light.
3489 //---------------------------------------------------
3490 void CUserEntity::light()
3491 {
3492 // Create the light
3493 if(_Light.empty())
3494 {
3495 // Check there is a skeleton and a bone to stick the light before to create it.
3496 if(!_Skeleton.empty() && _NameBoneId!=-1)
3497 {
3498 _Light = Scene->createPointLight();
3499 if(!_Light.empty())
3500 {
3501 // front of the player
3502 _Light.setPos(0.f,0.3f,0.f);
3503 // Setup the light
3504 _Light.setupAttenuation(12.0f, 20.0f);
3505 // Attach the light
3506 _Skeleton.stickObject(_Light, _NameBoneId);
3507 // The player light is the only one who can interact with Lightmapped objects
3508 _Light.setInfluenceLightMap(true);
3509
3510 // TestYoyo
3511 /*
3512 NL3D::UInstance inst;
3513 inst= Scene->createInstance("box.shape");
3514 if(!inst.empty())
3515 {
3516 inst.setScale(0.2f, 0.2f, 0.2f);
3517 inst.parent(_Light);
3518 }
3519 */
3520 }
3521 }
3522 else
3523 nlwarning("UE:light: there is no skeleton or Name Bone to stick the light.");
3524 }
3525 // Turn On/Off the Light
3526 _LightOn = !_LightOn;
3527 if(!_Light.empty())
3528 {
3529 if(_LightOn)
3530 _Light.show();
3531 else
3532 _Light.hide();
3533 }
3534 }// light //
3535
3536 //---------------------------------------------------
3537 // CSpeedFactor::init :
3538 // Initialize the Observer for the Speed Factor.
3539 //---------------------------------------------------
3540 void CUserEntity::CSpeedFactor::init()
3541 {
3542 _Value = 1.0f; // Default speed factor is 1.
3543 _ServerFactor = 1.0f;
3544 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3545 CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:SPEED_FACTOR", false);
3546 if(pNodeLeaf)
3547 {
3548 /* if(!pNodeLeaf->addToLeaves(this))
3549 nlwarning("UE:SP:init: cannot add the observer");*/
3550 ICDBNode::CTextId textId;
3551 pNodeLeaf->addObserver(this, textId);
3552 if ( pNodeLeaf->getValue64() != 0 )
3553 _Value = ((float)pNodeLeaf->getValue64())/100.0f; // may have been received before
3554 }
3555 else
3556 nlwarning("UE:SP:init: 'SERVER:USER:SPEED_FACTOR' does not exist.");
3557 }// CSpeedFactor::init //
3558
3559 //---------------------------------------------------
3560 // CMountHunger::init :
3561 //---------------------------------------------------
3562 void CUserEntity::CMountHunger::init()
3563 {}
3564
3565 //---------------------------------------------------
3566 // CMountSpeeds::init :
3567 //---------------------------------------------------
3568 void CUserEntity::CMountSpeeds::init()
3569 {
3570 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3571 CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_WALK_SPEED", false );
3572 BOMB_IF( ! pNodeLeaf, "MOUNT_WALK_SPEED not found", return );
3573 if(pNodeLeaf)
3574 {
3575 ICDBNode::CTextId textId;
3576 pNodeLeaf->addObserver(this, textId);
3577 _WalkSpeed = ((float)pNodeLeaf->getValue32()) / 1000.0f; // may have been received before
3578 }
3579 pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_RUN_SPEED", false );
3580 BOMB_IF( ! pNodeLeaf, "MOUNT_RUN_SPEED not found", return );
3581 if(pNodeLeaf)
3582 {
3583 ICDBNode::CTextId textId;
3584 pNodeLeaf->addObserver(this, textId);
3585 _RunSpeed = ((float)pNodeLeaf->getValue32()) / 1000.0f; // may have been received before
3586 }
3587 }
3588
3589 //---------------------------------------------------
3590
3591 void CUserEntity::CSpeedFactor::release()
3592 {
3593 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3594 CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:SPEED_FACTOR", false);
3595 if(pNodeLeaf)
3596 {
3597 /* if(!pNodeLeaf->addToLeaves(this))
3598 nlwarning("UE:SP:init: cannot add the observer");*/
3599 ICDBNode::CTextId textId;
3600 pNodeLeaf->removeObserver(this, textId);
3601 }
3602 else
3603 nlwarning("UE:SP:init: 'SERVER:USER:SPEED_FACTOR' does not exist.");
3604 }// CSpeedFactor::init //
3605
3606 void CUserEntity::CMountHunger::release()
3607 {}
3608
3609 void CUserEntity::CMountSpeeds::release()
3610 {
3611 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3612 CCDBNodeLeaf *pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_WALK_SPEED", false );
3613 BOMB_IF( ! pNodeLeaf, "MOUNT_WALK_SPEED not found", return );
3614 if(pNodeLeaf)
3615 {
3616 ICDBNode::CTextId textId;
3617 pNodeLeaf->removeObserver(this, textId);
3618 }
3619 pNodeLeaf = NLGUI::CDBManager::getInstance()->getDbProp( "SERVER:USER:MOUNT_RUN_SPEED", false );
3620 BOMB_IF( ! pNodeLeaf, "MOUNT_RUN_SPEED not found", return );
3621 if(pNodeLeaf)
3622 {
3623 ICDBNode::CTextId textId;
3624 pNodeLeaf->removeObserver(this, textId);
3625 }
3626 }
3627
3628
3629 //---------------------------------------------------
3630 // CSpeedFactor::update :
3631 // Callback called to update the speed factor.
3632 //---------------------------------------------------
3633 void CUserEntity::CSpeedFactor::update(ICDBNode *node) // virtual
3634 {
3635 CCDBNodeLeaf *leaf = safe_cast<CCDBNodeLeaf *>(node);
3636 _Value = ((float)leaf->getValue64())/100.0f;
3637 //nlinfo("SpeedFactor changed to %f / %" NL_I64 "u", _Value, leaf->getValue64());
3638
3639 // clamp the value (2.0 is the egg item or the level 6 speed up power up, nothing should be faster)
3640 // commented because ring editor speed is in fact faster
3641 //if(_Value > 2.0f)
3642 //{
3643 //nlwarning("HACK: you try to change the speed factor to %f", _Value);
3644 //nlstop;
3645 //_Value = 2.0f;
3646 //}
3647 }// CSpeedFactor::update //
3648
3649
3650 /*
3651 * Return true if the mount can run. Precondition: UserEntity->isRiding().
3652 */
3653 bool CUserEntity::CMountHunger::canRun() const
3654 {
3655 CEntityCL *mountEntity = UserEntity->getMountEntity();
3656 if ( ! mountEntity )
3657 return false;
3658
3659 // Find the mount's db leaf and check hunger
3660 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3661 CCDBNodeBranch *animalsNode = safe_cast<CCDBNodeBranch*>(NLGUI::CDBManager::getInstance()->getDB()->getNode( ICDBNode::CTextId( "SERVER:PACK_ANIMAL" ), false ));
3662 BOMB_IF( ! animalsNode, "! animalsNode", return false; );
3663 uint nbAnimals = (uint)animalsNode->getNbNodes();
3664 for ( uint i=0; i!=nbAnimals; ++i )
3665 {
3666 ICDBNode *beastNode = animalsNode->getNode( i );
3667 CCDBNodeLeaf *uidLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "UID" ) ));
3668 if ( ((CLFECOMMON::TClientDataSetIndex)uidLeaf->getValue32()) == mountEntity->dataSetId() )
3669 {
3670 CCDBNodeLeaf *hungerLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "HUNGER" ) ));
3671 return (hungerLeaf->getValue32() != (sint)ANIMAL_TYPE::DbHungryValue);
3672 }
3673 }
3674 return true;
3675 }
3676
3677
3678
3679 //---------------------------------------------------
3680 // CMountSpeeds::update :
3681 // Callback called to update the mount speed.
3682 //---------------------------------------------------
3683 void CUserEntity::CMountSpeeds::update(ICDBNode * /* node */) // virtual
3684 {
3685 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3686 _WalkSpeed = ((float)(NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:MOUNT_WALK_SPEED")->getValue32())) / 1000.0f;
3687 _RunSpeed = ((float)(NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:MOUNT_RUN_SPEED")->getValue32())) / 1000.0f;
3688 }
3689
3690
3691 /*
3692 * Return the mount entity if the user is riding, otherwise NULL
3693 */
3694 CEntityCL* CUserEntity::getMountEntity()
3695 {
3696 if ( _Mount < EntitiesMngr.entities().size() )
3697 {
3698 return EntitiesMngr.entities()[_Mount];
3699 }
3700 return NULL;
3701 }
3702
3703 /*
3704 * Return the DB entry for the specified user's animal (NULL if not found)
3705 */
3706 CCDBNodeBranch *CUserEntity::getBeastDBEntry( CLFECOMMON::TClientDataSetIndex uid )
3707 {
3708 // Find animal entry corresponding to datasetId
3709 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3710 CCDBNodeBranch *animalsNode = safe_cast<CCDBNodeBranch*>(NLGUI::CDBManager::getInstance()->getDB()->getNode( ICDBNode::CTextId( "SERVER:PACK_ANIMAL" ), false ));
3711 BOMB_IF( ! animalsNode, "! animalsNode", return NULL );
3712 uint nbAnimals = (uint)animalsNode->getNbNodes();
3713 for ( uint i=0; i!=nbAnimals; ++i )
3714 {
3715 ICDBNode *beastNode = animalsNode->getNode( i );
3716 CCDBNodeLeaf *pNodeLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "UID" ) ));
3717 if ( pNodeLeaf && (pNodeLeaf->getValue32() == (sint32)uid) )
3718 return (CCDBNodeBranch*)beastNode;
3719 }
3720 return NULL;
3721 }
3722
3723
3724 //---------------------------------------------------
3725 // displayDebug :
3726 // Display Debug Information.
3727 //---------------------------------------------------
3728 void CUserEntity::displayDebug(float x, float &y, float lineStep) // virtual
3729 {
3730 CPlayerCL::displayDebug(x, y, lineStep);
3731 }// displayDebug //
3732
3733 //---------------------------------------------------
3734 // displayModifiers :
3735 // Display dmg/heal numbers above the head.
3736 //---------------------------------------------------
3737 void CUserEntity::displayModifiers() // virtual
3738 {
3739 if(!UserControls.isInternalView())
3740 CPlayerCL::displayModifiers();
3741 }// displayModifiers //
3742
3743 //---------------------------------------------------
3744 // isVisible :
3745 // Return 'true' is the entity is displayed.
3746 //---------------------------------------------------
3747 bool CUserEntity::isVisible() const // virtual
3748 {
3749 return !UserControls.isInternalView();
3750 }// isVisible //
3751
3752
3753
3754
3755
3756
3757 //---------------------------------------------------
3758 // readWrite :
3759 // Read/Write Variables from/to the stream.
3760 //---------------------------------------------------
3761 void CUserEntity::readWrite(NLMISC::IStream &f)
3762 {
3763 CPlayerCL::readWrite(f);
3764
3765 // PROTECTED
3766 f.serial(_SpeedFactor);
3767 f.serial(_FrontVelocity);
3768 f.serial(_LateralVelocity);
3769 CVector dummyHead;
3770 f.serial(dummyHead);
3771 f.serial(_HeadPitch);
3772 f.serial(_EyesHeight);
3773 f.serial(_Run);
3774 f.serial(_WalkVelocity);
3775 f.serial(_RunVelocity);
3776 f.serial(_CurrentVelocity);
3777 f.serial(_Selection);
3778 f.serial(_Trader);
3779 f.serial(_Interlocutor);
3780 f.serial(_Selectable);
3781
3782 // PRIVATE
3783 f.serial(_OnMount);
3784 f.serial(_AnimAttackOn);
3785 // f.serialEnum(_ViewMode);
3786 }// readWrite //
3787
3788 //---------------------------------------------------
3789 // load :
3790 // To call after a read from a stream to re-initialize the entity.
3791 //---------------------------------------------------
3792 void CUserEntity::load() // virtual
3793 {
3794 CInterfaceManager *IM = CInterfaceManager::getInstance ();
3795 // Insert the user into PACS at his saved position
3796 pacsPos(pos());
3797
3798 // update
3799 if(!_WaitForAppearance)
3800 {
3801 // Visual properties A
3802 sint64 prop = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E"+toString("%d", _Slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->getValue64();
3803 updateVisualPropertyVpa(0, prop); // Vpa udapte vpb and vpc too.
3804 }
3805 }// load //
3806
3807
3808 //---------------------------------------------------
3809 void CUserEntity::CInvisibleObserver::update(ICDBNode* node)
3810 {
3811 UserEntity->buildInSceneInterface();
3812 }
3813
3814 //---------------------------------------------------
3815 void CUserEntity::CSkillPointsObserver::update(ICDBNode* node )
3816 {
3817 if (FarTP.isFarTPInProgress() || IngameDbMngr.initInProgress()) // prevent from displaying at the beginning of a FarTP (due to RESET_BANK or CDB resetData())
3818 return;
3819
3820 CInterfaceManager *pIM = CInterfaceManager::getInstance ();
3821 CCDBNodeLeaf *leaf = dynamic_cast<CCDBNodeLeaf*>(node);
3822 if (leaf)
3823 {
3824 sint32 oldValue = leaf->getOldValue32();
3825 if (oldValue != 0)
3826 {
3827 sint delta = leaf->getValue32()-oldValue;
3828 string deltaStr = toString("%+d", delta);
3829
3830 // get the sp title
3831 const string &spTitle = CI18N::get(toString("uiSkillPointsBold%d",SpType));
3832
3833 // run the popup
3834 CAHManager::getInstance()->runActionHandler("message_popup", NULL, "text1="+deltaStr+"|text0="+spTitle);
3835
3836 // Context help
3837 contextHelp ("skill_point");
3838 }
3839 }
3840 }
3841
3842
3843 //---------------------------------------------------
3844 // CFameObserver::update
3845 //---------------------------------------------------
3846 void CUserEntity::CFameObserver::update(ICDBNode* node )
3847 {
3848 CSkillManager *pSM = CSkillManager::getInstance();
3849 CCDBNodeLeaf *leaf = dynamic_cast<CCDBNodeLeaf*>(node);
3850 if (leaf)
3851 {
3852 sint32 fameValue = leaf->getValue32();
3853 pSM->tryToUnblockTitleFromMinFames( FactionIndex, fameValue );
3854 pSM->tryToUnblockTitleFromMaxFames( FactionIndex, fameValue );
3855 }
3856 }
3857
3858
3859 //---------------------------------------------------
3860 void CUserEntity::makeTransparent(bool t)
3861 {
3862 CPlayerCL::makeTransparent(t);
3863
3864 uint32 opaMin= getOpacityMin();
3865 uint8 opacity = (uint8)(opaMin + (255-opaMin) * (1.0 - _TranspFactor));
3866
3867 getFace()->makeInstanceTransparent(opacity, (uint8)opaMin);
3868 }// makeTransparent //
3869
3870 //---------------------------------------------------
3871 void CUserEntity::setDiffuse(bool onOff, NLMISC::CRGBA diffuse)
3872 {
3873 CPlayerCL::setDiffuse(onOff, diffuse);
3874 getFace()->setDiffuse(onOff, diffuse);
3875 }
3876
3877
3878
3879
3880 // Helper for CUserEntity::extractRM()
3881 bool findExtractionActionInMemory( CSPhraseManager *pm, CSBrickManager *bm, uint memoryLine, uint& index )
3882 {
3883 uint x;
3884 for ( x=0; x!=PHRASE_MAX_MEMORY_SLOT; ++x )
3885 {
3886 uint32 phraseSlot = pm->getMemorizedPhrase( memoryLine, x );
3887 const CSPhraseCom& phraseCom = pm->getPhrase( phraseSlot );
3888 if ( ! phraseCom.empty() )
3889 {
3890 CSBrickSheet *brickSheet = bm->getBrick( phraseCom.Bricks[0] );
3891 if ( brickSheet->isForageExtraction() && (!brickSheet->MandatoryFamilies.empty()) ) // assumes care root bricks have not mandatories
3892 {
3893 index = x;
3894 return true;
3895 }
3896 }
3897 }
3898 return false;
3899 }
3900
3901 //---------------------------------------------------
3902 void CUserEntity::extractRM()
3903 {
3904 CSPhraseManager *pm = CSPhraseManager::getInstance();
3905 uint index;
3906 uint memoryLine;
3907 bool autoFindPhrase = (_MoveToPhraseMemoryLine == std::numeric_limits<uint>::max());
3908 if ( ! autoFindPhrase )
3909 {
3910 // Use clicked phrase
3911 memoryLine = _MoveToPhraseMemoryLine;
3912 index = _MoveToPhraseMemorySlot;
3913 }
3914 else
3915 {
3916 // Find the first extraction phrase in the memory bar
3917 CSBrickManager *bm = CSBrickManager::getInstance();
3918 memoryLine = pm->getSelectedMemoryLineDB();
3919 if ( ! findExtractionActionInMemory( pm, bm, memoryLine, index ) )
3920 {
3921 // Search in other memory bar lines (because the auto-equip does not set the current line at once)
3922 memoryLine = std::numeric_limits<uint>::max();
3923 uint nbLines = pm->getNbMemoryLines();
3924 for ( uint j=0; j!=nbLines; ++j )
3925 {
3926 if ( j == memoryLine )
3927 continue;
3928 if ( findExtractionActionInMemory( pm, bm, j, index ) )
3929 {
3930 memoryLine = j;
3931 break;
3932 }
3933 }
3934 }
3935 }
3936
3937 if ( memoryLine != std::numeric_limits<uint>::max() )
3938 {
3939 // Open the forage (but not for care actions). Necessary for the case of redoing an extraction after a Drop All on the same source.
3940 uint32 phraseId = pm->getMemorizedPhrase( memoryLine, index );
3941 if ( phraseId != 0 )
3942 {
3943 const CSPhraseCom& phraseCom = pm->getPhrase( phraseId );
3944 if ( ! phraseCom.empty() )
3945 {
3946 CSBrickSheet *rootBrick = CSBrickManager::getInstance()->getBrick( phraseCom.Bricks[0] );
3947 if ( rootBrick )
3948 {
3949 if ( rootBrick->IndexInFamily == 1 ) // only extracting actions
3950 CTempInvManager::getInstance()->open( TEMP_INV_MODE::Forage );
3951 }
3952 }
3953 }
3954
3955 // Cast the extraction. if autoFindPhrase, clientExecute() not already called.
3956 if ( autoFindPhrase )
3957 {
3958 // decide now if cyclic or not
3959 _MoveToPhraseCyclic= true;
3960 if(pm->avoidCyclicForPhrase(pm->getMemorizedPhrase(memoryLine, index)))
3961 _MoveToPhraseCyclic= false;
3962
3963 // execute on client now
3964 pm->clientExecute( memoryLine, index, _MoveToPhraseCyclic);
3965 }
3966
3967 // execute on server
3968 pm->sendExecuteToServer( memoryLine, index, _MoveToPhraseCyclic );
3969
3970 // Because sendExecuteToServer() has been called, must NOT cancelClientExecute() at resetAnyMoveTo()
3971 _MoveToAction= CUserEntity::None;
3972 }
3973 else
3974 {
3975 CInterfaceManager::getInstance()->displaySystemInfo( CI18N::get("uiExtractionPhraseMissing"), "CHK" );
3976 return;
3977 }
3978 }
3979
3980
3981 // ***************************************************************************
3982 bool CUserEntity::canCastShadowMap() const
3983 {
3984 if(!CCharacterCL::canCastShadowMap())
3985 return false;
3986
3987 // don't cast shadow in first person, but in death mode (third person actually...)
3988 return viewMode() != FirstPV || UserControls.mode() == CUserControls::DeathMode;
3989 }
3990
3991
3992 // ***************************************************************************
3993 void CUserEntity::forceLookEntity(const NLMISC::CVectorD &dir2targIn, bool updateHeadPitch, bool /* start */)
3994 {
3995 CVectorD dir2targ= dir2targIn;
3996 float frontYawBefore = 0.f;
3997 float frontYawAfter;
3998
3999 // Third person: bkup current yaw
4000 if(viewMode()==ThirdPV)
4001 {
4002 frontYawBefore = frontYaw();
4003 }
4004
4005
4006 // **** Look at the entity
4007 dir2targ.normalize();
4008 front(dir2targ, false, false);
4009
4010
4011 // **** FirstPerson
4012 if(viewMode() == FirstPV)
4013 {
4014 if(updateHeadPitch && _FollowForceHeadPitch)
4015 {
4016 // rotate the head to the target
4017 CEntityCL *target = EntitiesMngr.entity(targetSlot());
4018 if(target)
4019 {
4020 // Both Z must be correct
4021 snapToGround();
4022 target->snapToGround();
4023
4024 // don't update to the real head position each frame (else jitter too much cause of target anim)
4025 CVector targetPos= target->pos() + CVector(0,0,_FollowHeadOffset);
4026
4027 // then look at this target
4028 CVector dirToTarget = targetPos - (pos()+CVector(0,0, UserEntity->eyesHeight()));
4029 if((dirToTarget.x != 0.0f) || (dirToTarget.y!=0.0f))
4030 {
4031 dirToTarget.normalize();
4032 setHeadPitch(atan2(dirToTarget.z, sqrt(sqr(dirToTarget.x)+sqr(dirToTarget.y))));
4033 }
4034
4035 // TestYoyo
4036 /*if(ClientCfg.Fly!=0.f)
4037 {
4038 nlinfo("Uy: %.3f. Hp: %.3f. UPos:(%.3f,%.3f,%.3f). TPos:(%.3f,%.3f,%.3f)",
4039 UserEntity->frontYaw(), UserEntity->getHeadPitch(), pos().x, pos().y, pos().z,
4040 targetPos.x, targetPos.y, targetPos.z);
4041 static float uy=0.f;
4042 static float hp=0.f;
4043 if( fabs(fmod(UserEntity->frontYaw()-uy, 2*Pi))>ClientCfg.Fly ||
4044 fabs(fmod(UserEntity->getHeadPitch()-hp, 2*Pi))>ClientCfg.Fly )
4045 {
4046 nlinfo("YOYOBREAK: ^^^^^^^^^^");
4047 }
4048 uy=UserEntity->frontYaw();
4049 hp=UserEntity->getHeadPitch();
4050 }*/
4051 }
4052 }
4053 }
4054 // **** Third person
4055 else if(viewMode()==ThirdPV)
4056 {
4057 // keep the current effective yaw. ONLY if no SmoothResetCameraYaw forced
4058 if(!UserControls.isResetSmoothCDYForced())
4059 {
4060 frontYawAfter = frontYaw();
4061 float deltaYaw= frontYawAfter - frontYawBefore;
4062
4063 // compensate rotation (NB: it stops also any SmoothReset)
4064 UserControls.appendCameraDeltaYaw(-deltaYaw);
4065 }
4066 }
4067
4068 // when looking to an entity, if automatic camera, center the view on it.
4069 if( ClientCfg.AutomaticCamera /*&& start*/ )
4070 {
4071 UserControls.resetSmoothCameraDeltaYaw();
4072 }
4073 }
4074
4075
4076 // ***************************************************************************
4077 void CUserEntity::startForceLookEntity(CLFECOMMON::TCLEntityId slot)
4078 {
4079 // Start a new follow: force head pitch to follow by default
4080 _FollowForceHeadPitch= true;
4081 // if a follow is started in first person, reset CameraYaw
4082 if(viewMode()==FirstPV)
4083 UserControls.resetCameraDeltaYaw();
4084
4085 // reorient now (important else may have a time shift because of resetCameraDeltaYaw above)
4086 CEntityCL *target = EntitiesMngr.entity(slot);
4087 if(target)
4088 {
4089 /* For complex reason, the target may not be still snapped on the ground. snap it now
4090 - this is because in common case, entities are snap only if they are visible (for speed up)
4091 => depends on camera
4092 - but in this case, the camera depends on real entity position (headPitch in first person)
4093 */
4094 target->snapToGround();
4095
4096 // For FirstPerson targeting. Get the current target head offset
4097 _FollowHeadOffset= 0.f;
4098 CVector headPos;
4099 if(target->getHeadPos(headPos))
4100 {
4101 _FollowHeadOffset= headPos.z - float(target->pos().z);
4102 }
4103
4104 // Look at the entity
4105 CVectorD dir2targ = target->pos() - pos();
4106 dir2targ.z = 0.0;
4107 if(dir2targ!=CVectorD::Null)
4108 {
4109 forceLookEntity(dir2targ, true, true);
4110 }
4111 }
4112 }
4113
4114
4115 // ***************************************************************************
4116 void CUserEntity::stopForceHeadPitchInFollow()
4117 {
4118 _FollowForceHeadPitch= false;
4119 }
4120
4121 // ***************************************************************************
4122 void CUserEntity::switchVelocity(bool userRequest)
4123 {
4124 if (ClientCfg.R2EDEnabled && R2::getEditor().getMode() == R2::CEditor::EditionMode)
4125 {
4126 // when in the R2 editor, force to run all the time
4127 _Run = true;
4128 }
4129 else
4130 {
4131 _Run = !_Run;
4132 }
4133 _CurrentVelocity = _Run ? runVelocity() : walkVelocity();
4134
4135 if (userRequest)
4136 {
4137 _RunWhenAble = _Run;
4138 }
4139
4140 // display message : your are running, you are walking
4141 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4142 string msg;
4143 if( _Run )
4144 msg = CI18N::get("msgUserIsRunning");
4145 else
4146 msg = CI18N::get("msgUserIsWalking");
4147 string cat = getStringCategory(msg, msg);
4148 pIM->displaySystemInfo(msg, cat);
4149
4150 // Write to the UI database, to update views
4151 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:PLAYER_RUNNING", false);
4152 if(node)
4153 node->setValue32(_Run);
4154 }
4155
4156 //-----------------------------------------------
4157 // autoEquipWithLastUsedWeapons
4158 //
4159 //-----------------------------------------------
4160 void CUserEntity::autoEquipWithLastUsedWeapons()
4161 {
4162 CInventoryManager *inv = CInventoryManager::getInstance();
4163 if ( !inv )
4164 {
4165 return;
4166 }
4167
4168 // Clear hands
4169 inv->unequip( "LOCAL:INVENTORY:HAND:1" );
4170 inv->unequip( "LOCAL:INVENTORY:HAND:0" );
4171
4172 uint ir,il;
4173 // Equip right hand
4174 if( _PreviousRightHandItem.Sheet != 0 )
4175 {
4176 // find item in bag with same properties than last used one in right hand
4177 for ( ir=0; ir<MAX_BAGINV_ENTRIES; ++ir )
4178 {
4179 if( _PreviousRightHandItem.Sheet == inv->getBagItem(ir).getSheetID() &&
4180 _PreviousRightHandItem.Quality == inv->getBagItem(ir).getQuality() &&
4181 _PreviousRightHandItem.Weight == inv->getBagItem(ir).getWeight() &&
4182 _PreviousRightHandItem.NameId == inv->getBagItem(ir).getNameId() )
4183 {
4184 break;
4185 }
4186 }
4187 if ( ir != MAX_BAGINV_ENTRIES )
4188 {
4189 // Equip right hand
4190 string bagPath = toString( "LOCAL:INVENTORY:BAG:%u", ir );
4191 inv->equip( bagPath, "LOCAL:INVENTORY:HAND:0" );
4192
4193 // Equip left hand if needed
4194 if( _PreviousLeftHandItem.Sheet != 0 )
4195 {
4196 for ( il=0; il<MAX_BAGINV_ENTRIES; ++il )
4197 {
4198 if( il != ir &&
4199 _PreviousLeftHandItem.Sheet == inv->getBagItem(il).getSheetID() &&
4200 _PreviousLeftHandItem.Quality == inv->getBagItem(il).getQuality() &&
4201 _PreviousLeftHandItem.Weight == inv->getBagItem(il).getWeight() &&
4202 _PreviousLeftHandItem.NameId == inv->getBagItem(il).getNameId() )
4203 {
4204 break;
4205 }
4206 }
4207 if ( il != MAX_BAGINV_ENTRIES )
4208 {
4209 bagPath = toString( "LOCAL:INVENTORY:BAG:%u", il );
4210 inv->equip( bagPath, "LOCAL:INVENTORY:HAND:1" );
4211 }
4212 }
4213 return;
4214 }
4215 }
4216
4217
4218 // TODO : choose the best one
4219
4220 }
4221
4222
4223 // ***************************************************************************
4224 void CUserEntity::executeCombatWithPhrase(CEntityCL *target, uint32 memoryLine, uint32 memoryIndex, bool cyclic)
4225 {
4226 nlassert(target);
4227 CSPhraseManager *pPM= CSPhraseManager::getInstance();
4228
4229 // is a melee combat?
4230 bool meleeCombat = false;
4231 // empty hand => yes!
4232 meleeCombat= true;
4233 uint32 rightHandSheet = getInventory().getRightHandItemSheet();
4234 if(rightHandSheet)
4235 meleeCombat = getInventory().isMeleeWeaponItem(rightHandSheet);
4236
4237 // If melee combat, and if the user entity is not well placed for fight, or if it has changed his target
4238 if( meleeCombat &&
4239 (
4240 !target->isPlacedToFight(pos(), front(), attackRadius() + ClientCfg.AttackDist) ||
4241 target->slot()!=_LastExecuteCombatSlot
4242 )
4243 )
4244 {
4245 _LastExecuteCombatSlot= target->slot();
4246
4247 // Cancel any follow
4248 disableFollow();
4249
4250 // Launch the moveToCombatPhrase, canceling any old action client execution.
4251 // NB: this will also force him to look at the entity
4252 moveToCombatPhrase(target->slot(), 2.0, memoryLine, memoryIndex, cyclic);
4253
4254 // And after (order is important), start the phrase execution on client
4255 pPM->clientExecute(memoryLine, memoryIndex, cyclic);
4256 }
4257 else
4258 {
4259 // Cancel any moveTo(), because don't want to continue reaching the prec entity
4260 // VERY important if previous MoveTo was a SPhrase MoveTo (because cancelClientExecute() must be called)
4261 resetAnyMoveTo();
4262
4263 // start client execution: NB: start client execution even if it
4264 pPM->clientExecute(memoryLine, memoryIndex, cyclic);
4265
4266 // inform Server of phrase cast
4267 pPM->sendExecuteToServer(memoryLine, memoryIndex, cyclic);
4268
4269 if( !meleeCombat && !cyclic )
4270 {
4271 pPM->executeDefaultAttack();
4272 }
4273 }
4274 }
4275
4276 // ***************************************************************************
4277 void CUserEntity::beginCast(const MBEHAV::CBehaviour &behaviour)
4278 {
4279 if(viewMode()==ThirdPV)
4280 {
4281 // backup front yaw
4282 float frontYawBefore = frontYaw();
4283 // begin cast
4284 CCharacterCL::beginCast( behaviour );
4285 // compensate the front change using a camera move
4286 float frontYawAfter = frontYaw();
4287 float deltaYaw= frontYawAfter - frontYawBefore;
4288 UserControls.appendCameraDeltaYaw(-deltaYaw);
4289 // if automatic camera, center the view behind the user
4290 if( ClientCfg.AutomaticCamera )
4291 {
4292 UserControls.resetSmoothCameraDeltaYaw();
4293 }
4294 }
4295 else
4296 {
4297 // in first person mode, reset the delta yaw
4298 UserControls.resetCameraDeltaYaw();
4299 CCharacterCL::beginCast( behaviour );
4300 }
4301 }
4302
4303 // ***************************************************************************
4304 void CUserEntity::updatePreCollision(const NLMISC::TTime &time, CEntityCL *target)
4305 {
4306 CPlayerCL::updatePreCollision(time, target);
4307
4308 // test each frame if the mode has changed
4309 if(SoundMngr)
4310 {
4311 // Play/stop music if comes from or goes to dead
4312 bool isDead = _Mode == MBEHAV::DEATH || _Mode == MBEHAV::SWIM_DEATH;
4313
4314 // must start music?
4315 if (isDead && SoundMngr->getEventMusicPlayed() != ClientCfg.DeathMusic)
4316 {
4317 SoundMngr->playEventMusic(ClientCfg.DeathMusic, 0, true);
4318 }
4319
4320 // must end music?
4321 if (!isDead && SoundMngr->getEventMusicPlayed() == ClientCfg.DeathMusic)
4322 {
4323 SoundMngr->stopEventMusic(ClientCfg.DeathMusic, CSoundManager::LoadingMusicXFade);
4324 }
4325 }
4326 }
4327
4328 // ***************************************************************************
4329 void CUserEntity::buildTotem()
4330 {
4331 const string msgName = "TOTEM:BUILD";
4332 CBitMemStream out;
4333 if( GenericMsgHeaderMngr.pushNameToStream( msgName, out ) )
4334 {
4335 NetMngr.push( out );
4336 nlinfo( "sending TOTEM:build message to server" );
4337 }
4338 }
4339
4340 // ***************************************************************************
4341 void CUserEntity::setR2CharMode(R2::TCharMode mode)
4342 {
4343 if (mode == R2::TCharMode::Editer || mode == R2::TCharMode::Dm)
4344 {
4345 _R2CharMode= mode;
4346 walkVelocity(ClientCfg.DmWalk);
4347 runVelocity(ClientCfg.DmRun);
4348 View.setCameraDistanceMaxForDm();
4349 CEntityCL *user = EntitiesMngr.entity(0);
4350 NLPACS::UMovePrimitive* prim = user?user->getPrimitive():0;
4351 if (prim)
4352 {
4353 prim->setObstacle(false);
4354 }
4355
4356 }
4357 else if (mode == R2::TCharMode::Player || mode == R2::TCharMode::Tester)
4358 {
4359 _R2CharMode= mode;
4360 walkVelocity(ClientCfg.Walk);
4361 runVelocity(ClientCfg.Run);
4362 View.setCameraDistanceMaxForPlayer();
4363 CEntityCL *user = EntitiesMngr.entity(0);
4364 NLPACS::UMovePrimitive* prim = user?user->getPrimitive():0;
4365 if (prim)
4366 {
4367 prim->setObstacle(true);
4368 }
4369 }
4370 else
4371 {
4372 nlwarning("R2Ed: Error Char Mode not handled %u", (uint32)mode.getValue());
4373 }
4374 }
4375
4376 bool CUserEntity::isInNpcControl() const
4377 {
4378 CInterfaceManager* pIM = CInterfaceManager::getInstance();
4379 CCDBNodeLeaf *sheet = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:SHEET", false);
4380 return sheet && NLMISC::CSheetId(sheet->getValue32())!=NLMISC::CSheetId::Unknown;
4381 }
4382
4383
4384 void CUserEntity::updateNpcContolSpeed()
4385 {
4386 CInterfaceManager* pIM = CInterfaceManager::getInstance();
4387 CCDBNodeLeaf *sheet = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:SHEET", false);
4388 CCDBNodeLeaf *walk = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:WALK", false);
4389 CCDBNodeLeaf *run = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:NPC_CONTROL:RUN", false);
4390 if (!sheet || !walk || !run)
4391 {
4392 return;
4393 }
4394
4395 static NLMISC::CSheetId oldSheet = NLMISC::CSheetId::Unknown;
4396 static float oldRun=0.f;
4397 static float oldWalk=0.f;
4398
4399 NLMISC::CSheetId sheetId(sheet->getValue32());
4400 float newRun = float(run->getValue32()) / 1000.0f;
4401 float newWalk = float(walk->getValue32()) / 1000.0f;
4402
4403 if (sheetId == oldSheet && oldRun == newRun && oldWalk == newWalk )
4404 {
4405 return;
4406 }
4407
4408 oldSheet = sheetId;
4409 oldRun = newRun;
4410 oldWalk = newWalk;
4411
4412 if (sheetId != NLMISC::CSheetId::Unknown)
4413 {
4414 walkVelocity(newWalk);
4415 runVelocity(newRun);
4416 }
4417 else
4418 {
4419 setR2CharMode(_R2CharMode);
4420 }
4421
4422 }
4423
4424 //-----------------------------------------------
4425 // cancelAllPhrases
4426 //-----------------------------------------------
4427 void CUserEntity::cancelAllPhrases()
4428 {
4429 CBitMemStream out;
4430 if(GenericMsgHeaderMngr.pushNameToStream("PHRASE:CANCEL_ALL", out))
4431 {
4432 NetMngr.push(out);
4433 }
4434 else
4435 {
4436 nlwarning("<CUserEntity::cancelAllPhrases> unknown message name '%s'", "PHRASE:CANCEL_ALL");
4437 }
4438 }
4439
4440
4441 //-----------------------------------------------
4442 // canChangeFront
4443 //-----------------------------------------------
4444 bool CUserEntity::canChangeFront()
4445 {
4446 return !(_CurrentBehaviour.Behaviour == MBEHAV::EXTRACTING
4447 || (_CurrentBehaviour.Behaviour == MBEHAV::RANGE_ATTACK && _Mode==MBEHAV::COMBAT && !UserControls.isMoving())
4448 || (_CurrentBehaviour.Behaviour >= MBEHAV::MAGIC_CASTING_BEHAVIOUR_BEGIN && _CurrentBehaviour.Behaviour <= MBEHAV::MAGIC_CASTING_BEHAVIOUR_END));
4449 }
4450
4451
4452 //-----------------------------------------------
4453 // rememberWeaponsInHand
4454 //
4455 //-----------------------------------------------
4456 void CUserEntity::rememberWeaponsInHand()
4457 {
4458 CInventoryManager * inv = CInventoryManager::getInstance();
4459 if( !inv )
4460 {
4461 return;
4462 }
4463
4464 // keep right hand item
4465 CItemImage * rightItemImg = inv->getHandItem(0);
4466 if( rightItemImg )
4467 {
4468 if( inv->isMeleeWeaponItem(rightItemImg->getSheetID()) || inv->isRangeWeaponItem(rightItemImg->getSheetID()) )
4469 {
4470 _PreviousRightHandItem = CItemSnapshot(*rightItemImg);
4471
4472 // keep left hand item too (could be ammo, second weapon, etc ..)
4473 CItemImage * leftItemImg = inv->getHandItem(1);
4474 if( leftItemImg )
4475 {
4476 _PreviousLeftHandItem = CItemSnapshot(*leftItemImg);
4477 }
4478 else
4479 {
4480 _PreviousLeftHandItem = CItemSnapshot();
4481 }
4482 }
4483 }
4484 }
4485
4486
4487 //-----------------------------------------------
4488 // snapshot of a CItemImage
4489 //
4490 //-----------------------------------------------
4491 CUserEntity::CItemSnapshot::CItemSnapshot( const CItemImage& i )
4492 {
4493 Sheet = i.getSheetID();
4494 Quality = i.getQuality();
4495 Quantity = i.getQuantity();
4496 UserColor = i.getUserColor();
4497 Price = i.getPrice();
4498 Weight = i.getWeight();
4499 NameId = i.getNameId();
4500 InfoVersion = i.getInfoVersion();
4501 }
4502
4503 sint CUserEntity::getLevel() const
4504 {
4505 CInterfaceManager *pIM = CInterfaceManager::getInstance();
4506 sint level = -1;
4507 for(uint i=0;i<EGSPD::CSPType::EndSPType;i++)
4508 {
4509 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:USER:SKILL_POINTS_%d:VALUE", i), false);
4510 if(node)
4511 {
4512 level = std::max(level, (sint) node->getValue32());
4513 }
4514 }
4515 return level;
4516 }
4517
4518 //-----------------------------------------------
4519 // interlocutor
4520 //-----------------------------------------------
4521 void CUserEntity::interlocutor( const CLFECOMMON::TCLEntityId &slot)
4522 {
4523 CLFECOMMON::TCLEntityId prevInterlocutor = _Interlocutor;
4524 _Interlocutor = slot;
4525
4526 // Refresh (hide or unhide) the icon for the interlocutor NPC
4527 if (prevInterlocutor != CLFECOMMON::INVALID_SLOT)
4528 EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(prevInterlocutor);
4529 if (_Interlocutor != CLFECOMMON::INVALID_SLOT)
4530 EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(_Interlocutor);
4531 }
4532
4533 //-----------------------------------------------
4534 // trader
4535 //-----------------------------------------------
4536 void CUserEntity::trader(const CLFECOMMON::TCLEntityId &slot)
4537 {
4538 CLFECOMMON::TCLEntityId prevTrader = _Trader;
4539 _Trader = slot;
4540
4541 // Refresh (hide or unhide) the icon for the trader NPC
4542 if (prevTrader != CLFECOMMON::INVALID_SLOT)
4543 EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(prevTrader);
4544 if (_Trader != CLFECOMMON::INVALID_SLOT)
4545 EntitiesMngr.refreshInsceneInterfaceOfFriendNPC(_Trader);
4546 }
4547