ryzom/common/src/game_share/scenario.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 #ifndef R2_SCENARIO_H
  18 #define R2_SCENARIO_H
  19
  20 #include "nel/misc/types_nl.h"
  21
  22 #include "nel/misc/md5.h"
  23 #include "nel/misc/sheet_id.h"
  24 #include "nel/misc/sheet_id.h"
  25 #include "nel/misc/entity_id.h"
  26 #include "nel/misc/smart_ptr.h"
  27 #include <list>
  28 #include <string>
  29 #include <map>
  30 #include <vector>
  31 #include <memory>
  32 #include "game_share/r2_types.h"
  33
  34 #include "r2_share_itf.h"
  35
  36 //#include "game_share/far_position.h"
  37
  38 namespace R2
  39 {
  40
  41
  42 class CObject;
  43 class CInstanceMap;
  44 class CInstanceMap;
  45 class CIdMaker;
  46
  47
  48
  49
  50
  51
  52 /*! Access Time optimised container Object Tree.
  53 * Transforms an object tree into a map for time access optimization to the different nodes.
  54 * The key used to find an element is set in the ctor
  55 */
  56 class CInstanceMap
  57 {
  58 public:
  59         /// Set the id Name (b.e. if "InstanceId" is used then look at the "InstanceId" attribute to Identify a node)
  60         CInstanceMap(const std::string& idName):_IdName(idName){}
  61
  62         /// Sets the initial tree (clear the container and add)
  63         void set(CObject* root);
  64
  65         /// Add a new tree (register all its node)
  66         void add(CObject* root);
  67
  68         /// Remove a tree (unregister all its node)
  69         void remove(CObject* root);
  70
  71         /// Find a element by its id
  72         CObject* find (const std::string& instanceId);
  73
  74
  75         //:XXX: Global functionality and specific must be in two different class
  76
  77         /// Returns the maximum  of id used by a character .
  78         sint32 getMaxId(const std::string& eid);
  79
  80         void setMaxId(const std::string &eid, sint32 maxId);
  81 private:
  82         /// Id to Object
  83         std::map<std::string, CObject*> _Map;
  84
  85         //:XXX: Must not be here
  86         /// UserId -> maximum id used
  87         std::map<std::string, sint32> _MapEids;
  88
  89         // The Name of the attribute used to identify a node.
  90         const std::string _IdName;
  91 };
  92
  93
  94
  95 /*! Hold a scenario
  96 * Contain a scenario
  97 * - Edition data / Animation data
  98 * - Palette used to create elements
  99 * - InstanceMap to give quick access to tree Node
 100 * - List of Current characters connect to this scenario
 101 */
 102
 103 //:XXX: _CurrentUsers will still be useful after session manager?
 104 class CScenario : public NLMISC::CRefCount
 105 {
 106
 107
 108
 109
 110 public:
 111         /*! ctor
 112         *       /param property the CObject node of the edition data.
 113         */
 114         explicit CScenario(CObject* property, TScenarioSessionType sessionType = st_edit);
 115
 116         ///dtor
 117         virtual ~CScenario();
 118
 119
 120
 121         /*! Reset the Edition data.
 122         * /param /highLevle the edition data
 123         */
 124         void setHighLevel(CObject* highLevel);
 125
 126         /*! Reset the Animation data.
 127         * /param /highLevle the edition data
 128         */
 129         void setRtData(CObject* rtScenario);
 130
 131
 132
 133         /*!
 134         Add, set, erase, move node of a scenario
 135         /see CObject definition
 136         */
 137         ///@{
 138
 139         bool setNode( const std::string& instanceId, const std::string& attrName, CObject* value);
 140
 141         bool insertNode(const std::string&  instanceId, const std::string & attrName, sint32 position,
 142                 const std::string& key, CObject* value);
 143
 144         bool eraseNode(const std::string&  instanceId, const std::string & attrName, sint32 position);
 145
 146         bool moveNode( const std::string& instanceId1, const std::string& attrName1, int position1,
 147                 const std::string& instanceId2, const std::string& attrName2, int position2);
 148
 149         ///@}
 150
 151         /// Find a node from the scenario tree by its InstanceId.
 152         CObject *find(const std::string& instanceId, const std::string& attrName = "", sint32 position = -1, const std::string &key ="");
 153
 154         /// Get the Edition Data tree
 155         CObject* getHighLevel() const;
 156
 157         /// Get the Animation Data tree
 158         CObject* getRtData() const;
 159
 160         /*! return the maxId used by a specific user
 161          *  /param eid the id of the pioneer
 162          *  /return The max InstanceId used by this user
 163          */
 164         sint32 getMaxId(const std::string& eid);
 165
 166         void setMaxId(const std::string& eid, sint32 range);
 167
 168
 169
 170         uint32 getMode() const { return _Mode; }
 171
 172         void setMode(uint32 mode) { _Mode = mode; }
 173
 174         bool isEditing() const;
 175
 176         bool isRunning() const;
 177
 178         bool isWaiting() const;
 179
 180         void setSessionType(const TScenarioSessionType& sessionType ) {  _SessionType = sessionType; }
 181
 182         void registerUserComponent(const NLMISC::CHashKeyMD5& md5) { _CUserComponent.insert(md5); }
 183
 184         void unregisterUserComponent(const NLMISC::CHashKeyMD5& md5) { _CUserComponent.erase(md5); }
 185
 186         uint32 getInitialActIndex() const { return _InitialActIndex;}
 187
 188         void setInitialActIndex(uint32 initialActIndex) { _InitialActIndex = initialActIndex; }
 189
 190         void serial( NLMISC::IStream &f);
 191
 192         void setClean(bool clean){ _Clean = clean; }
 193         bool getClean() const { return _Clean; }
 194
 195 private:
 196         //time stamp?
 197
 198         /// Palette used
 199         // :XXX: useful?
 200         CObject* _Palette;
 201
 202 /// list of chars
 203         /// :XXX: useful?
 204         uint32                  _Mode;
 205
 206         // Runtime Data
 207         CObject* _BasicBricks;
 208
 209
 210         CObject* _HighLevel;
 211         CInstanceMap* _InstanceMap;
 212         TScenarioSessionType _SessionType;
 213         uint32 _InitialActIndex;
 214         bool _Clean;
 215
 216
 217         struct CHashKeyMD5Less : public std::binary_function<NLMISC::CHashKeyMD5, NLMISC::CHashKeyMD5, bool>
 218         {
 219                 bool operator()(const NLMISC::CHashKeyMD5& x, const NLMISC::CHashKeyMD5& y) const { return x.operator<(y); }
 220         };
 221
 222
 223         std::set<NLMISC::CHashKeyMD5, CHashKeyMD5Less> _CUserComponent;
 224
 225
 226 };
 227
 228
 229
 230 class CUserComponent
 231 {
 232 public: //public type
 233         enum TComponentType {Compressed, Dev} ;
 234
 235 public://public functions
 236         CUserComponent();
 237
 238         CUserComponent(const std::string &filename,
 239                 uint8* uncompressedData,  uint32 uncompressedDataLength,
 240                 uint8* compressedData = 0,  uint32 compressedDataLength = 0
 241                 );
 242
 243         ~CUserComponent();
 244
 245         void computeMd5();
 246
 247         void  serial(NLMISC::IStream &f);
 248
 249         uint8* getUncompressedData() const;
 250
 251         uint32 getUncompressedDataLength() const;
 252
 253         void setType(TComponentType type) { ComponentType = type; }
 254
 255         TComponentType GetComponentType() const { return ComponentType; }
 256
 257         std::string getFilename() const { return Filename; }
 258
 259
 260 public: //public value
 261         NLMISC::CHashKeyMD5 Md5;
 262         NLMISC::CHashKeyMD5 Md5Id;
 263         uint32 TimeStamp;
 264         TComponentType ComponentType;
 265         std::string Filename;
 266         std::string Name;
 267         std::string Description;
 268         uint8* UncompressedData; //uncompressed
 269         uint32 UncompressedDataLength;
 270         uint8* CompressedData;
 271         uint32 CompressedDataLength;
 272 };
 273
 274
 275 class CEmoteBehavior
 276 {
 277 public:
 278         CEmoteBehavior();
 279         std::string get(const std::string& emoteId) const;
 280
 281 private:
 282         void load() const;
 283
 284 private:
 285         mutable std::map<std::string, std::string> _EmotesMap;
 286
 287 };
 288
 289
 290 class CScenarioValidatorLoadSuccededCallback;
 291
 292 class CScenarioValidator
 293 {
 294 public:
 295         typedef std::vector< std::pair<std::string, std::string> >  TValues;
 296
 297 public:
 298         static std::string AutoSaveSignature;
 299
 300 public:
 301         TValues _Values;
 302         CScenarioValidator(CScenarioValidatorLoadSuccededCallback* loadCb = 0 );
 303         ~CScenarioValidator();
 304         bool setScenarioToSave(const std::string& filename, CObject* scenario, const CScenarioValidator::TValues& value, std::string& md5);
 305         bool setScenarioToLoad(const std::string& filename, CScenarioValidator::TValues& values, std::string& md5, std::string& signature, bool checkMD5);
 306
 307         bool applySave(const std::string& signature);
 308         void applyLoad(std::string& filename, std::string& body, CScenarioValidator::TValues& values);
 309         std::string getBodyMd5() const { return _BodyMd5; }
 310
 311 private:
 312         std::string _HeaderBody;
 313         std::string _ScenarioBody;
 314         std::string _HeaderMd5;
 315         std::string _Filename;
 316         std::string _BodyMd5;
 317         CScenarioValidatorLoadSuccededCallback* _LoadCb;
 318
 319
 320 };
 321
 322 // Verify that a scenario is not alterated by user
 323
 324 class CScenarioValidatorLoadSuccededCallback
 325 {
 326 public:
 327         virtual ~CScenarioValidatorLoadSuccededCallback(){}
 328         virtual void doOperation(const std::string& filename, const std::string& body, const CScenarioValidator::TValues& values) = 0;
 329
 330
 331 };
 332
 333 class CUserComponentValidatorLoadSuccededCallback;
 334
 335 class CUserComponentValidator
 336 {
 337 public:
 338         typedef std::vector< std::pair<std::string, std::string> >  TValues;
 339
 340 public:
 341         static std::string AutoSaveSignature;
 342
 343 public:
 344         TValues _Values;
 345         CUserComponentValidator(CUserComponentValidatorLoadSuccededCallback* loadCb = 0 );
 346         ~CUserComponentValidator();
 347         bool setUserComponentToSave(const std::string& filename, const CUserComponentValidator::TValues& value, std::string& md5, const std::string &body);
 348         bool setUserComponentToLoad(const std::string& filename, CUserComponentValidator::TValues& values, std::string& md5, std::string& signature, bool checkMD5);
 349
 350         bool applySave(const std::string& signature);
 351         void applyLoad(std::string& filename, std::string& body, CScenarioValidator::TValues& values);
 352         std::string getBodyMd5() const { return _BodyMd5; }
 353
 354         std::string getFilename() const{ return _Filename;}
 355
 356 private:
 357         std::string _HeaderBody;
 358         std::string _UserComponentBody;
 359         std::string _HeaderMd5;
 360         std::string _Filename;
 361         std::string _BodyMd5;
 362         CUserComponentValidatorLoadSuccededCallback* _LoadCb;
 363
 364
 365 };
 366
 367 class CUserComponentValidatorLoadSuccededCallback
 368 {
 369 public:
 370         virtual ~CUserComponentValidatorLoadSuccededCallback(){}
 371         virtual void doOperation(const std::string& filename, const std::string& body, const CUserComponentValidator::TValues& values) = 0;
 372
 373
 374 };
 375
 376 } // namespace R2
 377 #endif //R2_SCENARIO_H