ryzom/tools/reynolds/reynolds_manager.h

   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_REYNOLDS_MANAGER_H
  20 #define NL_REYNOLDS_MANAGER_H
  21
  22 // NeL
  23 #include "nel/misc/types_nl.h"
  24 #include "nel/misc/smart_ptr.h"
  25
  26 #include "nel/georges/u_form.h"
  27 #include "nel/georges/u_form_elm.h"
  28
  29 // Game share
  30 #include "game_share/continent_container.h"
  31
  32 // ReynoldsLib
  33 #include "track.h"
  34
  35 // Stl
  36 #include <map>
  37
  38
  39
  40
  41 /**
  42  * Track manager
  43  * \author Benjamin Legros
  44  * \author Nevrax France
  45  * \date 2002
  46  */
  47 class CReynoldsManager
  48 {
  49         friend CTrack::~CTrack();
  50
  51 public:
  52
  53         /**
  54          * User Motion controlled Callback type
  55          * \param track is the base track
  56          */
  57         typedef void    (*TUserCallback) (CTrackBase *track);
  58
  59         /**
  60          * User Motion Callback type
  61          * Called each time a controlled track is updated
  62          * \param track is the base track
  63          * \param motion is the current motion to be applied -- WARNING do not crash this value, only add or substract value to it
  64          */
  65         typedef void    (*TUserMotionCallback) (CTrackBase *track, NLMISC::CVectorD &motion);
  66
  67
  68         /// The command interface
  69         class ICommandInterface
  70         {
  71         public:
  72                 /**
  73                  * Called when manager needs a sheet for an entity.
  74                  * Reply using setSheet(CEntityId)
  75                  */
  76                 virtual void    requestSheet(const NLMISC::CEntityId &id) = 0;
  77
  78                 /**
  79                  * Called when manager needs a position for an entity.
  80                  * Reply using setPosition(CEntityId)
  81                  */
  82                 virtual void    requestPosition(const NLMISC::CEntityId &id) = 0;
  83
  84                 /**
  85                  * Called when manager needs a position to be updated evently
  86                  * Reply using setPosition(CEntityId) evently
  87                  */
  88                 virtual void    requestPositionUpdates(const NLMISC::CEntityId &id) = 0;
  89
  90                 /**
  91                  * Called when manager doesn't need more position updates
  92                  */
  93                 virtual void    unrequestPositionUpdates(const NLMISC::CEntityId &id) = 0;
  94
  95                 /**
  96                  * Called when manager needs an entity vision to be updated evently
  97                  * Reply using setVision() evently
  98                  */
  99                 virtual void    requestVision(const NLMISC::CEntityId &id) = 0;
 100
 101                 /**
 102                  * Called when manager doesn't need more entity vision updates
 103                  */
 104                 virtual void    unrequestVision(const NLMISC::CEntityId &id) = 0;
 105
 106                 /**
 107                  * Called when a track position is updated
 108                  */
 109                 virtual void    updatePosition(const NLMISC::CEntityId &id, const NLMISC::CVectorD &position, float &heading) = 0;
 110
 111                 /**
 112                  * Called when track state changed
 113                  */
 114                 virtual void    stateChanged(const NLMISC::CEntityId &id, CTrackBase::TTrackState state) = 0;
 115
 116                 /**
 117                  * Called when manager leave control of an entity
 118                  */
 119                 virtual void    stopTrack(const NLMISC::CEntityId &id) = 0;
 120         };
 121
 122 public:
 123
 124         /// @name Reynolds Manager inits/update/release
 125         //@{
 126
 127         /// Init
 128         static void     init(const std::string &packSheetFile = "reynolds.packed_sheets");
 129
 130
 131         /// Load continent
 132         static void     loadContinent(const std::string &name, const std::string &file, sint index);
 133
 134         /// Set Sheet request callback
 135         static void     setCommandInterface(ICommandInterface *commandInterface)        { _CommandInterface = commandInterface; }
 136
 137         /// Set User init callback
 138         static void     setUserInitCallback(TUserCallback cb)                                           { _UserInitCallback = cb; }
 139
 140         /// Set User motion callback
 141         static void     setUserMotionCallback(TUserMotionCallback cb)                           { _UserMotionCallback = cb; }
 142
 143         /// Set User release callback
 144         static void     setUserReleaseCallback(TUserCallback cb)                                        { _UserReleaseCallback = cb; }
 145
 146         /// Update
 147         static void     update(double dt = 0.1);
 148
 149
 150         /// Release
 151         static void     release();
 152
 153         //@}
 154
 155
 156
 157
 158         /// @name Control methods over tracks
 159         //@{
 160
 161         /// Follow
 162         static void     follow(const NLMISC::CEntityId &entity, const NLMISC::CEntityId &target);
 163
 164         /// Go to
 165         static void     goTo(const NLMISC::CEntityId &entity, const NLMISC::CVectorD &position);
 166
 167         /// Stop
 168         static void     leaveMove(const NLMISC::CEntityId &entity);
 169
 170         /// Destroy a track
 171         static void     destroy(const NLMISC::CEntityId &entity);
 172
 173         //@}
 174
 175
 176
 177
 178         /// @name Tracks requests and state towards interface
 179         //@{
 180
 181         /// Request Sheet
 182         static void     requestSheet(const NLMISC::CEntityId &entity);
 183
 184         /// Request Position
 185         static void     requestPosition(const NLMISC::CEntityId &entity);
 186
 187         /// Request Position Updates
 188         static void     requestPositionUpdates(const NLMISC::CEntityId &entity);
 189
 190         /// Unrequest Position Updates
 191         static void     unrequestPositionUpdates(const NLMISC::CEntityId &entity);
 192
 193         /// Request Vision
 194         static void     requestVision(const NLMISC::CEntityId &entity);
 195
 196         /// Unrequest Vision
 197         static void     unrequestVision(const NLMISC::CEntityId &entity);
 198
 199         /// Track stopped following
 200         static void     trackStop(CTrack *track);
 201
 202         /// Updated position
 203         static void     updatedPosition(const NLMISC::CEntityId &entity, const NLMISC::CVectorD &position, float heading);
 204
 205         /// Updated state
 206         static void     stateChanged(const NLMISC::CEntityId &entity, CTrackBase::TTrackState state);
 207
 208
 209
 210         /// User init
 211         static void initUserMotion(CTrack *track)
 212         {
 213                 if (_UserInitCallback != NULL)
 214                         _UserInitCallback((CTrackBase*)track);
 215         }
 216
 217         /// User move
 218         static void applyUserMotion(CTrack *track, NLMISC::CVectorD &motion)
 219         {
 220                 if (_UserMotionCallback != NULL)
 221                         _UserMotionCallback((CTrackBase*)track, motion);
 222         }
 223
 224         /// User release
 225         static void releaseUserMotion(CTrack *track)
 226         {
 227                 if (_UserReleaseCallback != NULL)
 228                         _UserReleaseCallback((CTrackBase*)track);
 229         }
 230
 231
 232
 233         /// Create Move primitive
 234         static void     createMovePrimitive(const NLMISC::CVectorD &pos, NLPACS::UMovePrimitive *&primitive, NLPACS::UMoveContainer *&container);
 235
 236         /// Lookup a sheet
 237         static const CTrack::CSheet     *lookup(const NLMISC::CSheetId &sheet);
 238
 239         //@}
 240
 241
 242
 243
 244         /// @name Answers to tracks requests
 245         //@{
 246
 247         /// Set Sheet
 248         static void     setSheet(const NLMISC::CEntityId &id, const NLMISC::CSheetId &sheet);
 249
 250         /// Set Position
 251         static void     setPosition(const NLMISC::CEntityId &id, const NLMISC::CVectorD &position, float heading);
 252
 253         /// Update Vision
 254         static void     setVision(const NLMISC::CEntityId &id, const std::vector<NLMISC::CEntityId> &in, const std::vector<NLMISC::CEntityId> &out);
 255
 256         /// Update Vision
 257         static void     setVision(const NLMISC::CEntityId &id, const std::vector<NLMISC::CEntityId> &vision);
 258
 259         /// Get a track
 260         static CTrack   *getTrack(const NLMISC::CEntityId &entity)
 261         {
 262                 TTrackMap::iterator     it = _TrackMap.find(entity);
 263                 return (it == _TrackMap.end()) ? NULL : (*it).second;
 264         }
 265
 266         /// Get cycle
 267         static uint32   getCycle()      { return _Cycle; }
 268
 269         //@}
 270
 271
 272
 273
 274         /// Create a non controlled track, referenced in _TrackMap
 275         static CTrack   *createTrack(const NLMISC::CEntityId &entity);
 276
 277
 278 protected:
 279
 280         /// Constructor. Not to be used.
 281         CReynoldsManager();
 282
 283         /// Remove a track from the whole map -- only called by the CTrack destructor
 284         static void             removeTrackFromMap(const NLMISC::CEntityId &entity);
 285
 286         /// Checks interface is ok
 287         static bool             checkInterface()
 288         {
 289                 if (_CommandInterface == NULL)
 290                 {
 291                         nlwarning("CReynoldsLib:checkInterface(): CommandInterface not set");
 292                         return false;
 293                 }
 294                 return true;
 295         }
 296
 297         /// Init sheets
 298         static void             initSheets(const std::string &packSheetFilnamePrefix);
 299
 300
 301 protected:
 302
 303         /// Whole track container
 304         typedef std::map<NLMISC::CEntityId, CTrack* >                                           TTrackMap;
 305
 306         /// Only controlled track container
 307         typedef std::map<NLMISC::CEntityId, NLMISC::CSmartPtr<CTrack> >         TControlledTrackMap;
 308
 309
 310
 311
 312 protected:
 313
 314         /// Continents
 315         static CContinentContainer              _Continents;
 316
 317         /// Track Map, all tracks referenced, held by a simple pointer so when no one references a track, it is deleted
 318         static TTrackMap                                _TrackMap;
 319
 320         /// Controlled Track Map, only controlled tracks, held by a smart pointer
 321         static TControlledTrackMap              _ControlledTrackMap;
 322
 323
 324         /// Georges sheets
 325         static std::map<NLMISC::CSheetId, CTrack::CSheet> _Sheets;
 326
 327         /// Sheets initialised ?
 328         static bool                                             _Initialised;
 329
 330
 331         /// Command interface
 332         static ICommandInterface                *_CommandInterface;
 333
 334         /// User init callback
 335         static TUserCallback                    _UserInitCallback;
 336
 337         /// User motion callback
 338         static TUserMotionCallback              _UserMotionCallback;
 339
 340         /// User release callback
 341         static TUserCallback                    _UserReleaseCallback;
 342
 343
 344         /// Current internal cycle
 345         static uint32                                   _Cycle;
 346 };
 347
 348
 349 #endif // NL_REYNOLDS_MANAGER_H
 350
 351 /* End of reynolds_manager.h */