paralel build

.github/workflows/cmake-multi-platform.yml

@@ -706,12 +706,7 @@ jobs:
             -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
-        run: |
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
-          if [[ "${{ matrix.msystem }}" == "MINGW32" ]]; then
-            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath --parallel 1
-          else
-            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
-          fi
 
       - name: Run unit_tests.exe
         run: |

benchmark/benchmark_projectile_pred.cpp

@@ -2,105 +2,22 @@
 // Created by Vlad on 9/18/2025.
 //
 #include <benchmark/benchmark.h>
-#include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
+#include <omath/omath.hpp>
+using namespace omath;
 
-namespace
+using namespace omath::projectile_prediction;
+
+constexpr float simulation_time_step = 1.f / 1000.f;
+constexpr float hit_distance_tolerance = 5.f;
+
+void source_engine_projectile_prediction(benchmark::State& state)
 {
-    using Engine = omath::projectile_prediction::ProjPredEngineLegacy<>;
+    constexpr Target<float> target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    using Projectile = omath::projectile_prediction::Projectile<float>;
+    constexpr Projectile<float> projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
-    using Target = omath::projectile_prediction::Target<float>;
 
-    struct PredictionScenario
+    for ([[maybe_unused]] const auto _: state)
-    {
+        std::ignore = ProjPredEngineLegacy<>(400.f, simulation_time_step, 50.f, hit_distance_tolerance)
-        Projectile projectile;
+                              .maybe_calculate_aim_point(projectile, target);
-        Target target;
+}
-        float gravity;
-        float simulation_time_step;
-        float maximum_simulation_time;
-        float distance_tolerance;
-        bool expects_solution;
-    };
 
