Merge pull request #163 from orange-cpp/feature/serailization

Feature/serailization

include/omath/pathfinding/navigation_mesh.hpp

@@ -6,7 +6,9 @@
 
 #include "omath/linear_algebra/vector3.hpp"
 #include <expected>
+#include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace omath::pathfinding
@@ -28,10 +30,20 @@ namespace omath::pathfinding
         [[nodiscard]]
         bool empty() const;
 
-        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
+        // Events -- per-vertex optional tag (e.g. "jump", "teleport")
+        void set_event(const Vector3<float>& vertex, const std::string_view& event_id);
+        void clear_event(const Vector3<float>& vertex);
 
-        void deserialize(const std::vector<uint8_t>& raw) noexcept;
+        [[nodiscard]]
+        std::optional<std::string> get_event(const Vector3<float>& vertex) const noexcept;
+
+        [[nodiscard]] std::string serialize() const noexcept;
+
+        void deserialize(const std::string& raw);
 
         std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+
+    private:
+        std::unordered_map<Vector3<float>, std::string> m_vertex_events;
     };
 } // namespace omath::pathfinding

source/lua/lua_pattern_scan.cpp

@@ -10,7 +10,6 @@
 #include <omath/utility/pe_pattern_scan.hpp>
 #include <omath/utility/section_scan_result.hpp>
 #include <sol/sol.hpp>
-#endif
 
 namespace omath::lua
 {
@@ -101,4 +100,5 @@ namespace omath::lua
             return *result;
         };
     }
-} // namespace omath::lua
+} // namespace omath::lua
+#endif

source/pathfinding/navigation_mesh.cpp

@@ -3,9 +3,9 @@
 //
 #include "omath/pathfinding/navigation_mesh.hpp"
 #include <algorithm>
-#include <cstring>
-#include <limits>
+#include <sstream>
 #include <stdexcept>
+
 namespace omath::pathfinding
 {
     std::expected<Vector3<float>, std::string>
@@ -30,77 +30,72 @@ namespace omath::pathfinding
         return m_vertex_map.empty();
     }
 
-    std::vector<uint8_t> NavigationMesh::serialize() const noexcept
+    void NavigationMesh::set_event(const Vector3<float>& vertex, const std::string_view&  event_id)
     {
-        std::vector<std::uint8_t> raw;
+        if (!m_vertex_map.contains(vertex))
+            throw std::invalid_argument(std::format("Vertex '{}' not found", vertex));
 
-        // Pre-calculate total size for better performance
-        std::size_t total_size = 0;
-        for (const auto& [vertex, neighbors] : m_vertex_map)
-        {
-            total_size += sizeof(vertex) + sizeof(std::uint16_t) + sizeof(Vector3<float>) * neighbors.size();
-        }
-        raw.reserve(total_size);
-
-        auto dump_to_vector = [&raw]<typename T>(const T& t)
-        {
-            const auto* byte_ptr = reinterpret_cast<const std::uint8_t*>(&t);
-            raw.insert(raw.end(), byte_ptr, byte_ptr + sizeof(T));
-        };
-
-        for (const auto& [vertex, neighbors] : m_vertex_map)
-        {
-            // Clamp neighbors count to fit in uint16_t (prevents silent data corruption)
-            // NOTE: If neighbors.size() > 65535, only the first 65535 neighbors will be serialized.
-            // This is a limitation of the current serialization format using uint16_t for count.
-            const auto clamped_count =
-                    std::min<std::size_t>(neighbors.size(), std::numeric_limits<std::uint16_t>::max());
-            const auto neighbors_count = static_cast<std::uint16_t>(clamped_count);
-
-            dump_to_vector(vertex);
-            dump_to_vector(neighbors_count);
-
-            // Only serialize up to the clamped count
-            for (std::size_t i = 0; i < clamped_count; ++i)
-                dump_to_vector(neighbors[i]);
-        }
-        return raw;
+        m_vertex_events[vertex] = event_id;
     }
 
