mirror of
https://github.com/liyunfan1223/mod-playerbots.git
synced 2026-06-20 15:39:25 +02:00
Revert "Isolate travel changes from branch RpgGoCity"
This reverts commit 6298660a21fbb0c6a3d6c5ab36f8a1a9377bef6f.
This commit is contained in:
Keleborn
parent
6298660a21
commit
94a0fe73be
@ -1028,12 +1028,6 @@ AiPlayerbot.RestrictedHealerDPSMaps = "33,34,36,43,47,48,70,90,109,129,209,229,2
|
||||
# Default: 1 (enabled)
|
||||
AiPlayerbot.EnableNewRpgStrategy = 1
|
||||
|
||||
# Use pre-computed travel node paths for long-distance movement (>300 yards).
|
||||
# When enabled, bots use the travel node graph (A*, flight paths, transports)
|
||||
# instead of repeated mmap hops. Experimental.
|
||||
# Default: 0 (disabled)
|
||||
AiPlayerbot.EnableTravelNodes = 0
|
||||
|
||||
# Control probability weights for RPG status of bots. Takes effect only when the status meets its premise.
|
||||
# Sum of weights need not be 100. Set to 0 to disable the status.
|
||||
#
|
||||
|
||||
@ -275,7 +275,7 @@ bool DebugAction::Execute(Event event)
|
||||
[]
|
||||
{
|
||||
TravelNodeMap::instance().removeNodes();
|
||||
TravelNodeMap::instance().LoadNodeStore();
|
||||
TravelNodeMap::instance().loadNodeStore();
|
||||
});
|
||||
|
||||
t.detach();
|
||||
@ -297,7 +297,7 @@ bool DebugAction::Execute(Event event)
|
||||
|
||||
// uint32 time = 60 * IN_MILLISECONDS; //not used, line marked for removal.
|
||||
|
||||
std::vector<WorldPosition> ppath = l.second->GetPath();
|
||||
std::vector<WorldPosition> ppath = l.second->getPath();
|
||||
|
||||
for (auto p : ppath)
|
||||
{
|
||||
|
||||
@ -19,8 +19,83 @@
|
||||
#include "Transport.h"
|
||||
#include "Map.h"
|
||||
|
||||
// Transport helpers (GetTransportForPosTolerant, FindBoardingPointOnTransport,
|
||||
// BoardTransport) are now on MovementAction — inherited by FollowAction.
|
||||
namespace
|
||||
{
|
||||
Transport* GetTransportForPosTolerant(Map* map, WorldObject* ref, uint32 phaseMask, float x, float y, float z)
|
||||
{
|
||||
if (!map || !ref)
|
||||
return nullptr;
|
||||
|
||||
std::array<float, 4> const probes = { z, z + 0.5f, z + 1.5f, z - 0.5f };
|
||||
for (float const pz : probes)
|
||||
{
|
||||
if (Transport* t = map->GetTransportForPos(phaseMask, x, y, pz, ref))
|
||||
return t;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Attempts to find a point on the leader's transport that is closer to the bot,
|
||||
// by probing along the segment from master -> bot and returning the last point
|
||||
// that is still detected as being on the expected transport.
|
||||
bool FindBoardingPointOnTransport(Map* map, Transport* expectedTransport, WorldObject* ref,
|
||||
float masterX, float masterY, float masterZ,
|
||||
float botX, float botY, float botZ,
|
||||
float& outX, float& outY, float& outZ)
|
||||
{
|
||||
if (!map || !expectedTransport || !ref)
|
||||
return false;
|
||||
|
||||
uint32 const phaseMask = ref->GetPhaseMask();
|
||||
|
||||
// Ensure master is actually detected on that transport (tolerant).
|
||||
if (GetTransportForPosTolerant(map, ref, phaseMask, masterX, masterY, masterZ) != expectedTransport)
|
||||
return false;
|
||||
|
||||
// The raycast in GetTransportForPos starts at (z + 2). Probe with a safe Z.
|
||||
float const probeZ = std::max(masterZ, botZ);
|
||||
|
||||
// Adaptive step count: small platforms need tighter sampling.
|
||||
float const dx2 = botX - masterX;
|
||||
float const dy2 = botY - masterY;
|
||||
float const dist2d = std::sqrt(dx2 * dx2 + dy2 * dy2);
|
||||
int32 const steps = std::clamp(static_cast<int32>(dist2d / 0.75f), 10, 28);
|
||||
|
||||
float const dx = (botX - masterX) / static_cast<float>(steps);
|
||||
float const dy = (botY - masterY) / static_cast<float>(steps);
|
||||
|
||||
// Master must actually be on the expected transport for this to work.
|
||||
if (map->GetTransportForPos(ref->GetPhaseMask(), masterX, masterY, probeZ, ref) != expectedTransport)
|
||||
return false;
|
||||
|
||||
float lastX = masterX;
|
||||
float lastY = masterY;
|
||||
bool found = false;
|
||||
|
||||
for (int32 i = 1; i <= steps; ++i)
|
||||
{
|
||||
float const px = masterX + dx * i;
|
||||
float const py = masterY + dy * i;
|
||||
|
||||
Transport* const t = GetTransportForPosTolerant(map, ref, phaseMask, px, py, probeZ);
|
||||
if (t != expectedTransport)
|
||||
break;
|
||||
|
||||
lastX = px;
|
||||
lastY = py;
|
||||
found = true;
|
||||
}
|
||||
|
||||
if (!found)
|
||||
return false;
|
||||
|
||||
outX = lastX;
|
||||
outY = lastY;
|
||||
outZ = masterZ; // keep deck-level Z to encourage stepping onto the platform/boat
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool FollowAction::Execute(Event /*event*/)
|
||||
{
|
||||
|
||||
@ -11,7 +11,6 @@
|
||||
#include <string>
|
||||
|
||||
#include "Corpse.h"
|
||||
#include "DBCStores.h"
|
||||
#include "Event.h"
|
||||
#include "FleeManager.h"
|
||||
#include "G3D/Vector3.h"
|
||||
@ -20,9 +19,7 @@
|
||||
#include "LootObjectStack.h"
|
||||
#include "Map.h"
|
||||
#include "MotionMaster.h"
|
||||
#include "MoveSpline.h"
|
||||
#include "MoveSplineInitArgs.h"
|
||||
#include "TravelNode.h"
|
||||
#include "MovementGenerator.h"
|
||||
#include "ObjectDefines.h"
|
||||
#include "ObjectGuid.h"
|
||||
@ -39,7 +36,6 @@
|
||||
#include "SpellInfo.h"
|
||||
#include "Stances.h"
|
||||
#include "Timer.h"
|
||||
#include "Transport.h"
|
||||
#include "Unit.h"
|
||||
#include "Vehicle.h"
|
||||
#include "WaypointMovementGenerator.h"
|
||||
@ -132,8 +128,10 @@ bool MovementAction::MoveToLOS(WorldObject* target, bool ranged)
|
||||
float z = target->GetPositionZ();
|
||||
|
||||
// Use standard PathGenerator to find a route.
|
||||
PathResult path = GeneratePath(x, y, z, DEFAULT_PATH_ACCEPT_MASK, false);
|
||||
if (!path.reachable)
|
||||
PathGenerator path(bot);
|
||||
path.CalculatePath(x, y, z, false);
|
||||
PathType type = path.GetPathType();
|
||||
if (type != PATHFIND_NORMAL && type != PATHFIND_INCOMPLETE)
|
||||
return false;
|
||||
|
||||
if (!ranged)
|
||||
@ -142,9 +140,9 @@ bool MovementAction::MoveToLOS(WorldObject* target, bool ranged)
|
||||
float dist = FLT_MAX;
|
||||
PositionInfo dest;
|
||||
|
||||
if (!path.points.empty())
|
||||
if (!path.GetPath().empty())
|
||||
{
|
||||
for (auto& point : path.points)
|
||||
for (auto& point : path.GetPath())
|
||||
{
|
||||
if (botAI->HasStrategy("debug move", BOT_STATE_NON_COMBAT))
|
||||
CreateWp(bot, point.x, point.y, point.z, 0.0, 2334);
|
||||
@ -1734,19 +1732,6 @@ bool MovementAction::MoveInside(uint32 mapId, float x, float y, float z, float d
|
||||
// return current_z;
|
||||
// }
|
||||
|
||||
PathResult MovementAction::GeneratePath(float x, float y, float z, uint32 acceptMask, bool forceDestination)
|
||||
{
|
||||
PathResult result;
|
||||
PathGenerator gen(bot);
|
||||
gen.CalculatePath(x, y, z, forceDestination);
|
||||
result.pathType = gen.GetPathType();
|
||||
result.reachable = !(result.pathType & (~acceptMask));
|
||||
result.points = gen.GetPath();
|
||||
result.actualEnd = gen.GetActualEndPosition();
|
||||
result.end = gen.GetEndPosition();
|
||||
return result;
|
||||
}
|
||||
|
||||
const Movement::PointsArray MovementAction::SearchForBestPath(float x, float y, float z, float& modified_z,
|
||||
int maxSearchCount, bool normal_only, float step)
|
||||
{
|
||||
@ -2987,509 +2972,4 @@ bool MoveAwayFromPlayerWithDebuffAction::Execute(Event /*event*/)
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MoveAwayFromPlayerWithDebuffAction::isPossible()
|
||||
{
|
||||
return bot->CanFreeMove();
|
||||
}
|
||||
|
||||
bool MovementAction::CheckSplineProgress(TravelPlan& state)
|
||||
{
|
||||
if (!state.splineActive)
|
||||
return false;
|
||||
|
||||
if (bot->movespline->Finalized())
|
||||
{
|
||||
G3D::Vector3 const& endPt = state.walkPoints.back();
|
||||
float distToEnd = bot->GetExactDist(endPt.x, endPt.y, endPt.z);
|
||||
|
||||
if (distToEnd < 10.0f)
|
||||
{
|
||||
state.splineActive = false;
|
||||
state.walkPoints.clear();
|
||||
return true; // Arrived
|
||||
}
|
||||
|
||||
// If we havent arrived to destination, but are done moving then something interrupted it.
|
||||
// Need to restart. Reset state
|
||||
state.splineActive = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Stuck detection
|
||||
if (state.splineStartTime &&
|
||||
GetMSTimeDiffToNow(state.splineStartTime) > state.expectedDuration * 2 + (30 * IN_MILLISECONDS))
|
||||
{
|
||||
G3D::Vector3 const& endPt = state.walkPoints.back();
|
||||
botAI->TeleportTo(WorldLocation(bot->GetMapId(), endPt.x, endPt.y, endPt.z));
|
||||
state.splineActive = false;
|
||||
state.walkPoints.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false; // Still moving
|
||||
}
|
||||
|
||||
bool MovementAction::LaunchWalkSpline(TravelPlan& state)
|
||||
{
|
||||
if (state.walkPoints.size() < 2)
|
||||
{
|
||||
state.walkPoints.clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
// Trim to current position
|
||||
G3D::Vector3 botPos(bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ());
|
||||
float closestDist = FLT_MAX;
|
||||
size_t closestIdx = 0;
|
||||
for (size_t i = 0; i < state.walkPoints.size(); ++i)
|
||||
{
|
||||
float distance = (state.walkPoints[i] - botPos).squaredLength();
|
||||
if (distance < closestDist)
|
||||
{
|
||||
closestDist = distance;
|
||||
closestIdx = i;
|
||||
}
|
||||
}
|
||||
if (closestIdx > 0)
|
||||
state.walkPoints.erase(state.walkPoints.begin(), state.walkPoints.begin() + closestIdx);
|
||||
state.walkPoints.insert(state.walkPoints.begin(), botPos);
|
||||
|
||||
if (state.walkPoints.size() < 2)
|
||||
{
|
||||
state.walkPoints.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Mount up
|
||||
if (!bot->IsMounted() && !bot->IsInCombat() && bot->IsOutdoors() && bot->IsAlive())
|
||||
botAI->DoSpecificAction("check mount state", Event(), true);
|
||||
|
||||
float totalDist = 0;
|
||||
for (size_t i = 1; i < state.walkPoints.size(); ++i)
|
||||
totalDist += (state.walkPoints[i] - state.walkPoints[i - 1]).length();
|
||||
|
||||
float speed = bot->GetSpeed(MOVE_RUN);
|
||||
state.expectedDuration = static_cast<uint32>((totalDist / speed) * IN_MILLISECONDS);
|
||||
|
||||
bot->GetMotionMaster()->MoveSplinePath(&state.walkPoints, FORCED_MOVEMENT_RUN);
|
||||
|
||||
state.splineStartTime = getMSTime();
|
||||
state.splineActive = true;
|
||||
|
||||
LOG_DEBUG("playerbots", "[TravelPlan] Bot {} walk spline: {} points, {:.0f}y",
|
||||
bot->GetName(), state.walkPoints.size(), totalDist);
|
||||
|
||||
return false; // Walking
|
||||
}
|
||||
|
||||
bool MovementAction::MoveToSpline(TravelPlan& state, WorldPosition target)
|
||||
{
|
||||
if (!IsMovingAllowed())
|
||||
return false;
|
||||
|
||||
// Generate path
|
||||
state.walkPoints.clear();
|
||||
PathResult path = GeneratePath(target.GetPositionX(), target.GetPositionY(),
|
||||
target.GetPositionZ());
|
||||
for (auto const& pt : path.points)
|
||||
state.walkPoints.push_back(G3D::Vector3(pt.x, pt.y, pt.z));
|
||||
|
||||
if (state.walkPoints.size() < 2)
|
||||
{
|
||||
state.walkPoints.clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
// Launch spline movement
|
||||
LaunchWalkSpline(state);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MovementAction::GetTravelPlan(TravelPlan& plan, WorldPosition destination)
|
||||
{
|
||||
WorldPosition botPos(bot->GetMapId(), bot->GetPositionX(),
|
||||
bot->GetPositionY(), bot->GetPositionZ());
|
||||
|
||||
bool havePlan = sTravelNodeMap.GetFullPath(plan, botPos,
|
||||
bot->GetZoneId(), bot->GetTeamId(),
|
||||
destination);
|
||||
|
||||
if (!havePlan)
|
||||
TeleportFallback(plan, destination, "no plan");
|
||||
|
||||
return havePlan;
|
||||
}
|
||||
|
||||
bool MovementAction::ExecuteTravelPlan(TravelPlan& state)
|
||||
{
|
||||
if (!state.IsActive())
|
||||
return false;
|
||||
|
||||
if (bot->IsInFlight())
|
||||
return true;
|
||||
|
||||
// Handle active spline
|
||||
if (state.splineActive)
|
||||
{
|
||||
if (!CheckSplineProgress(state))
|
||||
{
|
||||
if (state.splineActive)
|
||||
return true; // Still moving
|
||||
else
|
||||
LaunchWalkSpline(state); // Interrupted, re-launch
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (state.stepIdx >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return true;
|
||||
}
|
||||
|
||||
const PathNodePoint& pt = state.steps[state.stepIdx];
|
||||
|
||||
switch (pt.type)
|
||||
{
|
||||
case PathNodeType::NODE_PREPATH:
|
||||
case PathNodeType::NODE_PATH:
|
||||
case PathNodeType::NODE_NODE:
|
||||
{
|
||||
// Batch consecutive walk points into one spline, capped at 100 points per tick.
|
||||
static constexpr uint32 MAX_SPLINE_POINTS = 100;
|
||||
state.walkPoints.clear();
|
||||
while (state.stepIdx < state.steps.size() && state.walkPoints.size() < MAX_SPLINE_POINTS)
|
||||
{
|
||||
const PathNodePoint& wp = state.steps[state.stepIdx];
|
||||
if (wp.type != PathNodeType::NODE_PREPATH && wp.type != PathNodeType::NODE_PATH && wp.type != PathNodeType::NODE_NODE)
|
||||
break;
|
||||
state.walkPoints.push_back(G3D::Vector3(wp.point.GetPositionX(), wp.point.GetPositionY(), wp.point.GetPositionZ()));
|
||||
state.stepIdx++;
|
||||
}
|
||||
|
||||
if (state.walkPoints.empty())
|
||||
return true;
|
||||
|
||||
// Already near end of batch?
|
||||
G3D::Vector3 const& last = state.walkPoints.back();
|
||||
float dist = bot->GetExactDist(last.x, last.y, last.z);
|
||||
if (dist < 10.0f)
|
||||
{
|
||||
state.walkPoints.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Too far from first point — teleport
|
||||
if (state.walkPoints.size() >= 2)
|
||||
{
|
||||
G3D::Vector3 const& first = state.walkPoints.front();
|
||||
float distToFirst = bot->GetExactDist( first.x, first.y, first.z);
|
||||
if (distToFirst > MAX_PATHFINDING_DISTANCE)
|
||||
{
|
||||
TeleportFallback(state, WorldPosition(bot->GetMapId(), last.x, last.y, last.z), "walk batch too far");
|
||||
state.walkPoints.clear();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// Single point — use PathGenerator directly
|
||||
if (state.walkPoints.size() < 2)
|
||||
{
|
||||
WorldPosition target(bot->GetMapId(), last.x, last.y, last.z);
|
||||
MoveToSpline(state, target);
|
||||
state.walkPoints.clear();
|
||||
return true;
|
||||
}
|
||||
LaunchWalkSpline(state);
|
||||
return true;
|
||||
}
|
||||
|
||||
case PathNodeType::NODE_PORTAL:
|
||||
{
|
||||
// Pair: source (pointIdx) + dest (pointIdx+1)
|
||||
if (state.stepIdx + 1 >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return false;
|
||||
}
|
||||
|
||||
const PathNodePoint& src = state.steps[state.stepIdx];
|
||||
const PathNodePoint& dst = state.steps[state.stepIdx + 1];
|
||||
|
||||
// Already on destination map?
|
||||
if (bot->GetMapId() == dst.point.GetMapId())
|
||||
{
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
// Walk to portal source
|
||||
float dist = bot->GetExactDist(src.point.GetPositionX(), src.point.GetPositionY(), src.point.GetPositionZ());
|
||||
if (dist > INTERACTION_DISTANCE)
|
||||
return MoveTo(src.point.GetMapId(), src.point.GetPositionX(), src.point.GetPositionY(), src.point.GetPositionZ());
|
||||
|
||||
// At portal, but havent teleported though
|
||||
TeleportFallback(state, dst.point, "portal walk-through");
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
case PathNodeType::NODE_TRANSPORT:
|
||||
{
|
||||
if (state.stepIdx + 1 >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return false;
|
||||
}
|
||||
|
||||
const PathNodePoint& board = state.steps[state.stepIdx];
|
||||
const PathNodePoint& arrive = state.steps[state.stepIdx + 1];
|
||||
// Arrived at destination?
|
||||
if (bot->GetMapId() == arrive.point.GetMapId() && !bot->GetTransport())
|
||||
{
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
// On transport — wait
|
||||
if (bot->GetTransport())
|
||||
{
|
||||
if (bot->GetMapId() == arrive.point.GetMapId())
|
||||
{
|
||||
bot->GetTransport()->RemovePassenger(bot);
|
||||
bot->StopMovingOnCurrentPos();
|
||||
state.stepIdx += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Walk to boarding point
|
||||
float dist = bot->GetExactDist(board.point.GetPositionX(), board.point.GetPositionY(), board.point.GetPositionZ());
|
||||
if (dist > 60.0f)
|
||||
return MoveTo(board.point.GetMapId(), board.point.GetPositionX(), board.point.GetPositionY(), board.point.GetPositionZ());
|
||||
|
||||
// Try to board
|
||||
if (board.entry)
|
||||
{
|
||||
Map* map = bot->GetMap();
|
||||
if (map)
|
||||
{
|
||||
Transport* transport =
|
||||
GetTransportForPosTolerant(map, bot, bot->GetPhaseMask(), board.point.GetPositionX(),
|
||||
board.point.GetPositionY(), board.point.GetPositionZ());
|
||||
if (transport && transport->GetEntry() == board.entry)
|
||||
{
|
||||
BoardTransport(transport);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Wait at boarding point
|
||||
if (dist > INTERACTION_DISTANCE)
|
||||
return MoveTo(board.point.GetMapId(), board.point.GetPositionX(), board.point.GetPositionY(), board.point.GetPositionZ());
|
||||
return true;
|
||||
}
|
||||
|
||||
case PathNodeType::NODE_FLIGHTPATH:
|
||||
{
|
||||
if (state.stepIdx + 1 >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return false;
|
||||
}
|
||||
|
||||
const PathNodePoint& dep = state.steps[state.stepIdx];
|
||||
const PathNodePoint& arr = state.steps[state.stepIdx + 1];
|
||||
|
||||
if (bot->IsInFlight())
|
||||
return true;
|
||||
|
||||
// Resolve taxi path
|
||||
if (state.route.empty())
|
||||
{
|
||||
uint32 fromTaxi = sObjectMgr->GetNearestTaxiNode(dep.point.GetPositionX(), dep.point.GetPositionY(),
|
||||
dep.point.GetPositionZ(), dep.point.GetMapId(), bot->GetTeamId());
|
||||
uint32 toTaxi = sObjectMgr->GetNearestTaxiNode(arr.point.GetPositionX(), arr.point.GetPositionY(),
|
||||
arr.point.GetPositionZ(), arr.point.GetMapId(), bot->GetTeamId());
|
||||
|
||||
if (fromTaxi && toTaxi && fromTaxi != toTaxi)
|
||||
state.route = sTravelNodeMap.FindTaxiPath(fromTaxi, toTaxi);
|
||||
|
||||
if (state.route.empty())
|
||||
{
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
Creature* flightMaster = sTravelMgr.GetNearestFlightMaster(bot);
|
||||
if (!flightMaster || !flightMaster->IsAlive())
|
||||
{
|
||||
state.route.clear();
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (bot->GetDistance(flightMaster) > INTERACTION_DISTANCE)
|
||||
return MoveTo(flightMaster, INTERACTION_DISTANCE);
|
||||
|
||||
botAI->RemoveShapeshift();
|
||||
if (bot->IsMounted())
|
||||
bot->Dismount();
|
||||
|
||||
if (bot->ActivateTaxiPathTo(state.route, flightMaster, 0))
|
||||
LOG_DEBUG("playerbots","[TravelPlan] Bot {} taking flight ({} nodes)", bot->GetName(), state.route.size());
|
||||
|
||||
state.route.clear();
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
case PathNodeType::NODE_TELEPORT:
|
||||
{
|
||||
if (state.stepIdx + 1 >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return false;
|
||||
}
|
||||
|
||||
const PathNodePoint& dst = state.steps[state.stepIdx + 1];
|
||||
TeleportFallback(state, dst.point, "teleport spell");
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
case PathNodeType::NODE_FLYING_MOUNT:
|
||||
{
|
||||
if (state.stepIdx + 1 >= state.steps.size())
|
||||
{
|
||||
state.Reset();
|
||||
return false;
|
||||
}
|
||||
|
||||
const PathNodePoint& dst = state.steps[state.stepIdx + 1];
|
||||
TeleportFallback(state, dst.point, "flying mount not implemented");
|
||||
state.stepIdx += 2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void MovementAction::TeleportFallback(TravelPlan& state, WorldPosition target, char const* reason)
|
||||
{
|
||||
LOG_INFO("playerbots", "[TravelPlan] Bot {} teleport fallback ({}): from map={} ({:.0f},{:.0f},{:.0f}) to map={} ({:.0f},{:.0f},{:.0f})",
|
||||
bot->GetName(), reason, bot->GetMapId(), bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(), target.GetMapId(), target.GetPositionX(),
|
||||
target.GetPositionY(), target.GetPositionZ());
|
||||
|
||||
botAI->TeleportTo(target);
|
||||
}
|
||||
|
||||
Transport* MovementAction::GetTransportForPosTolerant(Map* map, WorldObject* ref, uint32 phaseMask, float x, float y, float z)
|
||||
{
|
||||
if (!map || !ref)
|
||||
return nullptr;
|
||||
|
||||
std::array<float, 4> const probes = { z, z + 0.5f, z + 1.5f, z - 0.5f };
|
||||
for (float const pz : probes)
|
||||
{
|
||||
if (Transport* transport = map->GetTransportForPos(phaseMask, x, y, pz, ref))
|
||||
return transport;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool MovementAction::FindBoardingPointOnTransport(Map* map, Transport* expectedTransport, WorldObject* ref,
|
||||
float refX, float refY, float refZ, float botX, float botY, float botZ, float& outX, float& outY, float& outZ)
|
||||
{
|
||||
if (!map || !expectedTransport || !ref)
|
||||
return false;
|
||||
|
||||
uint32 const phaseMask = ref->GetPhaseMask();
|
||||
if (GetTransportForPosTolerant(map, ref, phaseMask, refX, refY, refZ)
|
||||
!= expectedTransport)
|
||||
return false;
|
||||
|
||||
float const probeZ = std::max(refZ, botZ);
|
||||
float const dx2 = botX - refX;
|
||||
float const dy2 = botY - refY;
|
||||
float const dist2d = std::sqrt(dx2 * dx2 + dy2 * dy2);
|
||||
int32 const steps = std::clamp(static_cast<int32>(dist2d / 0.75f), 10, 28);
|
||||
float const dx = (botX - refX) / static_cast<float>(steps);
|
||||
float const dy = (botY - refY) / static_cast<float>(steps);
|
||||
|
||||
if (map->GetTransportForPos(phaseMask, refX, refY, probeZ, ref) != expectedTransport)
|
||||
return false;
|
||||
|
||||
float lastX = refX;
|
||||
float lastY = refY;
|
||||
bool found = false;
|
||||
|
||||
for (int32 i = 1; i <= steps; ++i)
|
||||
{
|
||||
float const px = refX + dx * i;
|
||||
float const py = refY + dy * i;
|
||||
Transport* const t = GetTransportForPosTolerant(map, ref, phaseMask, px, py, probeZ);
|
||||
if (t != expectedTransport)
|
||||
break;
|
||||
lastX = px;
|
||||
lastY = py;
|
||||
found = true;
|
||||
}
|
||||
|
||||
if (!found)
|
||||
return false;
|
||||
|
||||
outX = lastX;
|
||||
outY = lastY;
|
||||
outZ = refZ;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MovementAction::BoardTransport(Transport* transport)
|
||||
{
|
||||
if (!transport || transport->IsStaticTransport())
|
||||
return false;
|
||||
|
||||
Map* map = bot->GetMap();
|
||||
if (!map)
|
||||
return false;
|
||||
|
||||
// Already on this transport
|
||||
if (bot->GetTransport() == transport)
|
||||
return true;
|
||||
|
||||
// Check if bot is on the transport surface
|
||||
float probeZ = std::max(bot->GetPositionZ(), transport->GetPositionZ());
|
||||
Transport* surface = GetTransportForPosTolerant(map, bot, bot->GetPhaseMask(), bot->GetPositionX(),
|
||||
bot->GetPositionY(), probeZ);
|
||||
|
||||
if (surface == transport)
|
||||
{
|
||||
transport->AddPassenger(bot, true);
|
||||
bot->StopMovingOnCurrentPos();
|
||||
return true;
|
||||
}
|
||||
// Not on surface — move toward the transport
|
||||
float destX = transport->GetPositionX();
|
||||
float destY = transport->GetPositionY();
|
||||
float destZ = transport->GetPositionZ();
|
||||
|
||||
// Try to find nearest boarding edge
|
||||
float edgeX, edgeY, edgeZ;
|
||||
if (FindBoardingPointOnTransport(map, transport, transport, transport->GetPositionX(), transport->GetPositionY(),
|
||||
transport->GetPositionZ(), bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(), edgeX, edgeY, edgeZ))
|
||||
{
|
||||
destX = edgeX;
|
||||
destY = edgeY;
|
||||
destZ = edgeZ;
|
||||
}
|
||||
|
||||
// MovePoint without pathfinding (transport is a moving object)
|
||||
if (MotionMaster* mm = bot->GetMotionMaster())
|
||||
{
|
||||
if (bot->IsSitState())
|
||||
bot->SetStandState(UNIT_STAND_STATE_STAND);
|
||||
|
||||
mm->MovePoint(0, destX, destY, destZ, FORCED_MOVEMENT_NONE, 0.0f, 0.0f, false, false);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
bool MoveAwayFromPlayerWithDebuffAction::isPossible() { return bot->CanFreeMove(); }
|
||||
|
||||
@ -10,7 +10,6 @@
|
||||
|
||||
#include "Action.h"
|
||||
#include "LastMovementValue.h"
|
||||
#include "PathGenerator.h"
|
||||
#include "PlayerbotAIConfig.h"
|
||||
|
||||
class Player;
|
||||
@ -23,19 +22,6 @@ class Position;
|
||||
#define ANGLE_90_DEG M_PI_2
|
||||
#define ANGLE_120_DEG (2.f * static_cast<float>(M_PI) / 3.f)
|
||||
|
||||
// Default acceptable path types for GeneratePath
|
||||
constexpr uint32 DEFAULT_PATH_ACCEPT_MASK = 0x01 /*PATHFIND_NORMAL*/ | 0x04 /*PATHFIND_INCOMPLETE*/;
|
||||
uint32 typeOk = PATHFIND_NORMAL | PATHFIND_INCOMPLETE | PATHFIND_FARFROMPOLY;
|
||||
|
||||
struct PathResult
|
||||
{
|
||||
Movement::PointsArray points;
|
||||
G3D::Vector3 actualEnd;
|
||||
G3D::Vector3 end;
|
||||
PathType pathType;
|
||||
bool reachable;
|
||||
};
|
||||
|
||||
class MovementAction : public Action
|
||||
{
|
||||
public:
|
||||
@ -81,26 +67,6 @@ protected:
|
||||
bool FleePosition(Position pos, float radius, uint32 minInterval = 1000);
|
||||
bool CheckLastFlee(float curAngle, std::list<FleeInfo>& infoList);
|
||||
|
||||
PathResult GeneratePath(float x, float y, float z, uint32 acceptMask = DEFAULT_PATH_ACCEPT_MASK, bool forceDestination = true);
|
||||
|
||||
bool GetTravelPlan(TravelPlan& plan, WorldPosition destination);
|
||||
bool ExecuteTravelPlan(TravelPlan& state);
|
||||
|
||||
// Transport boarding helpers (shared by FollowAction and travel plan)
|
||||
static Transport* GetTransportForPosTolerant(Map* map, WorldObject* ref,
|
||||
uint32 phaseMask, float x, float y, float z);
|
||||
static bool FindBoardingPointOnTransport(Map* map, Transport* transport,
|
||||
WorldObject* ref, float refX, float refY, float refZ,
|
||||
float botX, float botY, float botZ,
|
||||
float& outX, float& outY, float& outZ);
|
||||
bool BoardTransport(Transport* transport);
|
||||
|
||||
private:
|
||||
bool LaunchWalkSpline(TravelPlan& state);
|
||||
bool CheckSplineProgress(TravelPlan& state);
|
||||
bool MoveToSpline(TravelPlan& state, WorldPosition target);
|
||||
void TeleportFallback(TravelPlan& state, WorldPosition target, char const* reason);
|
||||
|
||||
protected:
|
||||
struct CheckAngle
|
||||
{
|
||||
|
||||
@ -468,21 +468,26 @@ bool NewRpgTravelFlightAction::Execute(Event /*event*/)
|
||||
data.inFlight = true;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (bot->GetDistance(data.fromPos) > INTERACTION_DISTANCE)
|
||||
return MoveFarTo(data.fromPos);
|
||||
|
||||
Creature* flightMaster = ObjectAccessor::GetCreature(*bot, data.fromFlightMasterGuid);
|
||||
Creature* flightMaster = ObjectAccessor::GetCreature(*bot, data.fromFlightMaster);
|
||||
if (!flightMaster || !flightMaster->IsAlive())
|
||||
{
|
||||
botAI->rpgInfo.ChangeToIdle();
|
||||
return true;
|
||||
}
|
||||
if (bot->GetDistance(flightMaster) > INTERACTION_DISTANCE)
|
||||
return MoveFarTo(flightMaster);
|
||||
|
||||
if (!TakeFlight(data.path, flightMaster))
|
||||
std::vector<uint32> nodes = data.path;
|
||||
|
||||
botAI->RemoveShapeshift();
|
||||
if (bot->IsMounted())
|
||||
bot->Dismount();
|
||||
|
||||
if (!bot->ActivateTaxiPathTo(nodes, flightMaster, 0))
|
||||
{
|
||||
LOG_DEBUG("playerbots", "[New RPG] {} active taxi path {} (from {} to {}) failed", bot->GetName(),
|
||||
flightMaster->GetEntry(), nodes[0], nodes[nodes.size() - 1]);
|
||||
botAI->rpgInfo.ChangeToIdle();
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -47,11 +47,11 @@ public:
|
||||
|
||||
protected:
|
||||
// static NewRpgStatusTransitionProb transitionMat;
|
||||
const int32 statusWanderNpcDuration = 5 * MINUTE * IN_MILLISECONDS;
|
||||
const int32 statusWanderRandomDuration = 5 * MINUTE * IN_MILLISECONDS;
|
||||
const int32 statusRestDuration = 30 * IN_MILLISECONDS;
|
||||
const int32 statusDoQuestDuration = 30 * MINUTE * IN_MILLISECONDS;
|
||||
const int32 statusOutDoorPvPDuration = HOUR * IN_MILLISECONDS;
|
||||
const int32 statusWanderNpcDuration = 5 * MINUTE * IN_MILLISECONDS ;
|
||||
const int32 statusWanderRandomDuration = 5 * MINUTE * IN_MILLISECONDS ;
|
||||
const int32 statusRestDuration = 30 * IN_MILLISECONDS ;
|
||||
const int32 statusDoQuestDuration = 30 * MINUTE * IN_MILLISECONDS ;
|
||||
const int32 statusOutDoorPvPDuration = HOUR * IN_MILLISECONDS ;
|
||||
};
|
||||
|
||||
class NewRpgGoGrindAction : public NewRpgBaseAction
|
||||
|
||||
@ -96,35 +96,25 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
|
||||
botAI->rpgInfo.stuckAttempts = 0;
|
||||
const AreaTableEntry* entry = sAreaTableStore.LookupEntry(bot->GetZoneId());
|
||||
std::string zone_name = PlayerbotAI::GetLocalizedAreaName(entry);
|
||||
LOG_DEBUG("playerbots","[New RPG] Teleport {} from ({},{},{},{}) to ({},{},{},{}) as it stuck when moving far - Zone: {} ({})",
|
||||
LOG_DEBUG(
|
||||
"playerbots",
|
||||
"[New RPG] Teleport {} from ({},{},{},{}) to ({},{},{},{}) as it stuck when moving far - Zone: {} ({})",
|
||||
bot->GetName(), bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(), bot->GetMapId(),
|
||||
dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(), dest.GetMapId(), bot->GetZoneId(), zone_name);
|
||||
botAI->TeleportTo(dest);
|
||||
return true;
|
||||
dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(), dest.GetMapId(), bot->GetZoneId(),
|
||||
zone_name);
|
||||
bot->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TELEPORTED | AURA_INTERRUPT_FLAG_CHANGE_MAP);
|
||||
return bot->TeleportTo(dest);
|
||||
}
|
||||
|
||||
float dis = bot->GetExactDist(dest);
|
||||
|
||||
// Long distance + travel nodes enabled: use the pre-computed node graph
|
||||
// (A*, flight paths, transports) instead of repeated mmap hops.
|
||||
if (dis > MAX_PATHFINDING_DISTANCE && sPlayerbotAIConfig.enableTravelNodes)
|
||||
{
|
||||
if (!botAI->rpgInfo.HasActiveTravelPlan())
|
||||
StartTravelPlan(dest);
|
||||
|
||||
return UpdateTravelPlan();
|
||||
}
|
||||
|
||||
// Crossed below the travel-node threshold — clear any leftover plan
|
||||
if (botAI->rpgInfo.HasActiveTravelPlan())
|
||||
botAI->rpgInfo.ClearTravel();
|
||||
|
||||
// Short range: close enough for a single mmap call
|
||||
if (dis < pathFinderDis)
|
||||
{
|
||||
return MoveTo(dest.GetMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(), false, false,
|
||||
false, true);
|
||||
}
|
||||
|
||||
const uint32 typeOk = PATHFIND_NORMAL | PATHFIND_INCOMPLETE | PATHFIND_FARFROMPOLY;
|
||||
|
||||
// Primary strategy: ask mmap for a route to the TRUE destination.
|
||||
// If mmap can reach it directly (PATHFIND_NORMAL) or partially
|
||||
// (PATHFIND_INCOMPLETE — destinations beyond the smooth-path cap
|
||||
@ -136,18 +126,23 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
|
||||
// subsequent ticks early-out via IsWaitingForLastMove and no
|
||||
// further PathGenerator calls fire until the bot arrives.
|
||||
{
|
||||
PathResult path = GeneratePath(dest.GetPositionX(), dest.GetPositionY(),
|
||||
dest.GetPositionZ(), RELAXED_PATH_ACCEPT_MASK);
|
||||
if (path.reachable)
|
||||
PathGenerator path(bot);
|
||||
path.CalculatePath(dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ());
|
||||
PathType type = path.GetPathType();
|
||||
bool canReach = !(type & (~typeOk));
|
||||
if (canReach)
|
||||
{
|
||||
const G3D::Vector3& endPos = path.GetActualEndPosition();
|
||||
// Only commit if the mmap endpoint actually makes progress
|
||||
// toward the destination. For pathological INCOMPLETE
|
||||
// results (e.g. disconnected polys that still report
|
||||
// INCOMPLETE) the endpoint can land right under the bot;
|
||||
// fall through to cone sampling in that case.
|
||||
float endDistToDest = dest.GetExactDist(path.actualEnd.x, path.actualEnd.y, path.actualEnd.z);
|
||||
float endDistToDest = dest.GetExactDist(endPos.x, endPos.y, endPos.z);
|
||||
if (endDistToDest + 5.0f < disToDest)
|
||||
return MoveTo(bot->GetMapId(), path.actualEnd.x, path.actualEnd.y, path.actualEnd.z, false, false, false, true);
|
||||
{
|
||||
return MoveTo(bot->GetMapId(), endPos.x, endPos.y, endPos.z, false, false, false, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -171,14 +166,18 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
|
||||
float dx = x + cos(angle) * sampleDis;
|
||||
float dy = y + sin(angle) * sampleDis;
|
||||
float dz = z + 0.5f;
|
||||
PathResult path = GeneratePath(dx, dy, dz, RELAXED_PATH_ACCEPT_MASK);
|
||||
PathGenerator path(bot);
|
||||
path.CalculatePath(dx, dy, dz);
|
||||
PathType type = path.GetPathType();
|
||||
bool canReach = !(type & (~typeOk));
|
||||
|
||||
if (path.reachable && fabs(delta) <= minDelta)
|
||||
if (canReach && fabs(delta) <= minDelta)
|
||||
{
|
||||
found = true;
|
||||
rx = path.actualEnd.x;
|
||||
ry = path.actualEnd.y;
|
||||
rz = path.actualEnd.z;
|
||||
const G3D::Vector3& endPos = path.GetActualEndPosition();
|
||||
rx = endPos.x;
|
||||
ry = endPos.y;
|
||||
rz = endPos.z;
|
||||
minDelta = fabs(delta);
|
||||
}
|
||||
}
|
||||
@ -189,31 +188,12 @@ bool NewRpgBaseAction::MoveFarTo(WorldPosition dest)
|
||||
return false;
|
||||
}
|
||||
|
||||
void NewRpgBaseAction::StartTravelPlan(WorldPosition dest)
|
||||
{
|
||||
TravelPlan& plan = botAI->rpgInfo.travelPlan;
|
||||
GetTravelPlan(plan, dest);
|
||||
|
||||
LOG_DEBUG("playerbots","[New RPG] Bot {} starting travel plan to ({:.0f},{:.0f},{:.0f}) map={}, {} points",
|
||||
bot->GetName(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(), dest.GetMapId(), plan.steps.size());
|
||||
}
|
||||
|
||||
bool NewRpgBaseAction::UpdateTravelPlan()
|
||||
{
|
||||
TravelPlan& plan = botAI->rpgInfo.travelPlan;
|
||||
|
||||
bool result = ExecuteTravelPlan(plan);
|
||||
|
||||
if (!plan.IsActive())
|
||||
botAI->rpgInfo.ClearTravel();
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool NewRpgBaseAction::MoveWorldObjectTo(ObjectGuid guid, float distance)
|
||||
{
|
||||
if (IsWaitingForLastMove(MovementPriority::MOVEMENT_NORMAL))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
WorldObject* object = botAI->GetWorldObject(guid);
|
||||
if (!object)
|
||||
@ -265,9 +245,13 @@ bool NewRpgBaseAction::MoveRandomNear(float moveStep, MovementPriority priority,
|
||||
float dy = y + distance * sin(angle);
|
||||
float dz = z;
|
||||
|
||||
PathResult path = GeneratePath(dx, dy, dz, RELAXED_PATH_ACCEPT_MASK);
|
||||
PathGenerator path(bot);
|
||||
path.CalculatePath(dx, dy, dz);
|
||||
PathType type = path.GetPathType();
|
||||
uint32 typeOk = PATHFIND_NORMAL | PATHFIND_INCOMPLETE | PATHFIND_FARFROMPOLY;
|
||||
bool canReach = !(type & (~typeOk));
|
||||
|
||||
if (!path.reachable)
|
||||
if (!canReach)
|
||||
continue;
|
||||
|
||||
if (!map->CanReachPositionAndGetValidCoords(bot, dx, dy, dz))
|
||||
@ -292,28 +276,6 @@ bool NewRpgBaseAction::ForceToWait(uint32 duration, MovementPriority priority)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool NewRpgBaseAction::TakeFlight(std::vector<uint32> const& taxiNodes, Creature* flightMaster)
|
||||
{
|
||||
if (taxiNodes.size() < 2 || !flightMaster || !flightMaster->IsAlive())
|
||||
return false;
|
||||
|
||||
botAI->RemoveShapeshift();
|
||||
if (bot->IsMounted())
|
||||
bot->Dismount();
|
||||
|
||||
if (!bot->ActivateTaxiPathTo(taxiNodes, flightMaster, 0))
|
||||
{
|
||||
LOG_DEBUG("playerbots", "[New RPG] Bot {} flight ({} nodes, {} to {}) failed",
|
||||
bot->GetName(), taxiNodes.size(), taxiNodes.front(), taxiNodes.back());
|
||||
return false;
|
||||
}
|
||||
|
||||
LOG_DEBUG("playerbots", "[New RPG] Bot {} taking flight ({} nodes, {} to {})",
|
||||
bot->GetName(), taxiNodes.size(), taxiNodes.front(), taxiNodes.back());
|
||||
return true;
|
||||
}
|
||||
|
||||
/// @TODO: Fix redundant code
|
||||
/// Quest related method refer to TalkToQuestGiverAction.h
|
||||
bool NewRpgBaseAction::InteractWithNpcOrGameObjectForQuest(ObjectGuid guid)
|
||||
@ -1016,10 +978,6 @@ WorldPosition NewRpgBaseAction::SelectRandomGrindPos(Player* bot)
|
||||
uint32 idx = urand(0, lo_prepared_locs.size() - 1);
|
||||
dest = lo_prepared_locs[idx];
|
||||
}
|
||||
|
||||
if (!dest.IsValid())
|
||||
return dest;
|
||||
|
||||
LOG_DEBUG("playerbots", "[New RPG] Bot {} select random grind pos Map:{} X:{} Y:{} Z:{} ({}+{} available in {})",
|
||||
bot->GetName(), dest.GetMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(),
|
||||
hi_prepared_locs.size(), lo_prepared_locs.size() - hi_prepared_locs.size(), locs.size());
|
||||
@ -1063,10 +1021,6 @@ WorldPosition NewRpgBaseAction::SelectRandomCampPos(Player* bot)
|
||||
uint32 idx = urand(0, prepared_locs.size() - 1);
|
||||
dest = prepared_locs[idx];
|
||||
}
|
||||
|
||||
if (!dest.IsValid())
|
||||
return dest;
|
||||
|
||||
LOG_DEBUG("playerbots", "[New RPG] Bot {} select random inn keeper pos Map:{} X:{} Y:{} Z:{} ({} available in {})",
|
||||
bot->GetName(), dest.GetMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(),
|
||||
prepared_locs.size(), locs.size());
|
||||
@ -1104,6 +1058,7 @@ bool NewRpgBaseAction::RandomChangeStatus(std::vector<NewRpgStatus> candidateSta
|
||||
probSum += sPlayerbotAIConfig.RpgStatusProbWeight[status];
|
||||
}
|
||||
}
|
||||
// Safety check. Default to "rest" if all RPG weights = 0
|
||||
if (availableStatus.empty() || probSum == 0)
|
||||
{
|
||||
botAI->rpgInfo.ChangeToRest();
|
||||
@ -1184,11 +1139,11 @@ bool NewRpgBaseAction::RandomChangeStatus(std::vector<NewRpgStatus> candidateSta
|
||||
}
|
||||
case RPG_TRAVEL_FLIGHT:
|
||||
{
|
||||
ObjectGuid flightMasterGuid;
|
||||
ObjectGuid flightMaster;
|
||||
std::vector<uint32> path;
|
||||
if (SelectRandomFlightTaxiNode(flightMasterGuid, path))
|
||||
if (SelectRandomFlightTaxiNode(flightMaster, path))
|
||||
{
|
||||
botAI->rpgInfo.ChangeToTravelFlight(flightMasterGuid, path);
|
||||
botAI->rpgInfo.ChangeToTravelFlight(flightMaster, path);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -1285,5 +1240,3 @@ bool NewRpgBaseAction::CheckRpgStatusAvailable(NewRpgStatus status)
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -33,7 +33,6 @@ protected:
|
||||
bool MoveWorldObjectTo(ObjectGuid guid, float distance = INTERACTION_DISTANCE);
|
||||
bool MoveRandomNear(float moveStep = 50.0f, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL, WorldObject* center = nullptr);
|
||||
bool ForceToWait(uint32 duration, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
|
||||
bool TakeFlight(std::vector<uint32> const& taxiNodes, Creature* flightMaster);
|
||||
|
||||
/* QUEST RELATED CHECK */
|
||||
ObjectGuid ChooseNpcOrGameObjectToInteract(bool questgiverOnly = false, float distanceLimit = 0.0f);
|
||||
@ -70,10 +69,6 @@ protected:
|
||||
// the teleport fires, but long enough that a genuine long
|
||||
// walk that is slowly making progress never triggers it.
|
||||
const uint32 stuckTime = 90 * 1000;
|
||||
|
||||
private:
|
||||
void StartTravelPlan(WorldPosition dest);
|
||||
bool UpdateTravelPlan();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -4,43 +4,33 @@
|
||||
|
||||
#include "Timer.h"
|
||||
|
||||
void NewRpgInfo::ClearTravel()
|
||||
{
|
||||
travelPlan.Reset();
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToGoGrind(WorldPosition pos)
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = GoGrind{pos};
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToGoCamp(WorldPosition pos)
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = GoCamp{pos};
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToWanderNpc()
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = WanderNpc{};
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToWanderRandom()
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = WanderRandom{};
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToDoQuest(uint32 questId, const Quest* quest)
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
DoQuest do_quest;
|
||||
do_quest.questId = questId;
|
||||
do_quest.quest = quest;
|
||||
@ -50,7 +40,6 @@ void NewRpgInfo::ChangeToDoQuest(uint32 questId, const Quest* quest)
|
||||
void NewRpgInfo::ChangeToTravelFlight(ObjectGuid fromFlightMaster, std::vector<uint32> path)
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
TravelFlight flight;
|
||||
flight.fromFlightMaster = fromFlightMaster;
|
||||
flight.path = std::move(path);
|
||||
@ -69,14 +58,12 @@ void NewRpgInfo::ChangeToOutdoorPvp(ObjectGuid::LowType capturePointSpawnId)
|
||||
void NewRpgInfo::ChangeToRest()
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = Rest{};
|
||||
}
|
||||
|
||||
void NewRpgInfo::ChangeToIdle()
|
||||
{
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
data = Idle{};
|
||||
}
|
||||
|
||||
@ -89,7 +76,6 @@ void NewRpgInfo::Reset()
|
||||
{
|
||||
data = Idle{};
|
||||
startT = getMSTime();
|
||||
ClearTravel();
|
||||
}
|
||||
|
||||
void NewRpgInfo::SetMoveFarTo(WorldPosition pos)
|
||||
|
||||
@ -74,9 +74,7 @@ struct NewRpgInfo
|
||||
uint32 stuckTs{0};
|
||||
uint32 stuckAttempts{0};
|
||||
WorldPosition moveFarPos;
|
||||
TravelPlan travelPlan;
|
||||
bool HasActiveTravelPlan() const { return travelPlan.IsActive(); }
|
||||
void ClearTravel();
|
||||
// END MOVE_FAR
|
||||
|
||||
using RpgData = std::variant<
|
||||
Idle,
|
||||
|
||||
@ -735,21 +735,6 @@ void PlayerbotAI::HandleCommand(uint32 type, const std::string& text, Player& fr
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerbotAI::TeleportTo(WorldLocation loc, bool resetAI)
|
||||
{
|
||||
if (!bot || bot->IsBeingTeleported() || !bot->IsInWorld())
|
||||
return;
|
||||
|
||||
bot->GetMotionMaster()->Clear();
|
||||
if (resetAI)
|
||||
Reset(true);
|
||||
else
|
||||
InterruptSpell();
|
||||
bot->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TELEPORTED | AURA_INTERRUPT_FLAG_CHANGE_MAP);
|
||||
bot->TeleportTo(loc.GetMapId(), loc.GetPositionX(), loc.GetPositionY(), loc.GetPositionZ(), 0);
|
||||
bot->SendMovementFlagUpdate();
|
||||
}
|
||||
|
||||
void PlayerbotAI::HandleTeleportAck()
|
||||
{
|
||||
if (!bot || !bot->GetSession())
|
||||
|
||||
@ -396,7 +396,6 @@ public:
|
||||
void HandleMasterIncomingPacket(WorldPacket const& packet);
|
||||
void HandleMasterOutgoingPacket(WorldPacket const& packet);
|
||||
void HandleTeleportAck();
|
||||
void TeleportTo(WorldLocation loc, bool resetAI = false);
|
||||
void ChangeEngine(BotState type);
|
||||
void ChangeEngineOnCombat();
|
||||
void ChangeEngineOnNonCombat();
|
||||
|
||||
@ -1696,7 +1696,14 @@ void RandomPlayerbotMgr::RandomTeleport(Player* bot, std::vector<WorldLocation>&
|
||||
break;
|
||||
}
|
||||
|
||||
botAI->TeleportTo(WorldLocation(loc.GetMapId(), x, y, z, 0), true);
|
||||
bot->GetMotionMaster()->Clear();
|
||||
PlayerbotAI* botAI = GET_PLAYERBOT_AI(bot);
|
||||
if (botAI)
|
||||
botAI->Reset(true);
|
||||
bot->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TELEPORTED | AURA_INTERRUPT_FLAG_CHANGE_MAP);
|
||||
bot->TeleportTo(loc.GetMapId(), x, y, z, 0);
|
||||
bot->SendMovementFlagUpdate();
|
||||
|
||||
if (pmo)
|
||||
pmo->finish();
|
||||
|
||||
|
||||
@ -687,6 +687,93 @@ std::vector<WorldPosition> WorldPosition::frommGridCoord(mGridCoord GridCoord)
|
||||
return retVec;
|
||||
}
|
||||
|
||||
// TODO: Cleanup — make this actually work.
|
||||
void WorldPosition::loadMapAndVMap(uint32 mapId, uint8 x, uint8 y)
|
||||
{
|
||||
std::string const fileName = "load_map_grid.csv";
|
||||
/*
|
||||
if (isOverworld() && false || false)
|
||||
{
|
||||
if (!MMAP::MMapFactory::createOrGetMMapMgr()->loadMap(mapId, x, y))
|
||||
if (sPlayerbotAIConfig.hasLog(fileName))
|
||||
{
|
||||
std::ostringstream out;
|
||||
out << sPlayerbotAIConfig.GetTimestampStr();
|
||||
out << "+00,\"mmap\", " << x << "," << y << "," << (TravelMgr::instance().isBadMmap(mapId, x, y) ? "0" : "1")
|
||||
<< ",";
|
||||
printWKT(fromGridCoord(GridCoord(x, y)), out, 1, true);
|
||||
sPlayerbotAIConfig.log(fileName, out.str().c_str());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// This needs to be disabled or maps will not load.
|
||||
// Needs more testing to check for impact on movement.
|
||||
if (false)
|
||||
if (!TravelMgr::instance().isBadVmap(mapId, x, y))
|
||||
{
|
||||
// load VMAPs for current map/grid...
|
||||
const MapEntry* i_mapEntry = sMapStore.LookupEntry(mapId);
|
||||
//const char* mapName = i_mapEntry ? i_mapEntry->name[sWorld->GetDefaultDbcLocale()] : "UNNAMEDMAP\x0"; //not used, (usage are commented out below), line marked for removal.
|
||||
|
||||
int vmapLoadResult = VMAP::VMapFactory::createOrGetVMapMgr()->loadMap(
|
||||
(sWorld->GetDataPath() + "vmaps").c_str(), mapId, x, y);
|
||||
switch (vmapLoadResult)
|
||||
{
|
||||
case VMAP::VMAP_LOAD_RESULT_OK:
|
||||
// LOG_ERROR("playerbots", "VMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
|
||||
// mapName, mapId, x, y, x, y);
|
||||
break;
|
||||
case VMAP::VMAP_LOAD_RESULT_ERROR:
|
||||
// LOG_ERROR("playerbots", "Could not load VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{},
|
||||
// y:{})", mapName, mapId, x, y, x, y);
|
||||
TravelMgr::instance().addBadVmap(mapId, x, y);
|
||||
break;
|
||||
case VMAP::VMAP_LOAD_RESULT_IGNORED:
|
||||
TravelMgr::instance().addBadVmap(mapId, x, y);
|
||||
// LOG_INFO("playerbots", "Ignored VMAP name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})",
|
||||
// mapName, mapId, x, y, x, y);
|
||||
break;
|
||||
}
|
||||
|
||||
if (sPlayerbotAIConfig.hasLog(fileName))
|
||||
{
|
||||
std::ostringstream out;
|
||||
out << sPlayerbotAIConfig.GetTimestampStr();
|
||||
out << "+00,\"vmap\", " << x << "," << y << ", " << (TravelMgr::instance().isBadVmap(mapId, x, y) ? "0" : "1")
|
||||
<< ",";
|
||||
printWKT(frommGridCoord(mGridCoord(x, y)), out, 1, true);
|
||||
sPlayerbotAIConfig.log(fileName, out.str().c_str());
|
||||
}
|
||||
}
|
||||
*/
|
||||
if (!TravelMgr::instance().isBadMmap(mapId, x, y))
|
||||
{
|
||||
// load navmesh
|
||||
Map* map = getMap();
|
||||
if (map && map->GetMapCollisionData().LoadMMapTile(x, y) == MMAP::MMAP_LOAD_RESULT_ERROR)
|
||||
TravelMgr::instance().addBadMmap(mapId, x, y);
|
||||
|
||||
if (sPlayerbotAIConfig.hasLog(fileName))
|
||||
{
|
||||
std::ostringstream out;
|
||||
out << sPlayerbotAIConfig.GetTimestampStr();
|
||||
out << "+00,\"mmap\", " << x << "," << y << "," << (TravelMgr::instance().isBadMmap(mapId, x, y) ? "0" : "1")
|
||||
<< ",";
|
||||
printWKT(fromGridCoord(GridCoord(x, y)), out, 1, true);
|
||||
sPlayerbotAIConfig.log(fileName, out.str().c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void WorldPosition::loadMapAndVMaps(WorldPosition secondPos)
|
||||
{
|
||||
for (auto& grid : getmGridCoords(secondPos))
|
||||
{
|
||||
loadMapAndVMap(GetMapId(), grid.first, grid.second);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<WorldPosition> WorldPosition::fromPointsArray(std::vector<G3D::Vector3> path)
|
||||
{
|
||||
std::vector<WorldPosition> retVec;
|
||||
@ -699,42 +786,34 @@ std::vector<WorldPosition> WorldPosition::fromPointsArray(std::vector<G3D::Vecto
|
||||
// A single pathfinding attempt from one position to another. Returns pathfinding status and path.
|
||||
std::vector<WorldPosition> WorldPosition::getPathStepFrom(WorldPosition startPos, Unit* bot)
|
||||
{
|
||||
Unit* pathUnit = bot;
|
||||
Creature* tempCreature = nullptr;
|
||||
if (!bot)
|
||||
return {};
|
||||
|
||||
if (!pathUnit)
|
||||
{
|
||||
// Create a temporary creature for PathGenerator (same entry as DebugAction "show node")
|
||||
Map* map = sMapMgr->FindBaseMap(startPos.GetMapId());
|
||||
if (!map)
|
||||
return {};
|
||||
// Load mmaps and vmaps between the two points.
|
||||
loadMapAndVMaps(startPos);
|
||||
|
||||
tempCreature = new Creature();
|
||||
if (!tempCreature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map,
|
||||
PHASEMASK_NORMAL, 1 /*entry*/, 0,
|
||||
startPos.GetPositionX(), startPos.GetPositionY(),
|
||||
startPos.GetPositionZ(), 0))
|
||||
{
|
||||
delete tempCreature;
|
||||
return {};
|
||||
}
|
||||
pathUnit = tempCreature;
|
||||
|
||||
// Ensure grids are created at both endpoints so mmap tiles are available.
|
||||
// EnsureGridCreated loads terrain + vmaps + mmaps but NOT objects,
|
||||
// which is all PathGenerator needs.
|
||||
map->EnsureGridCreated(Acore::ComputeGridCoord(startPos.GetPositionX(), startPos.GetPositionY()));
|
||||
map->EnsureGridCreated(Acore::ComputeGridCoord(GetPositionX(), GetPositionY()));
|
||||
}
|
||||
|
||||
PathGenerator path(pathUnit);
|
||||
path.CalculatePath(GetPositionX(), GetPositionY(), GetPositionZ());
|
||||
PathGenerator path(bot);
|
||||
path.CalculatePath(startPos.GetPositionX(), startPos.GetPositionY(), startPos.GetPositionZ());
|
||||
|
||||
Movement::PointsArray points = path.GetPath();
|
||||
PathType type = path.GetPathType();
|
||||
|
||||
if (tempCreature)
|
||||
delete tempCreature;
|
||||
if (sPlayerbotAIConfig.hasLog("pathfind_attempt_point.csv"))
|
||||
{
|
||||
std::ostringstream out;
|
||||
out << std::fixed << std::setprecision(1);
|
||||
printWKT({startPos, *this}, out);
|
||||
sPlayerbotAIConfig.log("pathfind_attempt_point.csv", out.str().c_str());
|
||||
}
|
||||
|
||||
if (sPlayerbotAIConfig.hasLog("pathfind_attempt.csv") && (type == PATHFIND_INCOMPLETE || type == PATHFIND_NORMAL))
|
||||
{
|
||||
std::ostringstream out;
|
||||
out << sPlayerbotAIConfig.GetTimestampStr() << "+00,";
|
||||
out << std::fixed << std::setprecision(1) << type << ",";
|
||||
printWKT(fromPointsArray(points), out, 1);
|
||||
sPlayerbotAIConfig.log("pathfind_attempt.csv", out.str().c_str());
|
||||
}
|
||||
|
||||
if (type == PATHFIND_INCOMPLETE || type == PATHFIND_NORMAL)
|
||||
return fromPointsArray(points);
|
||||
@ -1000,14 +1079,6 @@ GuidPosition::GuidPosition(GameObjectData const& goData)
|
||||
loadedFromDB = true;
|
||||
}
|
||||
|
||||
TravelDestination::~TravelDestination()
|
||||
{
|
||||
for (WorldPosition* point : points)
|
||||
delete point;
|
||||
|
||||
points.clear();
|
||||
}
|
||||
|
||||
std::vector<WorldPosition*> TravelDestination::getPoints(bool ignoreFull)
|
||||
{
|
||||
if (ignoreFull)
|
||||
@ -2314,7 +2385,9 @@ void TravelMgr::LoadQuestTravelTable()
|
||||
sPlayerbotAIConfig.openLog("unload_grid.csv", "w");
|
||||
sPlayerbotAIConfig.openLog("unload_obj.csv", "w");
|
||||
|
||||
// Node loading/generation is handled by TravelNodeMap::Init() called from TravelMgr::Init().
|
||||
TravelNodeMap::instance().loadNodeStore();
|
||||
|
||||
TravelNodeMap::instance().generateAll();
|
||||
|
||||
/*
|
||||
bool fullNavPointReload = false;
|
||||
@ -2705,7 +2778,7 @@ void TravelMgr::LoadQuestTravelTable()
|
||||
//if (preloadUnlinkedPaths && !startNode->hasLinkTo(endNode) && startNode->isUselessLink(endNode))
|
||||
// continue;
|
||||
|
||||
startNode->BuildPath(endNode, nullptr, false);
|
||||
startNode->buildPath(endNode, nullptr, false);
|
||||
|
||||
//if (startNode->hasLinkTo(endNode) && !startNode->getPathTo(endNode)->getComplete())
|
||||
//startNode->removeLinkTo(endNode);
|
||||
@ -2829,7 +2902,7 @@ void TravelMgr::LoadQuestTravelTable()
|
||||
|
||||
TravelNodePath nodePath = *path.second;
|
||||
|
||||
std::vector<WorldPosition> pPath = nodePath.GetPath();
|
||||
std::vector<WorldPosition> pPath = nodePath.getPath();
|
||||
std::reverse(pPath.begin(), pPath.end());
|
||||
|
||||
nodePath.setPath(pPath);
|
||||
@ -4292,7 +4365,8 @@ void TravelMgr::Init()
|
||||
PrepareZone2LevelBracket();
|
||||
PrepareDestinationCache();
|
||||
}
|
||||
sTravelNodeMap.Init();
|
||||
sTravelNodeMap.InitTaxiGraph();
|
||||
LOG_INFO("playerbots", "Playerbots Taxi graph and destination cache built.");
|
||||
}
|
||||
|
||||
Creature* TravelMgr::GetNearestFlightMaster(Player* bot)
|
||||
@ -4444,34 +4518,6 @@ std::vector<WorldLocation> TravelMgr::GetCityLocations(Player* bot)
|
||||
return fallbackLocations;
|
||||
}
|
||||
|
||||
bool TravelMgr::SelectAuctioneerByMap(Player* bot, NpcLocation& outAuctioneer)
|
||||
{
|
||||
uint16 botMapId = bot->GetMapId();
|
||||
auto const& cache = (bot->GetTeamId() == TEAM_HORDE) ? hordeAuctioneerCache : allianceAuctioneerCache;
|
||||
|
||||
auto mapIt = cache.find(botMapId);
|
||||
if (mapIt == cache.end() || mapIt->second.empty())
|
||||
return false;
|
||||
|
||||
// Collect all areas on this map that have auctioneers
|
||||
std::vector<uint32> areaIds;
|
||||
areaIds.reserve(mapIt->second.size());
|
||||
for (auto const& [areaId, npcs] : mapIt->second)
|
||||
{
|
||||
if (!npcs.empty())
|
||||
areaIds.push_back(areaId);
|
||||
}
|
||||
|
||||
if (areaIds.empty())
|
||||
return false;
|
||||
|
||||
// Pick a random area, then a random auctioneer in that area
|
||||
uint32 selectedArea = areaIds[urand(0, areaIds.size() - 1)];
|
||||
auto const& auctioneers = mapIt->second.at(selectedArea);
|
||||
outAuctioneer = auctioneers[urand(0, auctioneers.size() - 1)];
|
||||
return true;
|
||||
}
|
||||
|
||||
void TravelMgr::PrepareZone2LevelBracket()
|
||||
{
|
||||
// Classic WoW - Low - level zones
|
||||
@ -4558,7 +4604,6 @@ void TravelMgr::PrepareDestinationCache()
|
||||
uint32 flightMastersCount = 0;
|
||||
uint32 innkeepersCount = 0;
|
||||
uint32 bankerCount = 0;
|
||||
uint32 auctioneerCount = 0;
|
||||
|
||||
LOG_INFO("playerbots", "Preparing destination caches for {} levels...", maxLevel);
|
||||
// Temporary map to group creatures by entry and area
|
||||
@ -4683,7 +4728,7 @@ void TravelMgr::PrepareDestinationCache()
|
||||
creatureTemplate->Entry != 30606 && creatureTemplate->Entry != 30608 &&
|
||||
creatureTemplate->Entry != 29282)
|
||||
{
|
||||
NpcLocation bLoc;
|
||||
BankerLocation bLoc;
|
||||
bLoc.loc = WorldLocation(mapId, x + cos(orient) * 6.0f, y + sin(orient) * 6.0f, z + 2.0f, orient + M_PI);
|
||||
bLoc.entry = templateEntry;
|
||||
uint32 level = (creatureTemplate->minlevel + creatureTemplate->maxlevel + 1) / 2;
|
||||
@ -4706,31 +4751,6 @@ void TravelMgr::PrepareDestinationCache()
|
||||
}
|
||||
bankerCount++;
|
||||
}
|
||||
// === AUCTIONEERS ===
|
||||
else if (creatureTemplate->npcflag & UNIT_NPC_FLAG_AUCTIONEER)
|
||||
{
|
||||
FactionTemplateEntry const* factionEntry = sFactionTemplateStore.LookupEntry(creatureTemplate->faction);
|
||||
if (!factionEntry)
|
||||
continue;
|
||||
|
||||
bool forHorde = !(factionEntry->hostileMask & 4);
|
||||
bool forAlliance = !(factionEntry->hostileMask & 2);
|
||||
|
||||
if (!forHorde && !forAlliance)
|
||||
continue;
|
||||
|
||||
NpcLocation aLoc;
|
||||
aLoc.loc = WorldLocation(mapId, x + cos(orient) * 3.0f, y + sin(orient) * 3.0f, z + 0.5f, orient + M_PI);
|
||||
aLoc.entry = templateEntry;
|
||||
|
||||
if (forHorde)
|
||||
hordeAuctioneerCache[mapId][areaId].push_back(aLoc);
|
||||
|
||||
if (forAlliance)
|
||||
allianceAuctioneerCache[mapId][areaId].push_back(aLoc);
|
||||
|
||||
auctioneerCount++;
|
||||
}
|
||||
}
|
||||
|
||||
// Process temporary caches
|
||||
@ -4740,29 +4760,13 @@ void TravelMgr::PrepareDestinationCache()
|
||||
{
|
||||
CreatureTemplate const* creatureTemplate = sObjectMgr->GetCreatureTemplate(creatureDataList[0].id1);
|
||||
uint32 level = (creatureTemplate->minlevel + creatureTemplate->maxlevel + 1) / 2;
|
||||
|
||||
float totalX = 0.0f;
|
||||
float totalY = 0.0f;
|
||||
float totalZ = 0.0f;
|
||||
for (CreatureData const& creatureData : creatureDataList)
|
||||
{
|
||||
totalX += creatureData.posX;
|
||||
totalY += creatureData.posY;
|
||||
totalZ += creatureData.posZ;
|
||||
}
|
||||
|
||||
float avgX = totalX / creatureDataList.size();
|
||||
float avgY = totalY / creatureDataList.size();
|
||||
float avgZ = totalZ / creatureDataList.size();
|
||||
uint32 mapId = std::get<0>(gridTuple);
|
||||
|
||||
for (int32 l = (int32)level - (int32)sPlayerbotAIConfig.randomBotTeleLowerLevel;
|
||||
l <= (int32)level + (int32)sPlayerbotAIConfig.randomBotTeleHigherLevel; l++)
|
||||
{
|
||||
if (l < 1 || l > maxLevel)
|
||||
continue;
|
||||
|
||||
locsPerLevelCache[(uint8)l].push_back(WorldLocation(mapId, avgX, avgY, avgZ, 0.0f));
|
||||
locsPerLevelCache[(uint8)l].push_back(WorldLocation(std::get<0>(gridTuple)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4808,5 +4812,5 @@ void TravelMgr::PrepareDestinationCache()
|
||||
break;
|
||||
}
|
||||
}
|
||||
LOG_INFO("playerbots", ">> {} flight masters, {} innkeepers, {} bankers, {} auctioneers collected.", flightMastersCount, innkeepersCount, bankerCount, auctioneerCount);
|
||||
LOG_INFO("playerbots", ">> {} flight masters and {} innkeepers and {} banker locations for level collected.", flightMastersCount, innkeepersCount, bankerCount);
|
||||
}
|
||||
|
||||
@ -268,6 +268,12 @@ public:
|
||||
std::vector<mGridCoord> getmGridCoords(WorldPosition secondPos);
|
||||
std::vector<WorldPosition> frommGridCoord(mGridCoord GridCoord);
|
||||
|
||||
void loadMapAndVMap(uint32 mapId, uint8 x, uint8 y);
|
||||
|
||||
void loadMapAndVMap() { loadMapAndVMap(GetMapId(), getmGridCoord().first, getmGridCoord().second); }
|
||||
|
||||
void loadMapAndVMaps(WorldPosition secondPos);
|
||||
|
||||
// Display functions
|
||||
WorldPosition getDisplayLocation();
|
||||
float getDisplayX() { return getDisplayLocation().GetPositionY() * -1.0; }
|
||||
@ -501,15 +507,9 @@ public:
|
||||
radiusMin = radiusMin1;
|
||||
radiusMax = radiusMax1;
|
||||
}
|
||||
virtual ~TravelDestination();
|
||||
virtual ~TravelDestination() = default;
|
||||
|
||||
void addPoint(WorldPosition* pos)
|
||||
{
|
||||
if (!pos)
|
||||
return;
|
||||
|
||||
points.push_back(new WorldPosition(*pos));
|
||||
}
|
||||
void addPoint(WorldPosition* pos) { points.push_back(pos); }
|
||||
|
||||
void setExpireDelay(uint32 delay) { expireDelay = delay; }
|
||||
|
||||
@ -673,7 +673,7 @@ public:
|
||||
bool isActive(Player* bot) override;
|
||||
virtual CreatureTemplate const* GetCreatureTemplate();
|
||||
std::string const getName() override { return "RpgTravelDestination"; }
|
||||
int32 getEntry() override { return entry; }
|
||||
int32 getEntry() override { return 0; }
|
||||
std::string const getTitle() override;
|
||||
|
||||
protected:
|
||||
@ -846,12 +846,6 @@ protected:
|
||||
class TravelMgr
|
||||
{
|
||||
public:
|
||||
struct NpcLocation
|
||||
{
|
||||
WorldLocation loc;
|
||||
uint32 entry;
|
||||
};
|
||||
|
||||
static TravelMgr& instance()
|
||||
{
|
||||
static TravelMgr instance;
|
||||
@ -870,7 +864,6 @@ public:
|
||||
const std::vector<WorldLocation> GetTeleportLocations(Player* bot);
|
||||
const std::vector<WorldLocation> GetTravelHubs(Player* bot);
|
||||
std::vector<WorldLocation> GetCityLocations(Player* bot);
|
||||
bool SelectAuctioneerByMap(Player* bot, NpcLocation& outAuctioneer);
|
||||
const std::vector<WorldLocation>& GetLocsPerLevelCache(uint8 level) { return locsPerLevelCache[level]; }
|
||||
|
||||
template <class D, class W, class URBG>
|
||||
@ -975,14 +968,18 @@ private:
|
||||
bool InsideBracket(uint32 val) const { return val >= low && val <= high; }
|
||||
};
|
||||
|
||||
struct BankerLocation
|
||||
{
|
||||
WorldLocation loc;
|
||||
uint32 entry;
|
||||
};
|
||||
|
||||
// Navigation caches
|
||||
std::map<uint32, WorldPosition> allianceFlightMasterCache;
|
||||
std::map<uint32, WorldPosition> hordeFlightMasterCache;
|
||||
std::map<uint8, std::vector<WorldLocation>> allianceHubsPerLevelCache;
|
||||
std::map<uint8, std::vector<WorldLocation>> hordeHubsPerLevelCache;
|
||||
std::map<uint8, std::vector<NpcLocation>> bankerLocsPerLevelCache;
|
||||
std::unordered_map<uint16, std::unordered_map<uint32, std::vector<NpcLocation>>> hordeAuctioneerCache;
|
||||
std::unordered_map<uint16, std::unordered_map<uint32, std::vector<NpcLocation>>> allianceAuctioneerCache;
|
||||
std::map<uint8, std::vector<BankerLocation>> bankerLocsPerLevelCache;
|
||||
std::unordered_map<uint32, WorldLocation> bankerEntryToLocation;
|
||||
std::map<uint8, std::vector<WorldLocation>> locsPerLevelCache;
|
||||
std::unordered_map<uint32, std::vector<WorldLocation>> creatureSpawnsByTemplate;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -8,12 +8,11 @@
|
||||
|
||||
#include <shared_mutex>
|
||||
|
||||
#include "G3D/Vector3.h"
|
||||
#include "TravelMgr.h"
|
||||
|
||||
// THEORY
|
||||
//
|
||||
// Pathfinding in (c)mangos is based on detour recast, an opensource navmesh creation and pathfinding codebase.
|
||||
// Pathfinding in (c)mangos is based on detour recast an opensource nashmesh creation and pathfinding codebase.
|
||||
// This system is used for mob and npc pathfinding and in this codebase also for bots.
|
||||
// Because mobs and npc movement is based on following a player or a set path the PathGenerator is limited to 296y.
|
||||
// This means that when trying to find a path from A to B distances beyond 296y will be a best guess often moving in a
|
||||
@ -25,68 +24,33 @@
|
||||
// <S> ---> [N1] ---> [N2] ---> [N3] ---> <E>
|
||||
//
|
||||
// Bot at <S> wants to move to <E>
|
||||
// [N1],[N2],[N3] are predefined nodes for which we know we can move from [N1] to [N2] and from [N2] to [N3] but not
|
||||
// from [N1] to [N3]. If we can move from [S] to [N1] and from [N3] to [E] we have a complete route to travel.
|
||||
// [N1],[N2],[N3] are predefined nodes for wich we know we can move from [N1] to [N2] and from [N2] to [N3] but not
|
||||
// from [N1] to [N3] If we can move fom [S] to [N1] and from [N3] to [E] we have a complete route to travel.
|
||||
//
|
||||
// Terminology:
|
||||
// Node: A location on a map for which we know bots are likely to want to travel to or need to travel past to reach
|
||||
// other nodes. Stored in DB table `playerbots_travelnode`.
|
||||
// Link: The connection between two nodes. A link signifies that the bot can travel from one node to another.
|
||||
// A link is one-directional. Stored in `playerbots_travelnode_link`.
|
||||
// Path: The waypoint path returned by the standard PathGenerator to move from one node (or position) to another.
|
||||
// A path can be incomplete or empty which means there is no link. Stored in `playerbots_travelnode_path`.
|
||||
// Route: The list of nodes that give the shortest route from a node to a distant node. Routes are calculated using
|
||||
// a standard A* search based on links.
|
||||
// Termonology:
|
||||
// Node: a location on a map for which we know bots are likely to want to travel to or need to travel past to reach
|
||||
// other nodes. Link: the connection between two nodes. A link signifies that the bot can travel from one node to
|
||||
// another. A link is one-directional. Path: the waypointpath returned by the standard PathGenerator to move from one
|
||||
// node (or position) to another. A path can be imcomplete or empty which means there is no link. Route: the list of
|
||||
// nodes that give the shortest route from a node to a distant node. Routes are calculated using a standard A* search
|
||||
// based on links.
|
||||
//
|
||||
// Edge types (TravelNodePathType):
|
||||
// walk(1) — Walk via navmesh waypoints (stored in DB)
|
||||
// portal(2) — AreaTrigger teleport (auto-discovered at startup)
|
||||
// transport(3) — Boat/zeppelin (auto-discovered from MO_TRANSPORT)
|
||||
// flightPath(4) — Taxi flight between flight masters
|
||||
// teleportSpell(5) — Spell-based teleport (e.g. mage portals)
|
||||
// staticPortal(6) — Manually defined teleport link (DB only, not pruned by generation)
|
||||
// flyingMount (7) — Use Bots Flying mount to travel (Not currently enabled)
|
||||
//
|
||||
// On server start saved nodes and links are loaded via TravelNodeMap::Init(). An index of nodes by zone is prepared
|
||||
// (instead of scanning all ~4000 nodes), precomputes connected components for O(1) reachability checks, and builds
|
||||
// a taxi BFS graph. Paths and routes are calculated on the fly and saved for future use. Nodes are only added at
|
||||
// startup or via the console `.generate` command — runtime mutation was removed because taking a unique_lock
|
||||
// caused 100-250ms contention spikes against bot threads.
|
||||
// On server start saved nodes and links are loaded. Paths and routes are calculated on the fly but saved for future
|
||||
// use. Nodes can be added and removed realtime however because bots access the nodes from different threads this
|
||||
// requires a locking mechanism.
|
||||
//
|
||||
// Initially the current nodes have been made:
|
||||
// Flightmasters and Inns (Bots can use these to fast-travel so eventually they will be included in the route
|
||||
// calculation) WorldBosses and Unique bosses in instances (These are logical places bots might want to go in
|
||||
// calculation) WorldBosses and Unique bosses in instances (These are a logical places bots might want to go in
|
||||
// instances) Player start spawns (Obviously all lvl1 bots will spawn and move from here) Area triggers locations with
|
||||
// teleport and their teleport destinations (These used to travel in or between maps) Transports including elevators
|
||||
// (Again used to travel in and in maps) (sub)Zone means (These are the center most point for each sub-zone which is
|
||||
// good for global coverage).
|
||||
// good for global coverage)
|
||||
//
|
||||
// To increase coverage/linking extra nodes must be manually created via the "playerbot travel generatenode"
|
||||
// console command after importing the specified node. Current implementation places nodes on paths (including
|
||||
// complete) at sub-zone transitions or randomly. After calculating possible links the node is removed if it
|
||||
// does not create local coverage (.fullgenerate only).
|
||||
// To increase coverage/linking extra nodes can be automatically be created.
|
||||
// Current implentation places nodes on paths (including complete) at sub-zone transitions or randomly.
|
||||
// After calculating possible links the node is removed if it does not create local coverage.
|
||||
//
|
||||
// Travel Flow:
|
||||
//
|
||||
// GetFullPath finds nearest nodes (zone-indexed), runs A* to get a node route, then
|
||||
// BuildPath assembles a flat TravelPath with typed waypoints (walk, portal, transport, flight).
|
||||
// ExecuteTravelPlan iterates the path by stepIdx, dispatching on each point's PathNodeType.
|
||||
// Cross-map travel is handled naturally by portal/transport edges in the A* graph.
|
||||
//
|
||||
// If setup cannot resolve (no node, no route, no flight), the bot teleports directly to the destination
|
||||
// as a fallback.
|
||||
//
|
||||
// The use of hearthstones and mage teleporting was removed — it caused route mutations requiring locking that no longer made sense. Mage portals may be future item.
|
||||
//
|
||||
// Thread Safety:
|
||||
//
|
||||
// The node graph is immutable at runtime (no adds/removes after Init). A shared_timed_mutex (m_nMapMtx) still
|
||||
// exists and shared_locks are taken in GetFullPath and GenerateWalkPath for safety, but since there are no
|
||||
// runtime mutations these are effectively uncontested. The only exclusive locks are taken at startup
|
||||
// (saveNodeStore) and by the debug dump command.
|
||||
//
|
||||
|
||||
constexpr float MAX_PATHFINDING_DISTANCE = 296.0f;
|
||||
|
||||
enum class TravelNodePathType : uint8
|
||||
{
|
||||
@ -95,20 +59,21 @@ enum class TravelNodePathType : uint8
|
||||
portal = 2,
|
||||
transport = 3,
|
||||
flightPath = 4,
|
||||
teleportSpell = 5,
|
||||
staticPortal = 6,
|
||||
flyingMount = 7
|
||||
teleportSpell = 5
|
||||
};
|
||||
|
||||
// A connection between two nodes.
|
||||
class TravelNodePath
|
||||
{
|
||||
public:
|
||||
// Legacy Constructor for travelnodestore
|
||||
// TravelNodePath(float distance1, float extraCost1, bool portal1 = false, uint32 portalId1 = 0, bool transport1 =
|
||||
// false, bool calculated = false, uint8 maxLevelMob1 = 0, uint8 maxLevelAlliance1 = 0, uint8 maxLevelHorde1 = 0,
|
||||
// float swimDistance1 = 0, bool flightPath1 = false);
|
||||
|
||||
// Constructor
|
||||
TravelNodePath(float distance = 0.1f, float extraCost = 0,
|
||||
uint8 pathType = (uint8)TravelNodePathType::walk,
|
||||
uint32 pathObject = 0, bool calculated = false,
|
||||
std::vector<uint8> maxLevelCreature = {0, 0, 0},
|
||||
TravelNodePath(float distance = 0.1f, float extraCost = 0, uint8 pathType = (uint8)TravelNodePathType::walk,
|
||||
uint32 pathObject = 0, bool calculated = false, std::vector<uint8> maxLevelCreature = {0, 0, 0},
|
||||
float swimDistance = 0)
|
||||
: extraCost(extraCost),
|
||||
calculated(calculated),
|
||||
@ -120,7 +85,7 @@ public:
|
||||
{
|
||||
if (pathType != (uint8)TravelNodePathType::walk)
|
||||
complete = true;
|
||||
}
|
||||
};
|
||||
|
||||
TravelNodePath(TravelNodePath* basePath)
|
||||
{
|
||||
@ -133,11 +98,11 @@ public:
|
||||
swimDistance = basePath->swimDistance;
|
||||
pathType = basePath->pathType;
|
||||
pathObject = basePath->pathObject;
|
||||
}
|
||||
};
|
||||
|
||||
// Getters
|
||||
bool getComplete() { return complete || pathType != TravelNodePathType::walk; }
|
||||
std::vector<WorldPosition> GetPath() { return path; }
|
||||
std::vector<WorldPosition> getPath() { return path; }
|
||||
|
||||
TravelNodePathType getPathType() { return pathType; }
|
||||
uint32 getPathObject() { return pathObject; }
|
||||
@ -165,6 +130,9 @@ public:
|
||||
extraCost = distance / speed;
|
||||
}
|
||||
|
||||
// void setPortal(bool portal1, uint32 portalId1 = 0) { portal = portal1; portalId = portalId1; }
|
||||
// void setTransport(bool transport1) { transport = transport1; }
|
||||
|
||||
void setPathType(TravelNodePathType pathType1) { pathType = pathType1; }
|
||||
|
||||
void setPathObject(uint32 pathObject1) { pathObject = pathObject1; }
|
||||
@ -218,10 +186,9 @@ class TravelNode
|
||||
{
|
||||
public:
|
||||
// Constructors
|
||||
TravelNode() {}
|
||||
TravelNode(){};
|
||||
|
||||
TravelNode(WorldPosition point1, std::string const nodeName1 = "Travel Node",
|
||||
bool important1 = false)
|
||||
TravelNode(WorldPosition point1, std::string const nodeName1 = "Travel Node", bool important1 = false)
|
||||
{
|
||||
nodeName = nodeName1;
|
||||
point = point1;
|
||||
@ -240,11 +207,11 @@ public:
|
||||
void setPoint(WorldPosition point1) { point = point1; }
|
||||
|
||||
// Getters
|
||||
std::string const getName() { return nodeName; }
|
||||
WorldPosition* getPosition() { return &point; }
|
||||
std::string const getName() { return nodeName; };
|
||||
WorldPosition* getPosition() { return &point; };
|
||||
std::unordered_map<TravelNode*, TravelNodePath>* getPaths() { return &paths; }
|
||||
std::unordered_map<TravelNode*, TravelNodePath*>* getLinks() { return &links; }
|
||||
bool isImportant() { return important; }
|
||||
bool isImportant() { return important; };
|
||||
bool isLinked() { return linked; }
|
||||
|
||||
bool isTransport()
|
||||
@ -268,8 +235,7 @@ public:
|
||||
bool isPortal()
|
||||
{
|
||||
for (auto const& link : *getLinks())
|
||||
if (link.second->getPathType() == TravelNodePathType::portal ||
|
||||
link.second->getPathType() == TravelNodePathType::staticPortal)
|
||||
if (link.second->getPathType() == TravelNodePathType::portal)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
@ -285,25 +251,17 @@ public:
|
||||
}
|
||||
|
||||
// WorldLocation shortcuts
|
||||
uint32 GetMapId() { return point.GetMapId(); }
|
||||
uint32 getMapId() { return point.GetMapId(); }
|
||||
float getX() { return point.GetPositionX(); }
|
||||
float getY() { return point.GetPositionY(); }
|
||||
float getZ() { return point.GetPositionZ(); }
|
||||
float getO() { return point.GetOrientation(); }
|
||||
float getDistance(WorldPosition pos) { return point.distance(pos); }
|
||||
float getDistance(TravelNode* node)
|
||||
{
|
||||
return point.distance(node->getPosition());
|
||||
}
|
||||
float fDist(TravelNode* node)
|
||||
{
|
||||
return point.fDist(node->getPosition());
|
||||
}
|
||||
float getDistance(TravelNode* node) { return point.distance(node->getPosition()); }
|
||||
float fDist(TravelNode* node) { return point.fDist(node->getPosition()); }
|
||||
float fDist(WorldPosition pos) { return point.fDist(pos); }
|
||||
|
||||
TravelNodePath* setPathTo(TravelNode* node,
|
||||
TravelNodePath path = TravelNodePath(),
|
||||
bool isLink = true)
|
||||
TravelNodePath* setPathTo(TravelNode* node, TravelNodePath path = TravelNodePath(), bool isLink = true)
|
||||
{
|
||||
if (this != node)
|
||||
{
|
||||
@ -317,20 +275,10 @@ public:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool hasPathTo(TravelNode* node)
|
||||
{
|
||||
return paths.find(node) != paths.end();
|
||||
}
|
||||
TravelNodePath* getPathTo(TravelNode* node)
|
||||
{
|
||||
return &paths[node];
|
||||
}
|
||||
bool hasCompletePathTo(TravelNode* node)
|
||||
{
|
||||
return hasPathTo(node) && getPathTo(node)->getComplete();
|
||||
}
|
||||
TravelNodePath* BuildPath(TravelNode* endNode, Unit* bot,
|
||||
bool postProcess = false);
|
||||
bool hasPathTo(TravelNode* node) { return paths.find(node) != paths.end(); }
|
||||
TravelNodePath* getPathTo(TravelNode* node) { return &paths[node]; }
|
||||
bool hasCompletePathTo(TravelNode* node) { return hasPathTo(node) && getPathTo(node)->getComplete(); }
|
||||
TravelNodePath* buildPath(TravelNode* endNode, Unit* bot, bool postProcess = false);
|
||||
|
||||
void setLinkTo(TravelNode* node, float distance = 0.1f)
|
||||
{
|
||||
@ -343,18 +291,9 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
bool hasLinkTo(TravelNode* node)
|
||||
{
|
||||
return links.find(node) != links.end();
|
||||
}
|
||||
float linkCostTo(TravelNode* node)
|
||||
{
|
||||
return paths.find(node)->second.getDistance();
|
||||
}
|
||||
float linkDistanceTo(TravelNode* node)
|
||||
{
|
||||
return paths.find(node)->second.getDistance();
|
||||
}
|
||||
bool hasLinkTo(TravelNode* node) { return links.find(node) != links.end(); }
|
||||
float linkCostTo(TravelNode* node) { return paths.find(node)->second.getDistance(); }
|
||||
float linkDistanceTo(TravelNode* node) { return paths.find(node)->second.getDistance(); }
|
||||
void removeLinkTo(TravelNode* node, bool removePaths = false);
|
||||
|
||||
bool isEqual(TravelNode* compareNode);
|
||||
@ -365,8 +304,7 @@ public:
|
||||
bool cropUselessLinks();
|
||||
|
||||
// Returns all nodes that can be reached from this node.
|
||||
std::vector<TravelNode*> getNodeMap(bool importantOnly = false,
|
||||
std::vector<TravelNode*> ignoreNodes = {});
|
||||
std::vector<TravelNode*> getNodeMap(bool importantOnly = false, std::vector<TravelNode*> ignoreNodes = {});
|
||||
|
||||
// Checks if it is even possible to route to this node.
|
||||
bool hasRouteTo(TravelNode* node)
|
||||
@ -376,10 +314,7 @@ public:
|
||||
routes[mNode] = true;
|
||||
|
||||
return routes.find(node) != routes.end();
|
||||
}
|
||||
|
||||
void clearRoutes() { routes.clear(); }
|
||||
void setRouteTo(TravelNode* node) { routes[node] = true; }
|
||||
};
|
||||
|
||||
void print(bool printFailed = true);
|
||||
|
||||
@ -409,8 +344,24 @@ protected:
|
||||
// uint32 transportId = 0;
|
||||
};
|
||||
|
||||
class PortalNode : public TravelNode
|
||||
{
|
||||
public:
|
||||
PortalNode(TravelNode* baseNode) : TravelNode(baseNode){};
|
||||
|
||||
void SetPortal(TravelNode* baseNode, TravelNode* endNode, uint32 portalSpell)
|
||||
{
|
||||
nodeName = baseNode->getName();
|
||||
point = *baseNode->getPosition();
|
||||
paths.clear();
|
||||
links.clear();
|
||||
TravelNodePath path(0.1f, 0.1f, (uint8)TravelNodePathType::teleportSpell, portalSpell, true);
|
||||
setPathTo(endNode, path);
|
||||
};
|
||||
};
|
||||
|
||||
// Route step type
|
||||
enum class PathNodeType : uint8
|
||||
enum PathNodeType
|
||||
{
|
||||
NODE_PREPATH = 0,
|
||||
NODE_PATH = 1,
|
||||
@ -418,14 +369,13 @@ enum class PathNodeType : uint8
|
||||
NODE_PORTAL = 3,
|
||||
NODE_TRANSPORT = 4,
|
||||
NODE_FLIGHTPATH = 5,
|
||||
NODE_TELEPORT = 6,
|
||||
NODE_FLYING_MOUNT = 7
|
||||
NODE_TELEPORT = 6
|
||||
};
|
||||
|
||||
struct PathNodePoint
|
||||
{
|
||||
WorldPosition point;
|
||||
PathNodeType type = PathNodeType::NODE_PATH;
|
||||
PathNodeType type = NODE_PATH;
|
||||
uint32 entry = 0;
|
||||
};
|
||||
|
||||
@ -433,31 +383,24 @@ struct PathNodePoint
|
||||
class TravelPath
|
||||
{
|
||||
public:
|
||||
TravelPath() {}
|
||||
TravelPath(std::vector<PathNodePoint> fullPath1)
|
||||
{
|
||||
fullPath = fullPath1;
|
||||
}
|
||||
TravelPath(std::vector<WorldPosition> path,
|
||||
PathNodeType type = PathNodeType::NODE_PATH,
|
||||
uint32 entry = 0)
|
||||
TravelPath(){};
|
||||
TravelPath(std::vector<PathNodePoint> fullPath1) { fullPath = fullPath1; }
|
||||
TravelPath(std::vector<WorldPosition> path, PathNodeType type = NODE_PATH, uint32 entry = 0)
|
||||
{
|
||||
addPath(path, type, entry);
|
||||
}
|
||||
|
||||
void addPoint(PathNodePoint point) { fullPath.push_back(point); }
|
||||
void addPoint(WorldPosition point,
|
||||
PathNodeType type = PathNodeType::NODE_PATH,
|
||||
uint32 entry = 0)
|
||||
void addPoint(WorldPosition point, PathNodeType type = NODE_PATH, uint32 entry = 0)
|
||||
{
|
||||
fullPath.push_back(PathNodePoint{point, type, entry});
|
||||
}
|
||||
void addPath(std::vector<WorldPosition> path,
|
||||
PathNodeType type = PathNodeType::NODE_PATH,
|
||||
uint32 entry = 0)
|
||||
void addPath(std::vector<WorldPosition> path, PathNodeType type = NODE_PATH, uint32 entry = 0)
|
||||
{
|
||||
for (auto& p : path)
|
||||
{
|
||||
fullPath.push_back(PathNodePoint{p, type, entry});
|
||||
};
|
||||
}
|
||||
void addPath(std::vector<PathNodePoint> newPath)
|
||||
{
|
||||
@ -465,11 +408,8 @@ public:
|
||||
}
|
||||
void clear() { fullPath.clear(); }
|
||||
|
||||
bool empty() const { return fullPath.empty(); }
|
||||
size_t size() const { return fullPath.size(); }
|
||||
const PathNodePoint& operator[](size_t idx) const { return fullPath[idx]; }
|
||||
std::vector<PathNodePoint> GetPath() { return fullPath; }
|
||||
const std::vector<PathNodePoint>& GetPathRef() const { return fullPath; }
|
||||
bool empty() { return fullPath.empty(); }
|
||||
std::vector<PathNodePoint> getPath() { return fullPath; }
|
||||
WorldPosition getFront() { return fullPath.front().point; }
|
||||
WorldPosition getBack() { return fullPath.back().point; }
|
||||
|
||||
@ -479,9 +419,13 @@ public:
|
||||
for (auto const& p : fullPath)
|
||||
retVec.push_back(p.point);
|
||||
return retVec;
|
||||
}
|
||||
};
|
||||
|
||||
bool makeShortCut(WorldPosition startPos, float maxDist);
|
||||
bool shouldMoveToNextPoint(WorldPosition startPos, std::vector<PathNodePoint>::iterator beg,
|
||||
std::vector<PathNodePoint>::iterator ed, std::vector<PathNodePoint>::iterator p,
|
||||
float& moveDist, float maxDist);
|
||||
WorldPosition getNextPoint(WorldPosition startPos, float maxDist, TravelNodePathType& pathType, uint32& entry);
|
||||
|
||||
std::ostringstream const print();
|
||||
|
||||
@ -494,25 +438,17 @@ class TravelNodeRoute
|
||||
{
|
||||
public:
|
||||
TravelNodeRoute() {}
|
||||
TravelNodeRoute(std::vector<TravelNode*> nodes1)
|
||||
{
|
||||
nodes = nodes1;
|
||||
}
|
||||
TravelNodeRoute(std::vector<TravelNode*> nodes1) { nodes = nodes1; /*currentNode = route.begin();*/ }
|
||||
|
||||
bool isEmpty() { return nodes.empty(); }
|
||||
|
||||
bool hasNode(TravelNode* node)
|
||||
{
|
||||
return findNode(node) != nodes.end();
|
||||
}
|
||||
bool hasNode(TravelNode* node) { return findNode(node) != nodes.end(); }
|
||||
float getTotalDistance();
|
||||
|
||||
std::vector<TravelNode*> getNodes() { return nodes; }
|
||||
|
||||
TravelPath BuildPath(
|
||||
std::vector<WorldPosition> pathToStart = {},
|
||||
std::vector<WorldPosition> pathToEnd = {},
|
||||
Unit* bot = nullptr);
|
||||
TravelPath buildPath(std::vector<WorldPosition> pathToStart = {}, std::vector<WorldPosition> pathToEnd = {},
|
||||
Unit* bot = nullptr);
|
||||
|
||||
std::ostringstream const print();
|
||||
|
||||
@ -531,47 +467,12 @@ public:
|
||||
TravelNodeStub(TravelNode* dataNode1) { dataNode = dataNode1; }
|
||||
|
||||
TravelNode* dataNode;
|
||||
float totalCost = 0.0;
|
||||
float costFromStart = 0.0;
|
||||
float heuristic = 0.0;
|
||||
bool open = false;
|
||||
bool closed = false;
|
||||
float m_f = 0.0, m_g = 0.0, m_h = 0.0;
|
||||
bool open = false, close = false;
|
||||
TravelNodeStub* parent = nullptr;
|
||||
uint32 currentGold = 0;
|
||||
};
|
||||
|
||||
struct TravelPlan
|
||||
{
|
||||
WorldPosition destination;
|
||||
|
||||
// Flat waypoint path built upfront by GetFullPath:
|
||||
TravelPath steps;
|
||||
uint32 stepIdx{0};
|
||||
|
||||
// Spline scratch (used by executor):
|
||||
std::vector<G3D::Vector3> walkPoints;
|
||||
bool splineActive{false};
|
||||
uint32 splineStartTime{0};
|
||||
uint32 expectedDuration{0};
|
||||
|
||||
// Taxi scratch:
|
||||
std::vector<uint32> route;
|
||||
|
||||
bool IsActive() const { return !steps.empty(); }
|
||||
|
||||
void Reset()
|
||||
{
|
||||
destination = WorldPosition();
|
||||
steps.clear();
|
||||
stepIdx = 0;
|
||||
walkPoints.clear();
|
||||
splineActive = false;
|
||||
splineStartTime = 0;
|
||||
expectedDuration = 0;
|
||||
route.clear();
|
||||
}
|
||||
};
|
||||
|
||||
// The container of all nodes.
|
||||
class TravelNodeMap
|
||||
{
|
||||
@ -583,18 +484,14 @@ public:
|
||||
return instance;
|
||||
}
|
||||
|
||||
TravelNode* addNode(WorldPosition pos,
|
||||
std::string const preferedName = "Travel Node",
|
||||
bool isImportant = false,
|
||||
bool checkDuplicate = true,
|
||||
bool transport = false,
|
||||
uint32 transportId = 0);
|
||||
TravelNode* addNode(WorldPosition pos, std::string const preferedName = "Travel Node", bool isImportant = false,
|
||||
bool checkDuplicate = true, bool transport = false, uint32 transportId = 0);
|
||||
void removeNode(TravelNode* node);
|
||||
bool removeNodes()
|
||||
{
|
||||
if (m_nMapMtx.try_lock_for(std::chrono::seconds(10)))
|
||||
{
|
||||
for (auto& node : nodes)
|
||||
for (auto& node : m_nodes)
|
||||
removeNode(node);
|
||||
|
||||
m_nMapMtx.unlock();
|
||||
@ -602,32 +499,28 @@ public:
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
void fullLinkNode(TravelNode* startNode, Unit* bot);
|
||||
|
||||
// Get all nodes
|
||||
std::vector<TravelNode*> getNodes() { return nodes; }
|
||||
std::vector<TravelNode*> getNodes() { return m_nodes; }
|
||||
std::vector<TravelNode*> getNodes(WorldPosition pos, float range = -1);
|
||||
|
||||
// Find nearest node.
|
||||
TravelNode* getNode(TravelNode* sameNode)
|
||||
{
|
||||
for (auto& node : nodes)
|
||||
for (auto& node : m_nodes)
|
||||
{
|
||||
if (node->getName() == sameNode->getName()
|
||||
&& node->getPosition() == sameNode->getPosition())
|
||||
if (node->getName() == sameNode->getName() && node->getPosition() == sameNode->getPosition())
|
||||
return node;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
TravelNode* getNode(WorldPosition pos,
|
||||
std::vector<WorldPosition>& ppath,
|
||||
Unit* bot = nullptr, float range = -1);
|
||||
TravelNode* getNode(WorldPosition pos, Unit* bot = nullptr,
|
||||
float range = -1)
|
||||
TravelNode* getNode(WorldPosition pos, std::vector<WorldPosition>& ppath, Unit* bot = nullptr, float range = -1);
|
||||
TravelNode* getNode(WorldPosition pos, Unit* bot = nullptr, float range = -1)
|
||||
{
|
||||
std::vector<WorldPosition> ppath;
|
||||
return getNode(pos, ppath, bot, range);
|
||||
@ -643,16 +536,15 @@ public:
|
||||
return rNodes[urand(0, rNodes.size() - 1)];
|
||||
}
|
||||
|
||||
// Finds the best nodePath between two nodes (A* over the node graph)
|
||||
TravelNodeRoute GetNodeRoute(TravelNode* start, TravelNode* goal,
|
||||
Player* bot);
|
||||
// Finds the best nodePath between two nodes
|
||||
TravelNodeRoute getRoute(TravelNode* start, TravelNode* goal, Player* bot = nullptr);
|
||||
|
||||
// Find the nearest start/end nodes for two world positions
|
||||
TravelNodeRoute GetNearestNodes(WorldPosition startPos,
|
||||
WorldPosition endPos,
|
||||
std::vector<WorldPosition>& startPath,
|
||||
Player* bot = nullptr);
|
||||
// Find the best node between two positions
|
||||
TravelNodeRoute getRoute(WorldPosition startPos, WorldPosition endPos, std::vector<WorldPosition>& startPath,
|
||||
Player* bot = nullptr);
|
||||
|
||||
// Find the full path between those locations
|
||||
static TravelPath getFullPath(WorldPosition startPos, WorldPosition endPos, Player* bot = nullptr);
|
||||
|
||||
// Manage/update nodes
|
||||
void manageNodes(Unit* bot, bool mapFull = false);
|
||||
@ -671,17 +563,15 @@ public:
|
||||
void removeUselessPaths();
|
||||
void calculatePathCosts();
|
||||
void generateTaxiPaths();
|
||||
void generatePaths(bool fullGen = false);
|
||||
void generatePaths();
|
||||
|
||||
void generateAll();
|
||||
|
||||
void Init();
|
||||
|
||||
void printMap();
|
||||
|
||||
void printNodeStore();
|
||||
void saveNodeStore();
|
||||
void LoadNodeStore();
|
||||
void loadNodeStore();
|
||||
|
||||
bool cropUselessNode(TravelNode* startNode);
|
||||
TravelNode* addZoneLinkNode(TravelNode* startNode);
|
||||
@ -694,25 +584,8 @@ public:
|
||||
void InitTaxiGraph();
|
||||
std::vector<uint32> FindTaxiPath(uint32 fromNode, uint32 toNode);
|
||||
|
||||
void BuildZoneIndex();
|
||||
void PrecomputeReachability();
|
||||
|
||||
TravelNode* GetNearestNodeInZone(WorldPosition pos, uint32 zoneId);
|
||||
TravelNode* GetNearestNodeOnMap(WorldPosition pos);
|
||||
|
||||
bool GetFullPath(TravelPlan& plan, WorldPosition botPos,
|
||||
uint32 botZoneId, uint32 teamId,
|
||||
WorldPosition destination);
|
||||
|
||||
// Resolve A* route between two world positions (returns node vector)
|
||||
std::vector<TravelNode*> ResolveRoute(WorldPosition startPos,
|
||||
WorldPosition endPos);
|
||||
|
||||
// Get stored walk points for one edge (from→to). Empty if no path.
|
||||
std::vector<G3D::Vector3> GetEdgeWalkPoints(TravelNode* from,
|
||||
TravelNode* to);
|
||||
|
||||
std::shared_timed_mutex m_nMapMtx;
|
||||
std::unordered_map<ObjectGuid, std::unordered_map<uint32, TravelNode*>> teleportNodes;
|
||||
|
||||
private:
|
||||
TravelNodeMap() = default;
|
||||
@ -728,18 +601,13 @@ private:
|
||||
void BuildTaxiGraph();
|
||||
void ComputeAllPaths();
|
||||
std::unordered_map<uint32, uint32> BFS(uint32 startNode);
|
||||
std::vector<uint32> BuildPath(
|
||||
uint32 fromNode, uint32 toNode,
|
||||
const std::unordered_map<uint32, uint32>& parentMap);
|
||||
std::vector<uint32> BuildPath(uint32 fromNode, uint32 toNode,
|
||||
const std::unordered_map<uint32, uint32>& parentMap);
|
||||
|
||||
std::unordered_map<uint32, std::vector<uint32>> m_taxiGraph;
|
||||
std::map<uint32, std::map<uint32, std::vector<uint32>>>
|
||||
m_taxiPathCache;
|
||||
std::unordered_map<uint32, std::vector<uint32>> taxiGraph;
|
||||
std::map<uint32, std::map<uint32, std::vector<uint32>>> taxiPathCache;
|
||||
|
||||
std::vector<TravelNode*> nodes;
|
||||
|
||||
std::unordered_map<uint32, std::vector<TravelNode*>> m_zoneIndex;
|
||||
std::unordered_map<uint32, std::vector<TravelNode*>> m_mapIndex;
|
||||
std::vector<TravelNode*> m_nodes;
|
||||
|
||||
std::vector<std::pair<uint32, WorldPosition>> mapOffsets;
|
||||
|
||||
|
||||
@ -644,7 +644,6 @@ bool PlayerbotAIConfig::Initialize()
|
||||
autoTeleportForLevel = sConfigMgr->GetOption<bool>("AiPlayerbot.AutoTeleportForLevel", false);
|
||||
autoDoQuests = sConfigMgr->GetOption<bool>("AiPlayerbot.AutoDoQuests", true);
|
||||
enableNewRpgStrategy = sConfigMgr->GetOption<bool>("AiPlayerbot.EnableNewRpgStrategy", true);
|
||||
enableTravelNodes = sConfigMgr->GetOption<bool>("AiPlayerbot.EnableTravelNodes", false);
|
||||
|
||||
RpgStatusProbWeight[RPG_WANDER_RANDOM] = sConfigMgr->GetOption<int32>("AiPlayerbot.RpgStatusProbWeight.WanderRandom", 15);
|
||||
RpgStatusProbWeight[RPG_WANDER_NPC] = sConfigMgr->GetOption<int32>("AiPlayerbot.RpgStatusProbWeight.WanderNpc", 20);
|
||||
|
||||
@ -368,7 +368,6 @@ public:
|
||||
bool autoLearnTrainerSpells;
|
||||
bool autoDoQuests;
|
||||
bool enableNewRpgStrategy;
|
||||
bool enableTravelNodes;
|
||||
std::unordered_map<NewRpgStatus, uint32> RpgStatusProbWeight;
|
||||
bool syncLevelWithPlayers;
|
||||
bool autoLearnQuestSpells;
|
||||
|
||||
@ -20,7 +20,6 @@
|
||||
#include "PlayerbotMgr.h"
|
||||
#include "RandomPlayerbotMgr.h"
|
||||
#include "ScriptMgr.h"
|
||||
#include "TravelNode.h"
|
||||
|
||||
using namespace Acore::ChatCommands;
|
||||
|
||||
@ -42,16 +41,11 @@ public:
|
||||
{"unlink", HandleUnlinkAccountCommand, SEC_PLAYER, Console::No},
|
||||
};
|
||||
|
||||
static ChatCommandTable playerbotsTravelCommandTable = {
|
||||
{"generatenode", HandleGenerateTravelNodesCommand, SEC_GAMEMASTER, Console::Yes},
|
||||
};
|
||||
|
||||
static ChatCommandTable playerbotsCommandTable = {
|
||||
{"bot", HandlePlayerbotCommand, SEC_PLAYER, Console::No},
|
||||
{"gtask", HandleGuildTaskCommand, SEC_GAMEMASTER, Console::Yes},
|
||||
{"pmon", HandlePerfMonCommand, SEC_GAMEMASTER, Console::Yes},
|
||||
{"rndbot", HandleRandomPlayerbotCommand, SEC_GAMEMASTER, Console::Yes},
|
||||
{"travel", playerbotsTravelCommandTable},
|
||||
{"debug", playerbotsDebugCommandTable},
|
||||
{"account", playerbotsAccountCommandTable},
|
||||
};
|
||||
@ -112,15 +106,6 @@ public:
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool HandleGenerateTravelNodesCommand(ChatHandler* handler, char const* /*args*/)
|
||||
{
|
||||
handler->PSendSysMessage("Regenerating travel node paths...");
|
||||
LOG_INFO("playerbots", "Manual travel node regeneration started via console command.");
|
||||
sTravelNodeMap.generateAll();
|
||||
handler->PSendSysMessage("Travel node regeneration complete. Paths saved to database.");
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool HandleDebugBGCommand(ChatHandler* handler, char const* args)
|
||||
{
|
||||
return BGTactics::HandleConsoleCommand(handler, args);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user