Merge remote-tracking branch 'origin/main' into rando/new-item

include/d/actor/d_a_alink.h

@@ -4572,6 +4572,18 @@ public:
     void handleWolfHowl();
     void handleQuickTransform();
     bool checkGyroAimContext();
+
+    void onIronBallChainInterpCallback();
+
+    static const int IRON_BALL_CHAIN_COUNT = 102;
+    cXyz mIBChainInterpPrevPos[IRON_BALL_CHAIN_COUNT];
+    cXyz mIBChainInterpCurrPos[IRON_BALL_CHAIN_COUNT];
+    csXyz mIBChainInterpPrevAngle[IRON_BALL_CHAIN_COUNT];
+    csXyz mIBChainInterpCurrAngle[IRON_BALL_CHAIN_COUNT];
+    cXyz mIBChainInterpPrevHandRoot;
+    cXyz mIBChainInterpCurrHandRoot;
+    bool mIBChainInterpPrevValid;
+    bool mIBChainInterpCurrValid;
 #endif
 };  // Size: 0x385C
 

include/d/actor/d_a_e_db.h

@@ -80,6 +80,12 @@ public:
     /* 0x125C */ u32 field_0x125c;
     /* 0x1260 */ u8 field_0x1260[0x126C - 0x1260];
     /* 0x126C */ u8 HIOInit;
+#if TARGET_PC
+    cXyz mStalkLineInterpPrev[12];
+    cXyz mStalkLineInterpCurr[12];
+    bool mStalkLineInterpPrevValid;
+    bool mStalkLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_db_class) == 0x1270);

include/d/actor/d_a_e_hb.h

@@ -73,6 +73,12 @@ public:
     /* 0x124C */ f32 field_0x124c;
     /* 0x1250 */ u8 field_0x1250[0x1264 - 0x1250];
     /* 0x1264 */ u8 HIOInit;
+#if TARGET_PC
+    cXyz mStalkLineInterpPrev[12];
+    cXyz mStalkLineInterpCurr[12];
+    bool mStalkLineInterpPrevValid;
+    bool mStalkLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_hb_class) == 0x1268);

include/d/actor/d_a_e_s1.h

@@ -81,6 +81,15 @@ public:
     /* 0x306D */ u8 field_0x306D[0x307C - 0x306D];
     /* 0x307C */ u32 mBodyEffEmtrID;
     /* 0x3080 */ u8 mInitHIO;
+
+#if TARGET_PC
+    static const int HAIR_STRAND_COUNT = 22;
+    static const int HAIR_SEGMENT_COUNT = 16;
+    cXyz mHairInterpPrev[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
+    cXyz mHairInterpCurr[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
+    bool mHairInterpPrevValid;
+    bool mHairInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_s1_class) == 0x3084);

include/d/actor/d_a_e_yd.h

@@ -74,6 +74,12 @@ public:
     /* 0x1250 */ f32 field_0x1250;
     /* 0x1254 */ u8 field_0x1254[0x1268 - 0x1254];
     /* 0x1268 */ u8 field_0x1268;
+#if TARGET_PC
+    cXyz mLineMatInterpPrev[12];
+    cXyz mLineMatInterpCurr[12];
+    bool mLineMatInterpPrevValid;
+    bool mLineMatInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yd_class) == 0x126c);

include/d/actor/d_a_e_yg.h

@@ -63,6 +63,15 @@ public:
     /* 0x0BB4 */ yg_ke_s mYgKes[13];
     /* 0x1880 */ mDoExt_3DlineMat0_c mLineMat;
     /* 0x189C */ u8 mIsFirstSpawn;
+
+#if TARGET_PC
+    static const int TENTACLE_STRAND_COUNT = 13;
+    static const int TENTACLE_SEGMENT_COUNT = 10;
+    cXyz mTentacleInterpPrev[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
+    cXyz mTentacleInterpCurr[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
+    bool mTentacleInterpPrevValid;
+    bool mTentacleInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yg_class) == 0x18a0);

include/d/actor/d_a_e_yh.h

@@ -77,6 +77,12 @@ public:
     /* 0x1260 */ u32 field_0x1260;
     /* 0x1260 */ u8 field_0x1264[0x1270 - 0x1264];
     /* 0x1270 */ bool mIsHIOOwner;
