/******************************************************************************/
#include "pathfinder.h"
-#include "environment.h"
-#include "map.h"
-#include "log.h"
-#include "irr_aabb3d.h"
+#include "serverenvironment.h"
+#include "server.h"
+#include "nodedef.h"
//#define PATHFINDER_DEBUG
//#define PATHFINDER_CALC_TIME
/* Typedefs and macros */
/******************************************************************************/
-/** shortcut to print a 3d pos */
-#define PPOS(pos) "(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
-
#define LVL "(" << level << ")" <<
#ifdef PATHFINDER_DEBUG
#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
/******************************************************************************/
* @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 */
}
/******************************************************************************/
-void PathGridnode::setCost(v3s16 dir, PathCost cost)
+void PathGridnode::setCost(v3s16 dir, const PathCost &cost)
{
if (dir.X > 0) {
directions[DIR_XP] = cost;
void GridNodeContainer::initNode(v3s16 ipos, PathGridnode *p_node)
{
+ INodeDefManager *ndef = m_pathf->m_env->getGameDef()->ndef();
PathGridnode &elem = *p_node;
v3s16 realpos = m_pathf->getRealPos(ipos);
if ((current.param0 == CONTENT_IGNORE) ||
(below.param0 == CONTENT_IGNORE)) {
- DEBUG_OUT("Pathfinder: " << PPOS(realpos) <<
+ DEBUG_OUT("Pathfinder: " << PP(realpos) <<
" current or below is invalid element" << std::endl);
if (current.param0 == CONTENT_IGNORE) {
elem.type = 'i';
- DEBUG_OUT(PPOS(ipos) << ": " << 'i' << std::endl);
+ DEBUG_OUT(PP(ipos) << ": " << 'i' << std::endl);
}
return;
}
//don't add anything if it isn't an air node
- if ((current.param0 != CONTENT_AIR) ||
- (below.param0 == CONTENT_AIR )) {
- DEBUG_OUT("Pathfinder: " << PPOS(realpos)
+ if (ndef->get(current).walkable || !ndef->get(below).walkable) {
+ DEBUG_OUT("Pathfinder: " << PP(realpos)
<< " not on surface" << std::endl);
- if (current.param0 != CONTENT_AIR) {
+ if (ndef->get(current).walkable) {
elem.type = 's';
- DEBUG_OUT(PPOS(ipos) << ": " << 's' << std::endl);
+ DEBUG_OUT(PP(ipos) << ": " << 's' << std::endl);
} else {
elem.type = '-';
- DEBUG_OUT(PPOS(ipos) << ": " << '-' << std::endl);
+ DEBUG_OUT(PP(ipos) << ": " << '-' << std::endl);
}
return;
}
elem.valid = true;
elem.pos = realpos;
elem.type = 'g';
- DEBUG_OUT(PPOS(ipos) << ": " << 'a' << std::endl);
+ DEBUG_OUT(PP(ipos) << ": " << 'a' << std::endl);
if (m_pathf->m_prefetch) {
elem.directions[DIR_XP] = m_pathf->calcCost(realpos, v3s16( 1, 0, 0));
if (!startpos.valid) {
VERBOSE_TARGET << "invalid startpos" <<
- "Index: " << PPOS(StartIndex) <<
- "Realpos: " << PPOS(getRealPos(StartIndex)) << std::endl;
+ "Index: " << PP(StartIndex) <<
+ "Realpos: " << PP(getRealPos(StartIndex)) << std::endl;
return retval;
}
if (!endpos.valid) {
VERBOSE_TARGET << "invalid stoppos" <<
- "Index: " << PPOS(EndIndex) <<
- "Realpos: " << PPOS(getRealPos(EndIndex)) << std::endl;
+ "Index: " << PP(EndIndex) <<
+ "Realpos: " << PP(getRealPos(EndIndex)) << std::endl;
return retval;
}
/******************************************************************************/
PathCost Pathfinder::calcCost(v3s16 pos, v3s16 dir)
{
+ INodeDefManager *ndef = m_env->getGameDef()->ndef();
PathCost retval;
retval.updated = true;
//check limits
if (!m_limits.isPointInside(pos2)) {
- DEBUG_OUT("Pathfinder: " << PPOS(pos2) <<
+ DEBUG_OUT("Pathfinder: " << PP(pos2) <<
" no cost -> out of limits" << std::endl);
return retval;
}
//did we get information about node?
if (node_at_pos2.param0 == CONTENT_IGNORE ) {
VERBOSE_TARGET << "Pathfinder: (1) area at pos: "
- << PPOS(pos2) << " not loaded";
+ << PP(pos2) << " not loaded";
return retval;
}
- if (node_at_pos2.param0 == CONTENT_AIR) {
+ if (!ndef->get(node_at_pos2).walkable) {
MapNode node_below_pos2 =
m_env->getMap().getNodeNoEx(pos2 + v3s16(0, -1, 0));
//did we get information about node?
if (node_below_pos2.param0 == CONTENT_IGNORE ) {
VERBOSE_TARGET << "Pathfinder: (2) area at pos: "
- << PPOS((pos2 + v3s16(0, -1, 0))) << " not loaded";
+ << PP((pos2 + v3s16(0, -1, 0))) << " not loaded";
return retval;
}
- if (node_below_pos2.param0 != CONTENT_AIR) {
+ if (ndef->get(node_below_pos2).walkable) {
retval.valid = true;
retval.value = 1;
retval.direction = 0;
- DEBUG_OUT("Pathfinder: "<< PPOS(pos)
+ DEBUG_OUT("Pathfinder: "<< PP(pos)
<< " cost same height found" << std::endl);
}
else {
MapNode node_at_pos = m_env->getMap().getNodeNoEx(testpos);
while ((node_at_pos.param0 != CONTENT_IGNORE) &&
- (node_at_pos.param0 == CONTENT_AIR) &&
+ (!ndef->get(node_at_pos).walkable) &&
(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.MinEdge.Y) &&
(node_at_pos.param0 != CONTENT_IGNORE) &&
- (node_at_pos.param0 != CONTENT_AIR)) {
+ (ndef->get(node_at_pos).walkable)) {
if ((pos2.Y - testpos.Y - 1) <= m_maxdrop) {
retval.valid = true;
retval.value = 2;
MapNode node_at_pos = m_env->getMap().getNodeNoEx(testpos);
while ((node_at_pos.param0 != CONTENT_IGNORE) &&
- (node_at_pos.param0 != CONTENT_AIR) &&
+ (ndef->get(node_at_pos).walkable) &&
(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.MaxEdge.Y) &&
- (node_at_pos.param0 == CONTENT_AIR)) {
+ (!ndef->get(node_at_pos).walkable)) {
if (testpos.Y - pos2.Y <= m_maxjump) {
retval.valid = true;
v3s16 ipos2 = ipos + directions[i];
if (!isValidIndex(ipos2)) {
- DEBUG_OUT(LVL " Pathfinder: " << PPOS(ipos2) <<
- " out of range, max=" << PPOS(m_limits.MaxEdge) << std::endl);
+ DEBUG_OUT(LVL " Pathfinder: " << PP(ipos2) <<
+ " out of range, max=" << PP(m_limits.MaxEdge) << std::endl);
continue;
}
if (!g_pos2.valid) {
VERBOSE_TARGET << LVL "Pathfinder: no data for new position: "
- << PPOS(ipos2) << std::endl;
+ << PP(ipos2) << std::endl;
continue;
}
if ((g_pos2.totalcost < 0) ||
(g_pos2.totalcost > new_cost)) {
DEBUG_OUT(LVL "Pathfinder: updating path at: "<<
- PPOS(ipos2) << " from: " << g_pos2.totalcost << " to "<<
+ PP(ipos2) << " from: " << g_pos2.totalcost << " to "<<
new_cost << std::endl);
if (updateAllCosts(ipos2, invert(directions[i]),
new_cost, level)) {
else {
DEBUG_OUT(LVL "Pathfinder:"
" already found shorter path to: "
- << PPOS(ipos2) << std::endl);
+ << PP(ipos2) << std::endl);
}
}
else {
DEBUG_OUT(LVL "Pathfinder:"
" not moving to invalid direction: "
- << PPOS(directions[i]) << std::endl);
+ << PP(directions[i]) << std::endl);
}
}
}
v3s16 ipos2 = ipos + direction;
if (!isValidIndex(ipos2)) {
- DEBUG_OUT(LVL " Pathfinder: " << PPOS(ipos2) <<
- " out of range, max=" << PPOS(m_limits.MaxEdge) << std::endl);
+ DEBUG_OUT(LVL " Pathfinder: " << PP(ipos2) <<
+ " out of range, max=" << PP(m_limits.MaxEdge) << std::endl);
direction = getDirHeuristic(directions, g_pos);
continue;
}
if (!g_pos2.valid) {
VERBOSE_TARGET << LVL "Pathfinder: no data for new position: "
- << PPOS(ipos2) << std::endl;
+ << PP(ipos2) << std::endl;
direction = getDirHeuristic(directions, g_pos);
continue;
}
(m_min_target_distance < new_cost)) {
DEBUG_OUT(LVL "Pathfinder:"
" already longer than best already found path "
- << PPOS(ipos2) << std::endl);
+ << PP(ipos2) << std::endl);
return false;
}
if ((g_pos2.totalcost < 0) ||
(g_pos2.totalcost > new_cost)) {
DEBUG_OUT(LVL "Pathfinder: updating path at: "<<
- PPOS(ipos2) << " from: " << g_pos2.totalcost << " to "<<
+ PP(ipos2) << " from: " << g_pos2.totalcost << " to "<<
new_cost << " srcdir=" <<
- PPOS(invert(direction))<< std::endl);
+ PP(invert(direction))<< std::endl);
if (updateCostHeuristic(ipos2, invert(direction),
new_cost, level)) {
retval = true;
else {
DEBUG_OUT(LVL "Pathfinder:"
" already found shorter path to: "
- << PPOS(ipos2) << std::endl);
+ << PP(ipos2) << std::endl);
}
}
else {
DEBUG_OUT(LVL "Pathfinder:"
" not moving to invalid direction: "
- << PPOS(direction) << std::endl);
+ << PP(direction) << std::endl);
}
}
else {
DEBUG_OUT(LVL "Pathfinder:"
" skipping srcdir: "
- << PPOS(direction) << std::endl);
+ << PP(direction) << std::endl);
}
direction = getDirHeuristic(directions, g_pos);
}
unsigned int current = 0;
for (std::vector<v3s16>::iterator i = path.begin();
i != path.end(); ++i) {
- std::cout << std::setw(3) << current << ":" << PPOS((*i)) << std::endl;
+ std::cout << std::setw(3) << current << ":" << PP((*i)) << std::endl;
current++;
}
}
projects / oweals / minetest.git / blobdiff