src/server/activeobjectmgr.cpp

   1 // Luanti
   2 // SPDX-License-Identifier: LGPL-2.1-or-later
   3 // Copyright (C) 2010-2018 nerzhul, Loic BLOT <loic.blot@unix-experience.fr>
   4
   5 #include <log.h>
   6 #include "mapblock.h"
   7 #include "profiler.h"
   8 #include "activeobjectmgr.h"
   9
  10 namespace server
  11 {
  12
  13 ActiveObjectMgr::~ActiveObjectMgr()
  14 {
  15         if (!m_active_objects.empty()) {
  16                 warningstream << "server::ActiveObjectMgr::~ActiveObjectMgr(): not cleared."
  17                                 << std::endl;
  18                 clear();
  19         }
  20 }
  21
  22 void ActiveObjectMgr::clearIf(const std::function<bool(ServerActiveObject *, u16)> &cb)
  23 {
  24         for (auto &it : m_active_objects.iter()) {
  25                 if (!it.second)
  26                         continue;
  27                 if (cb(it.second.get(), it.first)) {
  28                         // Remove reference from m_active_objects
  29                         m_active_objects.remove(it.first);
  30                 }
  31         }
  32 }
  33
  34 void ActiveObjectMgr::step(
  35                 float dtime, const std::function<void(ServerActiveObject *)> &f)
  36 {
  37         size_t count = 0;
  38
  39         for (auto &ao_it : m_active_objects.iter()) {
  40                 if (!ao_it.second)
  41                         continue;
  42                 count++;
  43                 f(ao_it.second.get());
  44         }
  45
  46         g_profiler->avg("ActiveObjectMgr: SAO count [#]", count);
  47 }
  48
  49 bool ActiveObjectMgr::registerObject(std::unique_ptr<ServerActiveObject> obj)
  50 {
  51         assert(obj); // Pre-condition
  52         if (obj->getId() == 0) {
  53                 u16 new_id = getFreeId();
  54                 if (new_id == 0) {
  55                         errorstream << "Server::ActiveObjectMgr::addActiveObjectRaw(): "
  56                                         << "no free id available" << std::endl;
  57                         return false;
  58                 }
  59                 obj->setId(new_id);
  60         } else {
  61                 verbosestream << "Server::ActiveObjectMgr::addActiveObjectRaw(): "
  62                                 << "supplied with id " << obj->getId() << std::endl;
  63         }
  64
  65         if (!isFreeId(obj->getId())) {
  66                 errorstream << "Server::ActiveObjectMgr::addActiveObjectRaw(): "
  67                                 << "id is not free (" << obj->getId() << ")" << std::endl;
  68                 return false;
  69         }
  70
  71         if (objectpos_over_limit(obj->getBasePosition())) {
  72                 v3f p = obj->getBasePosition();
  73                 warningstream << "Server::ActiveObjectMgr::addActiveObjectRaw(): "
  74                                 << "object position (" << p.X << "," << p.Y << "," << p.Z
  75                                 << ") outside maximum range" << std::endl;
  76                 return false;
  77         }
  78
  79         auto obj_id = obj->getId();
  80         m_active_objects.put(obj_id, std::move(obj));
  81
  82         auto new_size = m_active_objects.size();
  83         verbosestream << "Server::ActiveObjectMgr::addActiveObjectRaw(): "
  84                         << "Added id=" << obj_id << "; there are now ";
  85         if (new_size == decltype(m_active_objects)::unknown)
  86                 verbosestream << "???";
  87         else
  88                 verbosestream << new_size;
  89         verbosestream << " active objects." << std::endl;
  90         return true;
  91 }
  92
  93 void ActiveObjectMgr::removeObject(u16 id)
  94 {
  95         verbosestream << "Server::ActiveObjectMgr::removeObject(): "
  96                         << "id=" << id << std::endl;
  97
  98         // this will take the object out of the map and then destruct it
  99         bool ok = m_active_objects.remove(id);
 100         if (!ok) {
 101                 infostream << "Server::ActiveObjectMgr::removeObject(): "
 102                                 << "id=" << id << " not found" << std::endl;
 103         }
 104 }
 105
 106 void ActiveObjectMgr::invalidateActiveObjectObserverCaches()
 107 {
 108         for (auto &active_object : m_active_objects.iter()) {
 109                 ServerActiveObject *obj = active_object.second.get();
 110                 if (!obj)
 111                         continue;
 112                 obj->invalidateEffectiveObservers();
 113         }
 114 }
 115
 116 void ActiveObjectMgr::getObjectsInsideRadius(const v3f &pos, float radius,
 117                 std::vector<ServerActiveObject *> &result,
 118                 std::function<bool(ServerActiveObject *obj)> include_obj_cb)
 119 {
 120         float r2 = radius * radius;
 121         for (auto &activeObject : m_active_objects.iter()) {
 122                 ServerActiveObject *obj = activeObject.second.get();
 123                 if (!obj)
 124                         continue;
 125                 const v3f &objectpos = obj->getBasePosition();
 126                 if (objectpos.getDistanceFromSQ(pos) > r2)
 127                         continue;
 128
 129                 if (!include_obj_cb || include_obj_cb(obj))
 130                         result.push_back(obj);
 131         }
 132 }
 133
 134 void ActiveObjectMgr::getObjectsInArea(const aabb3f &box,
 135                 std::vector<ServerActiveObject *> &result,
 136                 std::function<bool(ServerActiveObject *obj)> include_obj_cb)
 137 {
 138         for (auto &activeObject : m_active_objects.iter()) {
 139                 ServerActiveObject *obj = activeObject.second.get();
 140                 if (!obj)
 141                         continue;
 142                 const v3f &objectpos = obj->getBasePosition();
 143                 if (!box.isPointInside(objectpos))
 144                         continue;
 145
 146                 if (!include_obj_cb || include_obj_cb(obj))
 147                         result.push_back(obj);
 148         }
 149 }
 150
 151 void ActiveObjectMgr::getAddedActiveObjectsAroundPos(
 152                 const v3f &player_pos, const std::string &player_name,
 153                 f32 radius, f32 player_radius,
 154                 const std::set<u16> &current_objects,
 155                 std::vector<u16> &added_objects)
 156 {
 157         /*
 158                 Go through the object list,
 159                 - discard removed/deactivated objects,
 160                 - discard objects that are too far away,
 161                 - discard objects that are found in current_objects,
 162                 - discard objects that are not observed by the player.
 163                 - add remaining objects to added_objects
 164         */
 165         for (auto &ao_it : m_active_objects.iter()) {
 166                 u16 id = ao_it.first;
 167
 168                 // Get object
 169                 ServerActiveObject *object = ao_it.second.get();
 170                 if (!object)
 171                         continue;
 172
 173                 if (object->isGone())
 174                         continue;
 175
 176                 f32 distance_f = object->getBasePosition().getDistanceFrom(player_pos);
 177                 if (object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
 178                         // Discard if too far
 179                         if (distance_f > player_radius && player_radius != 0)
 180                                 continue;
 181                 } else if (distance_f > radius)
 182                         continue;
 183
 184                 if (!object->isEffectivelyObservedBy(player_name))
 185                         continue;
 186
 187                 // Discard if already on current_objects
 188                 auto n = current_objects.find(id);
 189                 if (n != current_objects.end())
 190                         continue;
 191                 // Add to added_objects
 192                 added_objects.push_back(id);
 193         }
 194 }
 195
 196 } // namespace server