-    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
+    void NavigationMesh::clear_event(const Vector3<float>& vertex)
     {
-        auto load_from_vector = [](const std::vector<uint8_t>& vec, std::size_t& offset, auto& value)
+        m_vertex_events.erase(vertex);
+    }
+
+    std::optional<std::string> NavigationMesh::get_event(const Vector3<float>& vertex) const noexcept
+    {
+        const auto it = m_vertex_events.find(vertex);
+        if (it == m_vertex_events.end())
+            return std::nullopt;
+        return it->second;
+    }
+
+    // Serialization format per vertex line:
+    //   x y z neighbor_count event_id
+    // where event_id is "-" when no event is set.
+    // Neighbor lines follow: nx ny nz
+
+    std::string NavigationMesh::serialize() const noexcept
+    {
+        std::ostringstream oss;
+        for (const auto& [vertex, neighbors] : m_vertex_map)
         {
-            if (offset + sizeof(value) > vec.size())
-                throw std::runtime_error("Deserialize: Invalid input data size.");
+            const auto event_it = m_vertex_events.find(vertex);
+            const std::string& event = (event_it != m_vertex_events.end()) ? event_it->second : "-";
 
-            std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
-            offset += sizeof(value);
-        };
+            oss << vertex.x << ' ' << vertex.y << ' ' << vertex.z << ' ' << neighbors.size() << ' ' << event << '\n';
 
+            for (const auto& n : neighbors)
+                oss << n.x << ' ' << n.y << ' ' << n.z << '\n';
+        }
+        return oss.str();
+    }
+
+    void NavigationMesh::deserialize(const std::string& raw)
+    {
         m_vertex_map.clear();
+        m_vertex_events.clear();
+        std::istringstream iss(raw);
 
-        std::size_t offset = 0;
-
-        while (offset < raw.size())
+        Vector3<float> vertex;
+        std::size_t neighbors_count;
+        std::string event;
+        while (iss >> vertex.x >> vertex.y >> vertex.z >> neighbors_count >> event)
         {
-            Vector3<float> vertex;
-            load_from_vector(raw, offset, vertex);
-
-            std::uint16_t neighbors_count;
-            load_from_vector(raw, offset, neighbors_count);
-
             std::vector<Vector3<float>> neighbors;
             neighbors.reserve(neighbors_count);
-
             for (std::size_t i = 0; i < neighbors_count; ++i)
             {
-                Vector3<float> neighbor;
-                load_from_vector(raw, offset, neighbor);
-                neighbors.push_back(neighbor);
+                Vector3<float> n;
+                if (!(iss >> n.x >> n.y >> n.z))
+                    throw std::runtime_error("Deserialize: Unexpected end of data.");
+                neighbors.push_back(n);
             }
-
             m_vertex_map.emplace(vertex, std::move(neighbors));
+
+            if (event != "-")
+                m_vertex_events.emplace(vertex, std::move(event));
         }
     }
 } // namespace omath::pathfinding

tests/general/unit_test_a_star.cpp

@@ -8,6 +8,29 @@
 using namespace omath;
 using namespace omath::pathfinding;
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+static NavigationMesh make_linear_chain(int length)
+{
+    // 0 -> 1 -> 2 -> ... -> length-1  (directed)
+    NavigationMesh nav;
+    for (int i = 0; i < length; ++i)
+    {
+        const Vector3<float> v{static_cast<float>(i), 0.f, 0.f};
+        if (i + 1 < length)
+            nav.m_vertex_map[v] = {Vector3<float>{static_cast<float>(i + 1), 0.f, 0.f}};
+        else
+            nav.m_vertex_map[v] = {};
+    }
+    return nav;
+}
+
+// ---------------------------------------------------------------------------
+// Basic reachability
+// ---------------------------------------------------------------------------
+
 TEST(AStarExtra, TrivialNeighbor)
 {
     NavigationMesh nav;
@@ -78,7 +101,7 @@ TEST(AStarExtra, LongerPathAvoidsBlock)
     constexpr Vector3<float> goal = idx(2, 1);
     const auto path = Astar::find_path(start, goal, nav);
     ASSERT_FALSE(path.empty());
-    EXPECT_EQ(path.front(), goal); // Astar convention: single-element or endpoint present
+    EXPECT_EQ(path.front(), goal);
 }
 
 TEST(AstarTests, TrivialDirectNeighborPath)
@@ -91,9 +114,6 @@ TEST(AstarTests, TrivialDirectNeighborPath)
     nav.m_vertex_map.emplace(v2, std::vector<Vector3<float>>{v1});
 
     const auto path = Astar::find_path(v1, v2, nav);
