diff --git a/README.md b/README.md
index 3e1cda9..e770918 100755
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # astar
 
-Fast and easy to use header only 2D astar algorithm library in C++20.
+Fast and easy to use standalone header only 2D astar algorithm library in C++20.
 
 I made it for learning how the astar algorithm works, try to make the fastest, tested and configurable as possible for my needs (future games and works).
 
@@ -24,6 +24,20 @@ It is an [astar algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm), t
 * [x] Debug mode in template argument and lambda function
 * [x] Support direct access and not access to the map
 * [x] Unit tests and benchmarks
+* [ ] Working CI (WIP)
+
+### Heuristic function
+
+You can set the heuristic function to calculate the distance between two points and return the cost.
+
+| Heuristic | C++ Function | Description |
+|-----------|--------------|-------------|
+| euclidean | AStar::Heuristic::euclidean | Default |
+| manhattan | AStar::Heuristic::manhattan |  |
+| octagonal | AStar::Heuristic::octagonal |  |
+| chebyshev | AStar::Heuristic::chebyshev |  |
+| euclideanNoSQR | AStar::Heuristic::euclideanNoSQR |  |
+| dijkstra | AStar::Heuristic::dijkstra | Always return 0 |
 
 # How to use it
 
diff --git a/include/astar/astar.hpp b/include/astar/astar.hpp
index 9aa8816..39d2e13 100644
--- a/include/astar/astar.hpp
+++ b/include/astar/astar.hpp
@@ -18,22 +18,22 @@
 #include <unordered_set>
 #include <vector>
 
-template <typename T>
-concept ArithmeticType = std::is_arithmetic<T>::value;
+template <typename CoordinateType>
+concept ArithmeticType = std::is_arithmetic<CoordinateType>::value;
 
-template <typename T>
-concept IntegerType = std::is_integral<T>::value;
+template <typename CoordinateType>
+concept IntegerType = std::is_integral<CoordinateType>::value;
 