+#if TARGET_PC
+    cXyz mLineInterpPrev[12];
+    cXyz mLineInterpCurr[12];
+    bool mLineInterpPrevValid;
+    bool mLineInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(e_yh_class) == 0x1274);

include/d/actor/d_a_obj_fchain.h

@@ -31,6 +31,10 @@ public:
     csXyz* getAngle() { return field_0x8a4; }
     J3DModelData* getModelData() { return mModelData; }
 
+#if TARGET_PC
+    void onInterpCallback();
+#endif
+
 private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModelData* mModelData;
@@ -42,6 +46,14 @@ private:
     /* 0x694 */ cXyz field_0x694[22];
     /* 0x79C */ cXyz field_0x79c[22];
     /* 0x8A4 */ csXyz field_0x8a4[22];
+
+#if TARGET_PC
+    static const int CHAIN_COUNT = 22;
+    cXyz mChainInterpPrev[CHAIN_COUNT];
+    cXyz mChainInterpCurr[CHAIN_COUNT];
+    bool mChainInterpPrevValid;
+    bool mChainInterpCurrValid;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daObjFchain_c) == 0x928);

include/d/d_com_inf_game.h

@@ -1845,6 +1845,12 @@ inline void dComIfGs_addDeathCount() {
     g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().addDeathCount();
 }
 
+#if TARGET_PC
+inline u16 dComIfGs_getDeathCount() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getDeathCount();
+}
+#endif
+
 inline char* dComIfGs_getPlayerName() {
     return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getPlayerName();
 }

include/d/d_event.h

@@ -196,7 +196,11 @@ public:
     /* 0x108 */ int mSkipTimer;
     /* 0x10C */ int mSkipParameter;
     /* 0x110 */ BOOL mIsSkipFade;
+#if TARGET_PC
+    /* 0x114 */ char mSkipEventName[21];
+#else
     /* 0x114 */ char mSkipEventName[20];
+#endif
     /* 0x128 */ u8 mCompulsory;
     /* 0x129 */ bool mRoomInfoSet;
     /* 0x12C */ int mRoomNo;

include/d/d_map.h

@@ -223,6 +223,9 @@ private:
     /* 0x8F */ u8 field_0x8f;
     /* 0x90 */ u8 field_0x90;
     /* 0x91 */ u8 field_0x91;
+#if TARGET_PC
+    bool previousMirror;
+#endif
 };  // Size: 0x94
 
 class dMap_HIO_list_c : public dMpath_HIO_n::hioList_c {

include/d/d_save.h

@@ -486,6 +486,9 @@ public:
             mDeathCount++;
         }
     }