-    // Current A* implementation returns the end vertex as the reconstructed
-    // path (single-element) in the simple neighbor scenario. Assert that the
-    // endpoint is present and reachable.
     ASSERT_EQ(path.size(), 1u);
     EXPECT_EQ(path.front(), v2);
 }
@@ -133,4 +153,155 @@ TEST(unit_test_a_star, finding_right_path)
     mesh.m_vertex_map[{0.f, 2.f, 0.f}] = {{0.f, 3.f, 0.f}};
     mesh.m_vertex_map[{0.f, 3.f, 0.f}] = {};
     std::ignore = omath::pathfinding::Astar::find_path({}, {0.f, 3.f, 0.f}, mesh);
-}
+}
+
+// ---------------------------------------------------------------------------
+// Directed edges
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, DirectedEdge_ForwardPathExists)
+{
+    // A -> B only; path from A to B should succeed
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {}; // no edge back
+
+    const auto path = Astar::find_path(a, b, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), b);
+}
+
+TEST(AstarTests, DirectedEdge_ReversePathMissing)
+{
+    // A -> B only; path from B to A should fail
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {};
+
+    const auto path = Astar::find_path(b, a, nav);
+    EXPECT_TRUE(path.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Vertex snapping
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, OffMeshStart_SnapsToNearestVertex)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> v1{0.f, 0.f, 0.f};
+    constexpr Vector3<float> v2{10.f, 0.f, 0.f};
+    nav.m_vertex_map[v1] = {v2};
+    nav.m_vertex_map[v2] = {v1};
+
+    // Start is slightly off v1 but closer to it than to v2
+    constexpr Vector3<float> off_start{0.1f, 0.f, 0.f};
+    const auto path = Astar::find_path(off_start, v2, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), v2);
+}
+
+TEST(AstarTests, OffMeshEnd_SnapsToNearestVertex)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> v1{0.f, 0.f, 0.f};
+    constexpr Vector3<float> v2{10.f, 0.f, 0.f};
+    nav.m_vertex_map[v1] = {v2};
+    nav.m_vertex_map[v2] = {v1};
+
+    // Goal is slightly off v2 but closer to it than to v1
+    constexpr Vector3<float> off_goal{9.9f, 0.f, 0.f};
+    const auto path = Astar::find_path(v1, off_goal, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), v2);
+}
+
+// ---------------------------------------------------------------------------
+// Cycle handling
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, CyclicGraph_FindsPathWithoutLooping)
+{
+    // Triangle: A <-> B <-> C <-> A
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    constexpr Vector3<float> c{0.5f, 1.f, 0.f};
+    nav.m_vertex_map[a] = {b, c};
+    nav.m_vertex_map[b] = {a, c};
+    nav.m_vertex_map[c] = {a, b};
+
+    const auto path = Astar::find_path(a, c, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), c);
+}
+
+TEST(AstarTests, SelfLoopVertex_DoesNotBreakSearch)
+{
+    // Vertex with itself as a neighbor
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {a, b}; // self-loop on a
+    nav.m_vertex_map[b] = {a};
+
+    const auto path = Astar::find_path(a, b, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), b);
+}
+
+// ---------------------------------------------------------------------------
+// Longer chains
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, LinearChain_ReachesEnd)
+{
+    constexpr int kLength = 10;
+    const NavigationMesh nav = make_linear_chain(kLength);
+
+    const Vector3<float> start{0.f, 0.f, 0.f};
+    const Vector3<float> goal{static_cast<float>(kLength - 1), 0.f, 0.f};
+
+    const auto path = Astar::find_path(start, goal, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), goal);
+}
+
+TEST(AstarTests, LinearChain_MidpointReachable)
+{
+    constexpr int kLength = 6;
+    const NavigationMesh nav = make_linear_chain(kLength);
+
+    const Vector3<float> start{0.f, 0.f, 0.f};
+    const Vector3<float> mid{3.f, 0.f, 0.f};
+
+    const auto path = Astar::find_path(start, mid, nav);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), mid);
+}
+
+// ---------------------------------------------------------------------------
+// Serialize -> pathfind integration
+// ---------------------------------------------------------------------------
+
+TEST(AstarTests, PathfindAfterSerializeDeserialize)
+{
+    NavigationMesh nav;
+    constexpr Vector3<float> a{0.f, 0.f, 0.f};
+    constexpr Vector3<float> b{1.f, 0.f, 0.f};
+    constexpr Vector3<float> c{2.f, 0.f, 0.f};
+    nav.m_vertex_map[a] = {b};
+    nav.m_vertex_map[b] = {a, c};
+    nav.m_vertex_map[c] = {b};
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    const auto path = Astar::find_path(a, c, nav2);
+    ASSERT_FALSE(path.empty());
+    EXPECT_EQ(path.back(), c);
+}

