idk man, I let it churn

tests/dGameTests/dPropertyBehaviorsTests/StripRotationIntegrationTest.cpp

@@ -0,0 +1,239 @@
+#define UNIT_TEST
+#include "GameDependencies.h"
+#include <gtest/gtest.h>
+
+#include "ModelComponent.h"
+#include "SimplePhysicsComponent.h"
+#include "Strip.h"
+#include "NiQuaternion.h"
+#include "NiPoint3.h"
+#include "dMath.h"
+
+using namespace std::literals;
+
+static float RemainingAngleDeg(const NiQuaternion& cur, const NiQuaternion& target) {
+    auto rem = cur.Diff(target);
+    float w = rem.w;
+    if (w < 0.0f) w = -w; // minimal quaternion
+    if (w > 1.0f) w = 1.0f;
+    return 2.0f * std::acos(w) * (180.0f / 3.14159265358979323846f);
+}
+
+// Test accessor must be global to match friend declaration in Strip.h
+#ifdef UNIT_TEST
+struct StripTestAccessor { static void InitRotation(Strip& s, const NiQuaternion& prev, const NiQuaternion& targ) {
+    s.m_IsRotating = true;
+    s.m_PreviousFrameRotation = prev;
+    s.m_RotationTarget = targ;
+}};
+#else
+struct StripTestAccessor { static void InitRotation(Strip&, const NiQuaternion&, const NiQuaternion&) {} };
+#endif
+
+// Integration-style harness: instantiate Entity+Components, set up a Strip rotation, step SimplePhysicsComponent and call Strip::CheckRotation
+TEST_F(GameDependenciesTest, SimulateStripRotationNoOvershoot) {
+    // Inline a lightweight dependency setup here to avoid loading CDClient defaults which
+    // attempt database access in this unit test environment.
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    info.scale = 1.0f;
+    info.spawner = nullptr;
+    info.lot = 999;
+    Game::logger = new Logger("./testing.log", true, true);
+    Game::server = new dServerMock();
+    Game::config = new dConfig("worldconfig.ini");
+    Game::entityManager = new EntityManager();
+    Game::zoneManager = new dZoneManager();
+    Database::_setDatabase(new TestSQLDatabase());
+    // Ensure CD client defaults are present so Entity initialization doesn't hit the DB
+    CDClientManager::LoadValuesFromDefaults();
+    Game::zoneManager->LoadZone(LWOZONEID(1, 0, 0));
+    // Build a minimal EntityInfo and Entity
+    EntityInfo info;
+    info.lot = 0;
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    Entity* entity = Game::entityManager->CreateEntity(info, nullptr, nullptr);
+
+    // Attach ModelComponent and SimplePhysicsComponent
+    auto* model = entity->AddComponent<ModelComponent>();
+    auto* phys = entity->AddComponent<SimplePhysicsComponent>(0);
+
+    // Prepare a Strip and configure it as if an action started: previous rotation and a 90deg XYZ delta target
+    Strip strip;
+    NiQuaternion previous = NiQuaternionConstant::IDENTITY;
+    NiPoint3 deltaDeg{90.0f, 90.0f, 90.0f};
+    NiPoint3 deltaRad = NiPoint3{deltaDeg.x, deltaDeg.y, deltaDeg.z} * (3.14159265f / 180.0f);
+    NiQuaternion deltaQ = NiQuaternion::FromEulerAngles(deltaRad);
+    NiQuaternion target = previous * deltaQ;
+
+    StripTestAccessor::InitRotation(strip, previous, target);
+
+    // Set entity rotation to previous
+    entity->SetRotation(previous);
+
+    // Simulate applying the delta in one frame by setting angular velocity so that Update will rotate the entity by deltaRad
+    // SimplePhysicsComponent applies rotation as FromEulerAngles(angularVelocity * dt)
+    float dt = 1.0f / 60.0f;
+    NiPoint3 requiredAngVel = NiPoint3{deltaRad.x / dt, deltaRad.y / dt, deltaRad.z / dt};
+    phys->SetAngularVelocity(requiredAngVel);
+
+    // Step physics once
+    phys->Update(dt);
+
+    // Now call Strip::CheckRotation which should observe the entity's rotation and snap because remaining <= EPS
+    bool finished = strip.CheckRotation(dt, *model);
+    EXPECT_TRUE(finished);
+
+    // Verify final rotation was snapped to exactly target
+    auto finalRot = entity->GetRotation();
+    float rem = RemainingAngleDeg(finalRot, target);
+    EXPECT_LE(rem, 0.2f);
+
+    TearDownDependencies();
+}
+
+// Multi-frame rotation: apply a 90deg X rotation over many frames and ensure no overshoot
+TEST_F(GameDependenciesTest, MultiFrameRotation_NoOvershoot) {
+    // Inline setup as above (avoid CDClientManager DB access)
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    info.scale = 1.0f;
+    info.spawner = nullptr;
+    info.lot = 999;
+    Game::logger = new Logger("./testing.log", true, true);
+    Game::server = new dServerMock();
+    Game::config = new dConfig("worldconfig.ini");
+    Game::entityManager = new EntityManager();
+    Game::zoneManager = new dZoneManager();
+    Database::_setDatabase(new TestSQLDatabase());
+    CDClientManager::LoadValuesFromDefaults();
+    Game::zoneManager->LoadZone(LWOZONEID(1, 0, 0));
+
+    EntityInfo info;
+    info.lot = 0;
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    Entity* entity = Game::entityManager->CreateEntity(info, nullptr, nullptr);
+
+    auto* model = entity->AddComponent<ModelComponent>();
+    auto* phys = entity->AddComponent<SimplePhysicsComponent>(0);
+
+    Strip strip;
+    NiQuaternion previous = NiQuaternionConstant::IDENTITY;
+    NiPoint3 deltaDeg{90.0f, 0.0f, 0.0f};
+    NiPoint3 deltaRad = NiPoint3{deltaDeg.x, deltaDeg.y, deltaDeg.z} * (3.14159265f / 180.0f);
+    NiQuaternion target = previous * NiQuaternion::FromEulerAngles(deltaRad);
+
+    StripTestAccessor::InitRotation(strip, previous, target);
+    entity->SetRotation(previous);
+
+    // Use a moderate angular velocity: 30 deg/s -> 0.5235987756 rad/s
+    const float angVelRad = Math::DegToRad(30.0f);
+    const float dt = 1.0f / 60.0f;
+
+    // Set angular velocity on physics component (rad/s)
+    phys->SetAngularVelocity(NiPoint3{angVelRad, 0.0f, 0.0f});
+
+    float initialRem = RemainingAngleDeg(previous, target);
+    float maxRem = initialRem;
+    const int maxFrames = 10000;
+    bool finished = false;
+
+    for (int i = 0; i < maxFrames; ++i) {
+    phys->Update(dt);
+    float rem = RemainingAngleDeg(entity->GetRotation(), target);
+        if (rem > maxRem) maxRem = rem;
+        if (strip.CheckRotation(dt, *model)) { finished = true; break; }
+    }
+
+    EXPECT_TRUE(finished);
+    float finalRem = RemainingAngleDeg(entity->GetRotation(), target);
+    EXPECT_LE(finalRem, 0.2f);
+    EXPECT_LE(maxRem, initialRem + 1.0f);
+
+    TearDownDependencies();
+}
+
+// Multi-axis multi-frame rotation: apply 90deg on X/Y/Z over several frames
+TEST_F(GameDependenciesTest, MultiFrame_MultiAxis_NoOvershoot) {
+    // Inline setup as above (avoid CDClientManager DB access)
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    info.scale = 1.0f;
+    info.spawner = nullptr;
+    info.lot = 999;
+    Game::logger = new Logger("./testing.log", true, true);
+    Game::server = new dServerMock();
+    Game::config = new dConfig("worldconfig.ini");
+    Game::entityManager = new EntityManager();
+    Game::zoneManager = new dZoneManager();
+    Database::_setDatabase(new TestSQLDatabase());
+    CDClientManager::LoadValuesFromDefaults();
+    Game::zoneManager->LoadZone(LWOZONEID(1, 0, 0));
+
+    EntityInfo info;
+    info.lot = 0;
+    info.pos = NiPoint3Constant::ZERO;
+    info.rot = NiQuaternionConstant::IDENTITY;
+    Entity* entity = Game::entityManager->CreateEntity(info, nullptr, nullptr);
+
+    auto* model = entity->AddComponent<ModelComponent>();
+    auto* phys = entity->AddComponent<SimplePhysicsComponent>(0);
+
+    Strip strip;
+    NiQuaternion previous = NiQuaternionConstant::IDENTITY;
+    NiPoint3 deltaDeg{90.0f, 90.0f, 90.0f};
+    NiPoint3 deltaRad = NiPoint3{deltaDeg.x, deltaDeg.y, deltaDeg.z} * (3.14159265f / 180.0f);
+    NiQuaternion target = previous * NiQuaternion::FromEulerAngles(deltaRad);
+
+    StripTestAccessor::InitRotation(strip, previous, target);
+    entity->SetRotation(previous);
+
+    // Perform the multi-axis rotation as three sequential single-axis actions (X, then Y, then Z)
+    const float angVelRad = Math::DegToRad(15.0f);
+    const float dt = 1.0f / 60.0f;
+
+    float initialRem = RemainingAngleDeg(previous, target);
+    float maxRem = initialRem;
+    const int maxFramesPerAxis = 10000;
+
+    NiQuaternion currentPrev = previous;
+    bool allFinished = true;
+
+    // helper to run one axis rotation
+    auto runAxis = [&](const NiPoint3& axisVel, const NiQuaternion& axisTarget) -> bool {
+        phys->SetAngularVelocity(axisVel);
+        for (int i = 0; i < maxFramesPerAxis; ++i) {
+        phys->Update(dt);
+        float rem = RemainingAngleDeg(entity->GetRotation(), axisTarget);
+            if (rem > maxRem) maxRem = rem;
+            if (strip.CheckRotation(dt, *model)) return true;
+        }
+        return false;
+    };
+
+    // X axis (90 deg)
+    NiQuaternion targetX = currentPrev * NiQuaternion::FromEulerAngles(NiPoint3{Math::DegToRad(90.0f), 0.0f, 0.0f});
+    StripTestAccessor::InitRotation(strip, currentPrev, targetX);
+    if (!runAxis(NiPoint3{angVelRad, 0.0f, 0.0f}, targetX)) allFinished = false;
+    currentPrev = entity->GetRotation();
+
+    // Y axis (90 deg)
+    NiQuaternion targetY = currentPrev * NiQuaternion::FromEulerAngles(NiPoint3{0.0f, Math::DegToRad(90.0f), 0.0f});
+    StripTestAccessor::InitRotation(strip, currentPrev, targetY);
+    if (!runAxis(NiPoint3{0.0f, angVelRad, 0.0f}, targetY)) allFinished = false;
+    currentPrev = entity->GetRotation();
+
+    // Z axis (90 deg)
+    NiQuaternion targetZ = currentPrev * NiQuaternion::FromEulerAngles(NiPoint3{0.0f, 0.0f, Math::DegToRad(90.0f)});
+    StripTestAccessor::InitRotation(strip, currentPrev, targetZ);
+    if (!runAxis(NiPoint3{0.0f, 0.0f, angVelRad}, targetZ)) allFinished = false;
+
+    EXPECT_TRUE(allFinished);
+    float finalRem = RemainingAngleDeg(entity->GetRotation(), targetZ);
+    EXPECT_LE(finalRem, 0.2f);
+    EXPECT_LE(maxRem, initialRem + 2.0f); // multi-axis sequential should still be bounded
+
+    TearDownDependencies();
+}