Add definable node_stone to biome API, mgv5, mgv7. Reduce and correct depth of mgv7...

[oweals/minetest.git] / src / server.cpp

diff --git a/src/server.cpp b/src/server.cpp
index 2558d0d6fee309b05984d14c96510af06aaee8ef..857114d0f0fc12461fd5a9c4840aa1c141d813d6 100644 (file)
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -181,7 +181,6 @@ Server::Server(
                        this),
        m_banmanager(NULL),
        m_rollback(NULL),
-       m_rollback_sink_enabled(true),
        m_enable_rollback_recording(false),
        m_emerge(NULL),
        m_script(NULL),
@@ -241,12 +240,11 @@ Server::Server(
                throw ServerError("Failed to initialize world");
 
        // Create ban manager
-       std::string ban_path = m_path_world+DIR_DELIM+"ipban.txt";
+       std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
        m_banmanager = new BanManager(ban_path);
 
        // Create rollback manager
-       std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
-       m_rollback = createRollbackManager(rollback_path, this);
+       m_rollback = new RollbackManager(m_path_world, this);
 
        ModConfiguration modconf(m_path_world);
        m_mods = modconf.getMods();
@@ -687,6 +685,7 @@ void Server::AsyncRunStep(bool initial_step)
                                        m_env->getGameTime(),
                                        m_lag,
                                        m_gamespec.id,
+                                       m_emerge->params.mg_name,
                                        m_mods);
                        counter = 0.01;
                }
@@ -707,7 +706,14 @@ void Server::AsyncRunStep(bool initial_step)
 
                // Radius inside which objects are active
                s16 radius = g_settings->getS16("active_object_send_range_blocks");
+               s16 player_radius = g_settings->getS16("player_transfer_distance");
+
+               if (player_radius == 0 && g_settings->exists("unlimited_player_transfer_distance") &&
+                               !g_settings->getBool("unlimited_player_transfer_distance"))
+                       player_radius = radius;
+
                radius *= MAP_BLOCKSIZE;
+               player_radius *= MAP_BLOCKSIZE;
 
                for(std::map<u16, RemoteClient*>::iterator
                        i = clients.begin();
@@ -733,9 +739,9 @@ void Server::AsyncRunStep(bool initial_step)
 
                        std::set<u16> removed_objects;
                        std::set<u16> added_objects;
-                       m_env->getRemovedActiveObjects(pos, radius,
+                       m_env->getRemovedActiveObjects(pos, radius, player_radius,
                                        client->m_known_objects, removed_objects);
-                       m_env->getAddedActiveObjects(pos, radius,
+                       m_env->getAddedActiveObjects(pos, radius, player_radius,
                                        client->m_known_objects, added_objects);
 
                        // Ignore if nothing happened
@@ -2416,17 +2422,18 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
                                        somebody is cheating, by checking the timing.
                                */
                                MapNode n(CONTENT_IGNORE);
-                               try
-                               {
-                                       n = m_env->getMap().getNode(p_under);
-                               }
-                               catch(InvalidPositionException &e)
-                               {
+                               bool pos_ok;
+                               n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
+                               if (pos_ok)
+                                       n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
+
+                               if (!pos_ok) {
                                        infostream<<"Server: Not punching: Node not found."
                                                        <<" Adding block to emerge queue."
                                                        <<std::endl;
                                        m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
                                }
+
                                if(n.getContent() != CONTENT_IGNORE)
                                        m_script->node_on_punch(p_under, n, playersao, pointed);
                                // Cheat prevention
@@ -2471,16 +2478,12 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
                        // Only digging of nodes
                        if(pointed.type == POINTEDTHING_NODE)
                        {
-                               MapNode n(CONTENT_IGNORE);
-                               try
-                               {
-                                       n = m_env->getMap().getNode(p_under);
-                               }
-                               catch(InvalidPositionException &e)
-                               {
-                                       infostream<<"Server: Not finishing digging: Node not found."
-                                                       <<" Adding block to emerge queue."
-                                                       <<std::endl;
+                               bool pos_ok;
+                               MapNode n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
+                               if (!pos_ok) {
+                                       infostream << "Server: Not finishing digging: Node not found."
+                                                  << " Adding block to emerge queue."
+                                                  << std::endl;
                                        m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
                                }
 
@@ -4829,8 +4832,6 @@ bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
 {
        infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
        ServerMap *map = (ServerMap*)(&m_env->getMap());
-       // Disable rollback report sink while reverting
-       BoolScopeSet rollback_scope_disable(&m_rollback_sink_enabled, false);
 
        // Fail if no actions to handle
        if(actions.empty()){
@@ -4910,14 +4911,6 @@ MtEventManager* Server::getEventManager()
 {
        return m_event;
 }
-IRollbackReportSink* Server::getRollbackReportSink()
-{
-       if(!m_enable_rollback_recording)
-               return NULL;
-       if(!m_rollback_sink_enabled)
-               return NULL;
-       return m_rollback;
-}
 
 IWritableItemDefManager* Server::getWritableItemDefManager()
 {