fix autosave spam

clear e_rd static boss ptr on delete

CMakeLists.txt

@@ -5,8 +5,19 @@ if (NOT CMAKE_BUILD_TYPE)
             "Build type options: Debug Release RelWithDebInfo MinSizeRel" FORCE)
 endif ()
 
-# obtain revision info from git
-find_package(Git)
+set(DUSK_VERSION_OVERRIDE "" CACHE STRING "Override version string (skips git detection and format validation)")
+
+if (DUSK_VERSION_OVERRIDE)
+    set(DUSK_WC_DESCRIBE "${DUSK_VERSION_OVERRIDE}")
+    set(DUSK_VERSION_STRING "0.0.0.0")
+    set(DUSK_SHORT_VERSION_STRING "0.0.0")
+    set(DUSK_WC_REVISION "")
+    set(DUSK_WC_BRANCH "")
+    set(DUSK_WC_DATE "")
+    message(STATUS "Dusklight version overridden to ${DUSK_WC_DESCRIBE}")
+else ()
+    # obtain revision info from git
+    find_package(Git)
 if (GIT_FOUND)
     # make sure version information gets re-run when the current Git HEAD changes
     execute_process(WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} COMMAND ${GIT_EXECUTABLE} rev-parse --git-path HEAD
@@ -63,6 +74,8 @@ else ()
     set(DUSK_SHORT_VERSION_STRING "0.0.0")
 endif ()
 
+endif ()
+
 # Add version information to CI environment variables
 if(DEFINED ENV{GITHUB_ENV})
     file(APPEND "$ENV{GITHUB_ENV}" "DUSK_VERSION=${DUSK_WC_DESCRIBE}\n")
@@ -112,11 +125,6 @@ option(DUSK_BUILD_WARNINGS "Enable compiler warnings (off by default)")
 option(DUSK_SELECTED_OPT "If on, selected parts of the project will be compiled with optimizations on Debug, intending to make the game run at 30 FPS. Note for MSVC: you will need to remove '/RTC1' from your debug flags in CMake.")
 option(DUSK_MOVIE_SUPPORT "If on, compile against libjpeg-turbo to enable THP file decoding" ON)
 option(DUSK_ENABLE_UPDATE_CHECKER "Enable update checking support" ON)
-
-if(ANDROID)
-    set(DUSK_MOVIE_SUPPORT OFF)
-endif ()
-
 option(DUSK_ENABLE_SENTRY_NATIVE "Enable sentry-native crash reporting support" OFF)
 set(DUSK_SENTRY_DSN "" CACHE STRING "Sentry DSN")
 set(DUSK_SENTRY_ENVIRONMENT "development" CACHE STRING "Sentry environment")
@@ -155,6 +163,8 @@ if (DUSK_MOVIE_SUPPORT)
             list(APPEND _jpeg_cmake_args -DCMAKE_TOOLCHAIN_FILE=${_jpeg_toolchain_file})
         endif ()
         set(_jpeg_passthrough_vars
+            ANDROID_ABI
+            ANDROID_PLATFORM
             CMAKE_BUILD_TYPE
             CMAKE_C_COMPILER
             CMAKE_C_COMPILER_LAUNCHER

CMakePresets.json

@@ -249,22 +249,11 @@
           "type": "BOOL",
           "value": false
         },
