Pathfinder: use core::aabbox3d instead of own type

There is no need to reinvent the wheel here, we have
great classes from irrlicht.

diff --git a/src/pathfinder.cpp b/src/pathfinder.cpp
index 28cad1733d5fbbcfb4a6cfc3b6a52e51492d097a..29a39233d827ffbb1679e96be274e6280419e1bf 100644 (file)
--- a/src/pathfinder.cpp
+++ b/src/pathfinder.cpp
@@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "environment.h"
 #include "map.h"
 #include "log.h"
+#include "irr_aabb3d.h"
 
 //#define PATHFINDER_DEBUG
 //#define PATHFINDER_CALC_TIME
@@ -157,18 +158,6 @@ public:
                        PathAlgorithm algo);
 
 private:
-       /** data struct for storing internal information */
-       struct limits {
-               struct limit {
-                       int min;
-                       int max;
-               };
-
-               limit X;
-               limit Y;
-               limit Z;
-       };
-
        /* helper functions */
 
        /**
@@ -274,27 +263,27 @@ private:
        void          buildPath(std::vector<v3s16> &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;            /**< 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_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;         /**< 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           */
 
-       bool m_prefetch;            /**< prefetch cost data                       */
+       bool m_prefetch;              /**< prefetch cost data                       */
 
-       v3s16 m_start;              /**< source position                          */
-       v3s16 m_destination;        /**< destination position                     */
+       v3s16 m_start;                /**< source position                          */
+       v3s16 m_destination;          /**< destination position                     */
 
-       limits m_limits;            /**< position limits in real map coordinates  */
+       core::aabbox3d<s16> m_limits; /**< position limits in real map coordinates  */
 
        /** 3d grid containing all map data already collected and analyzed */
        std::vector<std::vector<std::vector<PathGridnode> > > m_data;
 
-       ServerEnvironment *m_env;   /**< minetest environment pointer             */
+       ServerEnvironment *m_env;     /**< minetest environment pointer             */
 
 #ifdef PATHFINDER_DEBUG
 
@@ -528,16 +517,19 @@ std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
        int min_z = MYMIN(source.Z, destination.Z);
        int max_z = MYMAX(source.Z, destination.Z);
 
-       m_limits.X.min = min_x - searchdistance;
-       m_limits.X.max = max_x + searchdistance;
-       m_limits.Y.min = min_y - searchdistance;
-       m_limits.Y.max = max_y + searchdistance;
-       m_limits.Z.min = min_z - searchdistance;
-       m_limits.Z.max = max_z + searchdistance;
+       m_limits.MinEdge.X = min_x - searchdistance;
+       m_limits.MinEdge.Y = min_y - searchdistance;
+       m_limits.MinEdge.Z = min_z - searchdistance;
+
+       m_limits.MaxEdge.X = max_x + searchdistance;
+       m_limits.MaxEdge.Y = max_y + searchdistance;
+       m_limits.MaxEdge.Z = max_z + searchdistance;
+
+       v3s16 diff = m_limits.MaxEdge - m_limits.MinEdge;
 
