?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Resolve "Toggle Free Look with Hotkey"
[ryzomcore.git] / ryzom / server / src / gpm_service / world_entity.h
blobaad4c4f4888c6aa2b3bb958b0f9c4642ca4faf47
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17
18
19 #ifndef NL_WORLD_ENTITY_H
20 #define NL_WORLD_ENTITY_H
21
22 #include "nel/misc/types_nl.h"
23 #include "nel/misc/block_memory.h"
24 #include "nel/misc/debug.h"
25 #include "nel/misc/time_nl.h"
26
27 #include "nel/pacs/u_move_container.h"
28 #include "nel/pacs/u_move_primitive.h"
29
30 #include "gpm_utilities.h"
31 #include "gpm_defs.h"
32
33 #include "game_share/mirror_prop_value.h"
34 #include "game_share/ryzom_mirror_properties.h"
35 #include "server_share/msg_gpm_service.h"
36
37 #include <deque>
38
39 class CCell;
40 class CPlayerInfos;
41 class CWorldEntity;
42
43 typedef std::list<CWorldEntity*> TWorldEntityList;
44
45 struct CVisionEntry
46 {
47
48 CVisionEntry() { }
49 CVisionEntry(CWorldEntity* e, uint32 m, uint32 d) : Entity(e), Mask(m), Distance(d) { }
50
51 CWorldEntity* Entity;
52 uint32 Mask;
53 uint32 Distance;
54 };
55
56 /**
57 * World entity contained all properties positions in world for an entity
58 * \author Alain Saffray
59 * \author Nevrax France
60 * \date 2002
61 */
62 class CWorldEntity
63 {
64 friend class NLMISC::CBlockMemory<CWorldEntity>;
65
66 public:
67 typedef CSimpleSmartPointer<CWorldEntity> CWorldEntitySmartPointer;
68
69 enum TEntityType
70 {
71 Player = 0,
72 Object,
73 Trigger,
74 AI,
75 Unknown
76 };
77
78 /*
79 enum TVisionState // Enum of vision state for this entity
80 {
81 Ready = 0, // ready to use
82 Checked, // in check
83 Seen, // entity is seen by another
84 };
85 */
86
87 public:
88
89 NLMISC::CEntityId Id; // Id of entity
90 TDataSetRow Index;
91
92 CMirrorPropValue1DS<TYPE_POSX> X; // Coordinate X in world in unit
93 CMirrorPropValue1DS<TYPE_POSY> Y; // Coordinate Y in world in unit
94 CMirrorPropValue1DS<TYPE_POSZ> Z; // Coordinate Z in world in unit
95 CMirrorPropValue1DS<TYPE_POSX> LocalX; // Local Coordinate X in world in unit
96 CMirrorPropValue1DS<TYPE_POSY> LocalY; // Local Coordinate X in world in unit
97 CMirrorPropValue1DS<TYPE_POSZ> LocalZ; // Local Coordinate X in world in unit
98 CMirrorPropValue1DS<TYPE_ORIENTATION> Theta; // Heading in world
99 CMirrorPropValue1DS<TYPE_SHEET> Sheet; // Id sheet of entity
100 CMirrorPropValue1DS<NLMISC::TGameCycle> Tick; // GameCycle of other properties
101 CMirrorPropValue1DS<TYPE_CELL> Cell; // Current XY Cell where entity is
102 CMirrorPropValue1DS<TYPE_VISION_COUNTER> VisionCounter; // Number of times this entity is seen by players
103 uint32 PlayersSeeingMe;
104 CWorldEntity* ClosestPlayer;
105
106 CMirrorPropValue1DS<TYPE_WHO_SEES_ME> WhoSeesMe;
107
108 bool Dead; // Are player dead or alive
109
110 uint32 PatatEntryIndex; // The patat entry for the _PatatSubscribeManager
111
112 CCell *CellPtr; // pointer on cell where entity is
113
114 TWorldEntityList::iterator ListIterator; // Iterator on entity in world entity list
115 TWorldEntityList::iterator PrimIterator; // Iterator on entity in prmitived entity list
116
117 uint8 Continent; // index on the continent on which the player is located
118 bool PosInitialised; // Pos was initialised by mirror
119 bool UsePrimitive; // entity uses a primitive normally
120 bool ForceUsePrimitive; // forces entity to use a primitive temporarily (mount, etc.)
121 NLPACS::UMovePrimitive *Primitive; // Primitive for collision systeme (PACS)
122 NLPACS::UMoveContainer *MoveContainer; // MoveContainer entity is in
123 uint32 TickLock;
124
125 CWorldEntitySmartPointer Previous;
126 CWorldEntitySmartPointer Next;
127
128 CPlayerInfos *PlayerInfos; // The player infos associated to this entity (if there is some)
129
130 CWorldEntitySmartPointer Parent; // Which is entity we are in/on (ex: mount, ferry)
131 std::vector<CWorldEntitySmartPointer> Children; // Which are the child we contain
132 CWorldEntitySmartPointer Control; // Which entity is controlling us (ex: rider, pilot...)
133
134 bool ForceDontUsePrimitive; // forces entity not to use a primitive temporarily (mount, etc.)
135 bool CheckMotion;
136 bool HasVision; // Entity has vision
137
138 std::vector<CEntitySheetId> Content;
139
140 bool TempVisionState; // temporary flag for vision delta, telling if the entity is now visible
141 bool TempControlInVision; // temporary flag for vision delta, telling if the controller entity (if any) is in vision
142 bool TempParentInVision; // temporary flag for vision delta, telling if the parent (controlled) entity (if any) is in vision
143
144 sint32 RefCounter; // Number of references on this entity -- used by smart pointer
145
146 public:
147 /**
148 * destructor
149 */
150 ~CWorldEntity();
151
152 /**
153 * Init
154 * \param id is entity's CEntityId
155 */
156 void init( const NLMISC::CEntityId& id, const TDataSetRow &index );
157
158 /**
159 * Display debug
160 */
161 void display(NLMISC::CLog *log = NLMISC::InfoLog) const;
162
163 /**
164 * create primitive for fiche type entity
165 * \param ficheId is sheet type Id of entity
166 * \param pMoveContainer adress of the move container
167 * \param worldImage numvber of the world image in which the primitive is to be inserted
168 * \return pointer on PACS primitve
169 */
170 void createPrimitive(NLPACS::UMoveContainer *pMoveContainer, uint8 worldImage);
171
172 /**
173 * Removes primitive allocated previously
174 */
175 void removePrimitive();
176
177
178 /**
179 * removes entity from the cell it is in
180 */
181 //void removeFromCellAsEntity();
182
183 /**
184 * removes object from the cell it is in
185 */
186 //void removeFromCellAsObject();
187
188
189 /// Test if entity is linked in a cell
190 bool isLinked() const { return CellPtr != NULL; }
191
192 /// Get (const) CCell point in which entity is
193 const CCell* getCell() const { return CellPtr; }
194
195
196 /// Tests if entity uses a pacs primitive
197 bool hasPrimitive() const { return Primitive != NULL && !ForceDontUsePrimitive; }
198
199 /// local motion
200 bool localMotion() const { return Parent != NULL; }
201
202 /// has control ?
203 bool hasControl() const { return Parent != NULL && Parent->Control == this; }
204
205 /// is controlled ?
206 bool isControlled() const { return Control != NULL; }
207
208 /// has children
209 bool hasChildren() const { return !Children.empty(); }
210
211 /// remove from children
212 void removeFromChildren(CWorldEntity *entity)
213 {
214 std::vector<CWorldEntitySmartPointer>::iterator it;
215 for (it=Children.begin(); it!=Children.end(); ++it)
216 if ((CWorldEntity*)(*it) == entity)
217 it = Children.erase(it);
218
219 entity->Parent = NULL;
220 Control = NULL;
221 }
222
223 /// get controlled
224 CWorldEntity *getControlled()
225 {
226 if (!hasControl())
227 return NULL;
228
229 CWorldEntity *parent = Parent;
230 while (parent->hasControl())
231 parent = parent->Parent;
232
233 return parent;
234 }
235
236 /// update local or global position
237 void updatePosition(sint32 x, sint32 y, sint32 z, float theta, NLMISC::TGameCycle cycle, bool interior, bool water)
238 {
239 if (localMotion())
240 {
241 LocalX = x;
242 LocalY = y;
243 LocalZ = z;
244
245 setPosition(x + Parent->X(), y + Parent->Y(), z + Parent->Z(), true, interior, water);
246 }
247 else
248 {
249 setPosition(x, y, z, false, interior, water);
250 }
251
252 Tick = cycle;
253 Theta = theta;
254
255 // force position as valid
256 PosInitialised = true;
257 }
258
259 /// update global position for local motion
260 void updatePosition(bool interior, bool water)
261 {
262 if (localMotion())
263 {
264 setPosition(LocalX() + Parent->X(), LocalY() + Parent->Y(), LocalZ() + Parent->Z(), true, interior, water);
265 }
266 }
267
268 /// Set position
269 void setPosition(sint32 x, sint32 y, sint32 z, bool local, bool interior, bool water)
270 {
271 X = x;
272 Y = y;
273 Z = (z&(~7)) + (local ? 1 : 0) + (interior ? 2 : 0) + (water ? 4 : 0);
274 }
275
276 /// update position using move primitive
277 void updatePositionUsingMovePrimitive(uint wi);
278
279
280
281 /// get Type of the entity
282 TEntityType getType() const
283 {
284 return _Type;
285 }
286
287
288 private:
289
290 /// Is in interior
291 bool interior() const
292 {
293 return (Z()&2) != 0;
294 }
295
296 /// Type of the entity
297 TEntityType _Type;
298
299 public:
300
301 /// Creates a new entity (new equivalent). This must be initialised later using init();
302 static CWorldEntity* create();
303
304 /// Removes an entity (delete equivalent).
305 static void remove(CWorldEntity *entity);
306
307 protected:
308 /**
309 * Default constructor, used because of CBlockMemory
310 */
311 CWorldEntity() {}
312
313 private:
314
315 /// Static cell allocator
316 static NLMISC::CBlockMemory<CWorldEntity> _EntityAllocator;
317 };
318
319 //
320 typedef CWorldEntity::CWorldEntitySmartPointer CWorldEntityPtr;
321
322 /// A list of CWorldEntity, referred by smart pointers. First template param is the pointed type, second param is the pointer storage type (here smart pointer)
323 typedef CObjectList<CWorldEntity, CWorldEntityPtr> TEntityList;
324
325
326 /**
327 * Player Infos : contains all information specific to players (like vision and original front end)
328 * \author David Fleury
329 * \author Nevrax France
330 * \date 2002
331 */
332 class CPlayerInfos
333 {
334 friend class NLMISC::CBlockMemory<CPlayerInfos>;
335
336 public:
337 /// init
338 void init(const NLMISC::CEntityId &id, NLNET::TServiceId feId, CWorldEntity *entity)
339 {
340 WhoICanSee = 0xffffffff;
341
342 Next = NULL;
343 Previous = NULL;
344 ActivateSlot0 = false;
345 DesactivateSlot0 = false;
346 Slot0Active = false;
347
348 uint i;
349 for (i = MAX_SEEN_ENTITIES-1 ; i > 0; --i)
350 FreeSlots.push_back( i );
351
352 for (i = 0 ; i < MAX_SEEN_ENTITIES ; ++i)
353 Slots[i] = NULL;
354
355 LastVisionTick = 0;
356
357 _PlayerId = id;
358 FeId = feId;
359 Entity = entity;
360
361 CheckSpeed = true;
362 Indoor = false;
363 EnableVisionProcessing = true;
364 }
365
366 /// get playerId
367 inline const NLMISC::CEntityId &getPlayerId() const { return _PlayerId; }
368
369 /**
370 * Display debug
371 */
372 void display(NLMISC::CLog *log = NLMISC::InfoLog) const;
373
374 private:
375 /// the player Id
376 NLMISC::CEntityId _PlayerId;
377
378 /// default constructor
379 CPlayerInfos() { }
380
381 public:
382 /// original front end Id
383 NLNET::TServiceId FeId;
384
385 /// front end datas
386 TMapFrontEndData::iterator ItFrontEnd;
387
388 /// iterator in the update player list
389 TPlayerList::iterator ItUpdatePlayer;
390
391 /// tick at last vision update
392 NLMISC::TGameCycle LastVisionTick;
393
394 /// Delay vision till cycle
395 NLMISC::TGameCycle DelayVision;
396
397 ///
398 typedef CUnsafeConstantSizeStack<uint16, MAX_SEEN_ENTITIES+1> TSlotStack;
399
400 /// list of free slots for vision
401 TSlotStack FreeSlots;
402
403 /// The world entity for this player
404 CWorldEntityPtr Entity;
405
406 /// Previous player in list
407 CPlayerInfos* Previous;
408 /// Next player in list
409 CPlayerInfos* Next;
410
411 /// slots for this player
412 CWorldEntityPtr Slots[MAX_SEEN_ENTITIES];
413
414 bool ActivateSlot0;
415 bool DesactivateSlot0;
416 bool Slot0Active;
417
418 bool EnableVisionProcessing;
419
420 bool CheckSpeed;
421 bool Indoor;
422
423 /// Who I can see flag field
424 uint32 WhoICanSee;
425
426 #ifdef RECORD_LAST_PLAYER_POSITIONS
427 /// Distance history
428 std::deque< std::pair<NLMISC::CVectorD, uint> > DistanceHistory;
429 #endif
430
431 float meanSpeed() const
432 {
433 #ifdef RECORD_LAST_PLAYER_POSITIONS
434 float dist = 0.0f;
435 uint i;
436 for (i=0; i+1<DistanceHistory.size(); ++i)
437 {
438 double dx = DistanceHistory[i+1].first.x-DistanceHistory[i].first.x,
439 dy = DistanceHistory[i+1].first.y-DistanceHistory[i].first.y;
440
441 dist += (float)sqrt(dx*dx + dy*dy);
442 }
443
444 return DistanceHistory.size() > 1 ? (dist/(DistanceHistory.size()-1)) : 0.0f;
445 #else
446 return 0.0f;
447 #endif
448 }
449
450
451 struct CPlayerPos
452 {
453 NLMISC::TGameCycle AtTick;
454 NLPACS::UGlobalPosition GPos;
455 NLMISC::CVectorD Motion;
456 float Theta;
457 };
458
459 std::deque<CPlayerPos> PosHistory;
460
461 public:
462 /// Creates a new entity (new equivalent). This must be initialised later using init();
463 static CPlayerInfos *create() { return _PlayerAllocator.allocate(); }
464
465 /// Removes an entity (delete equivalent).
466 static void remove(CPlayerInfos *player) { _PlayerAllocator.freeBlock(player); }
467
468 private:
469
470 /// Static cell allocator
471 static NLMISC::CBlockMemory<CPlayerInfos> _PlayerAllocator;
472 };
473
474
475
476
477
478 #endif // NL_WORLD_ENTITY_H
479
480 /* End of world_entity.h */