-        "CMAKE_DISABLE_FIND_PACKAGE_BZip2": {
+        "CMAKE_DISABLE_FIND_PACKAGE_PkgConfig": {
           "type": "BOOL",
           "value": true
         },
-        "CMAKE_DISABLE_FIND_PACKAGE_LibLZMA": {
-          "type": "BOOL",
-          "value": true
-        },
-        "CMAKE_DISABLE_FIND_PACKAGE_zstd": {
-          "type": "BOOL",
-          "value": true
-        },
-        "CMAKE_DISABLE_FIND_PACKAGE_Freetype": {
-          "type": "BOOL",
-          "value": true
-        }
+        "CMAKE_IGNORE_PREFIX_PATH": "/opt/homebrew"
       },
       "vendor": {
         "microsoft.com/VisualStudioSettings/CMake/1.0": {
@@ -329,7 +318,11 @@
       "cacheVariables": {
         "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
         "CMAKE_TOOLCHAIN_FILE": "$env{ANDROID_HOME}/ndk/$env{ANDROID_NDK_VERSION}/build/cmake/android.toolchain.cmake",
-        "ANDROID_PLATFORM": "android-28"
+        "ANDROID_PLATFORM": "android-28",
+        "BUILD_SHARED_LIBS": {
+          "type": "BOOL",
+          "value": false
+        }
       }
     },
     {
@@ -416,7 +409,7 @@
         },
         "CMAKE_OSX_DEPLOYMENT_TARGET": "11.0",
         "CMAKE_IGNORE_PREFIX_PATH": "/opt/homebrew",
-        "DUSK_MOVIE_SUPPORT": {
+        "BUILD_SHARED_LIBS": {
           "type": "BOOL",
           "value": false
         }
@@ -449,11 +442,7 @@
       ],
       "cacheVariables": {
         "CMAKE_C_COMPILER_LAUNCHER": "sccache",
-        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache",
-        "DUSK_MOVIE_SUPPORT": {
-          "type": "BOOL",
-          "value": false
-        }
+        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache"
       }
     },
     {
@@ -463,11 +452,7 @@
       ],
       "cacheVariables": {
         "CMAKE_C_COMPILER_LAUNCHER": "sccache",
-        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache",
-        "DUSK_MOVIE_SUPPORT": {
-          "type": "BOOL",
-          "value": false
-        }
+        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache"
       }
     },
     {

files.cmake

@@ -1450,8 +1450,6 @@ set(DUSK_FILES
         src/dusk/imgui/ImGuiEngine.hpp
         src/dusk/imgui/ImGuiBloomWindow.cpp
         src/dusk/imgui/ImGuiBloomWindow.hpp
-        src/dusk/imgui/ImGuiEnhancedLightingWindow.cpp
-        src/dusk/imgui/ImGuiEnhancedLightingWindow.hpp
         src/dusk/imgui/ImGuiMenuTools.cpp
         src/dusk/imgui/ImGuiMenuTools.hpp
         src/dusk/imgui/ImGuiActorSpawner.cpp
@@ -1460,7 +1458,6 @@ set(DUSK_FILES
         src/dusk/imgui/ImGuiHeapOverlay.cpp
         src/dusk/imgui/ImGuiControllerOverlay.cpp
         src/dusk/imgui/ImGuiStubLog.cpp
-        src/dusk/imgui/ImGuiMapLoader.cpp
         src/dusk/imgui/ImGuiSaveEditor.cpp
         src/dusk/imgui/ImGuiStateShare.hpp
         src/dusk/imgui/ImGuiStateShare.cpp
@@ -1511,6 +1508,8 @@ set(DUSK_FILES
         src/dusk/ui/tab_bar.hpp
         src/dusk/ui/ui.cpp
         src/dusk/ui/ui.hpp
+        src/dusk/ui/warp.cpp
+        src/dusk/ui/warp.hpp
         src/dusk/ui/window.cpp
         src/dusk/ui/window.hpp
         src/dusk/achievements.cpp

flake.nix

@@ -50,7 +50,11 @@
 
       # Dusklight Actual (Linux x86_64 only — relies on prebuilt dawn/nod binaries)
       mkDusklight = pkgs:
-        let srcs = buildSources pkgs; in
+        let srcs = buildSources pkgs;
+          versionSuffix = if self ? shortRev && self.shortRev != null
+            then "nix-${self.shortRev}"
+            else "nix-dirty";
+        in
         pkgs.stdenv.mkDerivation {
           name = "dusklight";
           src = ./.;
@@ -62,6 +66,7 @@
           '';
           # Remove last line to re-enable tests
           cmakeFlags = [
+            "-DDUSK_VERSION_OVERRIDE=${versionSuffix}"
             "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
             "-DFETCHCONTENT_SOURCE_DIR_CXXOPTS=${pkgs.cxxopts.src}"
             "-DFETCHCONTENT_SOURCE_DIR_JSON=${pkgs.nlohmann_json.src}"
@@ -83,6 +88,14 @@
             mkdir -p $out/bin
             cp dusklight $out/bin/dusklight
             cp -r ./res $out/bin/res
+
+            mkdir -p $out/share/applications
+            cp $src/platforms/freedesktop/dusklight.desktop $out/share/applications/dusklight.desktop
+
+            for size in 16 32 48 64 128 256 512 1024; do
+              install -Dm644 $src/platforms/freedesktop/''${size}x''${size}/apps/dusklight.png \
+                $out/share/icons/hicolor/''${size}x''${size}/apps/dusklight.png
+            done
           '';
           nativeBuildInputs = [
             pkgs.cmake
@@ -212,4 +225,4 @@
         default = mkDevShell (pkgsFor system);
       });
     };
-}
+}

include/d/actor/d_a_alink.h

@@ -1733,6 +1733,9 @@ public:
     int checkNewItemChange(u8 i_selItemIdx);
     void deleteEquipItem(BOOL i_isPlaySound, BOOL i_isDeleteKantera);
     void setLight();
+    #if TARGET_PC
+    void setGhostLanternLight();
+    #endif
     void setFrontRollCrashShock(u8);
     void changeWarpMaterial(daAlink_c::daAlink_WARP_MAT_MODE i_matMode);
     void commonProcInit(daAlink_c::daAlink_PROC i_procID);
@@ -2656,8 +2659,14 @@ public:
     void checkWaterInKandelaar(f32);
     void offKandelaarModel();
     int kandelaarModelCallBack();
+    int ghostLanternModelCallBack();
     BOOL checkKandelaarEquipAnime() const;
     void preKandelaarDraw();
+    void preGhostLanternDraw();
+    static void* srchPoe(void*, void*);
+    #if TARGET_PC
+    void setGhostLanternModel();
+    #endif
     void setKandelaarModel();
     void resetOilBottleModel();
     void commonKandelaarPourInit();
@@ -3977,6 +3986,9 @@ public:
     /* 0x006FC */ J3DModel* mpKanteraModel;
     /* 0x00700 */ J3DModel* mpKanteraGlowModel;
     /* 0x00704 */ J3DAnmTextureSRTKey* mpKanteraGlowBtk;
+    /* 0x006FC */ J3DModel* mpGhostLanternModel;
+    /* 0x00700 */ J3DModel* mpGhostLanternGlowModel;
+    /* 0x00704 */ J3DAnmTextureSRTKey* mpGhostLanternGlowBtk;
     /* 0x00708 */ J3DModel* mHeldItemModel;
     /* 0x0070C */ J3DModel* mpHookTipModel;  // related to held item
     /* 0x00710 */ J3DModel* field_0x0710;    // related to held item
@@ -4373,6 +4385,7 @@ public:
     /* 0x03194 */ int field_0x3194;
     /* 0x03198 */ int field_0x3198;
     /* 0x0319C */ int field_0x319c;
+    /* 0x0319C */ s32 ghostLanternFlameEffect[2];
     /* 0x031A0 */ u32 mModeFlg;
     /* 0x031A4 */ int field_0x31a4;
     /* 0x031A8 */ u32 field_0x31a8[2];
@@ -4442,6 +4455,9 @@ public:
     /* 0x033F4 */ f32 field_0x33f4;
     /* 0x033F8 */ f32 field_0x33f8;
     /* 0x033FC */ f32 field_0x33fc;
+    #if TARGET_PC
+    /* 0x033FC */ f32 current_ghost_lantern_light_power;
+    #endif
     /* 0x03400 */ f32 field_0x3400;
     /* 0x03404 */ f32 field_0x3404;
     /* 0x03408 */ f32 field_0x3408;
@@ -4509,9 +4525,13 @@ public:
     /* 0x035F4 */ cXyz mMidnaAtnPos;
     /* 0x03600 */ cXyz mMidnaHairAtnPos;
     /* 0x0360C */ cXyz mKandelaarFlamePos;
+    /* 0x0360C */ cXyz mGhostLanternFlamePos;
     /* 0x03618 */ cXyz field_0x3618;
     /* 0x03624 */ cXyz field_0x3624;
     /* 0x03630 */ cXyz field_0x3630;
+    /* 0x03618 */ cXyz ghost_lantern_0x3618;
+    /* 0x03624 */ cXyz ghost_lantern_0x3624;
+    /* 0x03630 */ cXyz ghost_lantern_0x3630;
     /* 0x0363C */ cXyz field_0x363c[4];
     /* 0x0366C */ cXyz field_0x366c[4];
     /* 0x0369C */ cXyz field_0x369c;
@@ -6821,6 +6841,9 @@ public:
     static daAlinkHIO_boom_c0 const mBoomerang;
     static daAlinkHIO_bomb_c0 const mBomb;
     static daAlinkHIO_huLight_c0 const mLanternPL;
+    #if TARGET_PC
+    static daAlinkHIO_huLight_c0 const mGhostLanternPL;
+    #endif
     static daAlinkHIO_kandelaar_c0 const mLantern;
     static daAlinkHIO_fmChain_c0 const mFmChain;
     static daAlinkHIO_magneBoots_c0 const mIronBoots;

include/d/d_item.h

@@ -71,6 +71,7 @@ void item_func_WOOD_STICK();
 void item_func_BOOMERANG();
 void item_func_SPINNER();
 void item_func_IRONBALL();
+void item_func_GHOST_LANTERN();
 void item_func_BOW();
 void item_func_HOOKSHOT();
 void item_func_HVY_BOOTS();
@@ -260,6 +261,7 @@ int item_getcheck_func_WOOD_STICK();
 int item_getcheck_func_BOOMERANG();
 int item_getcheck_func_SPINNER();
 int item_getcheck_func_IRONBALL();
+int item_getcheck_func_GHOST_LANTERN();
 int item_getcheck_func_BOW();
 int item_getcheck_func_HOOKSHOT();
 int item_getcheck_func_HVY_BOOTS();

include/d/d_item_data.h

@@ -317,7 +317,7 @@ enum {
     /* 0xDE */ dItemNo_NOENTRY_222_e,
     /* 0xDF */ dItemNo_NOENTRY_223_e,
     /* 0xE0 */ dItemNo_POU_SPIRIT_e,
-    /* 0xE1 */ dItemNo_NOENTRY_225_e,
+    /* 0xE1 */ dItemNo_GHOST_LANTERN_e,
     /* 0xE2 */ dItemNo_NOENTRY_226_e,
     /* 0xE3 */ dItemNo_NOENTRY_227_e,
     /* 0xE4 */ dItemNo_NOENTRY_228_e,

include/d/d_menu_window_HIO.h

@@ -86,8 +86,8 @@ public:
     /* 0x047 */ u8 field_0x47;
     /* 0x048 */ u8 mPoes;
     /* 0x049 */ u8 mPoesCopy;
-    /* 0x04A */ u8 mItems[24];
-    /* 0x062 */ u8 mItemsCopy[24];
+    /* 0x04A */ u8 mItems[25];
+    /* 0x062 */ u8 mItemsCopy[25];
     /* 0x07A */ u8 field_0x7a[24];
     /* 0x092 */ u8 mSwords[4];
     /* 0x096 */ u8 mShields[3];

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/config_var.hpp

@@ -175,6 +175,7 @@ class ConfigVar : public ConfigVarBase {
     T defaultValue;
     T value;
     T overrideValue;
+    ConfigVarLayer priorLayer = ConfigVarLayer::Default;
 
 public:
     /**
@@ -265,6 +266,7 @@ public:
     void setSpeedrunValue(T newValue) {
         checkRegistered();
         if (layer != ConfigVarLayer::Override) {
+            priorLayer = layer;
             overrideValue = std::move(newValue);
             layer = ConfigVarLayer::Speedrun;
         }
@@ -282,9 +284,20 @@ public:
         checkRegistered();
         if (layer == ConfigVarLayer::Speedrun) {
             overrideValue = {};
-            layer = ConfigVarLayer::Value;
+            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>;

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/main.h

@@ -10,6 +10,7 @@ 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)

include/dusk/settings.h

@@ -120,13 +120,6 @@ struct UserSettings {
         ConfigVar<bool> enableDiscordPresence;
 
         // Graphics
-        ConfigVar<bool> enhancedLighting;
-        ConfigVar<bool> enableSpecularLighting;
-        ConfigVar<bool> enableRimLighting;
-        ConfigVar<float> specularIntensity;
-        ConfigVar<float> rimIntensity;
-        ConfigVar<float> ambientLightMultiplier;
-        ConfigVar<float> diffuseLightMultiplier;
         ConfigVar<BloomMode> bloomMode;
         ConfigVar<float> bloomMultiplier;
         ConfigVar<bool> disableWaterRefraction;
@@ -165,6 +158,7 @@ struct UserSettings {
         // Cheats
         ConfigVar<bool> infiniteHearts;
         ConfigVar<bool> infiniteArrows;
+        ConfigVar<bool> infiniteSeeds;
         ConfigVar<bool> infiniteBombs;
         ConfigVar<bool> infiniteOil;
         ConfigVar<bool> infiniteOxygen;
@@ -178,6 +172,7 @@ struct UserSettings {
         ConfigVar<bool> fastRoll;
         ConfigVar<bool> fastSpinner;
         ConfigVar<bool> freeMagicArmor;
+        ConfigVar<bool> invincibleEnemies;
 
         // Technical
         ConfigVar<bool> restoreWiiGlitches;

src/d/actor/d_a_alink.cpp

@@ -6100,6 +6100,21 @@ void daAlink_c::setItemMatrix(int param_0) {
             modelCalc(mpKanteraGlowModel);
         }
 
+        if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+            simpleAnmPlay(mpGhostLanternGlowBtk);
+
+            mDoMtx_stack_c::copy(mpLinkModel->getAnmMtx(mLeftItemJntNo));
+            mDoMtx_stack_c::transM(-2.0f, -0.1f, -0.7f);
+            mDoMtx_stack_c::XYZrotM(cM_deg2s(100.0f), cM_deg2s(9.3f), cM_deg2s(183.0f));
+            mDoMtx_stack_c::scaleM(0.75f, 0.75f, 0.75f);
+            mpGhostLanternModel->setBaseTRMtx(mDoMtx_stack_c::get());
+
+            modelCalc(mpGhostLanternModel);
+            mDoMtx_stack_c::transS(mGhostLanternFlamePos);
+            mpGhostLanternGlowModel->setBaseTRMtx(mDoMtx_stack_c::get());
+            modelCalc(mpGhostLanternGlowModel);
+        }
+
         setSwordPos();
         simpleAnmPlay(m_mSwordBtk);
         simpleAnmPlay(m_mSwordBrk);
@@ -6920,7 +6935,7 @@ const daAlink_BckData* daAlink_c::getMainBckData(daAlink_c::daAlink_ANM i_anmID)
         {dRes_ID_ALANM_BCK_WAITHS_e, dRes_ID_ALANM_BCK_WAITHK_e},
     };
 
-    if (mEquipItem == dItemNo_KANTERA_e) {
+    if (mEquipItem == dItemNo_KANTERA_e || mEquipItem == dItemNo_GHOST_LANTERN_e) {
         if (i_anmID == ANM_WAIT) {
             return &kandelaarAnm[0];
         }
@@ -12067,7 +12082,8 @@ void daAlink_c::itemUnequip(u16 i_itemID, f32 i_playSpeed) {
     u16 anm_id;
     const daAlinkHIO_anm_c* anm_data;
 
-    if (i_itemID == dItemNo_BOOMERANG_e || i_itemID == dItemNo_COPY_ROD_e || i_itemID == dItemNo_KANTERA_e ||
+    if (i_itemID == dItemNo_BOOMERANG_e || i_itemID == dItemNo_COPY_ROD_e ||
+        i_itemID == dItemNo_KANTERA_e || i_itemID == dItemNo_GHOST_LANTERN_e ||
         i_itemID == dItemNo_HOOKSHOT_e || checkBottleItem(i_itemID))
     {
         anm_id = dRes_ID_ALANM_BCK_TAKEL_e;
@@ -14157,6 +14173,11 @@ BOOL daAlink_c::setItemModel() {
         }
     }
 
+    if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+        setGhostLanternModel();
+        return 1;
+    }
+
     if (mEquipItem == dItemNo_KANTERA_e) {
         setKandelaarModel();
         return 1;
@@ -14498,6 +14519,7 @@ enum daAlink_ItemProc {
     /* 13 */ ITEM_PROC_BOTTLE_SWING,
     /* 14 */ ITEM_PROC_NOT_USE_ITEM,
     /* 15 */ ITEM_PROC_GRASS_WHISTLE,
+    /* 16 */ ITEM_PROC_GHOST_LANTERN,
 };
 
 int daAlink_c::changeItemTriggerKeepProc(u8 i_selItemIdx, int i_procType) {
@@ -14522,7 +14544,8 @@ int daAlink_c::changeItemTriggerKeepProc(u8 i_selItemIdx, int i_procType) {
         } else {
             procKandelaarPourInit();
         }
-    } else if (i_procType == ITEM_PROC_FISHING_FOOD) {
+    }
+    else if (i_procType == ITEM_PROC_FISHING_FOOD) {
         procFishingFoodInit();
     } else if (i_procType == ITEM_PROC_BOOTS_EQUIP) {
         procBootsEquipInit();
@@ -14827,6 +14850,43 @@ void daAlink_c::deleteEquipItem(BOOL i_isPlaySound, BOOL i_isDeleteKantera) {
     }
 }
 
+#if TARGET_PC
+void daAlink_c::setGhostLanternLight() {
+    const daAlinkHIO_huLight_c1* light_m = &mpHIO->mItem.mGhostLanternPL.m;
+
+    BOOL var_r28 = false;
+
+    f32 lightPower = 0.0f;
+    daE_HP_c* foundPoe = (daE_HP_c*)fopAcM_Search(srchPoe, this);
+    if (mEquipItem == dItemNo_GHOST_LANTERN_e && foundPoe != NULL) {
+        lightPower = 1.0f;
+    }
+
+    cLib_chaseF(&current_ghost_lantern_light_power, lightPower, 0.25f);
+
+    cXyz spB8;
+    f32 var_f27;
+    if (current_ghost_lantern_light_power > 0.0f) {
+        GXColor sp30 = {(u8)light_m->mColorR, (u8)light_m->mColorG, (u8)light_m->mColorB, 0xFF};
+        sp30.r = 120;
+        sp30.g = 150;
+        sp30.b = 150;
+
+        Vec sp5C = {0.0f, light_m->mYOffset, light_m->mZOffset};
+
+        f32 var_f26;
+        spB8 = mGhostLanternFlamePos;
+        var_f27 = 0.0f;
+        var_f26 = cM_sht2d(-shape_angle.y);
+
+        dKy_WolfEyeLight_set(&spB8, var_f27 + light_m->mXAngle, var_f26,
+            (light_m->mWidth * current_ghost_lantern_light_power) / light_m->mPower, &sp30, current_ghost_lantern_light_power,
+                             light_m->mAngleAttenuationType,
+                             light_m->mDistanceAttenuationType);
+    }
+}
+#endif
+
 void daAlink_c::setLight() {
     const daAlinkHIO_huLight_c1* light_m = &mpHIO->mItem.mLanternPL.m;
     BOOL var_r28 = false;
@@ -18265,7 +18325,8 @@ int daAlink_c::execute() {
                 resetUpperAnime(UPPER_2, 5.0f);
             }
 
-            if (mEquipItem == dItemNo_KANTERA_e && checkNoUpperAnime() && !checkKandelaarEquipAnime() &&
+            if ((mEquipItem == dItemNo_KANTERA_e || mEquipItem == dItemNo_GHOST_LANTERN_e) &&
+                checkNoUpperAnime() && !checkKandelaarEquipAnime() &&
                 (checkModeFlg(MODE_UNK_1000) || mProcID == PROC_CROUCH))
             {
                 if (checkReinRide()) {
@@ -18616,8 +18677,29 @@ int daAlink_c::execute() {
             setCollision();
             setAttentionPos();
             setLight();
+            #if TARGET_PC
+            setGhostLanternLight();
+            #endif
             setEffect();
 
+            if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+                cXyz effscale(0.75f, 0.75f, 0.75f);
+
+                static u16 particleNmaeDt[2] = {
+                    0x8789,
+                    0x878A,
+                };
+
+                for (s32 i = 0; i < 2; i++) {
+                    ghostLanternFlameEffect[i] = dComIfGp_particle_set(ghostLanternFlameEffect[i], particleNmaeDt[i],
+                                              &mGhostLanternFlamePos, 0, &effscale);
+                }
+            } else {
+                for (s32 i = 0; i < 2; i++) {
+                    stopDrawParticle(ghostLanternFlameEffect[i]);
+                }
+            }
+
             if (mClothesChangeWaitTimer != 0) {
                 mDoMtx_stack_c::copy(mpLinkModel->getBaseTRMtx());
 
@@ -19319,6 +19401,10 @@ void daAlink_c::shadowDraw() {
                     dComIfGd_addRealShadow(shadowID, mpKanteraModel);
                 }
 
+                if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+                    dComIfGd_addRealShadow(shadowID, mpGhostLanternModel);
+                }
+
                 if (checkEquipHeavyBoots()) {
                     for (int i = 0; i < 2; i++) {
                         dComIfGd_addRealShadow(shadowID, mpLinkBootModels[i]);
@@ -19479,6 +19565,22 @@ int daAlink_c::draw() {
         }
     }
 
+    if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+        daE_HP_c* foundPoe = (daE_HP_c*)fopAcM_Search(srchPoe, this);
+
+        for (s32 i = 0; i < 2; i++) {
+            JPABaseEmitter* emitter_gl = dComIfGp_particle_getEmitter(ghostLanternFlameEffect[i]);
+            if (emitter_gl != NULL) {
+                emitter_gl->setLocalTranslation({2.5f, -15.0f, 0.0f});
+                if (checkPlayerNoDraw() || foundPoe == NULL) {
+                    emitter_gl->stopDrawParticle();
+                } else {
+                    emitter_gl->playDrawParticle();
+                }
+            }
+        }
+    }
+
     if (mClothesChangeWaitTimer != 0) {
         if (mProcID == PROC_METAMORPHOSE) {
             if (mProcVar3.field_0x300e > 0) {
@@ -19804,6 +19906,15 @@ int daAlink_c::draw() {
             basicModelDraw(mpKanteraGlowModel);
         }
 
+        if (mEquipItem == dItemNo_GHOST_LANTERN_e) {
+            daE_HP_c* foundPoe = (daE_HP_c*)fopAcM_Search(srchPoe, this);
+            modelDraw(mpGhostLanternModel, isPlayerNoDraw);
+            if (foundPoe != NULL) {
+                preGhostLanternDraw();
+                modelDraw(mpGhostLanternGlowModel, isPlayerNoDraw);
+            }
+        }
+
         if (checkEquipHeavyBoots()) {
             GXColorS10 color = tevStr.TevColor;
             for (int i = 0; i < 2; i++) {

src/d/actor/d_a_alink_demo.inc

@@ -2184,7 +2184,7 @@ void daAlink_c::setGetSubBgm(int i_itemNo) {
         /* dItemNo_NOENTRY_222_e       */ SETYPE_NONE,
         /* dItemNo_NOENTRY_223_e       */ SETYPE_NONE,
         /* dItemNo_POU_SPIRIT_e        */ SETYPE_ITEM_GET_POU,
-        /* dItemNo_NOENTRY_225_e       */ SETYPE_NONE,
+        /* dItemNo_GHOST_LANTERN_e     */ SETYPE_ITEM_GET,
         /* dItemNo_NOENTRY_226_e       */ SETYPE_NONE,
         /* dItemNo_NOENTRY_227_e       */ SETYPE_NONE,
         /* dItemNo_NOENTRY_228_e       */ SETYPE_NONE,

src/d/actor/d_a_alink_kandelaar.inc

@@ -9,6 +9,7 @@
 #include "d/actor/d_a_tag_ss_drink.h"
 #include "m_Do/m_Do_lib.h"
 #include "SSystem/SComponent/c_math.h"
+#include "d/actor/d_a_e_hp.h"
 
 static fopAc_ac_c* daAlink_searchTagKandelaar(fopAc_ac_c* i_actor, void* i_data) {
     UNUSED(i_data);
@@ -138,6 +139,50 @@ int daAlink_c::kandelaarModelCallBack() {
     return 1;
 }
 
+int daAlink_c::ghostLanternModelCallBack() {
+    cXyz sp44;
+    mDoMtx_multVecZero(J3DSys::mCurrentMtx, &sp44);
+
+    ghost_lantern_0x3630 = ghost_lantern_0x3624;
+    ghost_lantern_0x3624 = mGhostLanternFlamePos;
+
+    cXyz sp38 = (mGhostLanternFlamePos - sp44) + ghost_lantern_0x3618;
+    sp38.y -= 3.0f;
+
+    cXyz sp2C;
+    mDoMtx_multVec(J3DSys::mCurrentMtx, &cXyz::BaseZ, &sp2C);
+
+    s16 var_r29 = sp2C.atan2sX_Z();
+    mDoMtx_stack_c::YrotS(-var_r29);
+    mDoMtx_stack_c::multVec(&sp38, &sp38);
+
+    s16 var_r28 = cLib_minMaxLimit<s16>(cM_atan2s(-sp38.z, -sp38.y), -0x1800, 0x1800);
+    s16 var_r27 = cLib_minMaxLimit<s16>(cM_atan2s(sp38.x, JMAFastSqrt(SQUARE(sp38.y) + SQUARE(sp38.z))), -0x1800, 0x1800);
+
+    mDoMtx_stack_c::transS(sp44);
+    if (mProcID != PROC_OPEN_TREASURE && (mProcID != PROC_GET_ITEM || mProcVar4.field_0x3010 == 0)) {
+        mDoMtx_stack_c::ZXYrotM(var_r28, var_r29, var_r27);
+    }
+
+    static Vec const ghostLanternOffset = {0.0f, -20.0f, 0.0f};
+    mDoMtx_stack_c::multVec(&ghostLanternOffset, &mGhostLanternFlamePos);
+
+    ghost_lantern_0x3618 = (mGhostLanternFlamePos - ghost_lantern_0x3624) * 0.9f;
+
+    if (!checkEndResetFlg1(ERFLG1_UNK_8) && mpGhostLanternModel != nullptr) {
+        f32 scale = JMAFastSqrt(SQUARE(J3DSys::mCurrentMtx[0][0]) + SQUARE(J3DSys::mCurrentMtx[1][0]) + SQUARE(J3DSys::mCurrentMtx[2][0]));
+        mDoMtx_stack_c::transS(J3DSys::mCurrentMtx[0][3], J3DSys::mCurrentMtx[1][3], J3DSys::mCurrentMtx[2][3]);
+        mDoMtx_stack_c::ZXYrotM(var_r28, var_r29, var_r27);
+        mDoMtx_stack_c::ZXYrotM(0, 0, -16384);
+        mDoMtx_stack_c::scaleM(scale, scale, scale);
+
+        mpGhostLanternModel->setAnmMtx(1, mDoMtx_stack_c::get());
+        cMtx_copy(mDoMtx_stack_c::get(), J3DSys::mCurrentMtx);
+    }
+
+    return 1;
+}
+
 static int daAlink_kandelaarModelCallBack(J3DJoint* i_joint, int param_1) {
     UNUSED(i_joint);
 
@@ -150,6 +195,18 @@ static int daAlink_kandelaarModelCallBack(J3DJoint* i_joint, int param_1) {
     return 1;
 }
 
+static int daAlink_ghostLanternModelCallBack(J3DJoint* i_joint, int param_1) {
+    UNUSED(i_joint);
+
+    daAlink_c* player_p = (daAlink_c*)j3dSys.getModel()->getUserArea();
+
+    if (param_1 == 0) {
+        player_p->ghostLanternModelCallBack();
+    }
+
+    return 1;
+}
+
 cXyz* daAlink_c::getKandelaarFlamePos() {
     if ((!checkNoResetFlg2(daPy_FLG2(FLG2_UNK_20000 | FLG2_UNK_1)) && !checkEndResetFlg1(ERFLG1_UNK_4)) ||
         checkWolf() || !checkNoResetFlg1(FLG1_UNK_80))
@@ -164,6 +221,60 @@ BOOL daAlink_c::checkKandelaarEquipAnime() const {
     return checkUpperAnime(dRes_ID_ALANM_BCK_WAITHK_e) || checkUpperAnime(dRes_ID_ALANM_BCK_WAITK_e);
 }
 
+void* daAlink_c::srchPoe(void* i_actor, void* i_this) {
+    if (i_actor != NULL && i_actor != i_this) {
+        if (fopAcM_IsExecuting(fopAcM_GetID(i_actor)) && fopAcM_GetName(i_actor) == fpcNm_E_HP_e) {
+            return i_actor;
+        }
+    }
+    return NULL;
+}
+
+void daAlink_c::preGhostLanternDraw() {
+    J3DMaterial* mat_p = mpGhostLanternGlowModel->getModelData()->getMaterialNodePointer(0);
+
+    J3DGXColorS10 color;
+    color.r = 120;
+    color.g = 150;
+    color.b = 150;
+    color.a = 255;
+    mat_p->setTevColor(1, &color);
+
+    color.r = 0;
+    color.g = 60;
+    color.b = 101;
+    mat_p->setTevColor(2, &color);
+
+    cXyz proj;
+    mDoLib_project(&mGhostLanternFlamePos, &proj);
+
+    camera_process_class* camera_p = dComIfGp_getCamera(0);
+    f32 trimHeight;
+    if (camera_p != NULL) {
+        trimHeight = camera_p->mCamera.TrimHeight();
+    } else {
+        trimHeight = 0.0f;
+    }
+
+    if (proj.x > 0.0f && proj.x < FB_WIDTH && proj.y > trimHeight && proj.y < FB_HEIGHT - trimHeight) {
+        dComIfGd_peekZ(proj.x, proj.y, &field_0x32c8);
+    } else {
+        field_0x32c8 = 0;
+    }
+
+    f32 near_ = dComIfGd_getView()->near_;
+    f32 far_ = dComIfGd_getView()->far_;
+
+    mDoLib_pos2camera(&mGhostLanternFlamePos, &proj);
+
+    proj.z += 30.0f;
+    if (proj.z > -0.01f) {
+        proj.z = -0.01f;
+    }
+
+    field_0x344c = ((near_ + (far_ * near_) / proj.z) / (far_ - near_) + 1.0f) * 1.6777215E7f;
+}
+
 void daAlink_c::preKandelaarDraw() {
     J3DMaterial* mat_p = mpKanteraGlowModel->getModelData()->getMaterialNodePointer(0);
 
@@ -208,6 +319,16 @@ void daAlink_c::preKandelaarDraw() {
     field_0x344c = ((near_ + (far_ * near_) / proj.z) / (far_ - near_) + 1.0f) * 1.6777215E7f;
 }
 
+void daAlink_c::setGhostLanternModel() {
+    field_0x2f94 = 0;
+
+    mDoMtx_multVecZero(mpLinkModel->getAnmMtx(mLeftItemJntNo), &mGhostLanternFlamePos);
+
+    ghost_lantern_0x3630 = ghost_lantern_0x3624;
+    ghost_lantern_0x3624 = mGhostLanternFlamePos;
+    ghost_lantern_0x3618 = cXyz::Zero;
+}
+
 void daAlink_c::setKandelaarModel() {
     field_0x2f94 = 0;
 

src/d/actor/d_a_alink_swindow.inc

@@ -77,7 +77,12 @@ int daAlink_c::loadModelDVD() {
             mpWlMidnaHairModel = NULL;
 
             if (!checkNoResetFlg2(FLG2_UNK_280000)) {
-                dComIfG_resDelete(&mPhaseReq, mArcName);
+                if (!dComIfG_resDelete(&mPhaseReq, mArcName)) {
+#if TARGET_PC
+                    // resDelete no-ops if load was in-progress; force-unregister before freeAll
+                    dComIfG_deleteObjectResMain(mArcName);
+#endif
+                }
                 cPhs_Reset(&mPhaseReq);
                 mpArcHeap->freeAll();
 

src/d/actor/d_a_alink_wolf.inc

@@ -300,6 +300,7 @@ void daAlink_c::changeWolf() {
     mAtSph.SetR(40.0f);
 
     mpKanteraModel = NULL;
+    mpGhostLanternModel = NULL;
     mpLinkHatModel = NULL;
     mpLinkFaceModel = NULL;
     mpLinkHandModel = NULL;
@@ -406,12 +407,20 @@ void daAlink_c::changeLink(int param_0) {
 
     modelData = static_cast<J3DModelData*>(dComIfG_getObjectRes(mArcName, "ef_ktGlow.bmd"));
     mpKanteraGlowModel = initModel(modelData, 0x200);
-
     mpKanteraGlowBtk = static_cast<J3DAnmTextureSRTKey*>(dComIfG_getObjectRes(mArcName, "ef_ktGlow.btk"));
     mpKanteraGlowBtk->setFrame(0.0f);
     mpKanteraGlowBtk->searchUpdateMaterialID(modelData);
     modelData->entryTexMtxAnimator(mpKanteraGlowBtk);
 
+    mpGhostLanternModel = initModelEnv(static_cast<J3DModelData*>(dComIfG_getObjectRes("E_HP", "hp_ori.bmd")), 0);
+
+    modelData = static_cast<J3DModelData*>(dComIfG_getObjectRes(mArcName, "ef_ktGlow.bmd"));
+    mpGhostLanternGlowModel = initModel(modelData, 0x200);
+    mpGhostLanternGlowBtk = static_cast<J3DAnmTextureSRTKey*>(dComIfG_getObjectRes(mArcName, "ef_ktGlow.btk"));
+    mpGhostLanternGlowBtk->setFrame(0.0f);
+    mpGhostLanternGlowBtk->searchUpdateMaterialID(modelData);
+    modelData->entryTexMtxAnimator(mpGhostLanternGlowBtk);
+
     mWoodSwordModel = initModel(static_cast<J3DModelData*>(dComIfG_getObjectRes(mArcName, "al_SWB.bmd")), 0);
 
     mDoExt_setCurrentHeap(current_heap);
@@ -504,6 +513,10 @@ void daAlink_c::changeLink(int param_0) {
 
     mpKanteraModel->setUserArea((uintptr_t)this);
     mpKanteraModel->getModelData()->getJointNodePointer(1)->setCallBack(daAlink_kandelaarModelCallBack);
+
+    mpGhostLanternModel->setUserArea((uintptr_t)this);
+    mpGhostLanternModel->getModelData()->getJointNodePointer(1)->setCallBack(daAlink_ghostLanternModelCallBack);
+
     mZ2Link.setLinkState(var_r27);
 
 #if VERSION != VERSION_SHIELD_DEBUG
@@ -8723,6 +8736,12 @@ int daAlink_c::procWolfCargoCarry() {
             return checkNextActionWolf(0);
         }
 
+#if TARGET_PC
+        if (field_0x280c.getActor() == NULL) {
+            return checkNextActionWolf(0);
+        }
+#endif
+
         mDoMtx_stack_c::copy(((e_yc_class*)field_0x280c.getActor())->getLegR3Mtx());
         mDoMtx_stack_c::transM(-9.0f, -7.0f, -30.0f);
         mDoMtx_stack_c::multVecZero(&current.pos);

src/d/actor/d_a_e_rd.cpp

@@ -7053,6 +7053,12 @@ static int daE_RD_IsDelete(e_rd_class*) {
 }
 
 static int daE_RD_Delete(e_rd_class* i_this) {
+#if TARGET_PC
+    if (boss == i_this) {
+        boss = NULL;
+    }
+#endif
+
     fopEn_enemy_c* enemy = (fopEn_enemy_c*)&i_this->enemy;
     fopAcM_RegisterDeleteID(i_this, "E_RD");
 

src/d/d_cc_uty.cpp

@@ -15,6 +15,7 @@
 #include "f_op/f_op_actor_mng.h"
 #if TARGET_PC
 #include "dusk/achievements.h"
+#include "dusk/settings.h"
 #endif
 
 static int plCutLRC[58] = {
@@ -429,6 +430,13 @@ fopAc_ac_c* cc_at_check(fopAc_ac_c* i_enemy, dCcU_AtInfo* i_AtInfo) {
             }
         }
 
+#if TARGET_PC
+        if (dusk::getSettings().game.invincibleEnemies &&
+            fopAcM_GetGroup(i_enemy) == fopAc_ENEMY_e) {
+            i_AtInfo->mAttackPower = 0;
+        }
+#endif
+
         if (i_AtInfo->mAttackPower != 0) {
             i_enemy->health -= i_AtInfo->mAttackPower;
         }

src/d/d_ev_camera.cpp

@@ -3882,7 +3882,11 @@ bool dCamera_c::hintTalkEvCamera() {
 
         cSAngle acStack_1fc(20.0f);
         for (i = 0; i < 2; i++) {
+#if AVOID_UB
+            for (j = 0; j < 10; j++) {
+#else
             for (j = 0; j < 12; j++) {
+#endif
                 cSAngle acStack_200(local_b0[j] * fVar22);
                 hintTalk->mDirection.U(acStack_1f8 + acStack_200);
                 hintTalk->mDirection.V(((hintTalk->field_0x28.V() * acStack_200.Cos()) * 0.2f) + acStack_1fc);

src/d/d_item.cpp

@@ -236,7 +236,7 @@ static void (*item_func_ptr[256])() = {
     item_func_noentry,
     item_func_noentry,
     item_func_POU_SPIRIT,
-    item_func_noentry,
+    item_func_GHOST_LANTERN,
     item_func_noentry,
     item_func_noentry,
     item_func_noentry,
@@ -504,7 +504,7 @@ static int (*item_getcheck_func_ptr[256])() = {
     item_getcheck_func_noentry,
     item_getcheck_func_noentry,
     item_getcheck_func_POU_SPIRIT,
-    item_getcheck_func_noentry,
+    item_getcheck_func_GHOST_LANTERN,
     item_getcheck_func_noentry,
     item_getcheck_func_noentry,
     item_getcheck_func_noentry,
@@ -791,6 +791,10 @@ void item_func_IRONBALL() {
     dComIfGs_setItem(SLOT_6, dItemNo_IRONBALL_e);
 }
 
+void item_func_GHOST_LANTERN() {
+    dComIfGs_setItem(SLOT_7, dItemNo_GHOST_LANTERN_e);
+}
+
 void item_func_BOW() {
     dComIfGs_setItem(SLOT_4, dItemNo_BOW_e);
     dComIfGs_setArrowNum(30);
@@ -1453,6 +1457,10 @@ int item_getcheck_func_IRONBALL() {
     return dComIfGs_getItem(SLOT_6, true) == dItemNo_IRONBALL_e ? TRUE : FALSE;
 }
 
+int item_getcheck_func_GHOST_LANTERN() {
+    return dComIfGs_getItem(SLOT_7, true) == dItemNo_GHOST_LANTERN_e ? TRUE : FALSE;
+}
+
 int item_getcheck_func_BOW() {
     return dComIfGs_getItem(SLOT_4, false) == dItemNo_BOW_e ? TRUE : FALSE;
 }

src/d/d_s_logo.cpp

@@ -1481,6 +1481,9 @@ void dScnLogo_c::dvdDataLoad() {
     OS_REPORT("\x1b[32m%d archiveHeap->getTotalFreeSize %08x\n\x1b[m", 2421, archiveHeap->getTotalFreeSize());
     archiveHeap->dump_sort();
 
+    rt = dComIfG_setObjectRes("E_HP", (u8)0, NULL);
+    JUT_ASSERT(2425, rt == 1);
+
     rt = dComIfG_setObjectRes("Alink", (u8)0, NULL);
     JUT_ASSERT(2429, rt == 1);
 

src/d/d_save.cpp

@@ -432,11 +432,11 @@ u8 dSv_player_item_c::getItem(int i_slotNo, bool i_checkCombo) const {
 }
 
 void dSv_player_item_c::setLineUpItem() {
-    static u8 i_item_lst[23] = {
+    static u8 i_item_lst[24] = {
         10, 8,  6,  2,  9,  4,  3,
-        0,  1,  23, 20, 5,  15, 16,
-        17, 11, 12, 13, 14, 19, 18,
-        22, 21
+        0,  1,  7,  23, 20, 5,  15,
+        16, 17, 11, 12, 13, 14, 19,
+        18, 22, 21
     };
 
     int slot_idx = 0;
@@ -445,7 +445,7 @@ void dSv_player_item_c::setLineUpItem() {
         mItemSlots[i] = dItemNo_NONE_e;
     }
 
-    for (int i = 0; i < 23; i++) {
+    for (int i = 0; i < 24; i++) {
         u8 current = i_item_lst[i];
         if (mItems[current] != dItemNo_NONE_e) {
             mItemSlots[slot_idx] = current;

src/dusk/autosave.cpp

@@ -26,8 +26,12 @@ void updateAutoSave() {
     (AutoSaveFuncsProc[mAutoSaveProc])();
 }
 
-void writeAutoSave() {
-    int stageNo = dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo());
+bool writeAutoSave() {
+    stage_stag_info_class* stagInfo = dComIfGp_getStageStagInfo();
+    if (stagInfo == nullptr) {
+        return false;
+    }
+    int stageNo = dStage_stagInfo_GetSaveTbl(stagInfo);
 
     dComIfGs_putSave(stageNo);
     dComIfGs_setMemoryToCard(mSaveBuffer, dComIfGs_getDataNum());
@@ -40,6 +44,7 @@ void writeAutoSave() {
     }
 
     g_mDoMemCd_control.save(mSaveBuffer, sizeof(mSaveBuffer), 0);
+    return true;
 }
 
 void autoSaving() {
@@ -48,8 +53,9 @@ void autoSaving() {
         if (cardState == 2) {
             mAutoSaveProc = 1;
         } else if (cardState == 1) {
-            writeAutoSave();
-            mAutoSaveProc = 3;
+            if (writeAutoSave()) {
+                mAutoSaveProc = 3;
+            }
         }
     }
 }

src/dusk/config.cpp

@@ -61,7 +61,7 @@ void ConfigImpl<T>::loadFromJson(ConfigVar<T>& cVar, const json& jsonValue) {
 
 template<ConfigValue T>
 nlohmann::json ConfigImpl<T>::dumpToJson(const ConfigVar<T>& cVar) {
-    return cVar.getValue();
+    return cVar.getValueForSave();
 }
 
 template<ConfigValue T> requires std::is_integral_v<T> && std::is_signed_v<T>
@@ -249,7 +249,8 @@ void dusk::config::Save() {
     json j;
 
     for (const auto& pair : RegisteredConfigVars) {
-        if (pair.second->getLayer() == ConfigVarLayer::Value) {
+        const auto layer = pair.second->getLayer();
+        if (layer == ConfigVarLayer::Value || layer == ConfigVarLayer::Speedrun) {
             j[pair.first] = pair.second->getImpl()->dumpToJson(*pair.second);
         }
     }

src/dusk/crash_reporting.cpp

@@ -61,7 +61,7 @@ std::string release_name() {
 }
 
 std::filesystem::path sentry_database_path() {
-    return dusk::ConfigPath / "sentry";
+    return dusk::CachePath / "sentry";
 }
 
 std::filesystem::path log_attachment_path() {

src/dusk/data.cpp

@@ -6,6 +6,7 @@
 #include "dusk/main.h"
 
 #include <array>
+#include <chrono>
 #include <filesystem>
 #include <optional>
 #include <ranges>
@@ -30,6 +31,21 @@ constexpr auto kLocationDescriptorName = "data_location.json";
 constexpr auto kPipelineCacheName = "pipeline_cache.db";
 constexpr auto kInitialPipelineCacheName = "initial_pipeline_cache.db";
 
+constexpr std::array<std::string_view, 4> kUserDataDirectories = {
+    "texture_replacements",
+    "USA",
+    "EUR",
+    "JAP",
+};
+constexpr std::array<std::string_view, 6> kUserDataFiles = {
+    "achievements.json",
+    "config.json",
+    "controller_ports.dat",
+    "imgui.ini",
+    "keyboard_bindings.dat",
+    "states.json",
+};
+
 enum class LocationMode {
     Default,
     Portable,
@@ -62,6 +78,7 @@ struct MigrationStats {
 
 std::optional<std::filesystem::path> sConfiguredDataPath;
 std::optional<std::filesystem::path> sActiveDescriptorPath;
+std::optional<std::filesystem::path> sActivePrefPath;
 
 std::filesystem::path path_from_utf8(std::string_view value) {
     return std::filesystem::path{
@@ -70,19 +87,22 @@ std::filesystem::path path_from_utf8(std::string_view value) {
     };
 }
 
-std::filesystem::path get_legacy_path() {
-    if (std::string_view{LegacyAppName}.empty()) {
+std::filesystem::path legacy_path_for_pref_path(const std::filesystem::path& prefPath) {
+    if (std::string_view{LegacyAppName}.empty() || prefPath.empty()) {
         return {};
     }
 
-    char* prefPath = SDL_GetPrefPath(OrgName, LegacyAppName);
-    if (!prefPath) {
-        Log.fatal("Unable to get PrefPath: {}", SDL_GetError());
+    auto normalizedPrefPath = prefPath;
+    if (normalizedPrefPath.filename().empty()) {
+        normalizedPrefPath = normalizedPrefPath.parent_path();
     }
 
-    std::filesystem::path result{reinterpret_cast<const char8_t*>(prefPath)};
-    SDL_free(prefPath);
-    return result;
+    const auto parentPath = normalizedPrefPath.parent_path();
+    if (parentPath.empty()) {
+        return {};
+    }
+
+    return parentPath / LegacyAppName;
 }
 
 std::filesystem::path get_pref_path() {
@@ -96,6 +116,13 @@ std::filesystem::path get_pref_path() {
     return result;
 }
 
+std::filesystem::path active_pref_path() {
+    if (sActivePrefPath) {
+        return *sActivePrefPath;
+    }
+    return get_pref_path();
+}
+
 std::filesystem::path base_path_relative(const std::filesystem::path& path) {
     const auto* basePath = SDL_GetBasePath();
     if (!basePath) {
@@ -249,6 +276,69 @@ std::filesystem::path absolute_path(const std::filesystem::path& path) {
     return absolute.lexically_normal();
 }
 
+std::filesystem::path rename_legacy_pref_path(
+    const std::filesystem::path& legacyPath, const std::filesystem::path& prefPath) {
+    if (legacyPath.empty() || prefPath.empty() ||
+        normalized_path(legacyPath) == normalized_path(prefPath))
+    {
+        return prefPath;
+    }
+
+    std::error_code ec;
+    if (!std::filesystem::exists(legacyPath, ec)) {
+        if (ec) {
+            Log.warn("Failed to inspect legacy data directory '{}': {}",
+                io::fs_path_to_string(legacyPath), ec.message());
+        }
+        return prefPath;
+    }
+
+    const bool prefExists = std::filesystem::exists(prefPath, ec);
+    if (ec) {
+        Log.warn("Failed to inspect data directory '{}': {}", io::fs_path_to_string(prefPath),
+            ec.message());
+        return prefPath;
+    }
+    if (prefExists) {
+        if (!std::filesystem::is_directory(prefPath, ec) ||
+            !std::filesystem::is_empty(prefPath, ec))
+        {
+            if (ec) {
+                Log.warn("Failed to inspect data directory '{}': {}",
+                    io::fs_path_to_string(prefPath), ec.message());
+            } else {
+                Log.info("Skipping legacy data directory rename because '{}' is not empty",
+                    io::fs_path_to_string(prefPath));
+            }
+            return prefPath;
+        }
+
+        std::filesystem::remove(prefPath, ec);
+        if (ec) {
+            Log.warn("Failed to remove empty data directory '{}' before legacy rename: {}",
+                io::fs_path_to_string(prefPath), ec.message());
+            return prefPath;
+        }
+    }
+
+    std::filesystem::rename(legacyPath, prefPath, ec);
+    if (ec) {
+        Log.warn("Failed to rename legacy data directory '{}' to '{}': {}",
+            io::fs_path_to_string(legacyPath), io::fs_path_to_string(prefPath), ec.message());
+        ec.clear();
+        if (!std::filesystem::exists(prefPath, ec) && !ec) {
+            Log.info("Using legacy data directory '{}' because the new data directory is absent",
+                io::fs_path_to_string(legacyPath));
+            return legacyPath;
+        }
+        return prefPath;
+    }
+
+    Log.info("Renamed legacy data directory '{}' to '{}'", io::fs_path_to_string(legacyPath),
+        io::fs_path_to_string(prefPath));
+    return prefPath;
+}
+
 bool is_same_or_inside(const std::filesystem::path& root, const std::filesystem::path& path) {
     const auto normalizedRoot = normalized_path(root);
     const auto normalizedPath = normalized_path(path);
@@ -283,85 +373,46 @@ bool should_skip_migration_path(const std::filesystem::path& path,
     return false;
 }
 
-bool has_location_descriptor(const std::filesystem::path& path) {
-    std::error_code ec;
-    return std::filesystem::exists(path / kLocationDescriptorName, ec);
+bool matches_name(std::string_view name, const auto& names) {
+    return std::ranges::find(names, name) != names.end();
 }
 
-bool remove_empty_destination_for_rename(const std::filesystem::path& path) {
-    std::error_code ec;
-    const bool exists = std::filesystem::exists(path, ec);
-    if (ec) {
-        Log.debug("Could not inspect migration destination '{}': {}", io::fs_path_to_string(path),
-            ec.message());
+bool should_migrate_user_data_path(
+    const std::filesystem::path& sourcePath, const std::filesystem::path& from) {
+    const auto relativePath = sourcePath.lexically_relative(from);
+    if (relativePath.empty() || relativePath.is_absolute()) {
         return false;
     }
-    if (!exists) {
+
+    auto it = relativePath.begin();
+    if (it == relativePath.end() || *it == "..") {
+        return false;
+    }
+
+    const auto first = io::fs_path_to_string(*it);
+    if (matches_name(first, kUserDataDirectories)) {
         return true;
     }
 
-    const bool canRemove = std::filesystem::is_directory(path, ec) &&
-                           std::filesystem::is_empty(path, ec) && !has_location_descriptor(path);
-    if (ec || !canRemove) {
-        if (ec) {
-            Log.debug("Could not inspect migration destination '{}': {}",
-                io::fs_path_to_string(path), ec.message());
-        }
+    ++it;
+    if (it != relativePath.end()) {
         return false;
     }
 
-    std::filesystem::remove(path, ec);
-    if (ec) {
-        Log.debug("Could not remove empty migration destination '{}': {}",
-            io::fs_path_to_string(path), ec.message());
-        return false;
+    const auto filename = io::fs_path_to_string(relativePath.filename());
+    if (matches_name(filename, kUserDataFiles)) {
+        return true;
     }
 
-    return true;
-}
-
-bool try_rename_directory_migration(
-    const std::filesystem::path& from, const std::filesystem::path& to) {
-    std::error_code ec;
-    if (!std::filesystem::is_directory(from, ec)) {
-        return false;
-    }
-    if (ec) {
-        Log.debug("Could not inspect migration source '{}': {}", io::fs_path_to_string(from),
-            ec.message());
-        return false;
-    }
-    if (has_location_descriptor(from)) {
-        return false;
-    }
-    if (!remove_empty_destination_for_rename(to)) {
-        return false;
-    }
-
-    std::filesystem::create_directories(to.parent_path(), ec);
-    if (ec) {
-        Log.debug("Could not create migration destination parent '{}': {}",
-            io::fs_path_to_string(to.parent_path()), ec.message());
-        return false;
-    }
-
-    std::filesystem::rename(from, to, ec);
-    if (ec) {
-        Log.debug("Could not rename data directory '{}' to '{}': {}", io::fs_path_to_string(from),
-            io::fs_path_to_string(to), ec.message());
-        return false;
-    }
-
-    Log.info("Renamed data directory '{}' to '{}'", io::fs_path_to_string(from),
-        io::fs_path_to_string(to));
-    return true;
+    return relativePath.extension() == ".controller" || relativePath.extension() == ".gci" ||
+           (filename.starts_with("MemoryCard") && filename.ends_with(".raw"));
 }
 
 std::filesystem::path current_data_path() {
     if (!ConfigPath.empty()) {
         return ConfigPath;
     }
-    const auto prefPath = get_pref_path();
+    const auto prefPath = active_pref_path();
     const auto descriptor = read_location_descriptor(prefPath);
     if (descriptor) {
         sActiveDescriptorPath = descriptor->path;
@@ -427,7 +478,7 @@ bool write_location_descriptor(LocationMode mode, const std::filesystem::path& t
         json["previousPath"] = io::fs_path_to_string(descriptor.previousPath);
     }
 
-    const auto prefPath = get_pref_path();
+    const auto prefPath = active_pref_path();
     for (const auto& path : descriptor_write_paths(prefPath)) {
         if (write_descriptor_json(path, json)) {
             sActiveDescriptorPath = path;
@@ -439,6 +490,61 @@ bool write_location_descriptor(LocationMode mode, const std::filesystem::path& t
     return false;
 }
 
+void set_error(std::string* errorOut, std::string error) {
+    if (errorOut != nullptr) {
+        *errorOut = std::move(error);
+    }
+}
+
+bool validate_writable_data_path(const std::filesystem::path& path, std::string* errorOut) {
+    if (path.empty()) {
+        set_error(errorOut, "Choose a folder.");
+        return false;
+    }
+
+    std::error_code ec;
+    std::filesystem::create_directories(path, ec);
+    if (ec) {
+        set_error(errorOut, fmt::format("{} could not create the selected folder.", AppName));
+        Log.warn("Failed to create custom data folder '{}': {}", io::fs_path_to_string(path),
+            ec.message());
+        return false;
+    }
+
+    if (!std::filesystem::is_directory(path, ec)) {
+        set_error(errorOut, "The selected path is not a folder.");
+        if (ec) {
+            Log.warn("Failed to inspect custom data folder '{}': {}", io::fs_path_to_string(path),
+                ec.message());
+        }
+        return false;
+    }
+
+    const auto probePath = path / fmt::format(".write-probe-{}.tmp",
+                                      std::chrono::steady_clock::now().time_since_epoch().count());
+    try {
+        io::FileStream::WriteAllText(probePath, "dusk");
+    } catch (const std::exception& e) {
+        set_error(errorOut, fmt::format("{} could not write to the selected folder.", AppName));
+        Log.warn("Failed write probe for custom data folder '{}': {}", io::fs_path_to_string(path),
+            e.what());
+        return false;
+    }
+
+    std::filesystem::remove(probePath, ec);
+    if (ec) {
+        set_error(
+            errorOut, fmt::format("{} could write to the selected folder, but could not remove "
+                                  "the test file it created.",
+                          AppName));
+        Log.warn("Failed to remove custom data folder write probe '{}': {}",
+            io::fs_path_to_string(probePath), ec.message());
+        return false;
+    }
+
+    return true;
+}
+
 std::uintmax_t remove_empty_directories(const std::filesystem::path& root, bool includeRoot) {
     std::error_code ec;
     std::vector<std::filesystem::path> directories;
@@ -647,14 +753,6 @@ void migrate_directory(const std::filesystem::path& from, const std::filesystem:
         return;
     }
 
-    if (try_rename_directory_migration(from, to)) {
-        return;
-    }
-
-    if (try_rename_directory_migration(from, to)) {
-        return;
-    }
-
     std::filesystem::create_directories(to, ec);
     if (ec) {
         ++stats.failures;
@@ -700,6 +798,16 @@ void migrate_directory(const std::filesystem::path& from, const std::filesystem:
             continue;
         }
 
+        if (!should_migrate_user_data_path(sourcePath, from)) {
+            ++stats.skippedUnsupportedEntries;
+            if (std::filesystem::is_directory(status)) {
+                it.disable_recursion_pending();
+            }
+            ec.clear();
+            it.increment(ec);
+            continue;
+        }
+
         const auto relativePath = sourcePath.lexically_relative(from);
         if (relativePath.empty() || relativePath.is_absolute()) {
             ++stats.failures;
@@ -761,8 +869,6 @@ void migrate_data(const std::filesystem::path& prefPath, const std::filesystem::
     const LocationDescriptor* descriptor) {
     if (descriptor && !descriptor->previousPath.empty()) {
         migrate_directory(descriptor->previousPath, dataPath, prefPath);
-    } else if (const auto legacyPath = get_legacy_path(); !legacyPath.empty()) {
-        migrate_directory(legacyPath, dataPath, prefPath);
     }
 }
 
@@ -899,17 +1005,25 @@ bool open_data_path() {
 #endif
 }
 
-bool set_custom_data_path(const std::filesystem::path& path) {
-    if (path.empty()) {
-        Log.warn("Ignoring empty custom data path");
+bool set_custom_data_path(const std::filesystem::path& path, std::string* errorOut) {
+    if (!validate_writable_data_path(path, errorOut)) {
         return false;
     }
 
-    return write_location_descriptor(LocationMode::Custom, path);
+    if (!write_location_descriptor(LocationMode::Custom, path)) {
+        set_error(errorOut, fmt::format("{} could not save the data folder setting.", AppName));
+        return false;
+    }
+
+    return true;
 }
 
-bool set_custom_data_path(const char* path) {
-    return set_custom_data_path(path_from_utf8(path));
+bool set_custom_data_path(const char* path, std::string* errorOut) {
+    if (path == nullptr) {
+        set_error(errorOut, "Choose a folder.");
+        return false;
+    }
+    return set_custom_data_path(path_from_utf8(path), errorOut);
 }
 
 bool set_portable_data_path() {
@@ -917,12 +1031,12 @@ bool set_portable_data_path() {
 }
 
 bool reset_data_path() {
-    const auto prefPath = get_pref_path();
+    const auto prefPath = active_pref_path();
     return write_location_descriptor(LocationMode::Default, default_data_path(prefPath));
 }
 
 bool is_default_data_path() {
-    const auto prefPath = get_pref_path();
+    const auto prefPath = active_pref_path();
     return normalized_path(configured_data_path()) == normalized_path(default_data_path(prefPath));
 }
 
@@ -931,7 +1045,7 @@ std::filesystem::path configured_data_path() {
         return *sConfiguredDataPath;
     }
 
-    const auto prefPath = get_pref_path();
+    const auto prefPath = active_pref_path();
     const auto descriptor = read_location_descriptor(prefPath);
     if (descriptor) {
         sActiveDescriptorPath = descriptor->path;
@@ -941,6 +1055,13 @@ std::filesystem::path configured_data_path() {
     return *sConfiguredDataPath;
 }
 
+std::filesystem::path cache_path() {
+    if (!CachePath.empty()) {
+        return CachePath;
+    }
+    return active_pref_path();
+}
+
 bool is_data_path_restart_pending() {
     if (ConfigPath.empty()) {
         return false;
@@ -949,8 +1070,12 @@ bool is_data_path_restart_pending() {
     return normalized_path(ConfigPath) != normalized_path(configured_data_path());
 }
 
-std::filesystem::path initialize_data() {
-    const auto prefPath = get_pref_path();
+Paths initialize_data() {
+    const auto preferredPrefPath = get_pref_path();
+    const auto prefPath =
+        rename_legacy_pref_path(legacy_path_for_pref_path(preferredPrefPath), preferredPrefPath);
+    sActivePrefPath = prefPath;
+
     const auto descriptor = read_location_descriptor(prefPath);
     if (descriptor) {
         sActiveDescriptorPath = descriptor->path;
@@ -963,9 +1088,13 @@ std::filesystem::path initialize_data() {
 
     migrate_data(prefPath, dataPath, descriptor ? &descriptor->descriptor : nullptr);
     ensure_data_directory(dataPath);
-    ensure_initial_pipeline_cache(dataPath);
+    ensure_data_directory(prefPath);
+    ensure_initial_pipeline_cache(prefPath);
 
-    return dataPath;
+    return Paths{
+        .userPath = dataPath,
+        .cachePath = prefPath,
+    };
 }
 
 }  // namespace dusk::data

src/dusk/data.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <filesystem>
+#include <string>
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
@@ -14,7 +15,7 @@
 #define DUSK_CAN_OPEN_DATA_FOLDER 0
 #endif
 
-#if defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST
+#if (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST) || defined(__ANDROID__)
 #define DUSK_CAN_CHANGE_DATA_FOLDER 0
 #else
 #define DUSK_CAN_CHANGE_DATA_FOLDER 1
@@ -22,11 +23,17 @@
 
 namespace dusk::data {
 
-std::filesystem::path initialize_data();
+struct Paths {
+    std::filesystem::path userPath;
+    std::filesystem::path cachePath;
+};
+
+Paths initialize_data();
 std::filesystem::path configured_data_path();
+std::filesystem::path cache_path();
 bool open_data_path();
-bool set_custom_data_path(const char* path);
-bool set_custom_data_path(const std::filesystem::path& path);
+bool set_custom_data_path(const char* path, std::string* errorOut);
+bool set_custom_data_path(const std::filesystem::path& path, std::string* errorOut);
 bool set_portable_data_path();
 bool reset_data_path();
 bool is_default_data_path();

src/dusk/imgui/ImGuiConsole.cpp

@@ -368,9 +368,7 @@ namespace dusk {
             m_menuTools.ShowProcessManager();
             m_menuTools.ShowHeapOverlay();
             m_menuTools.ShowStubLog();
-            m_menuTools.ShowMapLoader();
             m_menuTools.ShowBloomWindow();
-            m_menuTools.ShowEnhancedLightingWindow();
             m_menuTools.ShowPlayerInfo();
             m_menuTools.ShowAudioDebug();
             m_menuTools.ShowSaveEditor();

src/dusk/imgui/ImGuiEnhancedLightingWindow.cpp

@@ -1,103 +0,0 @@
-#include "imgui.h"
-
-#include "ImGuiEnhancedLightingWindow.hpp"
-#include "ImGuiMenuTools.hpp"
-#include "dusk/config.hpp"
-#include "dusk/settings.h"
-
-#include <aurora/gfx.h>
-
-namespace dusk {
-
-static void ApplyFromSettings() {
-    const auto& g = getSettings().game;
-    aurora_set_enhanced_lighting_state({
-        g.enhancedLighting.getValue(),
-        g.enableSpecularLighting.getValue(),
-        g.enableRimLighting.getValue(),
-        g.specularIntensity.getValue(),
-        g.rimIntensity.getValue(),
-        g.ambientLightMultiplier.getValue(),
-        g.diffuseLightMultiplier.getValue(),
-    });
-}
-
-void DrawEnhancedLightingWindow(bool& open) {
-    if (!open) {
-        return;
-    }
-
-    if (!ImGui::Begin("Enhanced Lighting", &open)) {
-        ImGui::End();
-        return;
-    }
-
-    auto& g = getSettings().game;
-    bool changed = false;
-
-    bool enabled = g.enhancedLighting.getValue();
-    if (ImGui::Checkbox("Enhanced Lighting", &enabled)) {
-        g.enhancedLighting.setValue(enabled);
-        changed = true;
-    }
-    if (ImGui::IsItemHovered()) {
-        ImGui::SetTooltip("Enables per-pixel lighting with Blinn-Phong shading.");
-    }
-
-    if (!enabled) {
-        ImGui::BeginDisabled();
-    }
-
-    bool enableSpecular = g.enableSpecularLighting.getValue();
-    if (ImGui::Checkbox("Specular Highlights", &enableSpecular)) {
-        g.enableSpecularLighting.setValue(enableSpecular);
-        changed = true;
-    }
-
-    bool enableRim = g.enableRimLighting.getValue();
-    if (ImGui::Checkbox("Rim Lighting", &enableRim)) {
-        g.enableRimLighting.setValue(enableRim);
-        changed = true;
-    }
-
-    float specularIntensity = g.specularIntensity.getValue();
-    if (ImGui::SliderFloat("Specular Intensity", &specularIntensity, 0.0f, 1.0f, "%.2f")) {
-        g.specularIntensity.setValue(specularIntensity);
-        changed = true;
-    }
-
-    float rimIntensity = g.rimIntensity.getValue();
-    if (ImGui::SliderFloat("Rim Intensity", &rimIntensity, 0.0f, 0.5f, "%.3f")) {
-        g.rimIntensity.setValue(rimIntensity);
-        changed = true;
-    }
-
-    float ambientMultiplier = g.ambientLightMultiplier.getValue();
-    if (ImGui::SliderFloat("Ambient Multiplier", &ambientMultiplier, 0.0f, 3.0f, "%.2f")) {
-        g.ambientLightMultiplier.setValue(ambientMultiplier);
-        changed = true;
-    }
-
-    float diffuseMultiplier = g.diffuseLightMultiplier.getValue();
-    if (ImGui::SliderFloat("Diffuse Multiplier", &diffuseMultiplier, 0.0f, 3.0f, "%.2f")) {
-        g.diffuseLightMultiplier.setValue(diffuseMultiplier);
-        changed = true;
-    }
-
-    if (!enabled) {
-        ImGui::EndDisabled();
-    }
-
-    if (changed) {
-        ApplyFromSettings();
-        config::Save();
-    }
-
-    ImGui::End();
-}
-
-void ImGuiMenuTools::ShowEnhancedLightingWindow() {
-    DrawEnhancedLightingWindow(m_showEnhancedLightingWindow);
-}
-
-}  // namespace dusk

src/dusk/imgui/ImGuiEnhancedLightingWindow.hpp

@@ -1,5 +0,0 @@
-#pragma once
-
-namespace dusk {
-void DrawEnhancedLightingWindow(bool& open);
-}  // namespace dusk

src/dusk/imgui/ImGuiMapLoader.cpp

@@ -1,149 +0,0 @@
-#include "d/d_com_inf_game.h"
-
-#include "imgui.h"
-#include <imgui_internal.h>
-#include "ImGuiConsole.hpp"
-#include "ImGuiMenuTools.hpp"
-#include "dusk/map_loader_definitions.h"
-#include "fmt/format.h"
-
-namespace dusk {
-    void ImGuiMenuTools::ShowMapLoader() {
-    if (!getSettings().backend.enableAdvancedSettings ||
-        !ImGuiConsole::CheckMenuViewToggle(ImGuiKey_F7, m_showMapLoader))
-    {
-            return;
-        }
-
-        ImGuiWindowFlags windowFlags = ImGuiWindowFlags_AlwaysAutoResize |
-            ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
-    
-        // ImGui::SetNextWindowBgAlpha(0.65f);
-    
-        if (!ImGui::Begin("Map Loader", &m_showMapLoader, windowFlags)) {
-            ImGui::End();
-            return;
-        }
-
-        ImGui::Checkbox("Show Internal Names", &m_mapLoaderInfo.showInternalNames);
-
-        const char* previewRegion = "None";
-        if (m_mapLoaderInfo.regionIdx != -1) {
-            previewRegion = gameRegions[m_mapLoaderInfo.regionIdx].regionName;
-        }
-
-        if (ImGui::BeginCombo("Select Region", previewRegion)) {
-            int idx = 0;
-            for (const auto& region : gameRegions) {
-                if (ImGui::Selectable(region.regionName)) {
-                    if (m_mapLoaderInfo.regionIdx != idx) {
-                        m_mapLoaderInfo.mapIdx = 0;
-                        m_mapLoaderInfo.roomNoIdx = 0;
-                        m_mapLoaderInfo.pointNoIdx = 0;
-                    }
-                    m_mapLoaderInfo.regionIdx = idx;
-                }
-                idx++;
-            }
-            ImGui::EndCombo();
-        }
-
-        if (m_mapLoaderInfo.regionIdx != -1) {
-            const auto& region = gameRegions[m_mapLoaderInfo.regionIdx];
-
-            std::string previewMap = "None";
-            if (m_mapLoaderInfo.mapIdx != -1) {
-                const auto& map = region.maps[m_mapLoaderInfo.mapIdx];
-                previewMap = m_mapLoaderInfo.showInternalNames ? fmt::format("{} ({})", map.mapName, map.mapFile) : map.mapName;
-            }
-
-            if (ImGui::BeginCombo("Select Map", previewMap.data())) {
-                int prevMapIdx = m_mapLoaderInfo.mapIdx;
-                for (int i = 0; i < region.maps.size(); ++i) {
-                    const auto& map = region.maps[i];
-                    std::string label = m_mapLoaderInfo.showInternalNames ? fmt::format("{} ({})", map.mapName, map.mapFile) : map.mapName;
-                    if (ImGui::Selectable(label.data())) {
-                        m_mapLoaderInfo.mapIdx = i;
-                    }
-                }
-                ImGui::EndCombo();
-                if (m_mapLoaderInfo.mapIdx != prevMapIdx) {
-                    m_mapLoaderInfo.roomNoIdx = 0;
-                    m_mapLoaderInfo.pointNoIdx = 0;
-                }
-            }
-        } else {
-            ImGui::Text("No region selected.");
-        }
-
-        if (m_mapLoaderInfo.regionIdx != -1 && m_mapLoaderInfo.mapIdx != -1) {
-            const auto& region = gameRegions[m_mapLoaderInfo.regionIdx];
-            const auto& map = region.maps[m_mapLoaderInfo.mapIdx];
-            const auto& room = map.mapRooms[m_mapLoaderInfo.roomNoIdx];
-
-            if (map.mapRooms.size() > 1) {
-                ImGui::Text("Selected Room:   %2d", room.roomNo);
-                ImGui::SameLine();
-                if (ImGui::Button("-###RoomNoIdxDec")) {
-                    m_mapLoaderInfo.roomNoIdx--;
-                    if (m_mapLoaderInfo.roomNoIdx < 0) {
-                        m_mapLoaderInfo.roomNoIdx = map.mapRooms.size() - 1;
-                    }
-                    m_mapLoaderInfo.pointNoIdx = 0;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("+###RoomNoIdxInc")) {
-                    m_mapLoaderInfo.roomNoIdx++;
-                    if (m_mapLoaderInfo.roomNoIdx >= map.mapRooms.size()) {
-                        m_mapLoaderInfo.roomNoIdx = 0;
-                    }
-                    m_mapLoaderInfo.pointNoIdx = 0;
-                }
-            }
-
-            constexpr int MAX_LAYER = 14;
-
-            ImGui::Text("Selected Layer: %3d", m_mapLoaderInfo.layer);
-            ImGui::SameLine();
-            if (ImGui::Button("-###layerDec")) {
-                m_mapLoaderInfo.layer--;
-                if (m_mapLoaderInfo.layer < -1) {
-                    m_mapLoaderInfo.layer = MAX_LAYER;
-                }
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("+###layerInc")) {
-                m_mapLoaderInfo.layer++;
-                if (m_mapLoaderInfo.layer > MAX_LAYER) {
-                    m_mapLoaderInfo.layer = -1;
-                }
-            }
-
-            if (room.roomPoints.size() > 1) {
-                ImGui::Text("Selected Point: %3d", room.roomPoints[m_mapLoaderInfo.pointNoIdx]);
-                ImGui::SameLine();
-                if (ImGui::Button("-###PointNoIdxDec")) {
-                    m_mapLoaderInfo.pointNoIdx--;
-                    if (m_mapLoaderInfo.pointNoIdx < 0) {
-                        m_mapLoaderInfo.pointNoIdx = room.roomPoints.size() - 1;
-                    }
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("+###PointNoIdxInc")) {
-                    m_mapLoaderInfo.pointNoIdx++;
-                    if (m_mapLoaderInfo.pointNoIdx >= room.roomPoints.size()) {
-                        m_mapLoaderInfo.pointNoIdx = 0;
-                    }
-                }
-            }
-
-            if (ImGui::Button("Warp")) {
-                dComIfGp_setNextStage(map.mapFile, room.roomPoints[m_mapLoaderInfo.pointNoIdx], room.roomNo, m_mapLoaderInfo.layer);
-            }
-        }
-
-    
-        ImGui::End();
-    }
-
-    }  // namespace dusk

src/dusk/imgui/ImGuiMenuTools.cpp

@@ -1,13 +1,11 @@
 #include "fmt/format.h"
 #include "imgui.h"
-#include <aurora/gfx.h>
+#include "aurora/gfx.h"
 
 #include "ImGuiConfig.hpp"
 #include "dusk/hotkeys.h"
 #include "dusk/settings.h"
-#include "ImGuiBloomWindow.hpp"
 #include "ImGuiConsole.hpp"
-#include "ImGuiEnhancedLightingWindow.hpp"
 #include "ImGuiMenuTools.hpp"
 
 #include "ImGuiEngine.hpp"
@@ -42,7 +40,6 @@ namespace dusk {
             ImGui::BeginDisabled(getSettings().game.speedrunMode);
 
             ImGui::MenuItem("Save Editor", hotkeys::SHOW_SAVE_EDITOR, &m_showSaveEditor);
-            ImGui::MenuItem("Map Loader", hotkeys::SHOW_MAP_LOADER, &m_showMapLoader);
             ImGui::MenuItem("State Share", hotkeys::SHOW_STATE_SHARE, &m_showStateShare);
 
             ImGui::EndDisabled();
@@ -106,7 +103,6 @@ namespace dusk {
             ImGui::MenuItem("Debug Camera", hotkeys::SHOW_DEBUG_CAMERA, &m_showCameraOverlay);
             ImGui::MenuItem("Audio Debug", hotkeys::SHOW_AUDIO_DEBUG, &m_showAudioDebug);
             ImGui::MenuItem("Bloom", nullptr, &m_showBloomWindow);
-            ImGui::MenuItem("Enhanced Lighting", nullptr, &m_showEnhancedLightingWindow);
             ImGui::MenuItem("Stub Log", nullptr, &m_showStubLog);
             ImGui::MenuItem("Actor Spawner", nullptr, &m_showActorSpawner);
 

src/dusk/imgui/ImGuiMenuTools.hpp

@@ -21,9 +21,7 @@ namespace dusk {
 		void ShowProcessManager();
 		void ShowHeapOverlay();
 		void ShowStubLog();
-		void ShowMapLoader();
         void ShowBloomWindow();
-        void ShowEnhancedLightingWindow();
         void ShowPlayerInfo();
         void ShowAudioDebug();
         void ShowSaveEditor();
@@ -44,23 +42,9 @@ namespace dusk {
 
 		bool m_showStubLog = false;
 
-		bool m_showMapLoader = false;
-
         bool m_showBloomWindow = false;
-        bool m_showEnhancedLightingWindow = false;
 
         bool m_showAudioDebug = false;
-		struct {
-			int mapIdx = -1;
-			int regionIdx = -1;
-			int roomNoIdx = 0;
-			int pointNoIdx = 0;
-			int roomNo = -1;
-			int pointNo = -1;
-			int spawnId = 0;
-			int layer = -1;
-			bool showInternalNames = false;
-		} m_mapLoaderInfo;
 
 		bool m_showPlayerInfo = false;
 		int m_playerInfoOverlayCorner = 1; // top-right

src/dusk/imgui/ImGuiSaveEditor.cpp

@@ -251,7 +251,7 @@ namespace dusk {
         { dItemNo_NOENTRY_222_e, {"Reserved"} },
         { dItemNo_NOENTRY_223_e, {"Reserved"} },
         { dItemNo_POU_SPIRIT_e, {"Poe Soul"} },
-        { dItemNo_NOENTRY_225_e, {"Reserved"} },
+        { dItemNo_GHOST_LANTERN_e, {"Ghost Lantern", ITEMTYPE_EQUIP_e} },
         { dItemNo_NOENTRY_226_e, {"Reserved"} },
         { dItemNo_NOENTRY_227_e, {"Reserved"} },
         { dItemNo_NOENTRY_228_e, {"Reserved"} },
@@ -393,6 +393,7 @@ namespace dusk {
         { SLOT_4,  dItemNo_BOW_e          },
         { SLOT_5,  dItemNo_HAWK_EYE_e     },
         { SLOT_6,  dItemNo_IRONBALL_e     },
+        { SLOT_7,  dItemNo_GHOST_LANTERN_e},
         { SLOT_8,  dItemNo_COPY_ROD_e     },
         { SLOT_9,  dItemNo_HOOKSHOT_e     },
         { SLOT_10, dItemNo_W_HOOKSHOT_e   },

src/dusk/settings.cpp

@@ -13,7 +13,7 @@ UserSettings g_userSettings = {
     },
 
     .audio = {
-        .masterVolume {"audio.masterVolume", 80},
+        .masterVolume {"audio.masterVolume", 60},
         .mainMusicVolume {"audio.mainMusicVolume", 100},
         .subMusicVolume {"audio.subMusicVolume", 100},
         .soundEffectsVolume {"audio.soundEffectsVolume", 100},
@@ -55,13 +55,6 @@ UserSettings g_userSettings = {
         .enableDiscordPresence {"game.enableDiscordPresence", true},
 
         // Graphics
-        .enhancedLighting {"game.enhancedLighting", false},
-        .enableSpecularLighting {"game.enableSpecularLighting", true},
-        .enableRimLighting {"game.enableRimLighting", true},
-        .specularIntensity {"game.specularIntensity", 0.2f},
-        .rimIntensity {"game.rimIntensity", 0.08f},
-        .ambientLightMultiplier {"game.ambientLightMultiplier", 1.0f},
-        .diffuseLightMultiplier {"game.diffuseLightMultiplier", 1.0f},
         .bloomMode {"game.bloomMode", BloomMode::Dusk},
         .bloomMultiplier {"game.bloomMultiplier", 1.0f},
         .disableWaterRefraction {"game.disableWaterRefraction", false},
@@ -100,6 +93,7 @@ UserSettings g_userSettings = {
         // Cheats
         .infiniteHearts {"game.infiniteHearts", false},
         .infiniteArrows {"game.infiniteArrows", false},
+        .infiniteSeeds {"game.infiniteSeeds", false},
         .infiniteBombs {"game.infiniteBombs", false},
         .infiniteOil {"game.infiniteOil", false},
         .infiniteOxygen {"game.infiniteOxygen", false},
@@ -113,6 +107,7 @@ UserSettings g_userSettings = {
         .fastRoll {"game.fastRoll", false},
         .fastSpinner {"game.fastSpinner", false},
         .freeMagicArmor {"game.freeMagicArmor", false},
+        .invincibleEnemies {"game.invincibleEnemies", false},
 
         // Technical
         .restoreWiiGlitches {"game.restoreWiiGlitches", false},
@@ -220,17 +215,6 @@ void registerSettings() {
     Register(g_userSettings.game.minimalHUD);
     Register(g_userSettings.game.pauseOnFocusLost);
     Register(g_userSettings.game.enableDiscordPresence);
-    
-    // Enhanced lighting
-    Register(g_userSettings.game.enhancedLighting);
-    Register(g_userSettings.game.enableSpecularLighting);
-    Register(g_userSettings.game.enableRimLighting);
-    Register(g_userSettings.game.specularIntensity);
-    Register(g_userSettings.game.rimIntensity);
-    Register(g_userSettings.game.ambientLightMultiplier);
-    Register(g_userSettings.game.diffuseLightMultiplier);
-
-    
     Register(g_userSettings.game.bloomMode);
     Register(g_userSettings.game.bloomMultiplier);
     Register(g_userSettings.game.disableWaterRefraction);
@@ -261,6 +245,7 @@ void registerSettings() {
     Register(g_userSettings.game.fastSpinner);
     Register(g_userSettings.game.infiniteHearts);
     Register(g_userSettings.game.infiniteArrows);
+    Register(g_userSettings.game.infiniteSeeds);
     Register(g_userSettings.game.infiniteBombs);
     Register(g_userSettings.game.infiniteOil);
     Register(g_userSettings.game.infiniteOxygen);
@@ -269,6 +254,7 @@ void registerSettings() {
     Register(g_userSettings.game.moonJump);
     Register(g_userSettings.game.superClawshot);
     Register(g_userSettings.game.alwaysGreatspin);
+    Register(g_userSettings.game.invincibleEnemies);
     Register(g_userSettings.game.enableFrameInterpolation);
     Register(g_userSettings.game.gyroMode);
     Register(g_userSettings.game.enableGyroAim);

src/dusk/speedrun.cpp

@@ -20,6 +20,7 @@ void resetForSpeedrunMode() {
 
     getSettings().game.infiniteHearts.setSpeedrunValue(false);
     getSettings().game.infiniteArrows.setSpeedrunValue(false);
+    getSettings().game.infiniteSeeds.setSpeedrunValue(false);
     getSettings().game.infiniteBombs.setSpeedrunValue(false);
     getSettings().game.infiniteOil.setSpeedrunValue(false);
     getSettings().game.infiniteOxygen.setSpeedrunValue(false);

src/dusk/ui/editor.cpp

@@ -26,6 +26,43 @@
 #include <vector>
 
 namespace dusk::ui {
+
+Rml::String stage_option_label(const MapEntry& map, bool showInternalNames) {
+    return showInternalNames ? fmt::format("{} ({})", map.mapName, map.mapFile) : map.mapName;
+}
+
+Rml::String stage_label_for_file(const Rml::String& stageFile, bool showInternalNames) {
+    for (const auto& region : gameRegions) {
+        for (const auto& map : region.maps) {
+            if (stageFile == map.mapFile) {
+                return stage_option_label(map, showInternalNames);
+            }
+        }
+    }
+    return stageFile;
+}
+
+void populate_stage_picker(Pane& pane, std::function<Rml::String()> getStageFile,
+    std::function<void(const char*)> setStageFile, bool showInternalNames) {
+    pane.clear();
+    for (const auto& region : gameRegions) {
+        pane.add_section(region.regionName);
+        for (const auto& map : region.maps) {
+            pane.add_button({
+                                .text = stage_option_label(map, showInternalNames),
+                                .isSelected =
+                                    [getStageFile, stageFile = map.mapFile] {
+                                        return getStageFile() == stageFile;
+                                    },
+                            })
+                .on_pressed([setStageFile, stageFile = map.mapFile] {
+                    mDoAud_seStartMenu(kSoundItemChange);
+                    setStageFile(stageFile);
+                });
+        }
+    }
+}
+
 namespace {
 
 bool has_save_data() {
@@ -155,44 +192,6 @@ bool parse_vec3(const Rml::String& value, float& x, float& y, float& z) {
     return *cursor == '\0';
 }
 
-Rml::String stage_option_label(const MapEntry& map) {
-    // TODO: option to show internal name?
-    // return fmt::format("{} ({})", map.mapName, map.mapFile);
-    return map.mapName;
-}
-
-Rml::String stage_label_for_file(const Rml::String& stageFile) {
-    for (const auto& region : gameRegions) {
-        for (const auto& map : region.maps) {
-            if (stageFile == map.mapFile) {
-                return stage_option_label(map);
-            }
-        }
-    }
-    return stageFile;
-}
-
-void populate_stage_picker(Pane& pane, std::function<Rml::String()> getStageFile,
-    std::function<void(const char*)> setStageFile) {
-    pane.clear();
-    for (const auto& region : gameRegions) {
-        pane.add_section(region.regionName);
-        for (const auto& map : region.maps) {
-            pane.add_button({
-                                .text = stage_option_label(map),
-                                .isSelected =
-                                    [getStageFile, stageFile = map.mapFile] {
-                                        return getStageFile() == stageFile;
-                                    },
-                            })
-                .on_pressed([setStageFile, stageFile = map.mapFile] {
-                    mDoAud_seStartMenu(kSoundItemChange);
-                    setStageFile(stageFile);
-                });
-        }
-    }
-}
-
 Rml::String get_player_name() {
     if (!has_save_data()) {
         return "";
@@ -451,7 +450,7 @@ std::map<int, itemInfo> itemMap = {
     {dItemNo_NOENTRY_222_e, {"Reserved"}},
     {dItemNo_NOENTRY_223_e, {"Reserved"}},
     {dItemNo_POU_SPIRIT_e, {"Poe Soul"}},
-    {dItemNo_NOENTRY_225_e, {"Reserved"}},
+    {dItemNo_GHOST_LANTERN_e, {"Reserved"}},
     {dItemNo_NOENTRY_226_e, {"Reserved"}},
     {dItemNo_NOENTRY_227_e, {"Reserved"}},
     {dItemNo_NOENTRY_228_e, {"Reserved"}},

src/dusk/ui/editor.hpp

@@ -1,8 +1,19 @@
 #pragma once
+
 #include "window.hpp"
 
+struct MapEntry;
+
 namespace dusk::ui {
 
+class Pane;
+
+Rml::String stage_option_label(const MapEntry& map, bool showInternalNames = false);
+Rml::String stage_label_for_file(const Rml::String& stageFile, bool showInternalNames = false);
+void populate_stage_picker(Pane& pane, std::function<Rml::String()> getStageFile,
+                           std::function<void(const char*)> setStageFile,
+                           bool showInternalNames = false);
+
 class EditorWindow : public Window {
 public:
     EditorWindow();

src/dusk/ui/graphics_tuner.cpp

@@ -184,7 +184,7 @@ Rml::String format_graphics_setting_value(GraphicsOption option, int value) {
         case BloomMode::Classic:
             return "Classic";
         case BloomMode::Dusk:
-            return "Dusk";
+            return "Dusklight";
         }
         break;
     case GraphicsOption::BloomMultiplier:

src/dusk/ui/menu_bar.cpp

@@ -18,6 +18,7 @@
 #include "modal.hpp"
 #include "settings.hpp"
 #include "ui.hpp"
+#include "warp.hpp"
 #include "window.hpp"
 
 #include <chrono>
@@ -51,11 +52,9 @@ MenuBar::MenuBar() : Document(kDocumentSource), mRoot(mDocument->GetElementById(
                                                   .autoSelect = false,
                                               });
     mTabBar->add_tab("Settings", [this] { push(std::make_unique<SettingsWindow>()); });
-    // mTabBar->add_tab("Warp", [] {
-    //     // TODO
-    // });
 
     if (getSettings().backend.enableAdvancedSettings) {
+        mTabBar->add_tab("Warp", [this] { push(std::make_unique<WarpWindow>()); });
         mTabBar->add_tab("Editor", [this] { push(std::make_unique<EditorWindow>()); });
     }
 

src/dusk/ui/overlay.cpp

@@ -354,8 +354,9 @@ void Overlay::update() {
         }
     }
 
+    u32 count = 0;
     const bool showControllerWarning = PADGetIndexForPort(PAD_CHAN0) < 0 &&
-                                       PADGetKeyButtonBindings(PAD_CHAN0, nullptr) == nullptr &&
+                                       PADGetKeyButtonBindings(PAD_CHAN0, &count) == nullptr &&
                                        dynamic_cast<Window*>(top_document()) == nullptr &&
                                        dynamic_cast<WindowSmall*>(top_document()) == nullptr;
     if (showControllerWarning && mControllerWarning == nullptr) {

src/dusk/ui/preset.cpp

@@ -83,7 +83,7 @@ PresetWindow::PresetWindow() : WindowSmall("modal", "modal-dialog") {
          "Enhancements disabled to match the GameCube version. "
          "Good for speedrunning or simple nostalgia!",
          applyPresetClassic},
-        {"Dusk",
+        {"Dusklight",
          "Graphics & quality of life tweaks, including some from the Wii U version. "
          "Our recommended way to play!",
          applyPresetDusk},

src/dusk/ui/settings.cpp

@@ -3,6 +3,7 @@
 #include "aurora/gfx.h"
 #include "bool_button.hpp"
 #include "controller_config.hpp"
+#include "dusk/app_info.hpp"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
 #include "dusk/config.hpp"
@@ -17,6 +18,7 @@
 #include "graphics_tuner.hpp"
 #include "m_Do/m_Do_main.h"
 #include "menu_bar.hpp"
+#include "modal.hpp"
 #include "number_button.hpp"
 #include "menu_bar.hpp"
 #include "pane.hpp"
@@ -25,6 +27,7 @@
 
 #include <aurora/lib/window.hpp>
 #include <SDL3/SDL_filesystem.h>
+#include <fmt/format.h>
 
 #if DUSK_ENABLE_SENTRY_NATIVE
 #include "dusk/crash_reporting.h"
@@ -184,6 +187,7 @@ void reset_for_speedrun_mode() {
 
     getSettings().game.infiniteHearts.setSpeedrunValue(false);
     getSettings().game.infiniteArrows.setSpeedrunValue(false);
+    getSettings().game.infiniteSeeds.setSpeedrunValue(false);
     getSettings().game.infiniteBombs.setSpeedrunValue(false);
     getSettings().game.infiniteOil.setSpeedrunValue(false);
     getSettings().game.infiniteOxygen.setSpeedrunValue(false);
@@ -197,6 +201,7 @@ void reset_for_speedrun_mode() {
     getSettings().game.fastRoll.setSpeedrunValue(false);
     getSettings().game.fastSpinner.setSpeedrunValue(false);
     getSettings().game.freeMagicArmor.setSpeedrunValue(false);
+    getSettings().game.invincibleEnemies.setSpeedrunValue(false);
 
     getSettings().game.pauseOnFocusLost.setSpeedrunValue(false);
     aurora_set_pause_on_focus_lost(false);
@@ -295,13 +300,49 @@ private:
     Rml::String mCurrentRml;
 };
 
+void show_data_folder_error_modal(std::string_view message) {
+    auto dismiss = [](Modal& modal) {
+        mDoAud_seStartMenu(kSoundWindowClose);
+        modal.pop();
+    };
+    push_document(std::make_unique<Modal>(Modal::Props{
+        .title = "Data Folder Not Changed",
+        .bodyRml = escape(message),
+        .actions =
+            {
+                ModalAction{
+                    .label = "OK",
+                    .onPressed = dismiss,
+                },
+            },
+        .onDismiss = dismiss,
+        .icon = "warning",
+    }));
+    if (auto* doc = top_document()) {
+        doc->focus();
+    }
+}
+
 void data_folder_dialog_callback(void*, const char* path, const char* error) {
-    if (error != nullptr || path == nullptr) {
+    if (error != nullptr) {
+        show_data_folder_error_modal(error);
         return;
     }
-    if (data::set_custom_data_path(path)) {
-        mDoAud_seStartMenu(kSoundItemChange);
+    if (path == nullptr) {
+        return;
     }
+
+    std::string dataPathError;
+    if (data::set_custom_data_path(path, &dataPathError)) {
+        mDoAud_seStartMenu(kSoundItemChange);
+        return;
+    }
+
+    if (dataPathError.empty()) {
+        dataPathError =
+            fmt::format("{} could not use the selected folder as its data folder.", AppName);
+    }
+    show_data_folder_error_modal(dataPathError);
 }
 
 const Rml::String kInternalResolutionHelpText =
@@ -912,7 +953,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                     [](int value) {
                         getSettings().audio.masterVolume.setValue(value);
                         config::Save();
-                        audio::SetMasterVolume(value / 100.f);
+                        audio::SetMasterVolume(audio::MasterVolumeToLinear(value / 100.0f));
                     },
                 .isModified =
                     [] {
@@ -1107,6 +1148,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         addCheat("Infinite Hearts", getSettings().game.infiniteHearts, "Keeps your health full.");
         addCheat(
             "Infinite Arrows", getSettings().game.infiniteArrows, "Keeps your arrow count full.");
+        addCheat("Infinite Seeds", getSettings().game.infiniteSeeds, "Keeps your slingshot pellets (seeds) full.");
         addCheat("Infinite Bombs", getSettings().game.infiniteBombs, "Keeps all bomb bags full.");
         addCheat("Infinite Oil", getSettings().game.infiniteOil, "Keeps your lantern oil full.");
         addCheat("Infinite Oxygen", getSettings().game.infiniteOxygen,
@@ -1133,6 +1175,8 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             "Speeds up Spinner movement while holding R.");
         addCheat("Free Magic Armor", getSettings().game.freeMagicArmor,
             "Lets the magic armor work without consuming rupees.");
+        addCheat("Invincible Enemies", getSettings().game.invincibleEnemies,
+            "Prevents enemies from taking damage.");
     });
 
     add_tab("Interface", [this](Rml::Element* content) {

src/dusk/ui/warp.cpp

@@ -0,0 +1,334 @@
+#include "warp.hpp"
+
+#include "editor.hpp"
+#include "pane.hpp"
+
+#include "dusk/map_loader_definitions.h"
+#include "fmt/format.h"
+
+namespace dusk::ui {
+namespace {
+
+constexpr int kMinLayer = -1;
+constexpr int kMaxLayer = 14;
+
+struct WarpSelectionState {
+    int regionIdx = 0;
+    int mapIdx = 0;
+    int roomIdx = 0;
+    int pointIdx = 0;
+    int layer = -1;
+    bool showInternalNames = false;
+};
+
+WarpSelectionState& selection_state() {
+    static WarpSelectionState state;
+    return state;
+}
+
+const RegionEntry* selected_region(const WarpSelectionState& state) {
+    if (state.regionIdx < 0 || state.regionIdx >= static_cast<int>(gameRegions.size())) {
+        return nullptr;
+    }
+    return &gameRegions[state.regionIdx];
+}
+
+const MapEntry* selected_map(const WarpSelectionState& state) {
+    const auto* region = selected_region(state);
+    if (region == nullptr || state.mapIdx < 0 || state.mapIdx >= static_cast<int>(region->maps.size())) {
+        return nullptr;
+    }
+    return &region->maps[state.mapIdx];
+}
+
+const RoomEntry* selected_room(const WarpSelectionState& state) {
+    const auto* map = selected_map(state);
+    if (map == nullptr || state.roomIdx < 0 || state.roomIdx >= static_cast<int>(map->mapRooms.size())) {
+        return nullptr;
+    }
+    return &map->mapRooms[state.roomIdx];
+}
+
+const s16* selected_point(const WarpSelectionState& state) {
+    const auto* room = selected_room(state);
+    if (room == nullptr || state.pointIdx < 0 ||
+        state.pointIdx >= static_cast<int>(room->roomPoints.size()))
+    {
+        return nullptr;
+    }
+    return &room->roomPoints[state.pointIdx];
+}
+
+void clamp_indices(WarpSelectionState& state) {
+    if (gameRegions.empty()) {
+        state.regionIdx = -1;
+        state.mapIdx = -1;
+        state.roomIdx = -1;
+        state.pointIdx = -1;
+        state.layer = std::clamp(state.layer, kMinLayer, kMaxLayer);
+        return;
+    }
+
+    state.regionIdx = std::clamp(state.regionIdx, 0, static_cast<int>(gameRegions.size()) - 1);
+    const auto& region = gameRegions[state.regionIdx];
+    if (region.maps.empty()) {
+        state.mapIdx = -1;
+        state.roomIdx = -1;
+        state.pointIdx = -1;
+        state.layer = std::clamp(state.layer, kMinLayer, kMaxLayer);
+        return;
+    }
+
+    state.mapIdx = std::clamp(state.mapIdx, 0, static_cast<int>(region.maps.size()) - 1);
+    const auto& map = region.maps[state.mapIdx];
+    if (map.mapRooms.empty()) {
+        state.roomIdx = -1;
+        state.pointIdx = -1;
+        state.layer = std::clamp(state.layer, kMinLayer, kMaxLayer);
+        return;
+    }
+
+    state.roomIdx = std::clamp(state.roomIdx, 0, static_cast<int>(map.mapRooms.size()) - 1);
+    const auto& room = map.mapRooms[state.roomIdx];
+    if (room.roomPoints.empty()) {
+        state.pointIdx = -1;
+    } else {
+        state.pointIdx = std::clamp(state.pointIdx, 0, static_cast<int>(room.roomPoints.size()) - 1);
+    }
+
+    state.layer = std::clamp(state.layer, kMinLayer, kMaxLayer);
+}
+
+bool can_warp(const WarpSelectionState& state) {
+    return selected_point(state) != nullptr;
+}
+
+void reset_selection(WarpSelectionState& state) {
+    state.roomIdx = 0;
+    state.pointIdx = 0;
+    state.layer = kMinLayer;
+    clamp_indices(state);
+}
+
+void populate_map_picker(Pane& pane, WarpSelectionState& state) {
+    pane.clear();
+    clamp_indices(state);
+    if (state.regionIdx < 0 || state.regionIdx >= static_cast<int>(gameRegions.size())) {
+        return;
+    }
+
+    pane.add_button({
+                    .text = "Show Internal Names",
+                    .isSelected = [&state] { return state.showInternalNames; },
+                })
+        .on_pressed([&pane, &state] {
+            mDoAud_seStartMenu(kSoundItemChange);
+            state.showInternalNames = !state.showInternalNames;
+            populate_map_picker(pane, state);
+        });
+
+    pane.add_section("Maps");
+    const auto& region = gameRegions[state.regionIdx];
+    for (int i = 0; i < static_cast<int>(region.maps.size()); ++i) {
+        pane.add_button({
+                        .text = stage_option_label(region.maps[i], state.showInternalNames),
+                        .isSelected = [i, &state] { return state.mapIdx == i; },
+                    })
+            .on_pressed([i, &state] {
+                mDoAud_seStartMenu(kSoundItemChange);
+                if (state.mapIdx != i) {
+                    state.mapIdx = i;
+                    reset_selection(state);
+                }
+            });
+    }
+}
+
+}  // namespace
+
+WarpWindow::WarpWindow() {
+    add_tab("Warp", [this](Rml::Element* content) {
+        auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
+        auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
+        auto& state = selection_state();
+        clamp_indices(state);
+
+        leftPane.add_section("Destination");
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Region",
+                .getValue =
+                    [&state] {
+                        clamp_indices(state);
+                        const auto* region = selected_region(state);
+                        return region == nullptr ? Rml::String{"None"} :
+                                                   Rml::String{region->regionName};
+                    },
+            }),
+            rightPane, [&state](Pane& pane) {
+                pane.clear();
+                for (int i = 0; i < static_cast<int>(gameRegions.size()); ++i) {
+                    pane.add_button({
+                                    .text = gameRegions[i].regionName,
+                                    .isSelected = [i, &state] { return state.regionIdx == i; },
+                                })
+                        .on_pressed([i, &state] {
+                            mDoAud_seStartMenu(kSoundItemChange);
+                            if (state.regionIdx != i) {
+                                state.regionIdx = i;
+                                state.mapIdx = 0;
+                                reset_selection(state);
+                            }
+                        });
+                }
+            });
+
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Map",
+                .getValue =
+                    [&state] {
+                        clamp_indices(state);
+                        const auto* map = selected_map(state);
+                        return map == nullptr ? Rml::String{"None"} :
+                                                stage_option_label(*map, state.showInternalNames);
+                    },
+            }),
+            rightPane, [&state](Pane& pane) { populate_map_picker(pane, state); });
+
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Room",
+                .getValue = [&state] {
+                        clamp_indices(state);
+                        const auto* room = selected_room(state);
+                        return room == nullptr ? Rml::String{"None"} :
+                                                 fmt::format("{}", room->roomNo);
+                    },
+                .isDisabled = [&state] {
+                        clamp_indices(state);
+                        const auto* map = selected_map(state);
+                        return map == nullptr || map->mapRooms.size() <= 1;
+                    },
+            }),
+            rightPane, [&state](Pane& pane) {
+                pane.clear();
+                clamp_indices(state);
+                if (state.regionIdx < 0 || state.regionIdx >= static_cast<int>(gameRegions.size())) {
+                    return;
+                }
+                const auto& region = gameRegions[state.regionIdx];
+                if (state.mapIdx < 0 || state.mapIdx >= static_cast<int>(region.maps.size())) {
+                    return;
+                }
+                const auto& map = region.maps[state.mapIdx];
+                for (int i = 0; i < static_cast<int>(map.mapRooms.size()); ++i) {
+                    pane.add_button({
+                                    .text = fmt::format("{}", map.mapRooms[i].roomNo),
+                                    .isSelected = [i, &state] { return state.roomIdx == i; },
+                                })
+                        .on_pressed([i, &state] {
+                            mDoAud_seStartMenu(kSoundItemChange);
+                            if (state.roomIdx != i) {
+                                state.roomIdx = i;
+                                state.pointIdx = 0;
+                                clamp_indices(state);
+                            }
+                        });
+                }
+            });
+
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Point",
+                .getValue = [&state] {
+                        clamp_indices(state);
+                        const auto* point = selected_point(state);
+                        return point == nullptr ? Rml::String{"None"} : fmt::format("{}", *point);
+                    },
+                .isDisabled = [&state] {
+                        clamp_indices(state);
+                        const auto* room = selected_room(state);
+                        return room == nullptr || room->roomPoints.size() <= 1;
+                    },
+            }),
+            rightPane, [&state](Pane& pane) {
+                pane.clear();
+                clamp_indices(state);
+                if (state.regionIdx < 0 || state.regionIdx >= static_cast<int>(gameRegions.size())) {
+                    return;
+                }
+                const auto& region = gameRegions[state.regionIdx];
+                if (state.mapIdx < 0 || state.mapIdx >= static_cast<int>(region.maps.size())) {
+                    return;
+                }
+                const auto& map = region.maps[state.mapIdx];
+                if (state.roomIdx < 0 || state.roomIdx >= static_cast<int>(map.mapRooms.size())) {
+                    return;
+                }
+                const auto& room = map.mapRooms[state.roomIdx];
+                for (int i = 0; i < static_cast<int>(room.roomPoints.size()); ++i) {
+                    pane.add_button({
+                                    .text = fmt::format("{}", room.roomPoints[i]),
+                                    .isSelected = [i, &state] { return state.pointIdx == i; },
+                                })
+                        .on_pressed([i, &state] {
+                            if (state.pointIdx != i) {
+                                mDoAud_seStartMenu(kSoundItemChange);
+                                state.pointIdx = i;
+                                clamp_indices(state);
+                            }
+                        });
+                }
+            });
+
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Layer",
+                .getValue = [&state] { return fmt::format("{}", state.layer); },
+            }),
+            rightPane, [&state](Pane& pane) {
+                pane.clear();
+                for (int layer = kMinLayer; layer <= kMaxLayer; ++layer) {
+                    pane.add_button({
+                                    .text = fmt::format("{}", layer),
+                                    .isSelected = [layer, &state] { return state.layer == layer; },
+                                })
+                        .on_pressed([layer, &state] {
+                            if (state.layer != layer) {
+                                mDoAud_seStartMenu(kSoundItemChange);
+                                state.layer = layer;
+                            }
+                        });
+                }
+            });
+
+        leftPane.add_section("Action");
+        leftPane.register_control(
+            leftPane.add_button({
+                        .text = "Warp",
+                        .isDisabled = [&state] {
+                            clamp_indices(state);
+                            return !can_warp(state);
+                        },
+                    })
+                .on_pressed([&state] {
+                    clamp_indices(state);
+                    if (!can_warp(state)) {
+                        return;
+                    }
+
+                    mDoAud_seStartMenu(kSoundClick);
+                    const auto& region = gameRegions[state.regionIdx];
+                    const auto& map = region.maps[state.mapIdx];
+                    const auto& room = map.mapRooms[state.roomIdx];
+                    dComIfGp_setNextStage( map.mapFile, room.roomPoints[state.pointIdx], room.roomNo, state.layer);
+                }),
+            rightPane, [](Pane& pane) {
+                pane.clear();
+                pane.add_text("Warp to the selected destination.");
+            });
+    });
+}
+
+}  // namespace dusk::ui

src/dusk/ui/warp.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "window.hpp"
+
+namespace dusk::ui {
+
+class WarpWindow : public Window {
+public:
+    WarpWindow();
+};
+
+}  // namespace dusk::ui

src/f_ap/f_ap_game.cpp

@@ -29,6 +29,8 @@
 #include "tracy/Tracy.hpp"
 #include <dusk/gamepad_color.h>
 #include <dusk/autosave.h>
+#include <d/actor/d_a_npc.h>
+#include <d/d_item.h>
 #endif
 
 fapGm_HIO_c::fapGm_HIO_c() {
@@ -741,11 +743,21 @@ static void fapGm_AfterRecord() {
 }
 
 BOOL isRecording = false;
+BOOL gotGhostLantern = false;
 
 static void duskExecute() {
     handleGamepadColor();
     updateAutoSave();
 
+    if (daNpcT_chkEvtBit(0x2B6) && !gotGhostLantern) {
+        execItemGet(dItemNo_GHOST_LANTERN_e);
+        gotGhostLantern = true;
+    } else if (!daNpcT_chkEvtBit(0x2B6) && gotGhostLantern) {
+        dComIfGs_offItemFirstBit(dItemNo_GHOST_LANTERN_e);
+        dComIfGp_setItem(SLOT_7, dItemNo_NONE_e);
+        gotGhostLantern = false;
+    }
+
     if (dusk::getSettings().game.recordingMode) {
         Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(0.0f, 0);
         Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(0.0f, 0);
@@ -792,6 +804,10 @@ static void duskExecute() {
         dComIfGs_setArrowNum(dComIfGs_getArrowMax());
     }
 
+    if (dusk::getSettings().game.infiniteSeeds) {
+        dComIfGs_setPachinkoNum(dComIfGs_getPachinkoMax());
+    }
+
     if (dusk::getSettings().game.infiniteBombs) {
         dComIfGs_setBombNum(0, 99);
         dComIfGs_setBombNum(1, 99);

src/f_pc/f_pc_base.cpp

@@ -136,8 +136,17 @@ base_process_class* fpcBs_Create(s16 i_profname, fpc_ProcID i_procID, void* i_ap
     u32 size;
 
     pprofile = (process_profile_definition*)fpcPf_Get(i_profname);
+    if (pprofile == NULL) {
+#if TARGET_PC
+        DuskLog.debug("fpcBs_Create: profile not found for profname={}", i_profname);
+#endif
+        return NULL;
+    }
+#if TARGET_PC
+    const char* procName = getProcName(i_profname);
     DuskLog.debug("fpcBs_Create: pid={} profname={} ({}) profile={} procSize={} unkSize={}",
-           i_procID, getProcName(i_profname), i_profname, (void*)pprofile, pprofile->process_size, pprofile->unk_size);
+           i_procID, procName ? procName : "(unknown)", i_profname, (void*)pprofile, pprofile->process_size, pprofile->unk_size);
+#endif
     size = pprofile->process_size + pprofile->unk_size;
 
     pprocess = (base_process_class*)cMl::memalignB(-4, size);

src/m_Do/m_Do_main.cpp

@@ -67,7 +67,6 @@
 
 #include <aurora/aurora.h>
 #include <aurora/event.h>
-#include <aurora/gfx.h>
 #include <aurora/main.h>
 #include <aurora/dvd.h>
 #include <dolphin/dvd.h>
@@ -81,6 +80,7 @@
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
 #include "dusk/config.hpp"
+#include "dusk/speedrun.h"
 #include "dusk/settings.h"
 #include "dusk/io.hpp"
 #include "dusk/version.hpp"
@@ -120,6 +120,7 @@ bool dusk::IsShuttingDown = false;
 bool dusk::IsGameLaunched = false;
 bool dusk::RestartRequested = false;
 std::filesystem::path dusk::ConfigPath;
+std::filesystem::path dusk::CachePath;
 #endif
 
 void dusk::RequestRestart() noexcept {
@@ -514,12 +515,17 @@ int game_main(int argc, char* argv[]) {
 
     const auto startupLogLevel =
         static_cast<AuroraLogLevel>(parsed_arg_options["log-level"].as<uint8_t>());
-    dusk::ConfigPath = dusk::data::initialize_data();
-    dusk::InitializeFileLogging(dusk::ConfigPath, startupLogLevel);
+    const auto dataPaths = dusk::data::initialize_data();
+    dusk::ConfigPath = dataPaths.userPath;
+    dusk::CachePath = dataPaths.cachePath;
+    dusk::InitializeFileLogging(dusk::CachePath, startupLogLevel);
 
     log_build_info();
 
     dusk::config::LoadFromUserPreferences();
+    if (dusk::getSettings().game.speedrunMode) {
+        dusk::resetForSpeedrunMode();
+    }
     ApplyCVarOverrides(parsed_arg_options["cvar"]);
     dusk::crash_reporting::initialize();
     // TODO: How to handle this?
@@ -537,10 +543,12 @@ int game_main(int argc, char* argv[]) {
     SDL_SetAppMetadata("Dusklight", DUSK_VERSION_STRING, "dev.twilitrealm.dusk");
 
     {
-        const auto configPathString = dusk::ConfigPath.u8string();
+        const auto userPathString = dusk::ConfigPath.u8string();
+        const auto cachePathString = dusk::CachePath.u8string();
         AuroraConfig config{};
         config.appName = dusk::AppName;
-        config.configPath = reinterpret_cast<const char*>(configPathString.c_str());
+        config.userPath = reinterpret_cast<const char*>(userPathString.c_str());
+        config.cachePath = reinterpret_cast<const char*>(cachePathString.c_str());
         config.vsync = dusk::getSettings().video.enableVsync;
         config.startFullscreen = dusk::getSettings().video.enableFullscreen;
         config.windowPosX = -1;
@@ -558,18 +566,6 @@ int game_main(int argc, char* argv[]) {
         config.allowTextureReplacements = true;
         config.allowTextureDumps = false;
         auroraInfo = aurora_initialize(argc, argv, &config);
-        {
-            const auto& g = dusk::getSettings().game;
-            aurora_set_enhanced_lighting_state({
-                g.enhancedLighting.getValue(),
-                g.enableSpecularLighting.getValue(),
-                g.enableRimLighting.getValue(),
-                g.specularIntensity.getValue(),
-                g.rimIntensity.getValue(),
-                g.ambientLightMultiplier.getValue(),
-                g.diffuseLightMultiplier.getValue(),
-            });
-        }
     }
 
 #ifdef DUSK_DISCORD
@@ -589,7 +585,7 @@ int game_main(int argc, char* argv[]) {
     }
     VISetFrameBufferScale(dusk::getSettings().game.internalResolutionScale.getValue());
 
-    dusk::audio::SetMasterVolume(dusk::getSettings().audio.masterVolume / 100.0f);
+    dusk::audio::SetMasterVolume(dusk::audio::MasterVolumeToLinear(dusk::getSettings().audio.masterVolume / 100.0f));
     dusk::audio::SetEnableReverb(dusk::getSettings().audio.enableReverb);
     dusk::audio::EnableHrtf = dusk::getSettings().audio.enableHrtf;