tests/general/unit_test_navigation_mesh.cpp

@@ -7,19 +7,18 @@ using namespace omath::pathfinding;
 TEST(NavigationMeshTests, SerializeDeserializeRoundTrip)
 {
     NavigationMesh nav;
-    Vector3<float> a{0.f,0.f,0.f};
-    Vector3<float> b{1.f,0.f,0.f};
-    Vector3<float> c{0.f,1.f,0.f};
+    Vector3<float> a{0.f, 0.f, 0.f};
+    Vector3<float> b{1.f, 0.f, 0.f};
+    Vector3<float> c{0.f, 1.f, 0.f};
 
-    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b,c});
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b, c});
     nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{a});
     nav.m_vertex_map.emplace(c, std::vector<Vector3<float>>{a});
 
-    auto data = nav.serialize();
+    std::string data = nav.serialize();
     NavigationMesh nav2;
     EXPECT_NO_THROW(nav2.deserialize(data));
 
-    // verify neighbors preserved
     EXPECT_EQ(nav2.m_vertex_map.size(), nav.m_vertex_map.size());
     EXPECT_EQ(nav2.get_neighbors(a).size(), 2u);
 }
@@ -27,7 +26,223 @@ TEST(NavigationMeshTests, SerializeDeserializeRoundTrip)
 TEST(NavigationMeshTests, GetClosestVertexWhenEmpty)
 {
     const NavigationMesh nav;
-    constexpr Vector3<float> p{5.f,5.f,5.f};
+    constexpr Vector3<float> p{5.f, 5.f, 5.f};
     const auto res = nav.get_closest_vertex(p);
     EXPECT_FALSE(res.has_value());
 }
