+/*
+ ************ Private methods *************
+*/
+
+u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object,
+ bool set_changed)
+{
+ assert(object);
+ if(object->getId() == 0)
+ {
+ u16 new_id = getFreeServerActiveObjectId(m_active_objects);
+ if(new_id == 0)
+ {
+ dstream<<"WARNING: ServerEnvironment::addActiveObjectRaw(): "
+ <<"no free ids available"<<std::endl;
+ delete object;
+ return 0;
+ }
+ object->setId(new_id);
+ }
+ if(isFreeServerActiveObjectId(object->getId(), m_active_objects) == false)
+ {
+ dstream<<"WARNING: ServerEnvironment::addActiveObjectRaw(): "
+ <<"id is not free ("<<object->getId()<<")"<<std::endl;
+ delete object;
+ return 0;
+ }
+ /*dstream<<"INGO: ServerEnvironment::addActiveObjectRaw(): "
+ <<"added (id="<<object->getId()<<")"<<std::endl;*/
+
+ m_active_objects.insert(object->getId(), object);
+
+ // Add static object to active static list of the block
+ v3f objectpos = object->getBasePosition();
+ std::string staticdata = object->getStaticData();
+ StaticObject s_obj(object->getType(), objectpos, staticdata);
+ // Add to the block where the object is located in
+ v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+ MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+ if(block)
+ {
+ block->m_static_objects.m_active.insert(object->getId(), s_obj);
+ object->m_static_exists = true;
+ object->m_static_block = blockpos;
+
+ if(set_changed)
+ block->setChangedFlag();
+ }
+ else{
+ dstream<<"WARNING: ServerEnv: Could not find a block for "
+ <<"storing newly added static active object"<<std::endl;
+ }
+
+ return object->getId();
+}
+
+/*
+ Remove objects that satisfy (m_removed && m_known_by_count==0)
+*/
+void ServerEnvironment::removeRemovedObjects()
+{
+ core::list<u16> objects_to_remove;
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ u16 id = i.getNode()->getKey();
+ ServerActiveObject* obj = i.getNode()->getValue();
+ // This shouldn't happen but check it
+ if(obj == NULL)
+ {
+ dstream<<"WARNING: NULL object found in ServerEnvironment"
+ <<" while finding removed objects. id="<<id<<std::endl;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ continue;
+ }
+
+ /*
+ We will delete objects that are marked as removed or thatare
+ waiting for deletion after deactivation
+ */
+ if(obj->m_removed == false && obj->m_pending_deactivation == false)
+ continue;
+
+ /*
+ Delete static data from block if is marked as removed
+ */
+ if(obj->m_static_exists && obj->m_removed)
+ {
+ MapBlock *block = m_map->getBlockNoCreateNoEx(obj->m_static_block);
+ if(block)
+ {
+ block->m_static_objects.remove(id);
+ block->setChangedFlag();
+ }
+ }
+
+ // If m_known_by_count > 0, don't actually remove.
+ if(obj->m_known_by_count > 0)
+ continue;
+
+ // Delete
+ delete obj;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ }
+ // Remove references from m_active_objects
+ for(core::list<u16>::Iterator i = objects_to_remove.begin();
+ i != objects_to_remove.end(); i++)
+ {
+ m_active_objects.remove(*i);
+ }
+}
+
+/*
+ Convert stored objects from blocks near the players to active.
+*/
+void ServerEnvironment::activateObjects(MapBlock *block)
+{
+ if(block==NULL)
+ return;
+ // Ignore if no stored objects (to not set changed flag)
+ if(block->m_static_objects.m_stored.size() == 0)
+ return;
+ // A list for objects that couldn't be converted to static for some
+ // reason. They will be stored back.
+ core::list<StaticObject> new_stored;
+ // Loop through stored static objects
+ for(core::list<StaticObject>::Iterator
+ i = block->m_static_objects.m_stored.begin();
+ i != block->m_static_objects.m_stored.end(); i++)
+ {
+ /*dstream<<"INFO: Server: Creating an active object from "
+ <<"static data"<<std::endl;*/
+ StaticObject &s_obj = *i;
+ // Create an active object from the data
+ ServerActiveObject *obj = ServerActiveObject::create
+ (s_obj.type, this, 0, s_obj.pos, s_obj.data);
+ // If couldn't create object, store static data back.
+ if(obj==NULL)
+ {
+ new_stored.push_back(s_obj);
+ continue;
+ }
+ // This will also add the object to the active static list
+ addActiveObjectRaw(obj, false);
+ //u16 id = addActiveObjectRaw(obj, false);
+ }
+ // Clear stored list
+ block->m_static_objects.m_stored.clear();
+ // Add leftover failed stuff to stored list
+ for(core::list<StaticObject>::Iterator
+ i = new_stored.begin();
+ i != new_stored.end(); i++)
+ {
+ StaticObject &s_obj = *i;
+ block->m_static_objects.m_stored.push_back(s_obj);
+ }
+ // Block has been modified
+ // NOTE: No it has not really. Save I/O here.
+ //block->setChangedFlag();
+}
+
+/*
+ Convert objects that are not in active blocks to static.
+
+ If m_known_by_count != 0, active object is not deleted, but static
+ data is still updated.
+
+ If force_delete is set, active object is deleted nevertheless. It
+ shall only be set so in the destructor of the environment.
+*/
+void ServerEnvironment::deactivateFarObjects(bool force_delete)
+{
+ core::list<u16> objects_to_remove;
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ ServerActiveObject* obj = i.getNode()->getValue();
+ u16 id = i.getNode()->getKey();
+ v3f objectpos = obj->getBasePosition();
+
+ // This shouldn't happen but check it
+ if(obj == NULL)
+ {
+ dstream<<"WARNING: NULL object found in ServerEnvironment"
+ <<std::endl;
+ assert(0);
+ continue;
+ }
+
+ // The block in which the object resides in
+ v3s16 blockpos_o = getNodeBlockPos(floatToInt(objectpos, BS));
+
+ // If block is active, don't remove
+ if(m_active_blocks.contains(blockpos_o))
+ continue;
+
+ /*
+ Update the static data
+ */
+
+ // Delete old static object
+ MapBlock *oldblock = NULL;
+ if(obj->m_static_exists)
+ {
+ MapBlock *block = m_map->getBlockNoCreateNoEx
+ (obj->m_static_block);
+ if(block)
+ {
+ block->m_static_objects.remove(id);
+ oldblock = block;
+ }
+ }
+ // Create new static object
+ std::string staticdata = obj->getStaticData();
+ StaticObject s_obj(obj->getType(), objectpos, staticdata);
+ // Add to the block where the object is located in
+ v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+ // Get or generate the block
+ MapBlock *block = m_map->emergeBlock(blockpos);
+
+ /*MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ // Block not found. Is the old block still ok?
+ if(oldblock)
+ block = oldblock;
+ // Load from disk or generate
+ else
+ block = m_map->emergeBlock(blockpos);
+ }*/
+
+ if(block)
+ {
+ block->m_static_objects.insert(0, s_obj);
+ block->setChangedFlag();
+ obj->m_static_exists = true;
+ obj->m_static_block = block->getPos();
+ }
+ else{
+ dstream<<"WARNING: ServerEnv: Could not find or generate "
+ <<"a block for storing static object"<<std::endl;
+ obj->m_static_exists = false;
+ continue;
+ }
+
+ /*
+ Delete active object if not known by some client,
+ else set pending deactivation
+ */
+
+ // If known by some client, don't delete.
+ if(obj->m_known_by_count > 0 && force_delete == false)
+ {
+ obj->m_pending_deactivation = true;
+ continue;
+ }
+
+ /*dstream<<"INFO: Server: Stored static data. Deleting object."
+ <<std::endl;*/
+ // Delete active object
+ delete obj;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ }
+
+ // Remove references from m_active_objects
+ for(core::list<u16>::Iterator i = objects_to_remove.begin();
+ i != objects_to_remove.end(); i++)
+ {
+ m_active_objects.remove(*i);
+ }
+}
+
+