-template <typename T>
-concept FloatingPointType = std::is_floating_point<T>::value;
+template <typename CoordinateType>
+concept FloatingPointType = std::is_floating_point<CoordinateType>::value;
 
 namespace AStar {
 
-template <IntegerType T = int32_t>
+template <IntegerType CoordinateType = int32_t>
 class Vec2 {
    public:
     Vec2() = default;
-    Vec2(T x_, T y_) : x(x_), y(y_) {}
+    Vec2(CoordinateType x_, CoordinateType y_) : x(x_), y(y_) {}
 
     bool operator==(const Vec2& pos) const noexcept { return (x == pos.x && y == pos.y); }
     Vec2 operator=(const Vec2& pos) noexcept {
@@ -49,25 +49,25 @@ class Vec2 {
         size_t operator()(const Vec2& pos) const noexcept { return std::hash<size_t>()(pos.x ^ (pos.y << 4)); }
     };
 
-    T x = 0;
-    T y = 0;
+    CoordinateType x = 0;
+    CoordinateType y = 0;
 };
 typedef Vec2<int32_t> Vec2i;
 
-template <IntegerType T = uint32_t>
+template <IntegerType CoordinateType = uint32_t>
 class Node {
    public:
     explicit Node() : pos(Vec2i(0, 0)), parentNode(nullptr) {}
     explicit Node(const Vec2i& pos, Node* parent = nullptr) : pos(pos), parentNode(parent) {}
-    explicit Node(const Vec2i& pos, const T pathCost, const T heuristicCost, Node* parent = nullptr)
+    explicit Node(const Vec2i& pos, const CoordinateType pathCost, const CoordinateType heuristicCost, Node* parent = nullptr)
         : pathCost(pathCost), heuristicCost(heuristicCost), pos(pos), parentNode(parent) {}
-    inline T getTotalCost() const noexcept { return pathCost + heuristicCost; }
+    inline CoordinateType getTotalCost() const noexcept { return pathCost + heuristicCost; }
     struct hash {
         size_t operator()(const Node* node) const noexcept { return std::hash<size_t>()(node->pos.x ^ (node->pos.y << 4)); }
     };
 
-    T pathCost = 0;
-    T heuristicCost = 0;
+    CoordinateType pathCost = 0;
+    CoordinateType heuristicCost = 0;
     Vec2i pos = {0, 0};
     Node* parentNode = nullptr;
 };
@@ -109,7 +109,7 @@ static constexpr uint32_t dijkstra([[maybe_unused]] const Vec2i& source,
 }
 };  // namespace Heuristic
 
-template <IntegerType T = uint32_t, bool enableDebug = false>
+template <IntegerType CoordinateType = uint32_t, bool enableDebug = false>
 class AStarVirtual {
    public:
     explicit AStarVirtual()
@@ -117,8 +117,8 @@ class AStarVirtual {
           _directionsCount(4),
           _heuristicWeight(10),
           _mouvemementCost(10),
-          _debugCurrentNode([](Node<T>*) {}),
-          _debugOpenNode([](Node<T>*) {}) {
+          _debugCurrentNode([](Node<CoordinateType>*) {}),
+          _debugOpenNode([](Node<CoordinateType>*) {}) {
         _directions = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
     }
     void setHeuristic(const std::function<uint32_t(Vec2i, Vec2i, uint32_t)>& heuristic) {
@@ -143,23 +143,23 @@ class AStarVirtual {
 
     std::vector<Vec2i>& getDirections() noexcept { return _directions; }
 
-    void setDebugCurrentNode(const std::function<void(Node<T>*)>& debugCurrentNode) noexcept { _debugCurrentNode = debugCurrentNode; }
-    void setDebugOpenNode(const std::function<void(Node<T>*)>& debugOpenNode) noexcept { _debugOpenNode = debugOpenNode; }
+    void setDebugCurrentNode(const std::function<void(Node<CoordinateType>*)>& debugCurrentNode) noexcept { _debugCurrentNode = debugCurrentNode; }
+    void setDebugOpenNode(const std::function<void(Node<CoordinateType>*)>& debugOpenNode) noexcept { _debugOpenNode = debugOpenNode; }
 
    protected:
     std::function<uint32_t(Vec2i, Vec2i, uint32_t)> _heuristicFunction;
     std::vector<Vec2i> _directions;
     size_t _directionsCount;
-    T _heuristicWeight;
+    CoordinateType _heuristicWeight;
     size_t _mouvemementCost = 10;
 
     // Only used if enableDebug is true
-    std::function<void(Node<T>*)> _debugCurrentNode;
-    std::function<void(Node<T>*)> _debugOpenNode;
+    std::function<void(Node<CoordinateType>*)> _debugCurrentNode;
+    std::function<void(Node<CoordinateType>*)> _debugOpenNode;
 };
 
-template <IntegerType T = uint32_t, bool enableDebug = false>
-class AStar final : public AStarVirtual<T, enableDebug> {
+template <IntegerType CoordinateType = uint32_t, bool enableDebug = false>
+class AStar final : public AStarVirtual<CoordinateType, enableDebug> {
    public:
     explicit AStar() {}
 
@@ -168,23 +168,23 @@ class AStar final : public AStarVirtual<T, enableDebug> {
             return {};
         }
 
-        Node<T>* currentNode = nullptr;
+        Node<CoordinateType>* currentNode = nullptr;
 
-        auto compareFn = [](const Node<T>* a, const Node<T>* b) { return a->getTotalCost() > b->getTotalCost(); };
-        std::priority_queue<Node<T>*, std::vector<Node<T>*>, decltype(compareFn)> openNodeVecPQueue =
-            std::priority_queue<Node<T>*, std::vector<Node<T>*>, decltype(compareFn)>(compareFn);
+        auto compareFn = [](const Node<CoordinateType>* a, const Node<CoordinateType>* b) { return a->getTotalCost() > b->getTotalCost(); };
+        std::priority_queue<Node<CoordinateType>*, std::vector<Node<CoordinateType>*>, decltype(compareFn)> openNodeVecPQueue =
+            std::priority_queue<Node<CoordinateType>*, std::vector<Node<CoordinateType>*>, decltype(compareFn)>(compareFn);
 
-        std::unordered_map<Vec2i, Node<T>*, Vec2i::hash> openNodeMap;
-        std::unordered_map<Vec2i, Node<T>*, Vec2i::hash> closedNodeMap;
+        std::unordered_map<Vec2i, Node<CoordinateType>*, Vec2i::hash> openNodeMap;
+        std::unordered_map<Vec2i, Node<CoordinateType>*, Vec2i::hash> closedNodeMap;
 
-        openNodeVecPQueue.push(new Node<T>(source));
+        openNodeVecPQueue.push(new Node<CoordinateType>(source));
         openNodeMap.insert({source, openNodeVecPQueue.top()});
 
         while (!openNodeVecPQueue.empty()) {
             currentNode = openNodeVecPQueue.top();
 
             if constexpr (enableDebug) {
-                AStarVirtual<T, enableDebug>::_debugCurrentNode(currentNode);
+                AStarVirtual<CoordinateType, enableDebug>::_debugCurrentNode(currentNode);
             }
 
             if (currentNode->pos == target) {
@@ -195,8 +195,8 @@ class AStar final : public AStarVirtual<T, enableDebug> {
             openNodeMap.erase(currentNode->pos);
             closedNodeMap.insert({currentNode->pos, currentNode});
 
-            for (size_t i = 0; i < AStarVirtual<T, enableDebug>::_directionsCount; ++i) {
-                Vec2i newPos = currentNode->pos + AStarVirtual<T, enableDebug>::_directions[i];
+            for (size_t i = 0; i < AStarVirtual<CoordinateType, enableDebug>::_directionsCount; ++i) {
+                Vec2i newPos = currentNode->pos + AStarVirtual<CoordinateType, enableDebug>::_directions[i];
 
                 if (_obstacles.contains(newPos)) {
                     continue;
@@ -210,14 +210,14 @@ class AStar final : public AStarVirtual<T, enableDebug> {
                     continue;
                 }
 
-                T nextCost = currentNode->pathCost + AStarVirtual<T, enableDebug>::_mouvemementCost;
-                Node<T>* nextNode = openNodeMap.find(newPos) != openNodeMap.end() ? openNodeMap[newPos] : nullptr;
+                CoordinateType nextCost = currentNode->pathCost + AStarVirtual<CoordinateType, enableDebug>::_mouvemementCost;
+                Node<CoordinateType>* nextNode = openNodeMap.find(newPos) != openNodeMap.end() ? openNodeMap[newPos] : nullptr;
 
                 if (nextNode == nullptr) {
-                    nextNode = new Node<T>(newPos, currentNode);
+                    nextNode = new Node<CoordinateType>(newPos, currentNode);
                     nextNode->pathCost = nextCost;
-                    nextNode->heuristicCost = static_cast<T>(AStarVirtual<T, enableDebug>::_heuristicFunction(
-                        nextNode->pos, target, AStarVirtual<T, enableDebug>::_heuristicWeight));
+                    nextNode->heuristicCost = static_cast<CoordinateType>(AStarVirtual<CoordinateType, enableDebug>::_heuristicFunction(
+                        nextNode->pos, target, AStarVirtual<CoordinateType, enableDebug>::_heuristicWeight));
                     openNodeVecPQueue.push(nextNode);
                     openNodeMap.insert({nextNode->pos, nextNode});
                 } else if (nextCost < nextNode->pathCost) {
@@ -226,7 +226,7 @@ class AStar final : public AStarVirtual<T, enableDebug> {
                 }
 
                 if constexpr (enableDebug) {
-                    AStarVirtual<T, enableDebug>::_debugOpenNode(nextNode);
+                    AStarVirtual<CoordinateType, enableDebug>::_debugOpenNode(nextNode);
                 }
             }
         }
@@ -264,33 +264,33 @@ class AStar final : public AStarVirtual<T, enableDebug> {
 };
 
 // Fast AStar are faster than normal AStar but use more ram and direct access to the map
-template <IntegerType T = uint32_t, bool enableDebug = false, IntegerType U = uint32_t>
-class AStarFast final : public AStarVirtual<T, enableDebug> {
+template <IntegerType CoordinateType = uint32_t, bool enableDebug = false, IntegerType MapElementType = uint32_t>
+class AStarFast final : public AStarVirtual<CoordinateType, enableDebug> {
    public:
-    explicit AStarFast() : _isObstacleFunction([](U value) { return value == 1; }) {}
+    explicit AStarFast() : _isObstacleFunction([](MapElementType value) { return value == 1; }) {}
 
     // Same as AStar::findPath() but use direct access to the map
-    std::vector<Vec2i> findPath(const Vec2i& source, const Vec2i& target, const std::vector<U>& map, const Vec2i& worldSize) {
+    std::vector<Vec2i> findPath(const Vec2i& source, const Vec2i& target, const std::vector<MapElementType>& map, const Vec2i& worldSize) {
         if (target.x < 0 || target.x >= worldSize.x || target.y < 0 || target.y >= worldSize.y) {
             return {};
         }
 
-        Node<T>* currentNode = nullptr;
+        Node<CoordinateType>* currentNode = nullptr;
 
-        auto compareFn = [](const Node<T>* a, const Node<T>* b) { return a->getTotalCost() > b->getTotalCost(); };
-        std::priority_queue<Node<T>*, std::vector<Node<T>*>, decltype(compareFn)> openNodeVecPQueue =
-            std::priority_queue<Node<T>*, std::vector<Node<T>*>, decltype(compareFn)>(compareFn);
-        std::unordered_map<Vec2i, Node<T>*, Vec2i::hash> openNodeMap;
-        std::unordered_map<Vec2i, Node<T>*, Vec2i::hash> closedNodeMap;
+        auto compareFn = [](const Node<CoordinateType>* a, const Node<CoordinateType>* b) { return a->getTotalCost() > b->getTotalCost(); };
+        std::priority_queue<Node<CoordinateType>*, std::vector<Node<CoordinateType>*>, decltype(compareFn)> openNodeVecPQueue =
+            std::priority_queue<Node<CoordinateType>*, std::vector<Node<CoordinateType>*>, decltype(compareFn)>(compareFn);
+        std::unordered_map<Vec2i, Node<CoordinateType>*, Vec2i::hash> openNodeMap;
+        std::unordered_map<Vec2i, Node<CoordinateType>*, Vec2i::hash> closedNodeMap;
 
-        openNodeVecPQueue.push(new Node<T>(source));
+        openNodeVecPQueue.push(new Node<CoordinateType>(source));
         openNodeMap.insert({source, openNodeVecPQueue.top()});
 
         while (!openNodeVecPQueue.empty()) {
             currentNode = openNodeVecPQueue.top();
 
             if constexpr (enableDebug) {
-                AStarVirtual<T, enableDebug>::_debugCurrentNode(currentNode);
+                AStarVirtual<CoordinateType, enableDebug>::_debugCurrentNode(currentNode);
             }
 
             if (currentNode->pos == target) {
@@ -301,8 +301,8 @@ class AStarFast final : public AStarVirtual<T, enableDebug> {
             openNodeMap.erase(currentNode->pos);
             closedNodeMap.insert({currentNode->pos, currentNode});
 
-            for (size_t i = 0; i < AStarVirtual<T, enableDebug>::_directionsCount; ++i) {
-                Vec2i newPos = currentNode->pos + AStarVirtual<T, enableDebug>::_directions[i];
+            for (size_t i = 0; i < AStarVirtual<CoordinateType, enableDebug>::_directionsCount; ++i) {
+                Vec2i newPos = currentNode->pos + AStarVirtual<CoordinateType, enableDebug>::_directions[i];
 
                 if (_isObstacleFunction(map[newPos.x + newPos.y * worldSize.x])) {
                     continue;
@@ -316,13 +316,13 @@ class AStarFast final : public AStarVirtual<T, enableDebug> {
                     continue;
                 }
 
-                T nextCost = currentNode->pathCost + AStarVirtual<T, enableDebug>::_mouvemementCost;
-                Node<T>* nextNode = openNodeMap.find(newPos) != openNodeMap.end() ? openNodeMap[newPos] : nullptr;
+                CoordinateType nextCost = currentNode->pathCost + AStarVirtual<CoordinateType, enableDebug>::_mouvemementCost;
+                Node<CoordinateType>* nextNode = openNodeMap.find(newPos) != openNodeMap.end() ? openNodeMap[newPos] : nullptr;
                 if (nextNode == nullptr) {
-                    nextNode = new Node<T>(newPos, currentNode);
+                    nextNode = new Node<CoordinateType>(newPos, currentNode);
                     nextNode->pathCost = nextCost;
-                    nextNode->heuristicCost = static_cast<T>(AStarVirtual<T, enableDebug>::_heuristicFunction(
-                        nextNode->pos, target, AStarVirtual<T, enableDebug>::_heuristicWeight));
+                    nextNode->heuristicCost = static_cast<CoordinateType>(AStarVirtual<CoordinateType, enableDebug>::_heuristicFunction(
+                        nextNode->pos, target, AStarVirtual<CoordinateType, enableDebug>::_heuristicWeight));
                     openNodeVecPQueue.push(nextNode);
                     openNodeMap.insert({nextNode->pos, nextNode});
                 } else if (nextCost < nextNode->pathCost) [[likely]] {
@@ -331,7 +331,7 @@ class AStarFast final : public AStarVirtual<T, enableDebug> {
                 }
 
                 if constexpr (enableDebug) {
-                    AStarVirtual<T, enableDebug>::_debugOpenNode(nextNode);
+                    AStarVirtual<CoordinateType, enableDebug>::_debugOpenNode(nextNode);
                 }
             }
         }
@@ -355,11 +355,11 @@ class AStarFast final : public AStarVirtual<T, enableDebug> {
 
         return path;
     }
-    void setObstacle(const std::function<bool(U)>& isObstacleFunction) noexcept { _isObstacleFunction = isObstacleFunction; }
-    std::function<bool(U)>& getObstacle() noexcept { return _isObstacleFunction; }
+    void setObstacle(const std::function<bool(MapElementType)>& isObstacleFunction) noexcept { _isObstacleFunction = isObstacleFunction; }
+    std::function<bool(MapElementType)>& getObstacle() noexcept { return _isObstacleFunction; }
 
    private:
-    std::function<bool(U)> _isObstacleFunction;
+    std::function<bool(MapElementType)> _isObstacleFunction;
 };
 
 }  // namespace AStar
diff --git a/test/source/benchmark/astar_bench.cpp b/test/source/benchmark/astar_bench.cpp
index 056e803..7bb49e4 100644
--- a/test/source/benchmark/astar_bench.cpp
+++ b/test/source/benchmark/astar_bench.cpp
@@ -18,7 +18,7 @@ static void DoSetup([[maybe_unused]] const benchmark::State& state) {}
 
 static void DoTeardown([[maybe_unused]] const benchmark::State& state) {}
 
-template <IntegerType T>
+template <IntegerType CoordinateType>
 static void astar_bench(benchmark::State& state) {
     auto range = state.range(0);
 
@@ -47,7 +47,7 @@ static void astar_bench(benchmark::State& state) {
     std::vector<uint8_t> blocks = std::vector<uint8_t>(mapWidth * mapHeight, 0);
     benchmark::DoNotOptimize(blocks);
 
-    AStar::AStar<T, false> pathFinder;
+    AStar::AStar<CoordinateType, false> pathFinder;
     benchmark::DoNotOptimize(pathFinder);
     pathFinder.setWorldSize({mapWidth, mapHeight});
     pathFinder.setHeuristic(AStar::Heuristic::euclidean);
@@ -104,7 +104,7 @@ BENCHMARK(astar_bench<uint32_t>)
     ->UseRealTime()
     ->Repetitions(repetitions);
 
-template <IntegerType T>
+template <IntegerType CoordinateType>
 static void astar_bench_fast(benchmark::State& state) {
     auto range = state.range(0);
 
@@ -133,7 +133,7 @@ static void astar_bench_fast(benchmark::State& state) {
     std::vector<uint32_t> blocks = std::vector<uint32_t>(mapWidth * mapHeight, 0);
     benchmark::DoNotOptimize(blocks);
 
-    AStar::AStarFast<T, false, uint32_t> pathFinder;
+    AStar::AStarFast<CoordinateType, false, uint32_t> pathFinder;
     benchmark::DoNotOptimize(pathFinder);
     pathFinder.setHeuristic(AStar::Heuristic::euclidean);
     pathFinder.setDiagonalMovement(true);