TiledGraphPathfinder.h

#pragma once

#include "Graphs.h"
#include "Types.h"
#include "TiledGraphPathfinderResult.h"
#include "AStarPriorityQueue.h"
#include "AStarState.h"
#include "TiledGraphEdge.h"
#include "VectorMath.h"

#include <vector>
#include <unordered_map>


namespace Eegeo
{
    namespace Graphs
    {
        class TiledGraphPathfinder : private Eegeo::NonCopyable
        {
        public:
            TiledGraphPathfinder(
                const TiledGraph& tiledGraph
            );

            TiledGraphPathfinderResult FindShortestPath(
                const TiledGraphEdgeId& graphEdgeA, 
                const float parameterisedPointOnEdgeA,
                bool allowUTurnAtA,
                const TiledGraphEdgeId& graphEdgeB,
                const float parameterisedPointOnEdgeB,
                bool allowUTurnAtB);

        private:
            typedef std::unordered_map<TiledGraphEdgeId, int, TiledGraphEdgeIdHash> TGraphEdgeIdToAStarState;

            TiledGraphPathfinderResult FindShortestPathInternal(
                const TiledGraphEdgeId& graphEdgeA,
                const float parameterisedPointOnEdgeA,
                const TiledGraphEdgeId& graphEdgeB,
                const float parameterisedPointOnEdgeB,
                const float maxCost);

            bool ValidateInput(
                const TiledGraphEdgeId& graphEdgeA,
                const float parameterisedPointOnEdgeA,
                const TiledGraphEdgeId& graphEdgeB,
                const float parameterisedPointOnEdgeB) const;

            void OpenEdge(const TiledGraphEdgeId& graphEdgeId, int priorStateIndex, const float costToPrior, const float costToTraverseEdge, const float h);
            void CloseEdge(const TiledGraphEdgeId& graphEdgeId);
            void OpenNeighbours(const TiledGraphEdgeId& graphNodeId);

            float Heuristic(const TiledGraphEdge& edge) const;
            float Distance(const dv3& a, const dv3& b) const;
            std::vector<TiledGraphEdgeId> ReconstructPathEdges() const;
            TiledGraphPathfinderResult BuildResult(bool succeeded) const;
            void Clear();
            

            const TiledGraph& m_tiledGraph;
            AStarStatePriorityComparer m_comparer;
            AStarPriorityQueue m_prioritisedOpenEdges;
            TGraphEdgeIdToAStarState m_graphEdgeIdToState;
            std::vector<AStarState> m_stateVector;

            std::vector<TiledGraphEdgeId> m_edgeIdsScratch;

            TiledGraphEdgeId m_startGraphEdgeId;
            float m_startParameterisedPointOnEdge;
            TiledGraphEdgeId m_goalGraphEdgeId;
            float m_goalParameterisedPointOnEdge;
            dv3 m_goalPoint;
            float m_maxCost;

        };
    }
}