-    void run_prediction_benchmark(benchmark::State& state, const PredictionScenario& scenario)
+BENCHMARK(source_engine_projectile_prediction)->Iterations(10'000);
-    {
-        const Engine engine(scenario.gravity, scenario.simulation_time_step, scenario.maximum_simulation_time,
-                            scenario.distance_tolerance);
-        auto projectile = scenario.projectile;
-        auto target = scenario.target;
-
-        if (engine.maybe_calculate_aim_point(projectile, target).has_value() != scenario.expects_solution)
-        {
-            state.SkipWithError("Projectile benchmark scenario returned an unexpected result");
-            return;
-        }
-
-        for ([[maybe_unused]] const auto _ : state)
-        {
-            benchmark::DoNotOptimize(projectile);
-            benchmark::DoNotOptimize(target);
-            auto result = engine.maybe_calculate_aim_point(projectile, target);
-            benchmark::DoNotOptimize(result);
-        }
-    }
-
-    void projectile_prediction_near_static_hit(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {3.f, 2.f, 1.f}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f},
-                .target = {.m_origin = {100.f, 0.f, 90.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 400.f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 50.f,
-                .distance_tolerance = 5.f,
-                .expects_solution = true,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_moving_hit(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 3000.f, .m_gravity_scale = 1.f},
-                .target = {.m_origin = {500.f, 100.f, 0.f}, .m_velocity = {-50.f, 20.f, 0.f}, .m_is_airborne = false},
-                .gravity = 800.f,
-                .simulation_time_step = 1.f / 500.f,
-                .maximum_simulation_time = 30.f,
-                .distance_tolerance = 10.f,
-                .expects_solution = true,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_unreachable_full_scan(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 1.f, .m_gravity_scale = 1.f},
-                .target = {.m_origin = {100'000.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 9.81f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 2.f,
-                .distance_tolerance = 5.f,
-                .expects_solution = false,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_receding_full_scan(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 100.f, .m_gravity_scale = 0.f},
-                .target = {.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {200.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 9.81f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 2.f,
-                .distance_tolerance = 0.01f,
-                .expects_solution = false,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-} // namespace
-
-BENCHMARK(projectile_prediction_near_static_hit);
-BENCHMARK(projectile_prediction_moving_hit);
-BENCHMARK(projectile_prediction_unreachable_full_scan);
-BENCHMARK(projectile_prediction_receding_full_scan);

include/omath/engines/source_engine/traits/pred_engine_trait.hpp

@@ -6,8 +6,6 @@
 #include "omath/engines/source_engine/formulas.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
-#include <cmath>
-#include <limits>
 #include <optional>
 
 namespace omath::source_engine
@@ -16,58 +14,19 @@ namespace omath::source_engine
     {
     public:
         [[nodiscard("projectile position result should not be discarded")]]
-        constexpr static Vector3<float>
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
-        predict_projectile_position(const projectile_prediction::Projectile<float>& projectile, const float pitch,
+                                                                    const float pitch, const float yaw,
-                                    const float yaw, const float time, const float gravity) noexcept
+                                                                    const float time, const float gravity) noexcept
         {
             const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            const auto pitch_angle = PitchAngle::from_degrees(-pitch);
+            auto current_pos = launch_pos
-            const auto yaw_angle = YawAngle::from_degrees(yaw);
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
-            const auto pitch_cos = pitch_angle.cos();
+                                                 RollAngle::from_degrees(0)})
-            // Roll is always zero here, so this is the exact first column of the rotation matrix.
+                                         * projectile.m_launch_speed * time;
-            const Vector3 forward{pitch_cos * yaw_angle.cos(), pitch_cos * yaw_angle.sin(), -pitch_angle.sin()};
-            auto current_pos = launch_pos + forward * projectile.m_launch_speed * time;
             current_pos.z -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
 
             return current_pos;
         }
-
-        [[nodiscard("reachability result should not be discarded")]]
-        static constexpr bool
-        can_projectile_reach_target_at_time(const projectile_prediction::Projectile<float>& projectile,
-                                            const Vector3<float>& target_position, const float time,
-                                            const float gravity, const float distance_tolerance) noexcept
-        {
-            if (!(distance_tolerance >= 0.f))
-                return false;
-
-            // After undoing gravity, every possible projectile position is on a sphere with radius speed * time.
-            const auto launch_position = projectile.m_origin + projectile.m_launch_offset;
-            auto adjusted_delta = target_position - launch_position;
-            const auto gravity_displacement = (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
-            adjusted_delta.z += gravity_displacement;
-
-            const auto target_distance_sqr = adjusted_delta.length_sqr();
-            const auto projectile_distance = std::abs(projectile.m_launch_speed * time);
-            const auto floating_point_margin =
-                    std::numeric_limits<float>::epsilon() * 8.f
-                    * (std::abs(target_position.x) + std::abs(target_position.y) + std::abs(target_position.z)
-                       + std::abs(launch_position.x) + std::abs(launch_position.y) + std::abs(launch_position.z)
-                       + std::abs(gravity_displacement) + projectile_distance + distance_tolerance + 1.f);
-
-            if (!std::isfinite(target_distance_sqr) || !std::isfinite(floating_point_margin)) [[unlikely]]
-                return true;
-
-            const auto conservative_tolerance = distance_tolerance + floating_point_margin;
-            const auto maximum_distance = projectile_distance + conservative_tolerance;
-            if (target_distance_sqr > maximum_distance * maximum_distance)
-                return false;
-
-            const auto minimum_distance =
-                    projectile_distance > conservative_tolerance ? projectile_distance - conservative_tolerance : 0.f;
-            return target_distance_sqr >= minimum_distance * minimum_distance;
-        }
-
         [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept

include/omath/hashing.hpp

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <string_view>
+
+namespace omath::hashing
+{
+    enum class Base64Error
+    {
+        INVALID_LENGTH,
+        INVALID_CHARACTER,
+        INVALID_PADDING
+    };
+
+    [[nodiscard("FNV-1a hash result should not be discarded")]]
+    constexpr std::uint64_t fnv1a(const std::string_view value) noexcept
+    {
+        std::uint64_t hash = 14695981039346656037ULL;
+
+        for (const char character : value)
+        {
+            hash ^= static_cast<std::uint8_t>(character);
+            hash *= 1099511628211ULL;
+        }
+
+        return hash;
+    }
+
+    [[nodiscard("CRC-32 checksum result should not be discarded")]]
+    constexpr std::uint32_t crc32(const std::string_view value) noexcept
+    {
+        std::uint32_t crc = 0xFFFFFFFFU;
+
+        for (const char character : value)
+        {
+            crc ^= static_cast<std::uint8_t>(character);
+
+            for (int bit = 0; bit < 8; bit++)
+            {
+                crc = crc & 1U ? (crc >> 1U) ^ 0xEDB88320U : crc >> 1U;
+            }
+        }
+
+        return crc ^ 0xFFFFFFFFU;
+    }
+
+    [[nodiscard("Base64 encoding result should not be discarded")]]
+    constexpr std::string base64_encode(const std::string_view value)
+    {
+        constexpr std::string_view alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+        std::string result;
+        result.reserve((value.size() + 2) / 3 * 4);
+
+        for (std::size_t index = 0; index < value.size(); index += 3)
+        {
+            const std::uint32_t first = static_cast<std::uint8_t>(value[index]);
+            const std::uint32_t second = index + 1 < value.size() ? static_cast<std::uint8_t>(value[index + 1]) : 0;
+            const std::uint32_t third = index + 2 < value.size() ? static_cast<std::uint8_t>(value[index + 2]) : 0;
+            const std::uint32_t chunk = first << 16U | second << 8U | third;
+
+            result += alphabet[(chunk >> 18U) & 0x3FU];
+            result += alphabet[(chunk >> 12U) & 0x3FU];
+            result += index + 1 < value.size() ? alphabet[(chunk >> 6U) & 0x3FU] : '=';
+            result += index + 2 < value.size() ? alphabet[chunk & 0x3FU] : '=';
+        }
+
+        return result;
+    }
+
+    [[nodiscard("Base64 decoding result should not be discarded")]]
+    constexpr std::expected<std::string, Base64Error> base64_decode(const std::string_view value)
+    {
+        if (value.size() % 4 != 0)
+            return std::unexpected(Base64Error::INVALID_LENGTH);
+
+        std::string result;
+        result.reserve(value.size() / 4 * 3);
+
+        for (std::size_t index = 0; index < value.size(); index += 4)
+        {
+            const auto decode_character = [](const char character) constexpr -> int
+            {
+                if (character >= 'A' && character <= 'Z')
+                    return character - 'A';
+                if (character >= 'a' && character <= 'z')
+                    return character - 'a' + 26;
+                if (character >= '0' && character <= '9')
+                    return character - '0' + 52;
+                if (character == '+')
+                    return 62;
+                if (character == '/')
+                    return 63;
+
+                return -1;
+            };
+
+            const bool is_last_chunk = index + 4 == value.size();
+            const int first = decode_character(value[index]);
+            const int second = decode_character(value[index + 1]);
+            const int third = value[index + 2] == '=' ? -2 : decode_character(value[index + 2]);
+            const int fourth = value[index + 3] == '=' ? -2 : decode_character(value[index + 3]);
+
+            if (first < 0 || second < 0 || third == -1 || fourth == -1)
+                return std::unexpected(Base64Error::INVALID_CHARACTER);
+            if (third == -2)
+            {
+                if (fourth != -2 || !is_last_chunk || (second & 0x0F) != 0)
+                    return std::unexpected(Base64Error::INVALID_PADDING);
+            }
+            else if (fourth == -2 && (!is_last_chunk || (third & 0x03) != 0))
+                return std::unexpected(Base64Error::INVALID_PADDING);
+
+            const std::uint32_t chunk = static_cast<std::uint32_t>(first) << 18U
+                                        | static_cast<std::uint32_t>(second) << 12U
+                                        | static_cast<std::uint32_t>(third < 0 ? 0 : third) << 6U
+                                        | static_cast<std::uint32_t>(fourth < 0 ? 0 : fourth);
+
+            result += static_cast<char>(chunk >> 16U);
+            if (third >= 0)
+                result += static_cast<char>(chunk >> 8U);
+            if (fourth >= 0)
+                result += static_cast<char>(chunk);
+        }
+
+        return result;
+    }
+} // namespace omath::hashing

include/omath/omath.hpp

@@ -6,6 +6,7 @@
 #pragma once
 
 // Basic math utilities
+#include "omath/hashing.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include "omath/trigonometry/angle.hpp"
 

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -9,7 +9,6 @@
 #include "omath/projectile_prediction/proj_pred_engine.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
-#include <cmath>
 #include <optional>
 
 namespace omath::projectile_prediction
@@ -18,8 +17,9 @@ namespace omath::projectile_prediction
     concept PredEngineConcept =
             requires(const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target,
                      const Vector3<ArithmeticType>& vec_a, const Vector3<ArithmeticType>& vec_b,
-                     Vector3<ArithmeticType> v3, ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time,
+                     Vector3<ArithmeticType> v3,
-                     ArithmeticType gravity, std::optional<ArithmeticType> maybe_pitch) {
+                     ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time, ArithmeticType gravity,
+                     std::optional<ArithmeticType> maybe_pitch) {
                 {
                     T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
                 } -> std::same_as<Vector3<ArithmeticType>>;
@@ -44,7 +44,8 @@ namespace omath::projectile_prediction
     class ProjPredEngineLegacy final : public ProjPredEngineInterface<ArithmeticType>
     {
     public:
-        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant, const ArithmeticType simulation_time_step,
+        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant,
+                                      const ArithmeticType simulation_time_step,
                                       const ArithmeticType maximum_simulation_time,
                                       const ArithmeticType distance_tolerance)
             : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
@@ -53,9 +54,8 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<Vector3<ArithmeticType>>
+        std::optional<Vector3<ArithmeticType>> maybe_calculate_aim_point(
-        maybe_calculate_aim_point(const Projectile<ArithmeticType>& projectile,
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
-                                  const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
@@ -66,16 +66,15 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<AimAngles<ArithmeticType>>
+        std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
-        maybe_calculate_aim_angles(const Projectile<ArithmeticType>& projectile,
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
-                                   const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
                 return std::nullopt;
 
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset,
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
-                                                                solution->predicted_target_position);
+                projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
             return AimAngles<ArithmeticType>{solution->pitch, yaw};
         }
 
@@ -90,39 +89,23 @@ namespace omath::projectile_prediction
         std::optional<Solution> find_solution(const Projectile<ArithmeticType>& projectile,
                                               const Target<ArithmeticType>& target) const
         {
-            if (!std::isfinite(m_simulation_time_step) || m_simulation_time_step <= ArithmeticType{0}
+            for (ArithmeticType time = ArithmeticType{0}; time < m_maximum_simulation_time;
-                || !std::isfinite(m_maximum_simulation_time) || m_maximum_simulation_time < ArithmeticType{0}
+                 time += m_simulation_time_step)
-                || !std::isfinite(projectile.m_launch_speed) || projectile.m_launch_speed <= ArithmeticType{0}
-                || !(m_distance_tolerance >= ArithmeticType{0})) [[unlikely]]
-                return std::nullopt;
-
-            for (ArithmeticType time = ArithmeticType{0}; time <= m_maximum_simulation_time;)
             {
                 const auto predicted_target_position =
                         EngineTrait::predict_target_position(target, time, m_gravity_constant);
 
-                if (is_target_potentially_reachable(projectile, predicted_target_position, time))
+                const auto projectile_pitch =
-                {
+                        maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
-                    const auto projectile_pitch =
-                            maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
 
-                    if (projectile_pitch.has_value()) [[likely]]
+                if (!projectile_pitch.has_value()) [[unlikely]]
-                    {
+                    continue;
-                        const auto yaw = EngineTrait::calc_direct_yaw_angle(
-                                projectile.m_origin + projectile.m_launch_offset, predicted_target_position);
 
-                        if (is_projectile_reached_target(predicted_target_position, projectile,
+                if (!is_projectile_reached_target(predicted_target_position, projectile, projectile_pitch.value(),
-                                                         projectile_pitch.value(), yaw, time))
+                                                  time))
-                            return Solution{predicted_target_position, projectile_pitch.value()};
+                    continue;
-                    }
-                }
 
-                if (time == m_maximum_simulation_time)
+                return Solution{predicted_target_position, projectile_pitch.value()};
-                    break;
-                const auto next_time = time + m_simulation_time_step;
-                if (!(next_time > time)) [[unlikely]]
-                    break;
-                time = next_time < m_maximum_simulation_time ? next_time : m_maximum_simulation_time;
             }
             return std::nullopt;
         }
@@ -161,46 +144,29 @@ namespace omath::projectile_prediction
             const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
             const auto distance2d_sqr = distance2d * distance2d;
             const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
-            const auto ballistic_term =
-                    bullet_gravity * distance2d_sqr
-                    + ArithmeticType{2} * EngineTrait::get_vector_height_coordinate(delta) * launch_speed_sqr;
 
-            ArithmeticType root = launch_speed_sqr * launch_speed_sqr - bullet_gravity * ballistic_term;
+            ArithmeticType root = launch_speed_sqr * launch_speed_sqr
+                                  - bullet_gravity
+                                            * (bullet_gravity * distance2d_sqr
+                                               + ArithmeticType{2} * EngineTrait::get_vector_height_coordinate(delta)
+                                                         * launch_speed_sqr);
 
             if (root < ArithmeticType{0}) [[unlikely]]
                 return std::nullopt;
 
             root = std::sqrt(root);
-            // This rationalized form avoids cancellation in launch_speed_sqr - root for low-angle shots.
+            const ArithmeticType angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
-            const ArithmeticType angle = std::atan2(ballistic_term, distance2d * (launch_speed_sqr + root));
 
             return angles::radians_to_degrees(angle);
         }
 
-        [[nodiscard]]
-        bool is_target_potentially_reachable(const Projectile<ArithmeticType>& projectile,
-                                             const Vector3<ArithmeticType>& target_position,
-                                             const ArithmeticType time) const noexcept
-        {
-            if constexpr (requires {
-                              {
-                                  EngineTrait::can_projectile_reach_target_at_time(
-                                          projectile, target_position, time, m_gravity_constant, m_distance_tolerance)
-                              } -> std::same_as<bool>;
-                              requires noexcept(EngineTrait::can_projectile_reach_target_at_time(
-                                      projectile, target_position, time, m_gravity_constant, m_distance_tolerance));
-                          })
-                return EngineTrait::can_projectile_reach_target_at_time(projectile, target_position, time,
-                                                                        m_gravity_constant, m_distance_tolerance);
-
-            return true;
-        }
-
         [[nodiscard]]
         bool is_projectile_reached_target(const Vector3<ArithmeticType>& target_position,
-                                          const Projectile<ArithmeticType>& projectile, const ArithmeticType pitch,
+                                          const Projectile<ArithmeticType>& projectile,
-                                          const ArithmeticType yaw, const ArithmeticType time) const noexcept
+                                          const ArithmeticType pitch, const ArithmeticType time) const noexcept
         {
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
+                projectile.m_origin + projectile.m_launch_offset, target_position);
             const auto projectile_position =
                     EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
 

tests/general/unit_test_hashing.cpp

@@ -0,0 +1,34 @@
+#include <gtest/gtest.h>
+#include <omath/hashing.hpp>
+
+TEST(unit_test_hashing, fnv1a)
+{
+    constexpr auto hash = omath::hashing::fnv1a("hello");
+
+    static_assert(hash == 0xA430D84680AABD0BULL);
+    EXPECT_EQ(hash, 0xA430D84680AABD0BULL);
+}
+
+TEST(unit_test_hashing, crc32)
+{
+    constexpr auto crc = omath::hashing::crc32("123456789");
+
+    static_assert(crc == 0xCBF43926U);
+    EXPECT_EQ(crc, 0xCBF43926U);
+}
+
+TEST(unit_test_hashing, base64_encode)
+{
+    static_assert(omath::hashing::base64_encode("foo") == "Zm9v");
+    EXPECT_EQ(omath::hashing::base64_encode("foobar"), "Zm9vYmFy");
+}
+
+TEST(unit_test_hashing, base64_decode)
+{
+    static_assert(omath::hashing::base64_decode("Zm9v").has_value());
+    static_assert(omath::hashing::base64_decode("Zm9v").value() == "foo");
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9vYmFy").value(), "foobar");
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9v=").error(), omath::hashing::Base64Error::INVALID_LENGTH);
+    EXPECT_EQ(omath::hashing::base64_decode("Zm?v").error(), omath::hashing::Base64Error::INVALID_CHARACTER);
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9=").error(), omath::hashing::Base64Error::INVALID_PADDING);
+}

tests/general/unit_test_pred_engine_trait.cpp

@@ -1,5 +1,4 @@
 // Tests for PredEngineTrait
-#include <array>
 #include <gtest/gtest.h>
 #include <omath/engines/source_engine/traits/pred_engine_trait.hpp>
 #include <omath/projectile_prediction/projectile.hpp>
@@ -78,77 +77,6 @@ TEST(PredEngineTrait, PredictProjectilePositionWithLaunchOffset)
     EXPECT_NEAR(pos_t1.z, -2.f - 9.81f * 0.5f, 1e-3f);
 }
 
-TEST(PredEngineTrait, PredictProjectilePositionMatchesRotationMatrix)
-{
-    constexpr Projectile projectile{
-            .m_origin = {10.f, -20.f, 30.f},
-            .m_launch_offset = {2.f, 3.f, -4.f},
-            .m_launch_speed = 750.f,
-            .m_gravity_scale = 0.6f,
-    };
-    struct TestCase
-    {
-        float pitch;
-        float yaw;
-        float time;
-    };
-    constexpr std::array test_cases{
-            TestCase{0.f, 0.f, 0.f},
-            TestCase{25.f, 45.f, 0.25f},
-            TestCase{-60.f, -135.f, 1.5f},
-            TestCase{120.f, 540.f, 2.f},
-    };
-    constexpr float gravity = 9.81f;
-
-    for (const auto& test_case : test_cases)
-    {
-        const auto launch_position = projectile.m_origin + projectile.m_launch_offset;
-        auto expected_position = launch_position
-                                 + forward_vector({PitchAngle::from_degrees(-test_case.pitch),
-                                                   YawAngle::from_degrees(test_case.yaw), RollAngle::from_degrees(0.f)})
-                                           * projectile.m_launch_speed * test_case.time;
-        expected_position.z -= gravity * projectile.m_gravity_scale * test_case.time * test_case.time * 0.5f;
-
-        const auto actual_position = PredEngineTrait::predict_projectile_position(
-                projectile, test_case.pitch, test_case.yaw, test_case.time, gravity);
-
-        EXPECT_NEAR(actual_position.x, expected_position.x, 1e-5f);
-        EXPECT_NEAR(actual_position.y, expected_position.y, 1e-5f);
-        EXPECT_NEAR(actual_position.z, expected_position.z, 1e-5f);
-    }
-}
-
-TEST(PredEngineTrait, ReachabilityCheckUsesDistanceTolerance)
-{
-    constexpr Projectile projectile{
-            .m_origin = {0.f, 0.f, 0.f},
-            .m_launch_speed = 100.f,
-            .m_gravity_scale = 0.f,
-    };
-
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {100.f, 0.f, 0.f}, 0.5f, 9.81f, 0.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {100.f, 0.f, 0.f}, 1.f, 9.81f, 0.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {101.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {99.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {101.f, 0.f, 0.f}, 1.f, 9.81f, 0.f));
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {98.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-}
-
-TEST(PredEngineTrait, ReachabilityCheckIncludesFloatingPointError)
-{
-    constexpr Projectile projectile{
-            .m_origin = {1.f, 2.f, 3.f},
-            .m_launch_offset = {0.1f, -0.2f, 0.3f},
-            .m_launch_speed = 100.f,
-            .m_gravity_scale = 1.f,
-    };
-    constexpr float gravity = 9.81f;
-    constexpr float time = 0.3f;
-    const auto target_position = PredEngineTrait::predict_projectile_position(projectile, 25.f, 45.f, time, gravity);
-
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, target_position, time, gravity, 0.f));
-}
-
 TEST(PredEngineTrait, ZeroLaunchOffsetMatchesOriginalBehavior)
 {
     Projectile p;

tests/general/unit_test_proj_pred_engine_legacy_more.cpp

@@ -1,5 +1,4 @@
 #include <gtest/gtest.h>
-#include <limits>
 #include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
 #include <omath/projectile_prediction/projectile.hpp>
 #include <omath/projectile_prediction/target.hpp>
@@ -16,45 +15,25 @@ struct FakeEngineZeroGravity
     {
         return t.m_origin;
     }
-    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/,
+    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/, float /*time*/, float /*gravity*/) noexcept
-                                                      float /*time*/, float /*gravity*/) noexcept
     {
         // Return a fixed point matching typical target used in the test
         return Vector3<float>{100.f, 0.f, 0.f};
     }
-    static float calc_vector_2d_distance(const Vector3<float>& v) noexcept
+    static float calc_vector_2d_distance(const Vector3<float>& v) noexcept { return std::hypot(v.x, v.y); }
-    {
+    static float get_vector_height_coordinate(const Vector3<float>& v) noexcept { return v.z; }
-        return std::hypot(v.x, v.y);
+    static Vector3<float> calc_viewpoint_from_angles(const Projectile& /*p*/, Vector3<float> /*v*/, std::optional<float> /*maybe_pitch*/) noexcept
-    }
-    static float get_vector_height_coordinate(const Vector3<float>& v) noexcept
-    {
-        return v.z;
-    }
-    static Vector3<float> calc_viewpoint_from_angles(const Projectile& /*p*/, Vector3<float> /*v*/,
-                                                     std::optional<float> /*maybe_pitch*/) noexcept
     {
         return Vector3<float>{1.f, 2.f, 3.f};
     }
-    static float calc_direct_pitch_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept
+    static float calc_direct_pitch_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept { return 12.5f; }
-    {
+    static float calc_direct_yaw_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept { return 0.f; }
-        return 12.5f;
-    }
-    static float calc_direct_yaw_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept
-    {
-        return 0.f;
-    }
-    static bool can_projectile_reach_target_at_time(const Projectile& /*projectile*/,
-                                                    const Vector3<float>& /*target_position*/, float /*time*/,
-                                                    float /*gravity*/, float /*distance_tolerance*/)
-    {
-        return false;
-    }
 };
 
 TEST(ProjPredLegacyMore, ZeroGravityUsesDirectPitchAndReturnsViewpoint)
 {
-    constexpr Projectile proj{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
+    constexpr Projectile proj{ .m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f };
-    constexpr Target target{.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
+    constexpr Target target{ .m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f,0.f,0.f}, .m_is_airborne = false };
 
     using Engine = omath::projectile_prediction::ProjPredEngineLegacy<FakeEngineZeroGravity>;
     const Engine engine(9.8f, 0.1f, 5.f, 1e-3f);
@@ -138,77 +117,3 @@ TEST(ProjPredLegacyMore, AngleComputedButMissReturnsNullopt)
     const auto res = engine.maybe_calculate_aim_point(proj, target);
     EXPECT_FALSE(res.has_value());
 }
-
-TEST(ProjPredLegacyMore, IncludesMaximumSimulationTime)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {10.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(0.f, 0.1f, 1.f, 0.f);
-
-    const auto result = engine.maybe_calculate_aim_point(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_NEAR(result->x, target.m_origin.x, 1e-6f);
-    EXPECT_NEAR(result->y, target.m_origin.y, 1e-6f);
-    EXPECT_NEAR(result->z, target.m_origin.z, 1e-6f);
-}
-
-TEST(ProjPredLegacyMore, RejectsInvalidSimulationSteps)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {10.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.f, 1.f, 1.f)
-                         .maybe_calculate_aim_point(projectile, target));
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, -0.1f, 1.f, 1.f)
-                         .maybe_calculate_aim_point(projectile, target));
-    EXPECT_FALSE(
-            omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, std::numeric_limits<float>::infinity(), 1.f, 1.f)
-                    .maybe_calculate_aim_point(projectile, target));
-}
-
-TEST(ProjPredLegacyMore, RejectsInvalidProjectileSpeedAndTolerance)
-{
-    constexpr Target target{.m_origin = {1.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    constexpr Projectile stopped_projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 0.f, .m_gravity_scale = 0.f};
-    constexpr Projectile moving_projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.1f, 1.f, 2.f)
-                         .maybe_calculate_aim_point(stopped_projectile, target));
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.1f, 1.f, -1.f)
-                         .maybe_calculate_aim_point(moving_projectile, target));
-}
-
-TEST(ProjPredLegacyMore, StablePitchFindsHighSpeedLowArc)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10'000.f, .m_gravity_scale = 1.f};
-    constexpr Target target{.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(9.81f, 0.01f, 0.02f, 0.0001f);
-
-    const auto result = engine.maybe_calculate_aim_angles(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_GT(result->pitch, 0.f);
-    EXPECT_NEAR(result->yaw, 0.f, 1e-6f);
-}
-
-TEST(ProjPredLegacyMore, CoincidentTargetReturnsLaunchOrigin)
-{
-    constexpr Projectile projectile{.m_origin = {5.f, 4.f, 3.f}, .m_launch_speed = 100.f, .m_gravity_scale = 1.f};
-    constexpr Target target{.m_origin = projectile.m_origin, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(9.81f, 0.01f, 0.01f, 0.f);
-
-    const auto result = engine.maybe_calculate_aim_point(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result.value(), projectile.m_origin);
-}
-
-TEST(ProjPredLegacyMore, TinyDistanceDoesNotUnderflowToAHit)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 1.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {1e-30f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(0.f, 0.1f, 0.f, 0.f);
-
-    EXPECT_FALSE(engine.maybe_calculate_aim_point(projectile, target));
-}