Reduce ServerEnvironment propagation (#9642)

ServerEnvironment is a huge class with many accessors. In various places it's not needed

Remove it to reduce the ServerEnvironment view.

Idea here is to reduce size of some of our objects to transport lightweight managers and permit easier testing

Pathfinder is now tied to a generic map, not a ServerMap, it can be
ported to client

diff --git a/src/mapgen/treegen.cpp b/src/mapgen/treegen.cpp
index 89bdef73b98f0b44829d56f2863ed2d8b76a9695..d538e15b494b6752642f6200ff0f716209cac2b7 100644 (file)
--- a/src/mapgen/treegen.cpp
+++ b/src/mapgen/treegen.cpp
@@ -25,7 +25,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/numeric.h"
 #include "map.h"
 #include "mapblock.h"
-#include "serverenvironment.h"
 #include "nodedef.h"
 #include "treegen.h"
 #include "voxelalgorithms.h"
@@ -120,10 +119,9 @@ void make_tree(MMVManip &vmanip, v3s16 p0, bool is_apple_tree,
 
 
 // L-System tree LUA spawner
-treegen::error spawn_ltree(ServerEnvironment *env, v3s16 p0,
+treegen::error spawn_ltree(ServerMap *map, v3s16 p0,
        const NodeDefManager *ndef, const TreeDef &tree_definition)
 {
-       ServerMap *map = &env->getServerMap();
        std::map<v3s16, MapBlock*> modified_blocks;
        MMVManip vmanip(map);
        v3s16 tree_blockp = getNodeBlockPos(p0);

diff --git a/src/mapgen/treegen.h b/src/mapgen/treegen.h
index 5ab79f428afcf9f4638492721c35e4421289db61..447baabb3758484a41e6540eb7cfe89ceb445931 100644 (file)
--- a/src/mapgen/treegen.h
+++ b/src/mapgen/treegen.h
@@ -26,8 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 class MMVManip;
 class NodeDefManager;
-class ServerEnvironment;
-
+class ServerMap;
 
 namespace treegen {
 
@@ -73,7 +72,7 @@ namespace treegen {
        treegen::error make_ltree(MMVManip &vmanip, v3s16 p0,
                const NodeDefManager *ndef, TreeDef tree_definition);
        // Spawn L-systems tree from LUA
-       treegen::error spawn_ltree (ServerEnvironment *env, v3s16 p0,
+       treegen::error spawn_ltree (ServerMap *map, v3s16 p0,
                const NodeDefManager *ndef, const TreeDef &tree_definition);
 
        // L-System tree gen helper functions

diff --git a/src/pathfinder.cpp b/src/pathfinder.cpp
index 8195bd643d4b3c6ae1a9a55c3bfc433737092392..3f0b98c1074ce35dbf54eb5719088318dd4a7726 100644 (file)
--- a/src/pathfinder.cpp
+++ b/src/pathfinder.cpp
@@ -23,8 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 /******************************************************************************/
 
 #include "pathfinder.h"
-#include "serverenvironment.h"
-#include "server.h"
+#include "map.h"
 #include "nodedef.h"
 
 //#define PATHFINDER_DEBUG
@@ -180,10 +179,8 @@ private:
 class Pathfinder {
 
 public:
-       /**
-        * default constructor
-        */
-       Pathfinder() = default;
+       Pathfinder() = delete;
+       Pathfinder(Map *map, const NodeDefManager *ndef) : m_map(map), m_ndef(ndef) {}
 
        ~Pathfinder();
 
@@ -197,8 +194,7 @@ public:
         * @param max_drop maximum number of blocks a path may drop
         * @param algo Algorithm to use for finding a path
         */
-       std::vector<v3s16> getPath(ServerEnvironment *env,
-                       v3s16 source,
+       std::vector<v3s16> getPath(v3s16 source,
                        v3s16 destination,
                        unsigned int searchdistance,
                        unsigned int max_jump,
@@ -328,7 +324,9 @@ private:
        friend class GridNodeContainer;
        GridNodeContainer *m_nodes_container = nullptr;
 
-       ServerEnvironment *m_env = 0;     /**< minetest environment pointer             */
+       Map *m_map = nullptr;
+
+       const NodeDefManager *m_ndef = nullptr;
 
        friend class PathfinderCompareHeuristic;
 
@@ -410,18 +408,15 @@ class PathfinderCompareHeuristic
 /* implementation                                                             */
 /******************************************************************************/
 
-std::vector<v3s16> get_path(ServerEnvironment* env,
-                                                       v3s16 source,
-                                                       v3s16 destination,
-                                                       unsigned int searchdistance,
-                                                       unsigned int max_jump,
-                                                       unsigned int max_drop,
-                                                       PathAlgorithm algo)
+std::vector<v3s16> get_path(Map* map, const NodeDefManager *ndef,
+               v3s16 source,
+               v3s16 destination,
+               unsigned int searchdistance,
+               unsigned int max_jump,
+               unsigned int max_drop,
+               PathAlgorithm algo)
 {
-       Pathfinder searchclass;
-
-       return searchclass.getPath(env,
-                               source, destination,
+       return Pathfinder(map, ndef).getPath(source, destination,
                                searchdistance, max_jump, max_drop, algo);
 }
 
@@ -521,13 +516,13 @@ void PathGridnode::setCost(v3s16 dir, const PathCost &cost)
 
 void GridNodeContainer::initNode(v3s16 ipos, PathGridnode *p_node)
 {
-       const NodeDefManager *ndef = m_pathf->m_env->getGameDef()->ndef();
+       const NodeDefManager *ndef = m_pathf->m_ndef;
        PathGridnode &elem = *p_node;
 
        v3s16 realpos = m_pathf->getRealPos(ipos);
 
-       MapNode current = m_pathf->m_env->getMap().getNode(realpos);
-       MapNode below   = m_pathf->m_env->getMap().getNode(realpos + v3s16(0, -1, 0));
+       MapNode current = m_pathf->m_map->getNode(realpos);
+       MapNode below   = m_pathf->m_map->getNode(realpos + v3s16(0, -1, 0));
 
 
        if ((current.param0 == CONTENT_IGNORE) ||
@@ -610,8 +605,7 @@ PathGridnode &MapGridNodeContainer::access(v3s16 p)
 
 
 /******************************************************************************/
-std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
-                                                       v3s16 source,
+std::vector<v3s16> Pathfinder::getPath(v3s16 source,
                                                        v3s16 destination,
                                                        unsigned int searchdistance,
                                                        unsigned int max_jump,
@@ -624,15 +618,8 @@ std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
 #endif
        std::vector<v3s16> retval;
 
-       //check parameters
-       if (env == 0) {
-               ERROR_TARGET << "Missing environment pointer" << std::endl;
-               return retval;
-       }
-
        //initialization
        m_searchdistance = searchdistance;
-       m_env = env;
        m_maxjump = max_jump;
        m_maxdrop = max_drop;
        m_start       = source;
@@ -681,15 +668,14 @@ std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
 #endif
 
        //fail if source or destination is walkable
-       const NodeDefManager *ndef = m_env->getGameDef()->ndef();
-       MapNode node_at_pos = m_env->getMap().getNode(destination);
-       if (ndef->get(node_at_pos).walkable) {
+       MapNode node_at_pos = m_map->getNode(destination);
+       if (m_ndef->get(node_at_pos).walkable) {
                VERBOSE_TARGET << "Destination is walkable. " <<
                                "Pos: " << PP(destination) << std::endl;
                return retval;
        }
-       node_at_pos = m_env->getMap().getNode(source);
-       if (ndef->get(node_at_pos).walkable) {
+       node_at_pos = m_map->getNode(source);
+       if (m_ndef->get(node_at_pos).walkable) {
                VERBOSE_TARGET << "Source is walkable. " <<
                                "Pos: " << PP(source) << std::endl;
                return retval;
@@ -843,7 +829,6 @@ v3s16 Pathfinder::getRealPos(v3s16 ipos)
 /******************************************************************************/
 PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
 {
-       const NodeDefManager *ndef = m_env->getGameDef()->ndef();
        PathCost retval;
 
        retval.updated = true;
@@ -857,7 +842,7 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
                return retval;
        }
 
-       MapNode node_at_pos2 = m_env->getMap().getNode(pos2);
+       MapNode node_at_pos2 = m_map->getNode(pos2);
 
        //did we get information about node?
        if (node_at_pos2.param0 == CONTENT_IGNORE ) {
@@ -866,9 +851,9 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
                        return retval;
        }
 
-       if (!ndef->get(node_at_pos2).walkable) {
+       if (!m_ndef->get(node_at_pos2).walkable) {
                MapNode node_below_pos2 =
-                       m_env->getMap().getNode(pos2 + v3s16(0, -1, 0));
+                       m_map->getNode(pos2 + v3s16(0, -1, 0));
 
                //did we get information about node?
                if (node_below_pos2.param0 == CONTENT_IGNORE ) {
@@ -878,7 +863,7 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
                }
 
                //test if the same-height neighbor is suitable
-               if (ndef->get(node_below_pos2).walkable) {
+               if (m_ndef->get(node_below_pos2).walkable) {
                        //SUCCESS!
                        retval.valid = true;
                        retval.value = 1;
@@ -889,19 +874,19 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
                else {
                        //test if we can fall a couple of nodes (m_maxdrop)
                        v3s16 testpos = pos2 + v3s16(0, -1, 0);
-                       MapNode node_at_pos = m_env->getMap().getNode(testpos);
+                       MapNode node_at_pos = m_map->getNode(testpos);
 
                        while ((node_at_pos.param0 != CONTENT_IGNORE) &&
-                                       (!ndef->get(node_at_pos).walkable) &&
+                                       (!m_ndef->get(node_at_pos).walkable) &&
                                        (testpos.Y > m_limits.MinEdge.Y)) {
                                testpos += v3s16(0, -1, 0);
-                               node_at_pos = m_env->getMap().getNode(testpos);
+                               node_at_pos = m_map->getNode(testpos);
                        }
 
                        //did we find surface?
                        if ((testpos.Y >= m_limits.MinEdge.Y) &&
                                        (node_at_pos.param0 != CONTENT_IGNORE) &&
-                                       (ndef->get(node_at_pos).walkable)) {
+                                       (m_ndef->get(node_at_pos).walkable)) {
                                if ((pos2.Y - testpos.Y - 1) <= m_maxdrop) {
                                        //SUCCESS!
                                        retval.valid = true;
@@ -927,34 +912,34 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
 
                v3s16 targetpos = pos2; // position for jump target
                v3s16 jumppos = pos; // position for checking if jumping space is free
-               MapNode node_target = m_env->getMap().getNode(targetpos);
-               MapNode node_jump = m_env->getMap().getNode(jumppos);
+               MapNode node_target = m_map->getNode(targetpos);
+               MapNode node_jump = m_map->getNode(jumppos);
                bool headbanger = false; // true if anything blocks jumppath
 
                while ((node_target.param0 != CONTENT_IGNORE) &&
-                               (ndef->get(node_target).walkable) &&
+                               (m_ndef->get(node_target).walkable) &&
                                (targetpos.Y < m_limits.MaxEdge.Y)) {
                        //if the jump would hit any solid node, discard
                        if ((node_jump.param0 == CONTENT_IGNORE) ||
-                                       (ndef->get(node_jump).walkable)) {
+                                       (m_ndef->get(node_jump).walkable)) {
                                        headbanger = true;
                                break;
                        }
                        targetpos += v3s16(0, 1, 0);
                        jumppos   += v3s16(0, 1, 0);
-                       node_target = m_env->getMap().getNode(targetpos);
-                       node_jump   = m_env->getMap().getNode(jumppos);
+                       node_target = m_map->getNode(targetpos);
+                       node_jump   = m_map->getNode(jumppos);
 
                }
                //check headbanger one last time
                if ((node_jump.param0 == CONTENT_IGNORE) ||
-                       (ndef->get(node_jump).walkable)) {
+                       (m_ndef->get(node_jump).walkable)) {
                        headbanger = true;
                }
 
                //did we find surface without banging our head?
                if ((!headbanger) && (targetpos.Y <= m_limits.MaxEdge.Y) &&
-                               (!ndef->get(node_target).walkable)) {
+                               (!m_ndef->get(node_target).walkable)) {
 
                        if (targetpos.Y - pos2.Y <= m_maxjump) {
                                //SUCCESS!
@@ -1254,21 +1239,20 @@ v3s16 Pathfinder::walkDownwards(v3s16 pos, unsigned int max_down) {
        if (max_down == 0)
                return pos;
        v3s16 testpos = v3s16(pos);
-       MapNode node_at_pos = m_env->getMap().getNode(testpos);
-       const NodeDefManager *ndef = m_env->getGameDef()->ndef();
+       MapNode node_at_pos = m_map->getNode(testpos);
        unsigned int down = 0;
        while ((node_at_pos.param0 != CONTENT_IGNORE) &&
-                       (!ndef->get(node_at_pos).walkable) &&
+                       (!m_ndef->get(node_at_pos).walkable) &&
                        (testpos.Y > m_limits.MinEdge.Y) &&
                        (down <= max_down)) {
                testpos += v3s16(0, -1, 0);
                down++;
-               node_at_pos = m_env->getMap().getNode(testpos);
+               node_at_pos = m_map->getNode(testpos);
        }
        //did we find surface?
        if ((testpos.Y >= m_limits.MinEdge.Y) &&
                        (node_at_pos.param0 != CONTENT_IGNORE) &&
-                       (ndef->get(node_at_pos).walkable)) {
+                       (m_ndef->get(node_at_pos).walkable)) {
                if (down == 0) {
                        pos = testpos;
                } else if ((down - 1) <= max_down) {

diff --git a/src/pathfinder.h b/src/pathfinder.h
index 70f3d6bbc8dbe823e8130df9069e3979cd1a278c..526aa0ee8d34f9b17f56e02378d01028eb3430e5 100644 (file)
--- a/src/pathfinder.h
+++ b/src/pathfinder.h
@@ -29,7 +29,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 /* Forward declarations                                                       */
 /******************************************************************************/
 
-class ServerEnvironment;
+class NodeDefManager;
+class Map;
 
 /******************************************************************************/
 /* Typedefs and macros                                                        */
@@ -54,10 +55,10 @@ typedef enum {
 /******************************************************************************/
 
 /** c wrapper function to use from scriptapi */
-std::vector<v3s16> get_path(ServerEnvironment *env,
-                                                       v3s16 source,
-                                                       v3s16 destination,
-                                                       unsigned int searchdistance,
-                                                       unsigned int max_jump,
-                                                       unsigned int max_drop,
-                                                       PathAlgorithm algo);
+std::vector<v3s16> get_path(Map *map, const NodeDefManager *ndef,
+               v3s16 source,
+               v3s16 destination,
+               unsigned int searchdistance,
+               unsigned int max_jump,
+               unsigned int max_drop,
+               PathAlgorithm algo);

diff --git a/src/script/lua_api/l_env.cpp b/src/script/lua_api/l_env.cpp
index 40e50e64a81ee8803928bd12fb6662a963d14fc8..e3afe186222efb08e133e1bfae18aa8af1a7bab2 100644 (file)
--- a/src/script/lua_api/l_env.cpp
+++ b/src/script/lua_api/l_env.cpp
@@ -577,7 +577,7 @@ int ModApiEnvMod::l_get_node_timer(lua_State *L)
 
        // Do it
        v3s16 p = read_v3s16(L, 1);
-       NodeTimerRef::create(L, p, env);
+       NodeTimerRef::create(L, p, &env->getServerMap());
        return 1;
 }
 
@@ -1193,7 +1193,7 @@ int ModApiEnvMod::l_find_path(lua_State *L)
                        algo = PA_DIJKSTRA;
        }
 
-       std::vector<v3s16> path = get_path(env, pos1, pos2,
+       std::vector<v3s16> path = get_path(&env->getServerMap(), env->getGameDef()->ndef(), pos1, pos2,
                searchdistance, max_jump, max_drop, algo);
 
        if (!path.empty()) {
@@ -1257,8 +1257,9 @@ int ModApiEnvMod::l_spawn_tree(lua_State *L)
        else
                return 0;
 
+       ServerMap *map = &env->getServerMap();
        treegen::error e;
-       if ((e = treegen::spawn_ltree (env, p0, ndef, tree_def)) != treegen::SUCCESS) {
+       if ((e = treegen::spawn_ltree (map, p0, ndef, tree_def)) != treegen::SUCCESS) {
                if (e == treegen::UNBALANCED_BRACKETS) {
                        luaL_error(L, "spawn_tree(): closing ']' has no matching opening bracket");
                } else {

diff --git a/src/script/lua_api/l_nodetimer.cpp b/src/script/lua_api/l_nodetimer.cpp
index 15a59744fd377761d10b2d2c499c2cb21c8d080c..c2df52c0523983c30fd6c7a1b516b7742e796468 100644 (file)
--- a/src/script/lua_api/l_nodetimer.cpp
+++ b/src/script/lua_api/l_nodetimer.cpp
@@ -41,11 +41,9 @@ int NodeTimerRef::l_set(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
        f32 t = readParam<float>(L,2);
        f32 e = readParam<float>(L,3);
-       env->getMap().setNodeTimer(NodeTimer(t, e, o->m_p));
+       o->m_map->setNodeTimer(NodeTimer(t, e, o->m_p));
        return 0;
 }
 
@@ -53,10 +51,8 @@ int NodeTimerRef::l_start(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
        f32 t = readParam<float>(L,2);
-       env->getMap().setNodeTimer(NodeTimer(t, 0, o->m_p));
+       o->m_map->setNodeTimer(NodeTimer(t, 0, o->m_p));
        return 0;
 }
 
@@ -64,9 +60,7 @@ int NodeTimerRef::l_stop(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
-       env->getMap().removeNodeTimer(o->m_p);
+       o->m_map->removeNodeTimer(o->m_p);
        return 0;
 }
 
@@ -74,10 +68,7 @@ int NodeTimerRef::l_is_started(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
-
-       NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+       NodeTimer t = o->m_map->getNodeTimer(o->m_p);
        lua_pushboolean(L,(t.timeout != 0));
        return 1;
 }
@@ -86,10 +77,7 @@ int NodeTimerRef::l_get_timeout(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
-
-       NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+       NodeTimer t = o->m_map->getNodeTimer(o->m_p);
        lua_pushnumber(L,t.timeout);
        return 1;
 }
@@ -98,37 +86,21 @@ int NodeTimerRef::l_get_elapsed(lua_State *L)
 {
        MAP_LOCK_REQUIRED;
        NodeTimerRef *o = checkobject(L, 1);
-       ServerEnvironment *env = o->m_env;
-       if(env == NULL) return 0;
-
-       NodeTimer t = env->getMap().getNodeTimer(o->m_p);
+       NodeTimer t = o->m_map->getNodeTimer(o->m_p);
        lua_pushnumber(L,t.elapsed);
        return 1;
 }
 
-
-NodeTimerRef::NodeTimerRef(v3s16 p, ServerEnvironment *env):
-       m_p(p),
-       m_env(env)
-{
-}
-
 // Creates an NodeTimerRef and leaves it on top of stack
 // Not callable from Lua; all references are created on the C side.
-void NodeTimerRef::create(lua_State *L, v3s16 p, ServerEnvironment *env)
+void NodeTimerRef::create(lua_State *L, v3s16 p, ServerMap *map)
 {
-       NodeTimerRef *o = new NodeTimerRef(p, env);
+       NodeTimerRef *o = new NodeTimerRef(p, map);
        *(void **)(lua_newuserdata(L, sizeof(void *))) = o;
        luaL_getmetatable(L, className);
        lua_setmetatable(L, -2);
 }
 
-void NodeTimerRef::set_null(lua_State *L)
-{
-       NodeTimerRef *o = checkobject(L, -1);
-       o->m_env = NULL;
-}
-
 void NodeTimerRef::Register(lua_State *L)
 {
        lua_newtable(L);

diff --git a/src/script/lua_api/l_nodetimer.h b/src/script/lua_api/l_nodetimer.h
index b894c5c8ca7ad2012eada0c27c427ab6dd096663..bbc975fd236b76ab738688159c54d40568bd997d 100644 (file)
--- a/src/script/lua_api/l_nodetimer.h
+++ b/src/script/lua_api/l_nodetimer.h
@@ -22,13 +22,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "irr_v3d.h"
 #include "lua_api/l_base.h"
 
-class ServerEnvironment;
+class ServerMap;
 
 class NodeTimerRef : public ModApiBase
 {
 private:
        v3s16 m_p;
-       ServerEnvironment *m_env = nullptr;
+       ServerMap *m_map;
 
        static const char className[];
        static const luaL_Reg methods[];
@@ -50,14 +50,12 @@ private:
        static int l_get_elapsed(lua_State *L);
 
 public:
-       NodeTimerRef(v3s16 p, ServerEnvironment *env);
+       NodeTimerRef(v3s16 p, ServerMap *map) : m_p(p), m_map(map) {}
        ~NodeTimerRef() = default;
 
        // Creates an NodeTimerRef and leaves it on top of stack
        // Not callable from Lua; all references are created on the C side.
-       static void create(lua_State *L, v3s16 p, ServerEnvironment *env);
-
-       static void set_null(lua_State *L);
+       static void create(lua_State *L, v3s16 p, ServerMap *map);
 
        static void Register(lua_State *L);
 };