Pathfinding.hpp

Go to the documentation of this file.

#ifndef PATHFINDING_HPP_INCLUDED
#define PATHFINDING_HPP_INCLUDED
 
#include "../../Core/Types/Tile.hpp"
#include <vector>
#include <functional>
 
namespace Pathfinding
{
    enum COLLISION_FLAG
    {
        OPEN            = 0,
        CLOSED          = 0xFFFFFF,
        UNINITIALIZED   = 0x1000000,
        OCCUPIED        = 0x100,
        SOLID           = 0x20000,
        BLOCKED         = 0x200000,
 
        NORTH           = 0x2,
        EAST            = 0x8,
        SOUTH           = 0x20,
        WEST            = 0x80,
 
        NORTHEAST       = 0x4,
        SOUTHEAST       = 0x10,
        SOUTHWEST       = 0x40,
        NORTHWEST       = 0x1
    };
 
    typedef enum PATHFINDER
    {
        BREADTH_FIRST_SEARCH
    } PATHFINDER;
 
    enum PATHFIND_OPTION
    {
        CHECK_COLLISION = (1 << 1),
        CHECK_WHITELIST = (1 << 2),
        CHECK_BLACKLIST = (1 << 3),
        GOAL_IS_LOCAL   = (1 << 4),
        RETURN_LOCAL    = (1 << 5)
    };
 
    class TileNode
    {
        public:
            std::int32_t X;
            std::int32_t Y;
            std::int32_t Flag;
            bool Inspected = false;
            bool MatchesWhitelist = false;
            bool MatchesBlacklist = false;
            std::int32_t Parent[2];
            TileNode();
            TileNode(std::int32_t X, std::int32_t Y, std::int32_t Flag);
            bool IsBlocked() const;
            Tile ToWorldTile() const;
            Tile ToWorldTile(std::int32_t ClientX, std::int32_t ClientY, std::int32_t ClientPlane) const;
            bool operator==(const TileNode& N) const;
            operator bool() const;
    };
 
    std::int32_t GetCurrentRegion();
 
    void GenerateNodes();
    void SetWhitelist(const std::vector<Tile>& W);
    void SetBlacklist(const std::vector<Tile>& B);
    std::vector<std::vector<TileNode>> GetNodes();
    std::vector<Tile> GetWhitelist();
    std::vector<Tile> GetBlacklist();
 
    Tile FindWalkableTile(const Tile& T);
    Tile FindWalkableTile(const Tile& T, const Tile& Min, const Tile& Max);
    std::vector<Tile> FindWalkableTiles(const Tile& T);
    std::vector<Tile> FindWalkableTiles(const Tile& T, const Tile& Min, const Tile& Max);
 
    std::vector<Tile> FindPathTo(const Tile& Goal,
                                 std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST,
                                 PATHFINDER Finder = BREADTH_FIRST_SEARCH);
 
    std::vector<Tile> FindPathTo(const std::vector<Tile>& Goals,
                                 std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST,
                                 PATHFINDER Finder = BREADTH_FIRST_SEARCH);
 
    std::vector<Pathfinding::TileNode> FindNodePathTo(const Tile& Goal,
                                                      std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST,
                                                      PATHFINDER Finder = BREADTH_FIRST_SEARCH);
 
    std::vector<Pathfinding::TileNode> FindNodePathTo(const std::vector<Tile>& Goals,
                                                      std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST,
                                                      PATHFINDER Finder = BREADTH_FIRST_SEARCH);
    //std::vector<std::vector<TileNode>> Nodes;
    //std::vector<Tile> Whitelist;
    //std::vector<Tile> Blacklist;
 
    bool IsInside(std::int32_t X, std::int32_t Y);
    std::vector<Pathfinding::TileNode*> GetNeighborsTo(std::int32_t X, std::int32_t Y, bool CheckCollision = true);
    std::vector<Pathfinding::TileNode> Finder_BFS(std::uint32_t StartX, std::uint32_t StartY, std::uint32_t EndX, std::uint32_t EndY, std::int32_t Options );
    std::vector<Pathfinding::TileNode> Finder_BFS(std::uint32_t StartX, std::uint32_t StartY, const std::vector<std::pair<std::uint32_t, std::uint32_t>>& Ends, std::int32_t Options );
}
 
#endif // PATHFINDING_HPP_INCLUDED