ryzom/server/src/ai_service/named_entity_manager.cpp

   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 #include "stdpch.h"
  18
  19 #include <queue>
  20 #include "named_entity_manager.h"
  21
  22 CNamedEntityManager* CNamedEntityManager::_instance = 0;
  23
  24 CNamedEntityManager* CNamedEntityManager::getInstance()
  25 {
  26         if (_instance==0)
  27                 _instance = new CNamedEntityManager();
  28         return _instance;
  29 }
  30
  31 void CNamedEntityManager::destroyInstance()
  32 {
  33         delete _instance;
  34         _instance = 0;
  35 }
  36
  37 CNamedEntity& CNamedEntityManager::create(std::string const& name)
  38 {
  39         return get(name);
  40 }
  41
  42 CNamedEntity& CNamedEntityManager::get(std::string const& name)
  43 {
  44         entity_name_container_t::iterator it = _nameIndex.find(name);
  45         if (it!=_nameIndex.end())
  46                 return *it->second;
  47         else
  48         {
  49                 CNamedEntity* ptr = new CNamedEntity(name);
  50                 _entities.insert(ptr);
  51                 _nameIndex.insert(std::make_pair(ptr->name(), ptr));
  52                 _idIndex.insert(std::make_pair(ptr->id(), ptr));
  53                 return *ptr;
  54         }
  55 }
  56
  57 CNamedEntity* CNamedEntityManager::get(NLMISC::CEntityId const& id)
  58 {
  59         entity_id_container_t::iterator it = _idIndex.find(id);
  60         if (it!=_idIndex.end())
  61                 return it->second;
  62         else
  63                 return 0;
  64 }
  65
  66 void CNamedEntityManager::destroy(CNamedEntity const& entity)
  67 {
  68         destroy(entity.name());
  69 }
  70
  71 void CNamedEntityManager::destroy(std::string const& name)
  72 {
  73         entity_name_container_t::iterator it = _nameIndex.find(name);
  74         if (it!=_nameIndex.end())
  75         {
  76                 CNamedEntity* ptr = it->second;
  77                 _nameIndex.erase(ptr->name());
  78                 _idIndex.erase(ptr->id());
  79                 _entities.erase(ptr);
  80                 delete ptr;
  81         }
  82 }
  83
  84 void CNamedEntityManager::destroy(NLMISC::CEntityId const& id)
  85 {
  86         entity_id_container_t::iterator it = _idIndex.find(id);
  87         if (it!=_idIndex.end())
  88         {
  89                 CNamedEntity* ptr = it->second;
  90                 _nameIndex.erase(ptr->name());
  91                 _idIndex.erase(ptr->id());
  92                 _entities.erase(ptr);
  93                 delete ptr;
  94         }
  95 }
  96
  97 bool CNamedEntityManager::exists(std::string const& name)
  98 {
  99         return _nameIndex.find(name) != _nameIndex.end();
 100 }
 101
 102 bool CNamedEntityManager::exists(NLMISC::CEntityId const& id)
 103 {
 104         return _idIndex.find(id) != _idIndex.end();
 105 }
 106
 107 /**     Valid format for request string is:
 108         - *                             Select all entities
 109         - <entity id>   Select the specified entity using his eid (format is "(id:type:crea:dyn)")
 110         - <name>                Select an entity with its name (any name allowed for a named entity)
 111 */
 112 void CNamedEntityManager::select(std::string const& request, std::vector<NLMISC::CEntityId>& entities)
 113 {
 114         if (request.empty())
 115                 return;
 116
 117         if (request == "*")
 118         {
 119                 // we want all entities
 120                 FOREACHC(it, entity_container_t, _entities)
 121                 {
 122                         entities.push_back((*it)->id());
 123                 }
 124         }
 125         else if (request[0] == '(')
 126         {
 127                 // we want a specific entity id
 128                 NLMISC::CEntityId id(request);
 129                 if (exists(id))
 130                         entities.push_back(id);
 131         }
 132         else
 133         {
 134                 // try with the name
 135                 if (exists(request))
 136                         entities.push_back(get(request).id());
 137         }
 138 }
 139
 140 #define ENTITY_VARIABLE(__name,__help) \
 141 struct __name##Class : public NLMISC::ICommand \
 142 { \
 143 __name##Class () : NLMISC::ICommand("variables",#__name, __help, "<entity> [<value>]") { Type = Variable; } \
 144         virtual bool execute(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human) \
 145         { \
 146                 if (args.size() != 1 && args.size() != 2) \
 147                         return false; \
 148  \
 149                 std::vector<NLMISC::CEntityId> entities; \
 150                 CNamedEntityManager::getInstance()->select(args[0], entities); \
 151  \
 152                 for (uint i = 0; i < entities.size(); i++) \
 153                 { \
 154                         std::string value; \
 155                         if (args.size()==2) \
 156                                 value = args[1]; \
 157                         else \
 158                                 value = "???"; \
 159                         pointer(entities[i], (args.size()==1), value); \
 160                         if (quiet) \
 161                                 log.displayNL("%s %s", entities[i].toString().c_str(), value.c_str()); \
 162                         else \
 163                                 log.displayNL("Entity %s Variable %s = %s", entities[i].toString().c_str(), _CommandName.c_str(), value.c_str()); \
 164                 } \
 165                 return true; \
 166         } \
 167         void pointer(NLMISC::CEntityId entity, bool get, std::string &value); \
 168 }; \
 169 __name##Class __name##Instance; \
 170 void __name##Class::pointer(NLMISC::CEntityId entity, bool get, std::string &value)
 171
 172 #define ENTITY_GET_NAMEDENTITY \
 173         CNamedEntity* namedEntity = CNamedEntityManager::getInstance()->get(entity); \
 174         if(namedEntity == 0) \
 175         { \
 176                 nlwarning("Unknown entity '%s'", entity.toString().c_str()); \
 177                 if (get) value = "UnknownEntity"; \
 178                 return; \
 179         } \
 180
 181
 182 struct NamedEntityChange
 183 {
 184         NamedEntityChange(NLMISC::CEntityId _id, std::string _prop, std::string _value)
 185                 : id(_id), prop(_prop), value(_value) { }
 186         NLMISC::CEntityId id;
 187         std::string prop;
 188         std::string value;
 189 };
 190 std::queue<NamedEntityChange> namedEntityChangeQueue;
 191
 192 void execNamedEntityChanges()
 193 {
 194         CNamedEntityManager* manager = CNamedEntityManager::getInstance();
 195         while (!namedEntityChangeQueue.empty())
 196         {
 197                 NamedEntityChange& namedEntityChange = namedEntityChangeQueue.front();
 198                 CNamedEntity* namedEntity = manager->get(namedEntityChange.id);
 199                 if(namedEntity != 0)
 200                 {
 201                         namedEntity->set(namedEntityChange.prop, namedEntityChange.value, true);
 202                 }
 203                 namedEntityChangeQueue.pop();
 204         }
 205 }
 206
 207
 208
 209 ENTITY_VARIABLE(NamedEntityName, "Name of a named entity")
 210 {
 211         ENTITY_GET_NAMEDENTITY
 212
 213         if (get)
 214                 value = namedEntity->name();
 215         else
 216                 nlwarning("Trying to change a named entity's name: '%s' to '%s'", namedEntity->name().c_str(), value.c_str());
 217 }
 218
 219 ENTITY_VARIABLE(NamedEntityState, "State of a named entity")
 220 {
 221         ENTITY_GET_NAMEDENTITY
 222
 223         if (get)
 224                 value = namedEntity->getState();
 225         else
 226         //      namedEntity->set("state", value, true);
 227                 namedEntityChangeQueue.push(NamedEntityChange(entity, "state", value));
 228 }
 229
 230 ENTITY_VARIABLE(NamedEntityParam1, "Param1 of a named entity")
 231 {
 232         ENTITY_GET_NAMEDENTITY
 233
 234         if (get)
 235                 value = namedEntity->getParam1();
 236         else
 237         //      namedEntity->set("param1", value, true);
 238                 namedEntityChangeQueue.push(NamedEntityChange(entity, "param1", value));
 239 }
 240
 241 ENTITY_VARIABLE(NamedEntityParam2, "Param1 of a named entity")
 242 {
 243         ENTITY_GET_NAMEDENTITY
 244
 245         if (get)
 246                 value = namedEntity->getParam2();
 247         else
 248         //      namedEntity->set("param2", value, true);
 249                 namedEntityChangeQueue.push(NamedEntityChange(entity, "param2", value));
 250 }