Merge pull request #6 from DanjelPiDev/feature/dw-link

Feature/dw link

Author: DanjelPiDev

CMakeLists.txt

@@ -6,7 +6,7 @@ message("Using toolchain file ${CMAKE_TOOLCHAIN_FILE}.")
 ########################################################################################################################
 project(
     DynamicSpeedController 
-    VERSION 1.5.0
+    VERSION 1.5.2
     DESCRIPTION "Skyrim Special Edition DSC."
     LANGUAGES CXX)
 

include/Settings.h

@@ -8,6 +8,7 @@
 
 struct Settings {
     enum class SmoothingMode { Exponential = 0, RateLimit = 1, ExpoThenRate = 2 };
+    enum class ScaleCompMode { Additive = 0, Inverse = 1 };
 
     // Slopes
     static inline std::atomic<bool> slopeEnabled{false};
@@ -47,6 +48,7 @@ struct Settings {
     static inline std::atomic<bool> scaleCompEnabled{false};
     static inline std::atomic<bool> scaleCompOnlyBelowOne{true};  // Only apply if player scale < 1.0
     static inline std::atomic<float> scaleCompPerUnitSM{120.0f};
+    static inline ScaleCompMode scaleCompMode{ScaleCompMode::Additive};
 
     static inline std::atomic<float> reduceOutOfCombat{45.0f};
     static inline std::atomic<float> reduceJoggingOutOfCombat{15.0f};
@@ -112,6 +114,16 @@ struct Settings {
     static inline std::atomic<float> magickaReducePct{15.0f};
     static inline std::atomic<float> magickaSmoothWidthPct{10.0f};
 
+    // DW (Dynamic Wetness) integration settings
+    static inline std::atomic<bool> dwEnabled{true};
+
+    static inline std::atomic<bool> dwSlopeFeatureEnabled{false};
+    static inline std::atomic<float> dwStartDeg{4.0f};
+    static inline std::atomic<float> dwFullDeg{16.0f};
+
+    static inline std::atomic<float> dwBuildUpPerSec{0.35f};
+    static inline std::atomic<float> dwDryPerSec{0.15f};
+
     // Location stuff
     static bool ParseFormSpec(const std::string& spec, std::string& plugin, std::uint32_t& id);
 

include/SpeedController.h

@@ -60,13 +60,21 @@ class SpeedController : public RE::BSTEventSink<RE::TESCombatEvent>,
     void ClearPathFor(RE::Actor* a);
     void PushPathSample(RE::Actor* a, const RE::NiPoint3& pos, uint64_t nowMs);
     bool ComputePathSlopeDeg(RE::Actor* a, float lookbackUnits, float maxAgeSec, float& outDeg);
+    void ClearScaleDeltaFor(RE::Actor* a);
+    bool UpdateScaleCompDelta(RE::Actor* a, float predictedNoScaleFinal);
+    float& ScaleDeltaSlot(RE::Actor* a);
 
     float diagResidualPlayer_ = 0.0f;
     std::unordered_map<std::uint32_t, float> diagResidualNPC_;
 
     float slopeResidualPlayer_ = 0.0f;
     std::unordered_map<std::uint32_t, float> slopeResidualNPC_;
 
+    float scaleResidualPlayer_ = 0.0f;
+    std::unordered_map<std::uint32_t, float> scaleResidualNPC_;
+    float scaleDeltaPlayer_ = 0.0f;
+    std::unordered_map<std::uint32_t, float> scaleDeltaNPC_;
+
     inline float& DiagResidualSlot(RE::Actor* a) {
         auto* pc = RE::PlayerCharacter::GetSingleton();
         if (a == pc) return diagResidualPlayer_;
@@ -77,6 +85,11 @@ class SpeedController : public RE::BSTEventSink<RE::TESCombatEvent>,
         if (a == pc) return slopeResidualPlayer_;
         return slopeResidualNPC_[a->GetFormID()];
     }
+    inline float& ScaleResidualSlot(RE::Actor* a) {
+        auto* pc = RE::PlayerCharacter::GetSingleton();
+        if (a == pc) return scaleResidualPlayer_;
+        return scaleResidualNPC_[a->GetFormID()];
+    }
 
 private:
     enum class MoveCase : std::uint8_t { Combat, Drawn, Sneak, Default };
@@ -196,6 +209,7 @@ class SpeedController : public RE::BSTEventSink<RE::TESCombatEvent>,
     void LoadToggleBindingFromJson();
 
     void StartHeartbeat();
+    void StopHeartbeat();
     void TryInitDrawnFromGraph();
 
     MoveCase ComputeCase(const RE::Actor* pc) const;

include/UI.h

@@ -13,6 +13,7 @@ namespace UI {
         void __stdcall RenderVitals();
         void __stdcall RenderLocations();
         void __stdcall RenderWeather();
+        void __stdcall RenderAddons();
 
         inline std::string saveIcon = FontAwesome::UnicodeToUtf8(0xf0c7) + " Save Settings";
 

src/Settings.cpp

@@ -149,7 +149,23 @@ bool Settings::SaveToJson(const std::filesystem::path& file) {
     j["kScaleCompEnabled"] = scaleCompEnabled.load();
     j["kScaleCompOnlyBelowOne"] = scaleCompOnlyBelowOne.load();
     j["kScaleCompPerUnitSM"] = scaleCompPerUnitSM.load();
+    switch (scaleCompMode) {
+        case ScaleCompMode::Inverse:
+            j["kScaleCompMode"] = "Inverse";
+            break;
+        case ScaleCompMode::Additive:
+        default:
+            j["kScaleCompMode"] = "Additive";
+            break;
+    }
 
+    j["kDwEnabled"] = dwEnabled.load();
+    j["kDwSlopeFeatureEnabled"] = dwSlopeFeatureEnabled.load();
+    j["kDwStartDeg"] = dwStartDeg.load();
+    j["kDwFullDeg"] = dwFullDeg.load();
+
+    j["kDwBuildUpPerSec"] = dwBuildUpPerSec.load();
+    j["kDwDryPerSec"] = dwDryPerSec.load();
 
     std::ofstream out(file);
     if (!out.is_open()) return false;
@@ -481,5 +497,39 @@ bool Settings::LoadFromJson(const std::filesystem::path& file) {
         scaleCompPerUnitSM = std::clamp(v, -300.0f, 300.0f);
     }
 
+    // DW (Dynamic Wetness) integration settings
+    if (j.contains("kDwEnabled")) {
+        dwEnabled = j["kDwEnabled"].get<bool>();
+    }
+    if (j.contains("kDwSlopeFeatureEnabled")) {
+        dwSlopeFeatureEnabled = j["kDwSlopeFeatureEnabled"].get<bool>();
+    }
+    if (j.contains("kDwStartDeg")) {
+        float v = j["kDwStartDeg"].get<float>();
+        dwStartDeg = std::clamp(v, 0.0f, dwFullDeg.load());
+    }
+    if (j.contains("kDwFullDeg")) {
+        float v = j["kDwFullDeg"].get<float>();
+        dwFullDeg = std::clamp(v, dwStartDeg.load(), 90.0f);
+    }
+    if (j.contains("kDwBuildUpPerSec")) {
+        float v = j["kDwBuildUpPerSec"].get<float>();
+        dwBuildUpPerSec = std::clamp(v, 0.0f, 20.0f);
+    }
+    if (j.contains("kDwDryPerSec")) {
+        float v = j["kDwDryPerSec"].get<float>();
+        dwDryPerSec = std::clamp(v, 0.0f, 20.0f);
+    }
+    if (j.contains("kScaleCompMode")) {
+        auto& m = j["kScaleCompMode"];
+        if (m.is_string()) {
+            std::string s = m.get<std::string>();
+            std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+            scaleCompMode = (s == "inverse") ? ScaleCompMode::Inverse : ScaleCompMode::Additive;
+        } else if (m.is_number_integer()) {
+            int v = m.get<int>();
+            scaleCompMode = (v == 1) ? ScaleCompMode::Inverse : ScaleCompMode::Additive;
+        }
+    }
     return true;
 }