ryzom/server/src/gpm_service/patat_subscribe_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_PATAT_SUBSCRIBE_MANAGER_H
  20 #define NL_PATAT_SUBSCRIBE_MANAGER_H
  21
  22 #include "nel/misc/types_nl.h"
  23 #include "nel/misc/entity_id.h"
  24 #include "nel/misc/vector.h"
  25 #include "nel/misc/stream.h"
  26
  27 #include "patat_grid.h"
  28 #include "nel/net/unified_network.h"
  29
  30 #include <map>
  31 #include <set>
  32 #include <vector>
  33 #include <string>
  34
  35 namespace NLPACS
  36 {
  37         class UMoveContainer;
  38 };
  39
  40 /**
  41  * Patat event subscription management.
  42  * Allows to be notified when an entity enters or leaves a patat.
  43  *
  44  * To use it, proceed this way :
  45  * 1. \c init() with world bounds (in meters)
  46  * 2. Load all needed patats with \c usePrim(<file>) where <file> points to a .prim file.
  47  * 3. \c build() the manager.
  48  *
  49  * Once this is done, you can't add more patats (won't be inserted anyway.)
  50  * Subscription is done by calling subscribe(), and removed by unsubscribe().
  51  * Call getNewEntryIndex() to update the patats events, and call emitChanges() at each update.
  52  *
  53  * \author Benjamin Legros
  54  * \author Nevrax France
  55  * \date 2002
  56  */
  57 class CPatatSubscribeManager
  58 {
  59 public:
  60         typedef uint16  TPatatId;
  61
  62         typedef std::pair<std::string, TPatatId>        TPatatSubscription;
  63
  64 protected:
  65
  66         class CPatat;
  67         class CSubscriber;
  68
  69         /// A Map of subscribed patats
  70         typedef std::map<sint32, CPatat>                TPatatMap;
  71
  72         /// A Map of subscribers
  73         typedef std::map<NLNET::TServiceId, CSubscriber>        TSubscriberMap;
  74
  75         /// A Map of id
  76         typedef std::map<std::string, sint32>   TTriggerIdMap;
  77
  78         /// A patat subscriber
  79         class CPatatSubscriber
  80         {
  81         public:
  82                 NLNET::TServiceId                               Service;
  83                 TSubscriberMap::iterator                SubscriberIterator;
  84                 TPatatId                                                PatatId;
  85         };
  86
  87         /// A patat
  88         class CPatat
  89         {
  90         public:
  91                 CPatat() : Modified(false) {}
  92                 std::string                                             Name;
  93                 sint32                                                  InternalPatatId;
  94                 std::vector<CPatatSubscriber>   Subscribers;
  95                 std::vector<NLMISC::CEntityId>  Ins;
  96                 std::vector<NLMISC::CEntityId>  Outs;
  97                 std::set<NLMISC::CEntityId>             StillIns;
  98                 bool                                                    Modified;
  99
 100                 void    serial(NLMISC::IStream &f)
 101                 {
 102                         f.serial(Name);
 103                         f.serial(InternalPatatId);
 104                 }
 105         };
 106
 107         /// A list of modified patats
 108         typedef std::vector<TPatatMap::iterator>        TModifiedPatats;
 109
 110         /// A subscribed patat
 111         class CSubscribedPatat
 112         {
 113         public:
 114                 sint32                                                  InternalPatatId;
 115                 TPatatId                                                PatatId;
 116                 TPatatMap::iterator                             PatatIterator;
 117         };
 118
 119         /// A subscriber
 120         class CSubscriber
 121         {
 122         public:
 123                 CSubscriber() : OutsMessage("",false), InsMessage("",false) {} // always output messages
 124
 125                 NLNET::TServiceId                               Service;
 126                 NLNET::CMessage                                 OutsMessage;
 127                 uint32                                                  OutsMsgSize;
 128                 NLNET::CMessage                                 InsMessage;
 129                 uint32                                                  InsMsgSize;
 130                 std::vector<CSubscribedPatat>   Patats;
 131         };
 132
 133         /// Patat grid
 134         CPatatGrid              _PatatGrid;
 135
 136         /// Subscribed patats
 137         TPatatMap               _PatatMap;
 138
 139         /// Subscribers
 140         TSubscriberMap  _SubscriberMap;
 141
 142         /// Triggers map
 143         TTriggerIdMap   _TriggerMap;
 144
 145         /// Modified patats
 146         TModifiedPatats _ModifiedPatats;
 147
 148 public:
 149
 150         /// Constructor
 151         CPatatSubscribeManager();
 152
 153         /// Destructor
 154         ~CPatatSubscribeManager();
 155
 156         /// Init
 157         void    init();
 158
 159         /// Serial
 160         void    serial(NLMISC::IStream &f);
 161
 162         /// Use a prim file, patats in file will be processed at build() time.
 163         void    usePrim(const std::string &primFile);
 164
 165         /// Register a pacs trigger id
 166         void    usePacsTrigger(sint32 id, const std::string &name);
 167
 168         /// Checks if patat exists
 169         bool    exist(const std::string &name) const { return _PatatGrid.exist(name); }
 170
 171         /// Subscribe to a patat
 172         void    subscribe(NLNET::TServiceId service, const TPatatSubscription &patat);
 173
 174         /// Unsubscribe
 175         void    unsubscribe(NLNET::TServiceId service, TPatatId patat);
 176
 177         /// Unsubscribe for a whole service
 178         void    unsubscribe(NLNET::TServiceId service);
 179
 180
 181         /// Get entry index at pos
 182         uint32  getEntryIndex(const NLMISC::CVector &pos)       { return _PatatGrid.getEntryIndex(pos); }
 183
 184         /// Move entity and get its new patats entry index
 185         uint32  getNewEntryIndex(const NLMISC::CEntityId &id, const NLMISC::CVector &pos, uint32 previousEntryIndex);
 186
 187         /// Set entry index
 188         void    setNewEntryIndex(const NLMISC::CEntityId &id, uint32 newEntryIndex, uint32 previousEntryIndex);
 189
 190         /// Process pacs trigger collisions
 191         void    processPacsTriggers(NLPACS::UMoveContainer *moveContainer);
 192
 193         /// Emit changes
 194         void    emitChanges();
 195
 196
 197         /// Display info for trigger
 198         void    displayTriggers(NLMISC::CLog *log = NLMISC::InfoLog);
 199
 200         /// Display info for trigger
 201         void    displayTriggerInfo(const std::string &name, NLMISC::CLog *log = NLMISC::InfoLog);
 202
 203         /// Display info for trigger
 204         void    displaySubscribers(NLMISC::CLog *log = NLMISC::InfoLog);
 205
 206         /// Display info for trigger
 207         void    displaySubscriberInfo(NLNET::TServiceId service, NLMISC::CLog *log = NLMISC::InfoLog);
 208
 209         /// Display patat grid info
 210         void    displayPatatGridInfo(NLMISC::CLog *log = NLMISC::InfoLog)
 211         {
 212                 _PatatGrid.displayInfo(log);
 213         }
 214
 215
 216         /// Add CPrimZone class filter
 217         void    addPrimZoneFilter(const std::string &filter)    { _PatatGrid.addPrimZoneFilter(filter); }
 218
 219         /// Remove CPrimZone class filter
 220         void    removePrimZoneFilter(const std::string &filter) { _PatatGrid.removePrimZoneFilter(filter); }
 221
 222         /// Reset CPrimZone class filter
 223         void    resetPrimZoneFilter()                                                   { _PatatGrid.resetPrimZoneFilter(); }
 224 };
 225
 226
 227 #endif // NL_PATAT_SUBSCRIBE_MANAGER_H
 228
 229 /* End of patat_subscribe_manager.h */