X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fpathfinder.cpp;h=76dd5560db53e942b4ed5797b431d62298fac18b;hb=fd9f195fcc2e4e592dbad3290876486eb08318b2;hp=073670c6d9bc33a17913a305fdc32a7cf4b1eba4;hpb=4d4b8bb8a46b6472d86fa848954dbc26b4fadb50;p=minetest.git diff --git a/src/pathfinder.cpp b/src/pathfinder.cpp index 073670c6d..76dd5560d 100644 --- a/src/pathfinder.cpp +++ b/src/pathfinder.cpp @@ -23,13 +23,9 @@ with this program; if not, write to the Free Software Foundation, Inc., /******************************************************************************/ #include "pathfinder.h" -#include "environment.h" -#include "gamedef.h" +#include "serverenvironment.h" +#include "server.h" #include "nodedef.h" -#include "map.h" -#include "log.h" -#include "irr_aabb3d.h" -#include "util/basic_macros.h" //#define PATHFINDER_DEBUG //#define PATHFINDER_CALC_TIME @@ -59,7 +55,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #define DEBUG_OUT(a) while(0) #define INFO_TARGET infostream << "Pathfinder: " #define VERBOSE_TARGET verbosestream << "Pathfinder: " -#define ERROR_TARGET errorstream << "Pathfinder: " +#define ERROR_TARGET warningstream << "Pathfinder: " #endif /******************************************************************************/ @@ -72,7 +68,7 @@ class PathCost { public: /** default constructor */ - PathCost(); + PathCost() = default; /** copy constructor */ PathCost(const PathCost &b); @@ -80,10 +76,10 @@ class PathCost { /** assignment operator */ PathCost &operator= (const PathCost &b); - bool valid; /**< movement is possible */ - int value; /**< cost of movement */ - int direction; /**< y-direction of movement */ - bool updated; /**< this cost has ben calculated */ + bool valid = false; /**< movement is possible */ + int value = 0; /**< cost of movement */ + int direction = 0; /**< y-direction of movement */ + bool updated = false; /**< this cost has ben calculated */ }; @@ -93,7 +89,7 @@ class PathGridnode { public: /** default constructor */ - PathGridnode(); + PathGridnode() = default; /** copy constructor */ PathGridnode(const PathGridnode &b); @@ -115,19 +111,19 @@ class PathGridnode { * @param dir direction to set cost for * @cost cost to set */ - void setCost(v3s16 dir, PathCost cost); + void setCost(v3s16 dir, const PathCost &cost); - bool valid; /**< node is on surface */ - bool target; /**< node is target position */ - bool source; /**< node is stating position */ - int totalcost; /**< cost to move here from starting point */ - v3s16 sourcedir; /**< origin of movement for current cost */ - v3s16 pos; /**< real position of node */ - PathCost directions[4]; /**< cost in different directions */ + bool valid = false; /**< node is on surface */ + bool target = false; /**< node is target position */ + bool source = false; /**< node is stating position */ + int totalcost = -1; /**< cost to move here from starting point */ + v3s16 sourcedir; /**< origin of movement for current cost */ + v3s16 pos; /**< real position of node */ + PathCost directions[4]; /**< cost in different directions */ /* debug values */ - bool is_element; /**< node is element of path detected */ - char type; /**< type of node */ + bool is_element = false; /**< node is element of path detected */ + char type = 'u'; /**< type of node */ }; class Pathfinder; @@ -136,7 +132,8 @@ class Pathfinder; class GridNodeContainer { public: virtual PathGridnode &access(v3s16 p)=0; - virtual ~GridNodeContainer() {} + virtual ~GridNodeContainer() = default; + protected: Pathfinder *m_pathf; @@ -145,7 +142,8 @@ class GridNodeContainer { class ArrayGridNodeContainer : public GridNodeContainer { public: - virtual ~ArrayGridNodeContainer() {} + virtual ~ArrayGridNodeContainer() = default; + ArrayGridNodeContainer(Pathfinder *pathf, v3s16 dimensions); virtual PathGridnode &access(v3s16 p); private: @@ -158,7 +156,8 @@ class ArrayGridNodeContainer : public GridNodeContainer { class MapGridNodeContainer : public GridNodeContainer { public: - virtual ~MapGridNodeContainer() {} + virtual ~MapGridNodeContainer() = default; + MapGridNodeContainer(Pathfinder *pathf); virtual PathGridnode &access(v3s16 p); private: @@ -172,7 +171,7 @@ class Pathfinder { /** * default constructor */ - Pathfinder(); + Pathfinder() = default; ~Pathfinder(); @@ -285,7 +284,7 @@ class Pathfinder { * @param level current recursion depth * @return true/false path to destination has been found */ - bool updateAllCosts(v3s16 ipos, v3s16 srcdir, int total_cost, int level); + bool updateAllCosts(v3s16 ipos, v3s16 srcdir, int current_cost, int level); /** * recursive try to find a patrh to destionation @@ -306,17 +305,17 @@ class Pathfinder { void buildPath(std::vector &path, v3s16 pos, int level); /* variables */ - int m_max_index_x; /**< max index of search area in x direction */ - int m_max_index_y; /**< max index of search area in y direction */ - int m_max_index_z; /**< max index of search area in z direction */ + int m_max_index_x = 0; /**< max index of search area in x direction */ + int m_max_index_y = 0; /**< max index of search area in y direction */ + int m_max_index_z = 0; /**< max index of search area in z direction */ - int m_searchdistance; /**< max distance to search in each direction */ - int m_maxdrop; /**< maximum number of blocks a path may drop */ - int m_maxjump; /**< maximum number of blocks a path may jump */ - int m_min_target_distance; /**< current smalest path to target */ + int m_searchdistance = 0; /**< max distance to search in each direction */ + int m_maxdrop = 0; /**< maximum number of blocks a path may drop */ + int m_maxjump = 0; /**< maximum number of blocks a path may jump */ + int m_min_target_distance = 0; /**< current smalest path to target */ - bool m_prefetch; /**< prefetch cost data */ + bool m_prefetch = true; /**< prefetch cost data */ v3s16 m_start; /**< source position */ v3s16 m_destination; /**< destination position */ @@ -326,9 +325,9 @@ class Pathfinder { /** contains all map data already collected and analyzed. Access it via the getIndexElement/getIdxElem methods. */ friend class GridNodeContainer; - GridNodeContainer *m_nodes_container; + GridNodeContainer *m_nodes_container = nullptr; - ServerEnvironment *m_env; /**< minetest environment pointer */ + ServerEnvironment *m_env = 0; /**< minetest environment pointer */ #ifdef PATHFINDER_DEBUG @@ -398,16 +397,6 @@ std::vector get_path(ServerEnvironment* env, searchdistance, max_jump, max_drop, algo); } -/******************************************************************************/ -PathCost::PathCost() -: valid(false), - value(0), - direction(0), - updated(false) -{ - //intentionaly empty -} - /******************************************************************************/ PathCost::PathCost(const PathCost &b) { @@ -428,20 +417,6 @@ PathCost &PathCost::operator= (const PathCost &b) return *this; } -/******************************************************************************/ -PathGridnode::PathGridnode() -: valid(false), - target(false), - source(false), - totalcost(-1), - sourcedir(v3s16(0, 0, 0)), - pos(v3s16(0, 0, 0)), - is_element(false), - type('u') -{ - //intentionaly empty -} - /******************************************************************************/ PathGridnode::PathGridnode(const PathGridnode &b) : valid(b.valid), @@ -500,7 +475,7 @@ PathCost PathGridnode::getCost(v3s16 dir) } /******************************************************************************/ -void PathGridnode::setCost(v3s16 dir, PathCost cost) +void PathGridnode::setCost(v3s16 dir, const PathCost &cost) { if (dir.X > 0) { directions[DIR_XP] = cost; @@ -732,9 +707,8 @@ std::vector Pathfinder::getPath(ServerEnvironment *env, //finalize path std::vector full_path; - for (std::vector::iterator i = path.begin(); - i != path.end(); ++i) { - full_path.push_back(getIndexElement(*i).pos); + for (const v3s16 &i : path) { + full_path.push_back(getIndexElement(i).pos); } #ifdef PATHFINDER_DEBUG @@ -767,24 +741,6 @@ std::vector Pathfinder::getPath(ServerEnvironment *env, return retval; } -/******************************************************************************/ -Pathfinder::Pathfinder() : - m_max_index_x(0), - m_max_index_y(0), - m_max_index_z(0), - m_searchdistance(0), - m_maxdrop(0), - m_maxjump(0), - m_min_target_distance(0), - m_prefetch(true), - m_start(0, 0, 0), - m_destination(0, 0, 0), - m_nodes_container(NULL), - m_env(0) -{ - //intentionaly empty -} - Pathfinder::~Pathfinder() { delete m_nodes_container; @@ -974,19 +930,19 @@ bool Pathfinder::updateAllCosts(v3s16 ipos, std::vector directions; - directions.push_back(v3s16( 1,0, 0)); - directions.push_back(v3s16(-1,0, 0)); - directions.push_back(v3s16( 0,0, 1)); - directions.push_back(v3s16( 0,0,-1)); + directions.emplace_back(1,0, 0); + directions.emplace_back(-1,0, 0); + directions.emplace_back(0,0, 1); + directions.emplace_back(0,0,-1); - for (unsigned int i=0; i < directions.size(); i++) { - if (directions[i] != srcdir) { - PathCost cost = g_pos.getCost(directions[i]); + for (v3s16 &direction : directions) { + if (direction != srcdir) { + PathCost cost = g_pos.getCost(direction); if (cost.valid) { - directions[i].Y = cost.direction; + direction.Y = cost.direction; - v3s16 ipos2 = ipos + directions[i]; + v3s16 ipos2 = ipos + direction; if (!isValidIndex(ipos2)) { DEBUG_OUT(LVL " Pathfinder: " << PP(ipos2) << @@ -1017,7 +973,7 @@ bool Pathfinder::updateAllCosts(v3s16 ipos, DEBUG_OUT(LVL "Pathfinder: updating path at: "<< PP(ipos2) << " from: " << g_pos2.totalcost << " to "<< new_cost << std::endl); - if (updateAllCosts(ipos2, invert(directions[i]), + if (updateAllCosts(ipos2, invert(direction), new_cost, level)) { retval = true; } @@ -1058,18 +1014,16 @@ v3s16 Pathfinder::getDirHeuristic(std::vector &directions, PathGridnode & DEBUG_OUT("Pathfinder: remaining dirs at beginning:" << directions.size() << std::endl); - for (std::vector::iterator iter = directions.begin(); - iter != directions.end(); - ++iter) { + for (v3s16 &direction : directions) { - v3s16 pos1 = v3s16(srcpos.X + iter->X, 0, srcpos.Z+iter->Z); + v3s16 pos1 = v3s16(srcpos.X + direction.X, 0, srcpos.Z+ direction.Z); int cur_manhattan = getXZManhattanDist(pos1); - PathCost cost = g_pos.getCost(*iter); + PathCost cost = g_pos.getCost(direction); if (!cost.updated) { - cost = calcCost(g_pos.pos, *iter); - g_pos.setCost(*iter, cost); + cost = calcCost(g_pos.pos, direction); + g_pos.setCost(direction, cost); } if (cost.valid) { @@ -1077,7 +1031,7 @@ v3s16 Pathfinder::getDirHeuristic(std::vector &directions, PathGridnode & if ((minscore < 0)|| (score < minscore)) { minscore = score; - retdir = *iter; + retdir = direction; } } } @@ -1127,10 +1081,10 @@ bool Pathfinder::updateCostHeuristic( v3s16 ipos, std::vector directions; - directions.push_back(v3s16( 1, 0, 0)); - directions.push_back(v3s16(-1, 0, 0)); - directions.push_back(v3s16( 0, 0, 1)); - directions.push_back(v3s16( 0, 0, -1)); + directions.emplace_back(1, 0, 0); + directions.emplace_back(-1, 0, 0); + directions.emplace_back(0, 0, 1); + directions.emplace_back(0, 0, -1); v3s16 direction = getDirHeuristic(directions, g_pos);