Big update.

src/TravelMgr.h

@@ -0,0 +1,988 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_TRAVELMGR_H
+#define _PLAYERBOT_TRAVELMGR_H
+
+#include "AiObject.h"
+#include "CreatureData.h"
+#include "GameObject.h"
+#include "GridDefines.h"
+#include "PlayerbotAIConfig.h"
+
+#include <boost/functional/hash.hpp>
+#include <random>
+
+class GuidPosition;
+class ObjectGuid;
+class Quest;
+class Player;
+class PlayerbotAI;
+
+struct QuestStatusData;
+
+namespace G3D
+{
+    class Vector2;
+    class Vector3;
+    class Vector4;
+}
+
+//Constructor types for WorldPosition
+enum WorldPositionConst
+{
+    WP_RANDOM           = 0,
+    WP_CENTROID         = 1,
+    WP_MEAN_CENTROID    = 2,
+    WP_CLOSEST          = 3
+};
+
+enum TravelState
+{
+    TRAVEL_STATE_IDLE                   = 0,
+    TRAVEL_STATE_TRAVEL_PICK_UP_QUEST   = 1,
+    TRAVEL_STATE_WORK_PICK_UP_QUEST     = 2,
+    TRAVEL_STATE_TRAVEL_DO_QUEST        = 3,
+    TRAVEL_STATE_WORK_DO_QUEST          = 4,
+    TRAVEL_STATE_TRAVEL_HAND_IN_QUEST   = 5,
+    TRAVEL_STATE_WORK_HAND_IN_QUEST     = 6,
+    TRAVEL_STATE_TRAVEL_RPG             = 7,
+    TRAVEL_STATE_TRAVEL_EXPLORE         = 8,
+    MAX_TRAVEL_STATE
+};
+
+enum TravelStatus
+{
+    TRAVEL_STATUS_NONE      = 0,
+    TRAVEL_STATUS_PREPARE   = 1,
+    TRAVEL_STATUS_TRAVEL    = 2,
+    TRAVEL_STATUS_WORK      = 3,
+    TRAVEL_STATUS_COOLDOWN  = 4,
+    TRAVEL_STATUS_EXPIRED   = 5,
+    MAX_TRAVEL_STATUS
+};
+
+class QuestTravelDestination;
+
+//A quest destination container for quick lookup of all destinations related to a quest.
+struct QuestContainer
+{
+    std::vector<QuestTravelDestination*> questGivers;
+    std::vector<QuestTravelDestination*> questTakers;
+    std::vector<QuestTravelDestination*> questObjectives;
+};
+
+typedef std::pair<int32, int32> mGridCoord;
+
+//Extension of WorldLocation with distance functions.
+class WorldPosition : public WorldLocation
+{
+    public:
+        //Constructors
+        WorldPosition() : WorldLocation() { };
+        WorldPosition(WorldLocation const& loc) : WorldLocation(loc) { }
+        WorldPosition(WorldPosition const& pos) : WorldLocation(pos), visitors(pos.visitors) { }
+        WorldPosition(std::string const str);
+        WorldPosition(uint32 mapid, float x, float y, float z = 0.f, float orientation = 0.f) : WorldLocation(mapid, x, y, z, orientation) { }
+        WorldPosition(uint32 mapId, const Position& pos);
+        WorldPosition(WorldObject const* wo);
+        WorldPosition(std::vector<WorldPosition*> list, WorldPositionConst conType);
+        WorldPosition(std::vector<WorldPosition> list, WorldPositionConst conType);
+        WorldPosition(uint32 mapid, GridCoord grid);
+        WorldPosition(uint32 mapid, CellCoord cell);
+        WorldPosition(uint32 mapid, mGridCoord grid);
+
+        //Setters
+        void set(const WorldLocation& pos);
+        void setMapId(uint32 id);
+        void setX(float x);
+        void setY(float y);
+        void setZ(float z);
+        void setO(float o);
+
+        void addVisitor()
+        {
+            ++visitors;
+        }
+
+        void remVisitor()
+        {
+            --visitors;
+        }
+
+        //Getters
+        operator bool() const;
+        bool operator==(WorldPosition const& p1);
+        bool operator!=(WorldPosition const& p1);
+
+        WorldPosition& operator+=(WorldPosition const& p1);
+        WorldPosition& operator-=(WorldPosition const& p1);
+
+        uint32 getMapId();
+        float getX();
+        float getY();
+        float getZ();
+        float getO();
+
+        G3D::Vector3 getVector3();
+        std::string const print();
+
+        std::string const to_string();
+
+        void printWKT(std::vector<WorldPosition> points, std::ostringstream& out, uint32 dim = 0, bool loop = false);
+        void printWKT(std::ostringstream& out) { printWKT({ *this }, out); }
+
+        uint32 getVisitors() { return visitors; }
+
+        bool isOverworld();
+        bool isInWater();
+        bool isUnderWater();
+
+        WorldPosition relPoint(WorldPosition* center);
+        WorldPosition offset(WorldPosition* center);
+        float size();
+
+        //Slow distance function using possible map transfers.
+        float distance(WorldPosition* center);
+        float distance(WorldPosition center)
+        {
+            return distance(&center);
+        }
+
+        float fDist(WorldPosition* center);
+        float fDist(WorldPosition center)
+        {
+            return fDist(&center);
+        }
+
+        template<class T>
+        std::pair<T, WorldPosition> closest(std::vector<std::pair<T, WorldPosition>> list)
+        {
+            return *std::min_element(list.begin(), list.end(), [this](std::pair<T, WorldPosition> i, std::pair<T, WorldPosition> j)
+            {
+                return this->distance(i.second) < this->distance(j.second);
+            });
+        }
+
+        template<class T>
+        std::pair<T, WorldPosition> closest(std::vector<T> list)
+        {
+            return closest(GetPosList(list));
+        }
+
+        //Returns the closest point from the list.
+        WorldPosition* closest(std::vector<WorldPosition*> list)
+        {
+            return *std::min_element(list.begin(), list.end(), [this](WorldPosition* i, WorldPosition* j) { return this->distance(i) < this->distance(j); });
+        }
+
+        WorldPosition closest(std::vector<WorldPosition> list)
+        {
+            return *std::min_element(list.begin(), list.end(), [this](WorldPosition i, WorldPosition j) { return this->distance(i) < this->distance(j); });
+        }
+
+        //Quick square distance in 2d plane.
+        float sqDistance2d(WorldPosition center)
+        {
+            return (getX() - center.getX()) * (getX() - center.getX()) + (getY() - center.getY()) * (getY() - center.getY());
+        }
+
+        //Quick square distance calculation without map check. Used for getting the minimum distant points.
+        float sqDistance(WorldPosition center)
+        {
+            return (getX() - center.getX()) * (getX() - center.getX()) + (getY() - center.getY()) *
+                (getY() - center.getY()) + (getZ() - center.getZ()) * (getZ() - center.getZ());
+        }
+
+        float sqDistance2d(WorldPosition* center)
+        {
+            return (getX() - center->getX()) * (getX() - center->getX()) + (getY() - center->getY()) * (getY() - center->getY());
+        }
+
+        float sqDistance(WorldPosition* center)
+        {
+            return (getX() - center->getX()) * (getX() - center->getX()) + (getY() - center->getY()) *
+                (getY() - center->getY()) + (getZ() - center->getZ()) * (getZ() - center->getZ());
+        }
+
+        //Returns the closest point of the list. Fast but only works for the same map.
+        WorldPosition* closestSq(std::vector<WorldPosition*> list)
+        {
+            return *std::min_element(list.begin(), list.end(), [this](WorldPosition* i, WorldPosition* j) { return this->sqDistance(i) < this->sqDistance(j); });
+        }
+
+        WorldPosition closestSq(std::vector<WorldPosition> list)
+        {
+            return *std::min_element(list.begin(), list.end(), [this](WorldPosition i, WorldPosition j) { return this->sqDistance(i) < this->sqDistance(j); });
+        }
+
+        float getAngleTo(WorldPosition endPos)
+        {
+            float ang = atan2(endPos.getY() - getY(), endPos.getX() - getX());
+            return (ang >= 0) ? ang : 2 * static_cast<float>(M_PI) + ang;
+        }
+
+        float getAngleBetween(WorldPosition dir1, WorldPosition dir2)
+        {
+            return abs(getAngleTo(dir1) - getAngleTo(dir2));
+        }
+
+        WorldPosition lastInRange(std::vector<WorldPosition> list, float minDist = -1.f, float maxDist = -1.f);
+        WorldPosition firstOutRange(std::vector<WorldPosition> list, float minDist = -1.f, float maxDist = -1.f);
+
+        float mSign(WorldPosition* p1, WorldPosition* p2)
+        {
+            return(getX() - p2->getX()) * (p1->getY() - p2->getY()) - (p1->getX() - p2->getX()) * (getY() - p2->getY());
+        }
+
+        bool isInside(WorldPosition* p1, WorldPosition* p2, WorldPosition* p3);
+
+        //Map functions. Player independent.
+        MapEntry const* getMapEntry();
+        uint32 getInstanceId();
+        Map* getMap();
+        const float getHeight();
+
+        std::set<Transport*> getTransports(uint32 entry = 0);
+
+        GridCoord getGridCoord() { return Acore::ComputeGridCoord(getX(), getY()); };
+        std::vector<GridCoord> getGridCoord(WorldPosition secondPos);
+        std::vector<WorldPosition> fromGridCoord(GridCoord GridCoord);
+
+        CellCoord getCellCoord() { return Acore::ComputeCellCoord(getX(), getY()); }
+        std::vector<WorldPosition> fromCellCoord(CellCoord cellCoord);
+        std::vector<WorldPosition> gridFromCellCoord(CellCoord cellCoord);
+
+        mGridCoord getmGridCoord()
+        {
+            return std::make_pair((int32)(CENTER_GRID_ID - getX() / SIZE_OF_GRIDS), (int32)(CENTER_GRID_ID - getY() / SIZE_OF_GRIDS));
+        }
+
+        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().getY() * -1.0;
+        }
+
+        float getDisplayY()
+        {
+            return getDisplayLocation().getX();
+        }
+
+        uint16 getAreaId();
+        AreaTableEntry const* getArea();
+        std::string const getAreaName(bool fullName = true, bool zoneName = false);
+
+        std::vector<WorldPosition> fromPointsArray(std::vector<G3D::Vector3> path);
+
+        //Pathfinding
+        std::vector<WorldPosition> getPathStepFrom(WorldPosition startPos, Unit* bot);
+        std::vector<WorldPosition> getPathFromPath(std::vector<WorldPosition> startPath, Unit* bot, uint8 maxAttempt = 40);
+
+        std::vector<WorldPosition> getPathFrom(WorldPosition startPos, Unit* bot)
+        {
+            return getPathFromPath({ startPos }, bot);
+        }
+
+        std::vector<WorldPosition> getPathTo(WorldPosition endPos, Unit* bot)
+        {
+            return endPos.getPathFrom(*this, bot);
+        }
+
+        bool isPathTo(std::vector<WorldPosition> path, float maxDistance = sPlayerbotAIConfig->targetPosRecalcDistance) { return !path.empty() && distance(path.back()) < maxDistance; };
+        bool cropPathTo(std::vector<WorldPosition>& path, float maxDistance = sPlayerbotAIConfig->targetPosRecalcDistance);
+        bool canPathTo(WorldPosition endPos, Unit* bot) { return endPos.isPathTo(getPathTo(endPos, bot)); }
+
+        float getPathLength(std::vector<WorldPosition> points)
+        {
+            float dist = 0.f;
+            for (auto& p : points)
+            {
+                if (&p == &points.front())
+                    dist = 0.f;
+                else
+                    dist += std::prev(&p, 1)->distance(p);
+            }
+
+            return dist;
+        }
+
+        bool GetReachableRandomPointOnGround(Player* bot, float radius, bool randomRange = true);
+
+        uint32 getUnitsAggro(GuidVector& units, Player* bot);
+
+        //Creatures
+        std::vector<CreatureData const*> getCreaturesNear(float radius = 0, uint32 entry = 0);
+
+        //GameObjects
+        std::vector<GameObjectData const*> getGameObjectsNear(float radius = 0, uint32 entry = 0);
+
+    private:
+        uint32 visitors = 0;
+};
+
+inline ByteBuffer& operator<<(ByteBuffer& b, WorldPosition& guidP)
+{
+    b << guidP.getMapId();
+    b << guidP.getX();
+    b << guidP.getY();
+    b << guidP.getZ();
+    b << guidP.getO();
+    b << guidP.getVisitors();
+    return b;
+}
+
+inline ByteBuffer& operator>>(ByteBuffer& b, WorldPosition& g)
+{
+    uint32 mapid;
+    float coord_x;
+    float coord_y;
+    float coord_z;
+    float orientation;
+    uint32 visitors = 0;
+    b >> mapid;
+    b >> coord_x;
+    b >> coord_y;
+    b >> coord_z;
+    b >> orientation;
+    b >> visitors;
+
+    return b;
+}
+
+//Generic creature finder
+class FindPointCreatureData
+{
+    public:
+        FindPointCreatureData(WorldPosition point1 = WorldPosition(), float radius1 = 0, uint32 entry1 = 0) { point = point1; radius = radius1; entry = entry1; }
+
+        void operator()(CreatureData const& dataPair);
+        std::vector<CreatureData const*> GetResult() const { return data; };
+
+    private:
+        WorldPosition point;
+        float radius;
+        uint32 entry;
+
+        std::vector<CreatureData const*> data;
+};
+
+//Generic gameObject finder
+class FindPointGameObjectData
+{
+    public:
+        FindPointGameObjectData(WorldPosition point1 = WorldPosition(), float radius1 = 0, uint32 entry1 = 0) { point = point1; radius = radius1; entry = entry1; }
+
+        void operator()(GameObjectData const& dataPair);
+        std::vector<GameObjectData const*> GetResult() const { return data; };
+
+    private:
+        WorldPosition point;
+        float radius;
+        uint32 entry;
+
+        std::vector<GameObjectData const*> data;
+};
+
+class GuidPosition : public ObjectGuid, public WorldPosition
+{
+    public:
+        GuidPosition() : ObjectGuid(), WorldPosition(), loadedFromDB(false) { }
+        GuidPosition(WorldObject* wo);
+        GuidPosition(CreatureData const& creData);
+        GuidPosition(GameObjectData const& goData);
+
+        CreatureTemplate const* GetCreatureTemplate();
+        GameObjectTemplate const* GetGameObjectTemplate();
+
+        WorldObject* GetWorldObject();
+        Creature* GetCreature();
+        Unit* GetUnit();
+        GameObject* GetGameObject();
+        Player* GetPlayer();
+
+        bool HasNpcFlag(NPCFlags flag);
+
+        bool isDead(); //For loaded grids check if the unit/object is unloaded/dead.
+
+        operator bool() const { return !IsEmpty(); }
+        bool operator==(ObjectGuid const& guid) const { return GetRawValue() == guid.GetRawValue(); }
+        bool operator!=(ObjectGuid const& guid) const { return GetRawValue() != guid.GetRawValue(); }
+        bool operator<(ObjectGuid const& guid) const { return GetRawValue() < guid.GetRawValue(); }
+
+    private:
+        bool loadedFromDB;
+};
+
+template<class T>
+std::vector<std::pair<T, WorldPosition>> GetPosList(std::vector<T> oList)
+{
+    std::vector<std::pair<T, WorldPosition>> retList;
+    for (auto& obj : oList)
+        retList.push_back(std::make_pair(obj, WorldPosition(obj)));
+
+    return std::move(retList);
+};
+
+template<class T>
+std::vector<std::pair<T, WorldPosition>> GetPosVector(std::vector<T> oList)
+{
+    std::vector<std::pair<T, WorldPosition>> retList;
+    for (auto& obj : oList)
+        retList.push_back(make_pair(obj, WorldPosition(obj)));
+
+    return std::move(retList);
+};
+
+class mapTransfer
+{
+    public:
+        mapTransfer(WorldPosition pointFrom1, WorldPosition pointTo1, float portalLength1 = 0.1f)
+            : pointFrom(pointFrom1), pointTo(pointTo1), portalLength(portalLength1) { }
+
+        bool isFrom(WorldPosition point)
+        {
+            return point.getMapId() == pointFrom.getMapId();
+        }
+
+        bool isTo(WorldPosition point)
+        {
+            return point.getMapId() == pointTo.getMapId();
+        }
+
+        WorldPosition* getPointFrom()
+        {
+            return &pointFrom;
+        }
+
+        WorldPosition* getPointTo()
+        {
+            return &pointTo;
+        }
+
+        bool isUseful(WorldPosition point)
+        {
+            return isFrom(point) || isTo(point);
+        }
+
+        float distance(WorldPosition point)
+        {
+            return isUseful(point) ? (isFrom(point) ? point.distance(pointFrom) : point.distance(pointTo)) : 200000;
+        }
+
+        bool isUseful(WorldPosition start, WorldPosition end)
+        {
+            return isFrom(start) && isTo(end);
+        }
+
+        float distance(WorldPosition start, WorldPosition end)
+        {
+            return (isUseful(start, end) ? (start.distance(pointFrom) + portalLength + pointTo.distance(end)) : 200000);
+        }
+
+        float fDist(WorldPosition start, WorldPosition end);
+
+    private:
+        WorldPosition pointFrom;
+        WorldPosition pointTo;
+        float portalLength = 0.1f;
+};
+
+//A destination for a bot to travel to and do something.
+class TravelDestination
+{
+    public:
+        TravelDestination() { }
+        TravelDestination(float radiusMin1, float radiusMax1)
+        {
+            radiusMin = radiusMin1; radiusMax = radiusMax1;
+        }
+        TravelDestination(std::vector<WorldPosition*> points1, float radiusMin1, float radiusMax1)
+        {
+            points = points1;  radiusMin = radiusMin1; radiusMax = radiusMax1;
+        }
+
+        void addPoint(WorldPosition* pos)
+        {
+            points.push_back(pos);
+        }
+
+        void setExpireDelay(uint32 delay)
+        {
+            expireDelay = delay;
+        }
+
+        void setCooldownDelay(uint32 delay)
+        {
+            cooldownDelay = delay;
+        }
+
+        void setMaxVisitors(uint32 maxVisitors1 = 0, uint32 maxVisitorsPerPoint1 = 0)
+        {
+            maxVisitors = maxVisitors1;
+            maxVisitorsPerPoint = maxVisitorsPerPoint1;
+        }
+
+        std::vector<WorldPosition*> getPoints(bool ignoreFull = false);
+        uint32 getExpireDelay() { return expireDelay; }
+        uint32 getCooldownDelay() { return cooldownDelay; }
+
+        void addVisitor()
+        {
+            ++visitors;
+        }
+
+        void remVisitor()
+        {
+            --visitors;
+        }
+
+        uint32 getVisitors()
+        {
+            return visitors;
+        }
+
+        virtual Quest const* GetQuestTemplate() { return nullptr; }
+        virtual bool isActive(Player* bot) { return false; }
+
+        bool isFull(bool ignoreFull = false);
+
+        virtual std::string const getName() { return "TravelDestination"; }
+        virtual int32 getEntry() { return 0; }
+        virtual std::string const getTitle() { return "generic travel destination"; }
+
+        WorldPosition* nearestPoint(WorldPosition* pos);
+
+        float distanceTo(WorldPosition* pos) { return nearestPoint(pos)->distance(pos); }
+        bool onMap(WorldPosition* pos) { return nearestPoint(pos)->getMapId() == pos->getMapId(); }
+        virtual bool isIn(WorldPosition* pos, float radius = 0.f) { return onMap(pos) && distanceTo(pos) <= (radius? radius : radiusMin); }
+        virtual bool isOut(WorldPosition* pos, float radius = 0.f) { return !onMap(pos) || distanceTo(pos) > (radius? radius : radiusMax); }
+        float getRadiusMin() { return radiusMin; }
+
+        std::vector<WorldPosition*> touchingPoints(WorldPosition* pos);
+        std::vector<WorldPosition*> sortedPoints(WorldPosition* pos);
+        std::vector<WorldPosition*> nextPoint(WorldPosition* pos, bool ignoreFull = true);
+
+    protected:
+        std::vector<WorldPosition*> points;
+        float radiusMin = 0;
+        float radiusMax = 0;
+
+        uint32 visitors = 0;
+        uint32 maxVisitors = 0;
+        uint32 maxVisitorsPerPoint = 0;
+        uint32 expireDelay = 5 * 1000;
+        uint32 cooldownDelay = 60 * 1000;
+};
+
+//A travel target that is always inactive and jumps to cooldown.
+class NullTravelDestination : public TravelDestination
+{
+    public:
+        NullTravelDestination(uint32 cooldownDelay1 = 5 * 60 * 1000) : TravelDestination()
+        {
+            cooldownDelay = cooldownDelay1;
+        };
+
+        Quest const* GetQuestTemplate() override { return nullptr; }
+
+        bool isActive(Player* bot) override { return false; }
+
+        std::string const getName() override { return "NullTravelDestination"; }
+        std::string const getTitle() override { return "no destination"; }
+
+        bool isIn(WorldPosition* pos, float radius = 0.f) override { return true; }
+        bool isOut(WorldPosition* pos, float radius = 0.f) override { return false; }
+};
+
+//A travel target specifically related to a quest.
+class QuestTravelDestination : public TravelDestination
+{
+    public:
+        QuestTravelDestination(uint32 questId1, float radiusMin1, float radiusMax1);
+
+        Quest const* GetQuestTemplate() override { return questTemplate;  }
+
+        bool isActive(Player* bot) override;
+
+        std::string const getName() override { return "QuestTravelDestination"; }
+        int32 getEntry() override { return 0; }
+        std::string const getTitle() override;
+
+    protected:
+        uint32 questId;
+        Quest const* questTemplate;
+};
+
+//A quest giver or taker.
+class QuestRelationTravelDestination : public QuestTravelDestination
+{
+    public:
+        QuestRelationTravelDestination(uint32 quest_id1, uint32 entry1, uint32 relation1, float radiusMin1, float radiusMax1) :
+            QuestTravelDestination(quest_id1, radiusMin1, radiusMax1)
+        {
+            entry = entry1;
+            relation = relation1;
+        }
+
+        bool isActive(Player* bot) override;
+        std::string const getName() override { return "QuestRelationTravelDestination"; }
+        int32 getEntry() override { return entry; }
+        std::string const getTitle() override;
+        virtual uint32 getRelation() { return relation; }
+
+    private:
+        uint32 relation;
+        int32 entry;
+};
+
+//A quest objective (creature/gameobject to grind/loot)
+class QuestObjectiveTravelDestination : public QuestTravelDestination
+{
+    public:
+        QuestObjectiveTravelDestination(uint32 quest_id1, uint32 entry1, uint32 objective1, float radiusMin1, float radiusMax1, uint32 itemId1 = 0) :
+            QuestTravelDestination(quest_id1, radiusMin1, radiusMax1)
+        {
+            objective = objective1;
+            entry = entry1;
+            itemId = itemId1;
+        }
+
+        bool isCreature();
+        uint32 ReqCreature();
+        uint32 ReqGOId();
+        uint32 ReqCount();
+
+        bool isActive(Player* bot) override;
+        std::string const getName() override { return "QuestObjectiveTravelDestination"; }
+        int32 getEntry() override { return entry; }
+        std::string const getTitle() override;
+
+    private:
+        uint32 objective;
+        uint32 entry;
+        uint32 itemId = 0;
+};
+
+//A location with rpg target(s) based on race and level
+class RpgTravelDestination : public TravelDestination
+{
+    public:
+        RpgTravelDestination(uint32 entry1, float radiusMin1, float radiusMax1) : TravelDestination(radiusMin1, radiusMax1)
+        {
+            entry = entry1;
+        }
+
+        bool isActive(Player* bot) override;
+        virtual CreatureTemplate const* GetCreatureTemplate();
+        std::string const getName() override { return "RpgTravelDestination"; }
+        int32 getEntry() override { return 0; }
+        std::string const getTitle() override;
+
+    protected:
+        uint32 entry;
+};
+
+//A location with zone exploration target(s)
+class ExploreTravelDestination : public TravelDestination
+{
+    public:
+        ExploreTravelDestination(uint32 areaId1, float radiusMin1, float radiusMax1) : TravelDestination(radiusMin1, radiusMax1)
+        {
+            areaId = areaId1;
+        }
+
+        bool isActive(Player* bot) override;
+        std::string const getName() override { return "ExploreTravelDestination"; }
+        int32 getEntry() override { return 0; }
+        std::string const getTitle() override;
+        virtual uint32 getAreaId() { return areaId; }
+
+    protected:
+        uint32 areaId;
+};
+
+//A location with zone exploration target(s)
+class GrindTravelDestination : public TravelDestination
+{
+    public:
+        GrindTravelDestination(int32 entry1, float radiusMin1, float radiusMax1) : TravelDestination(radiusMin1, radiusMax1)
+        {
+            entry = entry1;
+        }
+
+        bool isActive(Player* bot) override;
+        virtual CreatureTemplate const* GetCreatureTemplate();
+        std::string const getName() override { return "GrindTravelDestination"; }
+        int32 getEntry() override { return entry; }
+        std::string const getTitle() override;
+
+    protected:
+        int32 entry;
+};
+
+//A location with a boss
+class BossTravelDestination : public TravelDestination
+{
+    public:
+        BossTravelDestination(int32 entry1, float radiusMin1, float radiusMax1) : TravelDestination(radiusMin1, radiusMax1)
+        {
+            entry = entry1;
+            cooldownDelay = 1000;
+        }
+
+        bool isActive(Player* bot) override;
+        CreatureTemplate const* getCreatureTemplate();
+        std::string const getName() override { return "BossTravelDestination"; }
+        int32 getEntry() override { return entry; }
+        std::string const getTitle() override;
+
+    protected:
+        int32 entry;
+};
+
+//Current target and location for the bot to travel to.
+//The flow is as follows:
+//PREPARE   (wait until no loot is near)
+//TRAVEL    (move towards target until close enough) (rpg and grind is disabled)
+//WORK      (grind/rpg until the target is no longer active) (rpg and grind is enabled on quest mobs)
+//COOLDOWN  (wait some time free to do what the bot wants)
+//EXPIRE    (if any of the above actions take too long pick a new target)
+class TravelTarget : AiObject
+{
+    public:
+        TravelTarget(PlayerbotAI* botAI) : AiObject(botAI), m_status(TRAVEL_STATUS_NONE), startTime(getMSTime()) { };
+        TravelTarget(PlayerbotAI* botAI, TravelDestination* tDestination1, WorldPosition* wPosition1) : AiObject(botAI), m_status(TRAVEL_STATUS_NONE), startTime(getMSTime())
+        {
+            setTarget(tDestination1, wPosition1);
+        }
+
+        ~TravelTarget();
+
+        void setTarget(TravelDestination* tDestination1, WorldPosition* wPosition1, bool groupCopy1 = false);
+        void setStatus(TravelStatus status);
+        void setExpireIn(uint32 expireMs)
+        {
+            statusTime = getExpiredTime() + expireMs;
+        }
+
+        void incRetry(bool isMove)
+        {
+            if (isMove)
+                ++moveRetryCount;
+            else
+                ++extendRetryCount;
+        }
+
+        void setRetry(bool isMove, uint32 newCount = 0)
+        {
+            if (isMove)
+                moveRetryCount = newCount;
+            else
+                extendRetryCount = newCount;
+        }
+
+        void setForced(bool forced1)
+        {
+            forced = forced1;
+        }
+
+        void setRadius(float radius1)
+        {
+            radius = radius1;
+        }
+
+        void copyTarget(TravelTarget* target);
+        void addVisitors();
+        void releaseVisitors();
+
+        float distance(Player* bot);
+
+        WorldPosition* getPosition();
+        TravelDestination* getDestination();
+
+        uint32 getEntry()
+        {
+            if (!tDestination)
+                return 0;
+
+            return tDestination->getEntry();
+        }
+
+        PlayerbotAI* getAi()
+        {
+            return botAI;
+        }
+
+        uint32 getExpiredTime()
+        {
+            return getMSTime() - startTime;
+        }
+
+        uint32 getTimeLeft()
+        {
+            return statusTime - getExpiredTime();
+        }
+
+        uint32 getMaxTravelTime();
+        uint32 getRetryCount(bool isMove)
+        {
+            return isMove ? moveRetryCount: extendRetryCount;
+        }
+
+        bool isTraveling();
+        bool isActive();
+        bool isWorking();
+        bool isPreparing();
+        bool isMaxRetry(bool isMove)
+        {
+            return isMove ? (moveRetryCount > 5) : (extendRetryCount > 5);
+        }
+
+        TravelStatus getStatus()
+        {
+            return m_status;
+        }
+
+        TravelState getTravelState();
+
+        bool isGroupCopy()
+        {
+            return groupCopy;
+        }
+
+        bool isForced()
+        {
+            return forced;
+        }
+
+    protected:
+        TravelStatus m_status;
+
+        uint32 startTime;
+        uint32 statusTime = 0;
+
+        bool forced = false;
+        float radius = 0.f;
+        bool groupCopy = false;
+        bool visitor = true;
+
+        uint32 extendRetryCount = 0;
+        uint32 moveRetryCount = 0;
+
+        TravelDestination* tDestination = nullptr;
+        WorldPosition* wPosition = nullptr;
+};
+
+//General container for all travel destinations.
+class TravelMgr
+{
+    public:
+        TravelMgr() { };
+
+        static TravelMgr* instance()
+        {
+            static TravelMgr instance;
+            return &instance;
+        }
+
+        void Clear();
+        void LoadQuestTravelTable();
+
+        template <class D, class W, class URBG>
+        void weighted_shuffle(D first, D last, W first_weight, W last_weight, URBG&& g)
+        {
+            while (first != last && first_weight != last_weight)
+            {
+                std::discrete_distribution<int>dd(first_weight, last_weight);
+                auto i = dd(g);
+
+                if (i)
+                {
+                    std::swap(*first, *std::next(first, i));
+                    std::swap(*first_weight, *std::next(first_weight, i));
+                }
+                ++first;
+                ++first_weight;
+            }
+        }
+
+        std::vector<WorldPosition*> getNextPoint(WorldPosition* center, std::vector<WorldPosition*> points, uint32 amount = 1);
+        std::vector<WorldPosition> getNextPoint(WorldPosition center, std::vector<WorldPosition> points, uint32 amount = 1);
+        QuestStatusData* getQuestStatus(Player* bot, uint32 questId);
+        bool getObjectiveStatus(Player* bot, Quest const* pQuest, uint32 objective);
+        uint32 getDialogStatus(Player* pPlayer, int32 questgiver, Quest const* pQuest);
+        std::vector<TravelDestination*> getQuestTravelDestinations(Player* bot, int32 questId = -1, bool ignoreFull = false, bool ignoreInactive = false, float maxDistance = 5000, bool ignoreObjectives = false);
+        std::vector<TravelDestination*> getRpgTravelDestinations(Player* bot, bool ignoreFull = false, bool ignoreInactive = false, float maxDistance = 5000);
+        std::vector<TravelDestination*> getExploreTravelDestinations(Player* bot, bool ignoreFull = false, bool ignoreInactive = false);
+        std::vector<TravelDestination*> getGrindTravelDestinations(Player* bot, bool ignoreFull = false, bool ignoreInactive = false, float maxDistance = 5000);
+        std::vector<TravelDestination*> getBossTravelDestinations(Player* bot, bool ignoreFull = false, bool ignoreInactive = false, float maxDistance = 25000);
+
+        void setNullTravelTarget(Player* player);
+
+        void addMapTransfer(WorldPosition start, WorldPosition end, float portalDistance = 0.1f, bool makeShortcuts = true);
+        void loadMapTransfers();
+        float mapTransDistance(WorldPosition start, WorldPosition end);
+        float fastMapTransDistance(WorldPosition start, WorldPosition end);
+
+        NullTravelDestination* nullTravelDestination = new NullTravelDestination();
+        WorldPosition* nullWorldPosition = new WorldPosition();
+
+        void addBadVmap(uint32 mapId, uint8 x, uint8 y)
+        {
+            badVmap.push_back(std::make_tuple(mapId, x, y));
+        }
+
+        void addBadMmap(uint32 mapId, uint8 x, uint8 y)
+        {
+            badMmap.push_back(std::make_tuple(mapId, x, y));
+        }
+
+        bool isBadVmap(uint32 mapId, uint8 x, uint8 y)
+        {
+            return std::find(badVmap.begin(), badVmap.end(), std::make_tuple(mapId, x, y)) != badVmap.end();
+        }
+
+        bool isBadMmap(uint32 mapId, uint8 x, uint8 y)
+        {
+            return std::find(badMmap.begin(), badMmap.end(), std::make_tuple(mapId, x, y)) != badMmap.end();
+        }
+
+        void printGrid(uint32 mapId, int x, int y, std::string const type);
+        void printObj(WorldObject* obj, std::string const type);
+
+    //protected:
+        void logQuestError(uint32 errorNr, Quest* quest, uint32 objective = 0, uint32 unitId = 0, uint32 itemId = 0);
+
+        std::vector<uint32> avoidLoaded;
+
+        std::vector<QuestTravelDestination*> questGivers;
+        std::vector<RpgTravelDestination*> rpgNpcs;
+        std::vector<GrindTravelDestination*> grindMobs;
+        std::vector<BossTravelDestination*> bossMobs;
+
+        std::unordered_map<uint32, ExploreTravelDestination*> exploreLocs;
+        std::unordered_map<uint32, QuestContainer*> quests;
+
+        std::vector<std::tuple<uint32, uint8, uint8>> badVmap, badMmap;
+
+        std::unordered_map<std::pair<uint32, uint32>, std::vector<mapTransfer>, boost::hash<std::pair<uint32, uint32>>> mapTransfersMap;
+};
+
+#define sTravelMgr TravelMgr::instance()
+
+#endif