-       m_max_index_x = m_limits.X.max - m_limits.X.min;
-       m_max_index_y = m_limits.Y.max - m_limits.Y.min;
-       m_max_index_z = m_limits.Z.max - m_limits.Z.min;
+       m_max_index_x = diff.X;
+       m_max_index_y = diff.Y;
+       m_max_index_z = diff.Z;
 
        //build data map
        if (!buildCostmap()) {
@@ -654,7 +646,6 @@ Pathfinder::Pathfinder() :
        m_prefetch(true),
        m_start(0, 0, 0),
        m_destination(0, 0, 0),
-       m_limits(),
        m_data(),
        m_env(0)
 {
@@ -664,23 +655,14 @@ Pathfinder::Pathfinder() :
 /******************************************************************************/
 v3s16 Pathfinder::getRealPos(v3s16 ipos)
 {
-       v3s16 retval = ipos;
-
-       retval.X += m_limits.X.min;
-       retval.Y += m_limits.Y.min;
-       retval.Z += m_limits.Z.min;
-
-       return retval;
+       return m_limits.MinEdge + ipos;
 }
 
 /******************************************************************************/
 bool Pathfinder::buildCostmap()
 {
-       INFO_TARGET << "Pathfinder build costmap: (" << m_limits.X.min << ","
-                                                                                               << m_limits.Z.min << ") ("
-                                                                                               << m_limits.X.max << ","
-                                                                                               << m_limits.Z.max << ")"
-                                                                                               << std::endl;
+       INFO_TARGET << "Pathfinder build costmap: min="
+               << PPOS(m_limits.MinEdge) << ", max=" << PPOS(m_limits.MaxEdge) << std::endl;
        m_data.resize(m_max_index_x);
        for (int x = 0; x < m_max_index_x; x++) {
                m_data[x].resize(m_max_index_z);
@@ -766,10 +748,7 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
        v3s16 pos2 = pos + dir;
 
        //check limits
-       if (    (pos2.X < m_limits.X.min) ||
-                       (pos2.X >= m_limits.X.max) ||
-                       (pos2.Z < m_limits.Z.min) ||
-                       (pos2.Z >= m_limits.Z.max)) {
+       if (!m_limits.isPointInside(pos2)) {
                DEBUG_OUT("Pathfinder: " << PPOS(pos2) <<
                                " no cost -> out of limits" << std::endl);
                return retval;
@@ -808,13 +787,13 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
 
                        while ((node_at_pos.param0 != CONTENT_IGNORE) &&
                                        (node_at_pos.param0 == CONTENT_AIR) &&
-                                       (testpos.Y > m_limits.Y.min)) {
+                                       (testpos.Y > m_limits.MinEdge.Y)) {
                                testpos += v3s16(0, -1, 0);
                                node_at_pos = m_env->getMap().getNodeNoEx(testpos);
                        }
 
                        //did we find surface?
-                       if ((testpos.Y >= m_limits.Y.min) &&
+                       if ((testpos.Y >= m_limits.MinEdge.Y) &&
                                        (node_at_pos.param0 != CONTENT_IGNORE) &&
                                        (node_at_pos.param0 != CONTENT_AIR)) {
                                if ((pos2.Y - testpos.Y - 1) <= m_maxdrop) {
@@ -842,13 +821,13 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
 
                while ((node_at_pos.param0 != CONTENT_IGNORE) &&
                                (node_at_pos.param0 != CONTENT_AIR) &&
-                               (testpos.Y < m_limits.Y.max)) {
+                               (testpos.Y < m_limits.MaxEdge.Y)) {
                        testpos += v3s16(0, 1, 0);
                        node_at_pos = m_env->getMap().getNodeNoEx(testpos);
                }
 
                //did we find surface?
-               if ((testpos.Y <= m_limits.Y.max) &&
+               if ((testpos.Y <= m_limits.MaxEdge.Y) &&
                                (node_at_pos.param0 == CONTENT_AIR)) {
 
                        if (testpos.Y - pos2.Y <= m_maxjump) {
@@ -873,12 +852,7 @@ PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
 /******************************************************************************/
 v3s16 Pathfinder::getIndexPos(v3s16 pos)
 {
-       v3s16 retval = pos;
-       retval.X -= m_limits.X.min;
-       retval.Y -= m_limits.Y.min;
-       retval.Z -= m_limits.Z.min;
-
-       return retval;
+       return pos - m_limits.MinEdge;
 }
 
 /******************************************************************************/
@@ -952,9 +926,7 @@ bool Pathfinder::updateAllCosts(v3s16 ipos,
 
                                if (!isValidIndex(ipos2)) {
                                        DEBUG_OUT(LVL " Pathfinder: " << PPOS(ipos2) <<
-                                                       " out of range (" << m_limits.X.max << "," <<
-                                                       m_limits.Y.max << "," << m_limits.Z.max
-                                                       <<")" << std::endl);
+                                               " out of range, max=" << PPOS(m_limits.MaxEdge) << std::endl);
                                        continue;
                                }
 
@@ -1110,9 +1082,7 @@ bool Pathfinder::updateCostHeuristic(     v3s16 ipos,
 
                                if (!isValidIndex(ipos2)) {
                                        DEBUG_OUT(LVL " Pathfinder: " << PPOS(ipos2) <<
-                                                       " out of range (" << m_limits.X.max << "," <<
-                                                       m_limits.Y.max << "," << m_limits.Z.max
-                                                       <<")" << std::endl);
+                                               " out of range, max=" << PPOS(m_limits.MaxEdge) << std::endl);
                                        direction = getDirHeuristic(directions, g_pos);
                                        continue;
                                }