+#if TARGET_PC
+    u16 getDeathCount() const { return mDeathCount; }
+#endif
     char* getPlayerName() const { return const_cast<char*>(mPlayerName); }
     void setPlayerName(const char* i_name) {
 #if AVOID_UB

include/dusk/achievements.h

@@ -12,9 +12,8 @@
 namespace dusk {
 
 enum class AchievementCategory : uint8_t {
-    Story,
-    Collection,
     Challenge,
+    Collection,
     Minigame,
     Misc,
     Glitched

include/dusk/action_bindings.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "dusk/config_var.hpp"
+
+namespace dusk {
+
+enum class ActionBinds {
+    FIRST_PERSON_CAMERA,
+    CALL_MIDNA,
+    OPEN_DUSKLIGHT_MENU,
+    TURBO_SPEED_BUTTON,
+    COUNT,
+};
+
+struct ActionBindData {
+    std::array<config::ActionBindConfigVar, 4>* configVars{};
+    std::string actionName{};
+};
+
+struct ActionBindPressData {
+    bool pressedCurFrame{false};
+    bool pressedPrevFrame{false};
+};
+
+using ActionBindsMap = std::unordered_map<ActionBinds, ActionBindData>;
+
+ActionBindsMap& getActionBinds();
+
+bool isActionBound(ActionBinds action, u32 port);
+
+void updateActionBindings();
+
+bool getActionBindTrig(ActionBinds action, u32 port);
+
+bool getActionBindHold(ActionBinds action, u32 port);
+
+bool getActionBindHoldAnyPort(ActionBinds action);
+
+int getActionBindButton(ActionBinds action, u32 port);
+
+}

include/dusk/app_info.hpp

@@ -7,7 +7,12 @@ namespace dusk {
      *
      * This gets used for file paths and such, and cannot be changed!
      */
-    constexpr auto AppName = "Dusk";
+    constexpr auto AppName = "Dusklight";
+
+    /**
+     * Previous AppName to migrate data from.
+     */
+    constexpr auto LegacyAppName = "Dusk";
 
     /**
      * \brief The internal organization name for the game.

include/dusk/audio/DuskAudioSystem.h

@@ -1,8 +1,19 @@
 #pragma once
 
+#include <cmath>
 #include <dolphin/types.h>
 
 namespace dusk::audio {
+
+    // Converts a 0-1 volume to a linear amplitude multiplier.
+    // The curve is -4 dB per 10% step: 100% = 0 dB, 90% = -4 dB, ..., 0% = -inf dB
+    inline f32 MasterVolumeToLinear(f32 v) {
+        if (v <= 0.0f) {
+            return 0.0f;
+        }
+        return std::pow(10.0f, (v - 1.0f) * 2.0f);
+    }
+
     /**
      * Initialize the audio system and start playing audio.
      */

include/dusk/autosave.h

@@ -13,5 +13,6 @@ void enterAutoSave();
 void autoSaving();
 void waitingForWrite();
 void endAutoSave();
+void toggleAutoSave(bool enabled);
 
 #endif

include/dusk/config.hpp

@@ -1,6 +1,7 @@
 #ifndef DUSK_CONFIG_HPP
 #define DUSK_CONFIG_HPP
 
+#include <functional>
 #include <stdexcept>
 #include "nlohmann/json.hpp"
 #include "config_var.hpp"
@@ -111,6 +112,18 @@ void Save();
  */
 ConfigVarBase* GetConfigVar(std::string_view name);
 
+/**
+ * \brief Resets all custom action bindings for a specific port to nothing
+ *
+ * @param port The port to be cleared of action bindings
+ */
+void ClearAllActionBindings(int port);
+
+/**
+ * \brief Call a function on every registered CVar.
+ */
+void EnumerateRegistered(std::function<void(ConfigVarBase&)> callback);
+
 template <ConfigValue T>
 const ConfigImplBase* GetConfigImpl() {
     static ConfigImpl<T> config;

include/dusk/config_var.hpp

@@ -48,6 +48,13 @@ enum class ConfigVarLayer : u8 {
      * Will not get saved to config.
      */
     Override,
+
+    /**
+     * The CVar is temporarily overridden by speedrun mode.
+     * Will not get saved to config. Cleared when speedrun mode is disabled.
+     * Lower priority than Override, so launch args still win.
+     */
+    Speedrun,
 };
 
 class ConfigImplBase;
@@ -113,6 +120,12 @@ public:
      * This is necessary to make it legal to access.
      */
     void markRegistered();
+
+    /**
+     * Clear a speedrun-mode override if one is active on this CVar.
+     * Safe to call on any CVar, no-op if not at the Speedrun layer.
+     */
+    virtual void clearSpeedrunOverride() {}
 };
 
 template <typename T>
@@ -162,6 +175,7 @@ class ConfigVar : public ConfigVarBase {
     T defaultValue;
     T value;
     T overrideValue;
+    ConfigVarLayer priorLayer = ConfigVarLayer::Default;
 
 public:
     /**
@@ -189,6 +203,7 @@ public:
         case ConfigVarLayer::Value:
             return value;
         case ConfigVarLayer::Override:
+        case ConfigVarLayer::Speedrun:
             return overrideValue;
         default:
             abort();
@@ -239,8 +254,54 @@ public:
         overrideValue = std::move(newValue);
         layer = ConfigVarLayer::Override;
     }
+
+    /**
+     * \brief Give a CVar a speedrun-mode override value.
+     *
+     * Lower priority than a launch-arg override. Cleared when speedrun mode is disabled.
+     * The overridden value will not get saved to config.
+     *
+     * @param newValue The new value the CVar will get.
+     */
+    void setSpeedrunValue(T newValue) {
+        checkRegistered();
+        if (layer != ConfigVarLayer::Override) {
+            priorLayer = layer;
+            overrideValue = std::move(newValue);
+            layer = ConfigVarLayer::Speedrun;
+        }
+    }
+
+    void clearOverride() {
+        checkRegistered();
+        if (layer == ConfigVarLayer::Override) {
+            overrideValue = {};
+            layer = ConfigVarLayer::Value;
+        }
+    }
+
+    void clearSpeedrunOverride() override {
+        checkRegistered();
+        if (layer == ConfigVarLayer::Speedrun) {
+            overrideValue = {};
+            layer = priorLayer;
+        }
+    }
+
+    /**
+     * \brief Get the user-persisted value, ignoring any temporary overrides.
+     *
+     * Used by Save() to write the correct value even when a speedrun override is active.
+     */
+    [[nodiscard]] constexpr const T& getValueForSave() const noexcept {
+        checkRegistered();
+        const ConfigVarLayer effectiveLayer = (layer == ConfigVarLayer::Speedrun) ? priorLayer : layer;
+        return effectiveLayer == ConfigVarLayer::Default ? defaultValue : value;
+    }
 };
 
+using ActionBindConfigVar = ConfigVar<int>;
+
 }
 
 #endif  // DUSK_CONFIG_VAR_HPP

include/dusk/crash_reporting.h

@@ -1,8 +1,17 @@
 #pragma once
 
-namespace dusk {
+namespace dusk::crash_reporting {
 
-void InitializeCrashReporting();
-void ShutdownCrashReporting();
+enum class Consent {
+    Unavailable,
+    Unknown,
+    Given,
+    Revoked,
+};
 
-}  // namespace dusk
+void initialize();
+void shutdown();
+Consent get_consent();
+void set_consent(bool enabled);
+
+}  // namespace dusk::crash_reporting

include/dusk/gyro.h

@@ -12,6 +12,7 @@ void rollgoalTableOffset(s16& out_ax, s16& out_az);
 extern bool s_sensor_keep_alive;
 bool get_sensor_keep_alive();
 void set_sensor_keep_alive(bool value);
+bool rollgoal_gyro_enabled();
 }  // namespace dusk::gyro
 
 #endif

include/dusk/hotkeys.h

@@ -14,7 +14,6 @@ constexpr const char* SHOW_DEBUG_OVERLAY = "F3";
 constexpr const char* SHOW_HEAP_VIEWER = "F4";
 constexpr const char* SHOW_PLAYER_INFO = "F5";
 constexpr const char* SHOW_SAVE_EDITOR = "F6";
-constexpr const char* SHOW_MAP_LOADER = "F7";
 constexpr const char* SHOW_STATE_SHARE = "F8";
 constexpr const char* SHOW_DEBUG_CAMERA = "F9";
 constexpr const char* SHOW_AUDIO_DEBUG = "F10";

include/dusk/io.hpp

@@ -1,6 +1,7 @@
 #ifndef DUSK_IO_HPP
 #define DUSK_IO_HPP
 
+#include <filesystem>
 #include <vector>
 
 // I can't believe it's 2026 and neither SDL (no error codes) nor
@@ -15,7 +16,7 @@ namespace dusk::io {
  * Methods on this class throw appropriate C++ exceptions when an error occurs.
  */
 class FileStream {
-    void* file;
+    FILE* file;
 
 public:
     FileStream() noexcept;
@@ -23,7 +24,7 @@ public:
     /**
      * \brief Take ownership of a FILE* handle.
      */
-    explicit FileStream(void* file);
+    explicit FileStream(FILE* file);
     FileStream(const FileStream& other) = delete;
     FileStream(FileStream&& other) noexcept;
 
@@ -34,6 +35,11 @@ public:
      */
     static FileStream OpenRead(const char* utf8Path);
 
+    /**
+     * \brief Open a file for reading at the given path.
+     */
+    static FileStream OpenRead(const std::filesystem::path& path);
+
     /**
      * \brief Create a file for writing.
      *
@@ -41,16 +47,33 @@ public:
      */
     static FileStream Create(const char* utf8Path);
 
+    /**
+     * \brief Create a file for writing.
+     *
+     * If there is an existing file, its contents are demolished.
+     */
+    static FileStream Create(const std::filesystem::path& path);
+
     /**
      * \brief Read the byte contents of a file directly into a vector.
      */
     static std::vector<u8> ReadAllBytes(const char* utf8Path);
 
+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static std::vector<u8> ReadAllBytes(const std::filesystem::path& path);
+
     /**
      * \brief Read the byte contents of a file directly into a vector.
      */
     static void WriteAllText(const char* utf8Path, std::string_view text);
 
+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static void WriteAllText(const std::filesystem::path& path, std::string_view text);
+
     /**
      * \brief Read the remaining contents of the file directly into a vector.
      */
@@ -59,17 +82,24 @@ public:
     /**
      * Get direct access to the underlying FILE* handle.
      */
-    [[nodiscard]] void* GetFileHandle() const noexcept {
-        return file;
-    }
+    [[nodiscard]] void* GetFileHandle() const noexcept { return file; }
 
     /**
      * Write data to the file.
      */
     void Write(const char* data, size_t dataLen);
+
+    FILE* ToInner();
 };
 
+/**
+ * Converts a std::filesystem::path to a std::string, UTF-8, without exploding on Windows.
+ */
+inline std::string fs_path_to_string(const std::filesystem::path& path) {
+    const auto u8str = path.u8string();
+    return {reinterpret_cast<const char*>(u8str.c_str())};
 }
 
+}  // namespace dusk::io
 
 #endif  // DUSK_IO_HPP

include/dusk/main.h

@@ -1,28 +1,26 @@
 #ifndef DUSK_MAIN_H
 #define DUSK_MAIN_H
 
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
 #include <filesystem>
 
 namespace dusk {
-    extern bool IsRunning;
-    extern bool IsShuttingDown;
-    extern bool IsGameLaunched;
-    extern bool IsFocusPaused;
-    extern bool RestartRequested;
-    extern std::filesystem::path ConfigPath;
 
-#if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) || \
+extern bool IsRunning;
+extern bool IsShuttingDown;
+extern bool IsGameLaunched;
+extern bool RestartRequested;
+extern std::filesystem::path ConfigPath;
+extern std::filesystem::path CachePath;
+
+#if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) ||                           \
     (defined(TARGET_OS_TV) && TARGET_OS_TV)
-    inline constexpr bool SupportsProcessRestart = false;
+inline constexpr bool SupportsProcessRestart = false;
 #else
-    inline constexpr bool SupportsProcessRestart = true;
+inline constexpr bool SupportsProcessRestart = true;
 #endif
 
-    void RequestRestart() noexcept;
-}
+void RequestRestart() noexcept;
+
+}  // namespace dusk
 
 #endif  // DUSK_MAIN_H

include/dusk/settings.h

@@ -1,6 +1,8 @@
 #ifndef DUSK_CONFIG_H
 #define DUSK_CONFIG_H
 
+#include <array>
+
 #include "dusk/config_var.hpp"
 
 namespace dusk {
@@ -27,6 +29,11 @@ enum class DiscVerificationState : u8 {
     HashMismatch,
 };
 
+enum class GyroMode : u8 {
+    Sensor = 0,
+    Mouse = 1,
+};
+
 namespace config {
 template <>
 struct ConfigEnumRange<BloomMode> {
@@ -45,6 +52,12 @@ struct ConfigEnumRange<DiscVerificationState> {
     static constexpr auto min = DiscVerificationState::Unknown;
     static constexpr auto max = DiscVerificationState::HashMismatch;
 };
+
+template <>
+struct ConfigEnumRange<GyroMode> {
+    static constexpr auto min = GyroMode::Sensor;
+    static constexpr auto max = GyroMode::Mouse;
+};
 }
 
 // Persistent user settings
@@ -102,8 +115,9 @@ struct UserSettings {
         ConfigVar<bool> minimalHUD;
         ConfigVar<bool> pauseOnFocusLost;
         ConfigVar<bool> enableLinkDollRotation;
-        ConfigVar<bool> enableAchievementNotifications;
-
+        ConfigVar<bool> enableAchievementToasts;
+        ConfigVar<bool> enableControllerToasts;
+        ConfigVar<bool> enableDiscordPresence;
 
         // Graphics
         ConfigVar<BloomMode> bloomMode;
@@ -114,12 +128,14 @@ struct UserSettings {
         ConfigVar<int> shadowResolutionMultiplier;
         ConfigVar<bool> enableDepthOfField;
         ConfigVar<bool> enableMapBackground;
+        ConfigVar<bool> disableCutscenePillarboxing;
 
         // Audio
         ConfigVar<bool> noLowHpSound;
         ConfigVar<bool> midnasLamentNonStop;
 
         // Input
+        ConfigVar<GyroMode> gyroMode;
         ConfigVar<bool> enableGyroAim;
         ConfigVar<bool> enableGyroRollgoal;
         ConfigVar<float> gyroSensitivityX;
@@ -132,13 +148,17 @@ struct UserSettings {
         ConfigVar<bool> freeCamera;
         ConfigVar<bool> invertCameraXAxis;
         ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<bool> invertFirstPersonXAxis;
+        ConfigVar<bool> invertFirstPersonYAxis;
         ConfigVar<float> freeCameraSensitivity;
         ConfigVar<bool> debugFlyCam;
         ConfigVar<bool> debugFlyCamLockEvents;
+        ConfigVar<bool> allowBackgroundInput;
 
         // Cheats
         ConfigVar<bool> infiniteHearts;
         ConfigVar<bool> infiniteArrows;
+        ConfigVar<bool> infiniteSeeds;
         ConfigVar<bool> infiniteBombs;
         ConfigVar<bool> infiniteOil;
         ConfigVar<bool> infiniteOxygen;
@@ -149,19 +169,25 @@ struct UserSettings {
         ConfigVar<bool> alwaysGreatspin;
         ConfigVar<bool> enableFastIronBoots;
         ConfigVar<bool> canTransformAnywhere;
+        ConfigVar<bool> fastRoll;
         ConfigVar<bool> fastSpinner;
         ConfigVar<bool> freeMagicArmor;
+        ConfigVar<bool> invincibleEnemies;
 
         // Technical
         ConfigVar<bool> restoreWiiGlitches;
 
         // Controls
         ConfigVar<bool> enableTurboKeybind;
+        ConfigVar<bool> enableResetKeybind;
 
         // Tools
         ConfigVar<bool> speedrunMode;
         ConfigVar<bool> liveSplitEnabled;
+        ConfigVar<bool> showSpeedrunRTATimer;
         ConfigVar<bool> recordingMode;
+        ConfigVar<bool> showInputViewer;
+        ConfigVar<bool> showInputViewerGyro;
     } game;
 
     struct {
@@ -171,11 +197,18 @@ struct UserSettings {
         ConfigVar<bool> skipPreLaunchUI;
         ConfigVar<bool> showPipelineCompilation;
         ConfigVar<bool> wasPresetChosen;
-        ConfigVar<bool> enableCrashReporting;
         ConfigVar<bool> checkForUpdates;
         ConfigVar<int> cardFileType;
         ConfigVar<bool> enableAdvancedSettings;
     } backend;
+
+    // Arrays of size 4 for 4 ports
+    struct {
+        std::array<ActionBindConfigVar, 4> firstPersonCamera;
+        std::array<ActionBindConfigVar, 4> callMidna;
+        std::array<ActionBindConfigVar, 4> openDusklightMenu;
+        std::array<ActionBindConfigVar, 4> turboSpeedButton;
+    } actionBindings;
 };
 
 UserSettings& getSettings();

include/dusk/speedrun.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <aurora/aurora.h>
+
+namespace dusk {
+
+struct SpeedrunInfo {
+    void startRun() {
+        m_isRunStarted = true;
+        m_startTimestamp = OSGetTime();
+    }
+
+    void stopRun() {
+        m_isRunStarted = false;
+        m_endTimestamp = OSGetTime() - m_startTimestamp;
+    }
+
+    void reset() {
+        m_isRunStarted = false;
+        m_startTimestamp = 0;
+        m_endTimestamp = 0;
+        m_isPauseIGT = false;
+        m_loadStartTimestamp = 0;
+        m_totalLoadTime = 0;
+        m_igtTimer = 0;
+    }
+
+    bool m_isRunStarted = false;
+    OSTime m_startTimestamp = 0;
+    OSTime m_endTimestamp = 0;
+
+    bool m_isPauseIGT = false;
+    OSTime m_loadStartTimestamp = 0;
+    OSTime m_totalLoadTime = 0;
+    OSTime m_igtTimer = 0;
+};
+
+extern SpeedrunInfo m_speedrunInfo;
+
+void resetForSpeedrunMode();
+
+}  // namespace dusk