+
+TEST(NavigationMeshTests, SerializeEmptyMesh)
+{
+    const NavigationMesh nav;
+    const std::string data = nav.serialize();
+    EXPECT_TRUE(data.empty());
+}
+
+TEST(NavigationMeshTests, DeserializeEmptyString)
+{
+    NavigationMesh nav;
+    EXPECT_NO_THROW(nav.deserialize(""));
+    EXPECT_TRUE(nav.empty());
+}
+
+TEST(NavigationMeshTests, SerializeProducesHumanReadableText)
+{
+    NavigationMesh nav;
+    nav.m_vertex_map.emplace(Vector3<float>{1.f, 2.f, 3.f}, std::vector<Vector3<float>>{{4.f, 5.f, 6.f}});
+
+    const std::string data = nav.serialize();
+
+    // Must contain the vertex and neighbor coords as plain text
+    EXPECT_NE(data.find("1"), std::string::npos);
+    EXPECT_NE(data.find("2"), std::string::npos);
+    EXPECT_NE(data.find("3"), std::string::npos);
+    EXPECT_NE(data.find("4"), std::string::npos);
+    EXPECT_NE(data.find("5"), std::string::npos);
+    EXPECT_NE(data.find("6"), std::string::npos);
+}
+
+TEST(NavigationMeshTests, DeserializeRestoresNeighborValues)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 2.f, 3.f};
+    const Vector3<float> n1{4.f, 5.f, 6.f};
+    const Vector3<float> n2{7.f, 8.f, 9.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{n1, n2});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    const auto& neighbors = nav2.get_neighbors(v);
+    ASSERT_EQ(neighbors.size(), 2u);
+    EXPECT_EQ(neighbors[0], n1);
+    EXPECT_EQ(neighbors[1], n2);
+}
+
+TEST(NavigationMeshTests, DeserializeOverwritesPreviousData)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    // Load a different mesh into the same object
+    NavigationMesh other;
+    const Vector3<float> a{10.f, 20.f, 30.f};
+    other.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+
+    nav.deserialize(other.serialize());
+
+    EXPECT_EQ(nav.m_vertex_map.size(), 1u);
+    EXPECT_EQ(nav.m_vertex_map.count(v), 0u);
+    EXPECT_EQ(nav.m_vertex_map.count(a), 1u);
+}
+
+TEST(NavigationMeshTests, RoundTripNegativeAndFractionalCoords)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{-1.5f, 0.25f, -3.75f};
+    const Vector3<float> n{100.f, -200.f, 0.001f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{n});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    const auto& neighbors = nav2.get_neighbors(v);
+    ASSERT_EQ(neighbors.size(), 1u);
+    EXPECT_NEAR(neighbors[0].x, n.x, 1e-3f);
+    EXPECT_NEAR(neighbors[0].y, n.y, 1e-3f);
+    EXPECT_NEAR(neighbors[0].z, n.z, 1e-3f);
+}
+
+TEST(NavigationMeshTests, GetClosestVertexReturnsNearest)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{10.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+
+    const auto res = nav.get_closest_vertex({1.f, 0.f, 0.f});
+    ASSERT_TRUE(res.has_value());
+    EXPECT_EQ(res.value(), a);
+}
+
+TEST(NavigationMeshTests, VertexWithNoNeighborsRoundTrip)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{5.f, 5.f, 5.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_EQ(nav2.m_vertex_map.count(v), 1u);
+    EXPECT_TRUE(nav2.get_neighbors(v).empty());
+}
+
+// ---------------------------------------------------------------------------
+// Vertex events
+// ---------------------------------------------------------------------------
+
+TEST(NavigationMeshTests, SetEventOnNonExistentVertexThrows)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{99.f, 99.f, 99.f};
+    EXPECT_THROW(nav.set_event(v, "jump"), std::invalid_argument);
+}
+
+TEST(NavigationMeshTests, EventNotSetByDefault)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{0.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}
+
+TEST(NavigationMeshTests, SetAndGetEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+
+    const auto event = nav.get_event(v);
+    ASSERT_TRUE(event.has_value());
+    EXPECT_EQ(event.value(), "jump");
+}
+
+TEST(NavigationMeshTests, OverwriteEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+    nav.set_event(v, "teleport");
+
+    EXPECT_EQ(nav.get_event(v).value(), "teleport");
+}
+
+TEST(NavigationMeshTests, ClearEvent)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+    nav.clear_event(v);
+
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}
+
+TEST(NavigationMeshTests, EventRoundTripSerialization)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{1.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{b});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+    nav.set_event(b, "jump");
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    ASSERT_FALSE(nav2.get_event(a).has_value());
+    ASSERT_TRUE(nav2.get_event(b).has_value());
+    EXPECT_EQ(nav2.get_event(b).value(), "jump");
+}
+
+TEST(NavigationMeshTests, MultipleEventsRoundTrip)
+{
+    NavigationMesh nav;
+    const Vector3<float> a{0.f, 0.f, 0.f};
+    const Vector3<float> b{1.f, 0.f, 0.f};
+    const Vector3<float> c{2.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(a, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(b, std::vector<Vector3<float>>{});
+    nav.m_vertex_map.emplace(c, std::vector<Vector3<float>>{});
+    nav.set_event(a, "spawn");
+    nav.set_event(c, "teleport");
+
+    NavigationMesh nav2;
+    nav2.deserialize(nav.serialize());
+
+    EXPECT_EQ(nav2.get_event(a).value(), "spawn");
+    EXPECT_FALSE(nav2.get_event(b).has_value());
+    EXPECT_EQ(nav2.get_event(c).value(), "teleport");
+}
+
+TEST(NavigationMeshTests, DeserializeClearsOldEvents)
+{
+    NavigationMesh nav;
+    const Vector3<float> v{0.f, 0.f, 0.f};
+    nav.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+    nav.set_event(v, "jump");
+
+    // Deserialize a mesh that has no events
+    NavigationMesh empty_events;
+    empty_events.m_vertex_map.emplace(v, std::vector<Vector3<float>>{});
+
+    nav.deserialize(empty_events.serialize());
+    EXPECT_FALSE(nav.get_event(v).has_value());
+}

tests/lua/pe_scanner_tests.lua

@@ -0,0 +1,66 @@
+-- PatternScanner tests: generic scan over a Lua string buffer
+
+function PatternScanner_FindsExactPattern()
+    local buf = "\x90\x01\x02\x03\x04"
+    local offset = omath.PatternScanner.scan(buf, "90 01 02")
+    assert(offset ~= nil, "expected pattern to be found")
+    assert(offset == 0, "expected offset 0, got " .. tostring(offset))
+end
+
+function PatternScanner_FindsPatternAtNonZeroOffset()
+    local buf = "\x00\x00\xAB\xCD\xEF"
+    local offset = omath.PatternScanner.scan(buf, "AB CD EF")
+    assert(offset ~= nil, "expected pattern to be found")
+    assert(offset == 2, "expected offset 2, got " .. tostring(offset))
+end
+
+function PatternScanner_WildcardMatches()
+    local buf = "\xDE\xAD\xBE\xEF"
+    local offset = omath.PatternScanner.scan(buf, "DE ?? BE")
+    assert(offset ~= nil, "expected wildcard match")
+    assert(offset == 0)
+end
+
+function PatternScanner_ReturnsNilWhenNotFound()
+    local buf = "\x01\x02\x03"
+    local offset = omath.PatternScanner.scan(buf, "AA BB CC")
+    assert(offset == nil, "expected nil for not-found pattern")
+end
+
+function PatternScanner_ReturnsNilForEmptyBuffer()
+    local offset = omath.PatternScanner.scan("", "90 01")
+    assert(offset == nil)
+end
+
+-- PePatternScanner tests: scan_in_module uses FAKE_MODULE_BASE injected from C++
+-- The fake module contains {0x90, 0x01, 0x02, 0x03, 0x04} placed at raw offset 0x200
+
+function PeScanner_FindsExactPattern()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 01 02")
+    assert(addr ~= nil, "expected pattern to be found in module")
+    local offset = addr - FAKE_MODULE_BASE
+    assert(offset == 0x200, string.format("expected offset 0x200, got 0x%X", offset))
+end
+
+function PeScanner_WildcardMatches()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 ?? 02")
+    assert(addr ~= nil, "expected wildcard match in module")
+    local offset = addr - FAKE_MODULE_BASE
+    assert(offset == 0x200, string.format("expected offset 0x200, got 0x%X", offset))
+end
+
+function PeScanner_ReturnsNilWhenNotFound()
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "AA BB CC DD")
+    assert(addr == nil, "expected nil for not-found pattern")
+end
+
+function PeScanner_CustomSectionFallsBackToNil()
+    -- Request a section that doesn't exist in our fake module
+    local addr = omath.PePatternScanner.scan_in_module(FAKE_MODULE_BASE, "90 01 02", ".rdata")
+    assert(addr == nil, "expected nil for wrong section name")
+end
+
+-- SectionScanResult: verify the type is registered and tostring works on a C++-returned value
+function SectionScanResult_TypeIsRegistered()
+    assert(omath.SectionScanResult ~= nil, "SectionScanResult type should be registered")
+end

tests/lua/unit_test_lua_pe_scanner.cpp

@@ -0,0 +1,113 @@
+//
+// Created by orange on 10.03.2026.
+//
+#include <gtest/gtest.h>
+#include <lua.hpp>
+#include <omath/lua/lua.hpp>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace
+{
+    std::vector<std::uint8_t> make_fake_pe_module(std::uint32_t base_of_code, std::uint32_t size_code,
+                                                  const std::vector<std::uint8_t>& code_bytes)
+    {
+        constexpr std::uint32_t e_lfanew         = 0x80;
+        constexpr std::uint32_t nt_sig           = 0x4550;
+        constexpr std::uint16_t opt_magic        = 0x020B; // PE32+
+        constexpr std::uint16_t num_sections     = 1;
+        constexpr std::uint16_t opt_hdr_size     = 0xF0;
+        constexpr std::uint32_t section_table_off = e_lfanew + 4 + 20 + opt_hdr_size;
+        constexpr std::uint32_t section_hdr_size = 40;
+        constexpr std::uint32_t text_chars       = 0x60000020;
+
+        const std::uint32_t headers_end = section_table_off + section_hdr_size;
+        const std::uint32_t code_end    = base_of_code + size_code;
+        const std::uint32_t total_size  = std::max(headers_end, code_end) + 0x100;
+        std::vector<std::uint8_t> buf(total_size, 0);
+
+        auto w16 = [&](std::size_t off, std::uint16_t v) { std::memcpy(buf.data() + off, &v, 2); };
+        auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+        auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
+
+        w16(0x00, 0x5A4D);
+        w32(0x3C, e_lfanew);
+        w32(e_lfanew, nt_sig);
+
+        const std::size_t fh  = e_lfanew + 4;
+        w16(fh + 2,  num_sections);
+        w16(fh + 16, opt_hdr_size);
+
+        const std::size_t opt = fh + 20;
+        w16(opt + 0,   opt_magic);
+        w32(opt + 4,   size_code);
+        w32(opt + 20,  base_of_code);
+        w64(opt + 24,  0);
+        w32(opt + 32,  0x1000);
+        w32(opt + 36,  0x200);
+        w32(opt + 56,  code_end);
+        w32(opt + 60,  headers_end);
+        w32(opt + 108, 0);
+
+        const std::size_t sh = section_table_off;
+        std::memcpy(buf.data() + sh, ".text", 5);
+        w32(sh + 8,  size_code);
+        w32(sh + 12, base_of_code);
+        w32(sh + 16, size_code);
+        w32(sh + 20, base_of_code);
+        w32(sh + 36, text_chars);
+
+        if (base_of_code + code_bytes.size() <= buf.size())
+            std::memcpy(buf.data() + base_of_code, code_bytes.data(), code_bytes.size());
+
+        return buf;
+    }
+} // namespace
+
+class LuaPeScanner : public ::testing::Test
+{
+protected:
+    lua_State*                  L            = nullptr;
+    std::vector<std::uint8_t>   m_fake_module;
+
+    void SetUp() override
+    {
+        const std::vector<std::uint8_t> code = {0x90, 0x01, 0x02, 0x03, 0x04};
+        m_fake_module = make_fake_pe_module(0x200, static_cast<std::uint32_t>(code.size()), code);
+
+        L = luaL_newstate();
+        luaL_openlibs(L);
+        omath::lua::LuaInterpreter::register_lib(L);
+
+        lua_pushinteger(L, static_cast<lua_Integer>(
+                reinterpret_cast<std::uintptr_t>(m_fake_module.data())));
+        lua_setglobal(L, "FAKE_MODULE_BASE");
+
+        if (luaL_dofile(L, LUA_SCRIPTS_DIR "/pe_scanner_tests.lua") != LUA_OK)
+            FAIL() << lua_tostring(L, -1);
+    }
+
+    void TearDown() override { lua_close(L); }
+
+    void check(const char* func_name)
+    {
+        lua_getglobal(L, func_name);
+        if (lua_pcall(L, 0, 0, 0) != LUA_OK)
+        {
+            FAIL() << lua_tostring(L, -1);
+            lua_pop(L, 1);
+        }
+    }
+};
+
+TEST_F(LuaPeScanner, PatternScanner_FindsExactPattern)       { check("PatternScanner_FindsExactPattern"); }
+TEST_F(LuaPeScanner, PatternScanner_FindsPatternAtOffset)    { check("PatternScanner_FindsPatternAtNonZeroOffset"); }
+TEST_F(LuaPeScanner, PatternScanner_WildcardMatches)         { check("PatternScanner_WildcardMatches"); }
+TEST_F(LuaPeScanner, PatternScanner_ReturnsNilWhenNotFound)  { check("PatternScanner_ReturnsNilWhenNotFound"); }
+TEST_F(LuaPeScanner, PatternScanner_ReturnsNilForEmptyBuffer){ check("PatternScanner_ReturnsNilForEmptyBuffer"); }
+TEST_F(LuaPeScanner, PeScanner_FindsExactPattern)            { check("PeScanner_FindsExactPattern"); }
+TEST_F(LuaPeScanner, PeScanner_WildcardMatches)              { check("PeScanner_WildcardMatches"); }
+TEST_F(LuaPeScanner, PeScanner_ReturnsNilWhenNotFound)       { check("PeScanner_ReturnsNilWhenNotFound"); }
+TEST_F(LuaPeScanner, PeScanner_CustomSectionFallsBackToNil)  { check("PeScanner_CustomSectionFallsBackToNil"); }
+TEST_F(LuaPeScanner, SectionScanResult_TypeIsRegistered)     { check("SectionScanResult_TypeIsRegistered"); }