Implement dynamic safe mode (#6)

* initial impl

* update optional api

* update workflow lol

* extra hook listener for good measure

* initial impl

* update optional api

* extra hook listener for good measure

* add cheat info

* adjust cheat options

Author: BlueWitherer

include/horrible/API.h

@@ -34,6 +34,8 @@ namespace horrible {
         geode::utils::StringMap<std::shared_ptr<Option>> m_options;  // Map of registered options
         std::vector<std::string> m_categories;                       // Array of auto-registered categories
 
+        std::unordered_map<std::string_view, std::weak_ptr<Option>> m_enabledCheats;  // Map of currently enabled cheat options, used for dynamic safe mode
+
         geode::utils::StringMap<const geode::Mod* const> m_integrations;  // Map of auto-registered external mods using this API
 
         std::unordered_map<std::string_view, std::vector<Callback>> m_delegates;  // Map of option ID to array of delegates to call when that option is toggled
@@ -91,6 +93,13 @@ namespace horrible {
          */
         void registerOption(std::shared_ptr<Option> option);
 
+        /**
+         * Check if a cheat option is currently enabled
+         *
+         * @returns Whether cheating is on
+         */
+        bool isCheatEnabled() const noexcept;
+
         /**
          * Returns a reference to the array of all registered options
          *
@@ -125,6 +134,15 @@ namespace horrible {
          */
         [[nodiscard]] bool isViewed(geode::ZStringView id) const;
 
+        /**
+         * Quickly check if an option is a cheat option
+         *
+         * @param id The ID of the option to check
+         *
+         * @returns Boolean of whether this option is a cheat or not
+         */
+        [[nodiscard]] bool isCheating(geode::ZStringView id) const;
+
         /**
          * Quickly check the default toggle state of an option
          *
@@ -161,6 +179,13 @@ namespace horrible {
          */
         [[nodiscard]] size_t getDelegateCount(std::string_view id) const noexcept;
 
+        /**
+         * Check if Safe Mode should be enabled based on the current state of options and settings
+         *
+         * @returns Whether Safe Mode should be enabled or not
+         */
+        [[nodiscard]] bool shouldBeSafeMode() const noexcept;
+
         /**
          * Set the toggle state of an option
          *

include/horrible/Events.hpp

@@ -13,6 +13,10 @@ namespace horrible {
         using ThreadSafeGlobalEvent::ThreadSafeGlobalEvent;
     };
 
+    struct OptionCheatingEvent final : public geode::Event<OptionEvent, bool(bool)> {
+        using Event::Event;
+    };
+
     inline geode::ListenerHandle* listenForHorribleOptionChanges(std::string id, geode::CopyableFunction<void(HorribleOptionSave)>&& callback) {
         return OptionEvent(std::move(id)).listen(std::move(callback)).leak();
     };

include/horrible/Option.hpp

@@ -39,6 +39,7 @@ namespace horrible {
         bool m_online = false;                                // If the option requires an active internet connection to work properly
         bool m_restart = false;                               // If the option requires a game restart to take effect
         std::vector<Platform> m_platforms = {Platform::All};  // Platforms that the option supports
+        bool m_isCheating = false;                            // If the option counts as cheating and will trigger dynamic safe mode
         const geode::Mod* const m_integration = nullptr;      // External mod that registered this option
 
     public:
@@ -60,6 +61,7 @@ namespace horrible {
         std::shared_ptr<Option> setOnline(bool online);
         std::shared_ptr<Option> setRequiresRestart(bool required);
         std::shared_ptr<Option> setSupportedPlatforms(std::vector<Platform> platforms);
+        std::shared_ptr<Option> setCheating(bool cheat);
 
         std::shared_ptr<Option> autoRegister();
 
@@ -72,6 +74,7 @@ namespace horrible {
         [[nodiscard]] bool isOnline() const noexcept;
         [[nodiscard]] bool isRestartRequired() const noexcept;
         [[nodiscard]] std::span<const Platform> getSupportedPlatforms() const noexcept;
+        [[nodiscard]] bool isCheating() const noexcept;
         [[nodiscard]] const geode::Mod* getIntegration() const noexcept;
 
         void enable() &;

include/horrible/OptionalAPI.hpp

@@ -28,6 +28,7 @@ namespace horrible {
         bool online;                      // If the option requires an active internet connection to work properly
         bool restart;                     // If the option requires a game restart to take effect
         std::vector<Platform> platforms;  // Platforms that the option supports
+        bool cheating;                    // If the option counts as cheating and will trigger dynamic safe mode
 
         OptionV2() = default;  // Default constructor
 
@@ -41,7 +42,8 @@ namespace horrible {
             bool state = false,
             bool online = false,
             bool restart = false,
-            std::vector<Platform> platforms = {Platform::All}) :
+            std::vector<Platform> platforms = {Platform::All},
+            bool cheating = false) :
             id(std::move(id)),
             name(std::move(name)),
             description(std::move(description)),
@@ -51,6 +53,7 @@ namespace horrible {
             online(online),
             restart(restart),
             platforms(std::move(platforms)),
+            cheating(cheating),
             integration(geode::Mod::get()) {};
 
         inline const geode::Mod* getIntegration() const noexcept {

mod.json

@@ -47,12 +47,6 @@
         }
     },
     "settings": {
-        "safe-mode": {
-            "type": "bool",
-            "name": "Safe Mode",
-            "description": "Prevent accidentally saving progress made in levels while using this mod's features. <co>We recommend keeping this enabled while this mod is active!</cr>",
-            "default": true
-        },
         "button": {
             "type": "custom:menu",
             "name": " "
@@ -66,6 +60,25 @@
             ],
             "category": "universal"
         },
+        "safe-mode-section": {
+            "type": "title",
+            "name": "Safe Mode",
+            "description": "Settings for Safe Mode."
+        },
+        "safe-mode": {
+            "type": "bool",
+            "name": "Enable",
+            "description": "Prevent accidentally saving progress made in levels while using this mod's features. <co>We recommend keeping this enabled while this mod is active!</cr>",
+            "default": true,
+            "enable-if": "!dyn-safe-mode",
+            "enable-if-description": "Disable Automatic Safe Mode to manually change this setting."
+        },
+        "dyn-safe-mode": {
+            "type": "bool",
+            "name": "Automatic",
+            "description": "Automatically toggle Safe Mode whenever you toggle any options that are marked as cheats.",
+            "default": true
+        },
         "ui": {
             "type": "title",
             "name": "Interface",

src/API.cpp

@@ -70,6 +70,11 @@ std::shared_ptr<Option> Option::setSupportedPlatforms(std::vector<Platform> plat
     return shared_from_this();
 };
 
+std::shared_ptr<Option> Option::setCheating(bool isCheat) {
+    m_isCheating = isCheat;
+    return shared_from_this();
+};
+
 ZStringView Option::getID() const noexcept {
     return m_id;
 };
@@ -106,6 +111,10 @@ std::span<const Platform> Option::getSupportedPlatforms() const noexcept {
     return m_platforms;
 };
 
+bool Option::isCheating() const noexcept {
+    return m_isCheating;
+};
+
 const Mod* Option::getIntegration() const noexcept {
     return m_integration;
 };
@@ -168,8 +177,16 @@ void OptionManager::registerOption(std::shared_ptr<Option> option) {
 
         std::string id = option->getID();
 
+        auto cheats = m_enabledCheats.size();
+
+        if (option->isCheating()) {
+            if (isEnabled(id)) m_enabledCheats.emplace(option->getID(), option);
+        };
+
         m_options.emplace(std::move(id), option);
         log::debug("Registered option {} of category {}", option->getID(), option->getCategory());
+
+        if (cheats == 0 && m_enabledCheats.size() > cheats) (void)OptionCheatingEvent().send(true);
     };
 };
 
@@ -178,6 +195,10 @@ void OptionManager::addDelegate(ZStringView id, Callback&& callback) {
     thisDelegate.push_back(std::move(callback));
 };
 
+bool OptionManager::isCheatEnabled() const noexcept {
+    return m_enabledCheats.size() > 0;
+};
+
 std::vector<std::weak_ptr<Option>> OptionManager::getOptions() const {
     std::vector<std::weak_ptr<Option>> out;
     out.reserve(m_options.size());
@@ -212,6 +233,11 @@ bool OptionManager::isViewed(ZStringView id) const {
     return getOption(id).viewed;
 };
 
+bool OptionManager::isCheating(ZStringView id) const {
+    if (auto o = getOptionInfo(id).lock()) return o->isCheating();
+    return false;
+};
+
 bool OptionManager::getDefaultToggleState(ZStringView id) const noexcept {
     if (auto o = getOptionInfo(id).lock()) return o->getDefaultToggleState();
     return false;
@@ -231,6 +257,11 @@ size_t OptionManager::getDelegateCount(std::string_view id) const noexcept {
     return 0;
 };
 
+bool OptionManager::shouldBeSafeMode() const noexcept {
+    if (Mod::get()->getSettingValue<bool>("dyn-safe-mode")) return isCheatEnabled();
+    return Mod::get()->getSettingValue<bool>("safe-mode");
+};
+
 void OptionManager::toggleOption(ZStringView id, bool enable) {
     setOption(id, enable, isPinned(id));
 };
@@ -243,10 +274,30 @@ void OptionManager::setOption(ZStringView id, bool enable, bool pin, bool viewed
 
     log::trace("Called {} delegates {} for option {}", it != m_delegates.end() ? it->second.size() : 0, enable ? "on" : "off", id);
 
-    auto save = HorribleOptionSave{enable, pin, viewed};
+    auto cheats = m_enabledCheats.size();
+
+    auto const save = HorribleOptionSave{enable, pin, viewed};
 
     (void)Mod::get()->setSavedValue(id, save);
     (void)OptionEvent(id).send(save);
+
+    if (auto it = m_enabledCheats.find(id); it != m_enabledCheats.end()) {
+        if (!enable) m_enabledCheats.erase(it);
+    } else if (enable) {
+        if (auto o = getOptionInfo(id).lock()) {
+            if (o->isCheating()) {
+                log::debug("Enabled cheat option {}, adding to enabled cheats map", id);
+                m_enabledCheats.emplace(id, o);
+            };
+        };
+    };
+
+    auto cheatsNow = m_enabledCheats.size();
+
+    if (isCheating(id) && cheats != cheatsNow) {
+        if (cheats == 0 && cheatsNow > 0) (void)OptionCheatingEvent().send(true);
+        if (cheats > 0 && cheatsNow == 0) (void)OptionCheatingEvent().send(false);
+    };
 };
 
 OptionManager* OptionManager::get() noexcept {
@@ -291,7 +342,8 @@ void OptionManagerV2::registerOption(OptionV2 const& option) {
                        ->setDefaultToggleState(option.state)
                        ->setOnline(option.online)
                        ->setRequiresRestart(option.restart)
-                       ->setSupportedPlatforms(option.platforms);
+                       ->setSupportedPlatforms(option.platforms)
+                       ->setCheating(option.cheating);
 
         om->registerOption(opt);
         (void)OptionEvent(opt->getID()).send(om->getOption(opt->getID()));

src/Utils.h

@@ -76,6 +76,7 @@ namespace horrible {
     // For convenience
     namespace setting {
         inline constexpr auto SafeMode = "safe-mode";
+        inline constexpr auto DynamicSafeMode = "dyn-safe-mode";
         inline constexpr auto FloatingBtn = "floating-btn";
     };
 

src/hooks/Dementia.cpp

@@ -15,6 +15,7 @@ static auto const o = Option::create(THIS_ID)
                           ->setDescription("Chance for the player to occasionally randomly teleport a few steps back while playing a level.\n<cl>suggested by imdissapearinghelp</c>")
                           ->setCategory(category::misc)
                           ->setSillyTier(SillyTier::Medium)
+                          ->setCheating(true)
                           ->autoRegister();
 
 class $modify(DementiaPlayerObject, PlayerObject) {

src/hooks/DoubleJump.cpp

@@ -14,6 +14,7 @@ static auto const o = Option::create(THIS_ID)
                           ->setDescription("Allows your character to double-jump in a level.\n<cl>created by Cheeseworks</c>")
                           ->setCategory(category::misc)
                           ->setSillyTier(SillyTier::Low)
+                          ->setCheating(true)
                           ->autoRegister();
 
 class $modify(DoubleJumpPlayerObject, PlayerObject) {

src/hooks/Gambler.cpp

@@ -14,6 +14,7 @@ static auto const o = Option::create(THIS_ID)
                           ->setDescription("When reaching 95% in a level, you have a 50/50 chance at randomly being blasted way far back.\n<cl>suggested by Timered</c>")
                           ->setCategory(category::misc)
                           ->setSillyTier(SillyTier::High)
+                          ->setCheating(true)
                           ->autoRegister();
 
 class $modify(GamblerPlayLayer, PlayLayer) {