pending clos

files.cmake

@@ -1432,10 +1432,15 @@ set(DUSK_FILES
         src/dusk/dvd_asset.hpp
         src/dusk/extras.c
         src/dusk/frame_interpolation.cpp
+        src/dusk/commands.cpp
+        src/dusk/commands.hpp
         src/dusk/game_clock.cpp
         src/dusk/gamepad_color.cpp
         src/dusk/globals.cpp
         src/dusk/gyro.cpp
+        src/dusk/game_combos.cpp
+        src/dusk/d_trigger_view.cpp
+        #src/dusk/m_Do_ext_dusk.cpp
         src/dusk/imgui/ImGuiActorSpawner.cpp
         src/dusk/imgui/ImGuiBloomWindow.cpp
         src/dusk/imgui/ImGuiBloomWindow.hpp
@@ -1509,6 +1514,8 @@ set(DUSK_FILES
         src/dusk/touch_camera.cpp
         src/dusk/ui/achievements.cpp
         src/dusk/ui/achievements.hpp
+        src/dusk/ui/command_console.cpp
+        src/dusk/ui/command_console.hpp
         src/dusk/ui/bool_button.cpp
         src/dusk/ui/bool_button.hpp
         src/dusk/ui/button.cpp

include/d/d_stage.h

@@ -1351,6 +1351,9 @@ enum dStage_SaveTbl {
 
 const char* dStage_getName2(s16, s8);
 dStage_objectNameInf* dStage_searchName(const char*);
+#if TARGET_PC
+dStage_objectNameInf* dStage_searchNameCI(const char*);
+#endif
 static int dStage_stageKeepTresureInit(dStage_dt_c*, void*, int, void*);
 static int dStage_filiInfo2Init(dStage_dt_c*, void*, int, void*);
 static int dStage_mapPathInitCommonLayer(dStage_dt_c*, void*, int, void*);

res/rml/command_console.rcss

@@ -0,0 +1,80 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    display: block;
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    overflow: visible;
+    pointer-events: none;
+}
+
+console {
+    position: absolute;
+    bottom: 10dp;
+    left: 10dp;
+    width: 50%;
+    display: flex;
+    flex-direction: column;
+    background-color: rgba(0, 0, 0, 60%);
+    pointer-events: auto;
+    font-family: "Noto Mono";
+    font-size: 14dp;
+    color: #FFFFFF;
+}
+
+output {
+    display: block;
+    overflow: hidden;
+    max-height: 480dp;
+    padding: 4dp 8dp;
+    line-height: 1.4em;
+}
+
+output[open] {
+    height: 480dp;
+    max-height: 480dp;
+    overflow-y: scroll;
+}
+
+console:not([open]) {
+    pointer-events: none;
+}
+
+line {
+    display: block;
+    white-space: nowrap;
+}
+
+line.cmd {
+    color: #FFD966;
+}
+
+line.copyable {
+    color: #80C8FF;
+    cursor: pointer;
+}
+
+line.copyable:hover {
+    color: #FFFFFF;
+    background-color: rgba(255, 255, 255, 12%);
+}
+
+console input {
+    display: none;
+    width: 100%;
+    background-color: rgba(0, 0, 0, 40%);
+    border: 0dp;
+    border-top: 1dp rgba(255, 255, 255, 20%);
+    color: #FFFFFF;
+    font-family: "Noto Mono";
+    font-size: 14dp;
+    padding: 4dp 8dp;
+}
+
+console[open] input {
+    display: block;
+}

src/d/d_camera.cpp

@@ -30,6 +30,7 @@
 
 #if TARGET_PC
 #include "dusk/camera_operators.hpp"
+#include "dusk/commands.hpp"
 #include "dusk/frame_interpolation.h"
 #include "dusk/logging.h"
 #include "dusk/action_bindings.h"
@@ -1054,6 +1055,11 @@ void dCamera_c::debugDrawInit() {
 bool dCamera_c::Run() {
 #if TARGET_PC
     ResetView();
+    if (dusk::isCameraDetached()) {
+        mFrameCounter++;
+        mTicks++;
+        return true;
+    }
     if (executeDebugFlyCam() || dusk::mods::camera_run_operators(this)) {
         mFrameCounter++;
         mTicks++;
@@ -11123,6 +11129,9 @@ camera_class* dCam_getCamera() {
 
 dCamera_c* dCam_getBody() {
     camera_process_class* camera = (camera_process_class*)dCam_getCamera();
+#if TARGET_PC
+    if (camera == nullptr) { return nullptr; }
+#endif
     return &camera->mCamera;
 }
 

src/d/d_drawlist.cpp

@@ -18,7 +18,7 @@
 #include <typeindex>
 #include "JSystem/JKernel/JKRHeap.h"
 #include "absl/container/flat_hash_map.h"
-#include "client/TracyScoped.hpp"
+#include "tracy/Tracy.hpp"
 #include "dusk/frame_interpolation.h"
 #include "helpers/gx_helper.h"
 #include "dusk/logging.h"

src/d/d_s_play.cpp

@@ -41,6 +41,7 @@
 
 #if TARGET_PC
 #include "dusk/autosave.h"
+#include "dusk/d_trigger_view.h"
 #include "dusk/memory.h"
 #include "dusk/ui/ui.hpp"
 #endif
@@ -675,6 +676,10 @@ static int dScnPly_Draw(dScnPly_c* i_this) {
         dComIfG_Ccsp()->Draw();
         dComIfG_Bgsp().Draw();
 
+        #if TARGET_PC
+        dusk::TriggerView::execute();
+        #endif
+
         #if DEBUG
         dPath_Draw();
         #endif

src/d/d_stage.cpp

@@ -1537,6 +1537,27 @@ dStage_objectNameInf* dStage_searchName(char const* objName) {
     return NULL;
 }
 
+#if TARGET_PC
+dStage_objectNameInf* dStage_searchNameCI(char const* objName) {
+    dStage_objectNameInf* obj = l_objectName;
+
+    for (u32 i = 0; i < ARRAY_SIZEU(l_objectName); i++) {
+        const char* a = obj->name;
+        const char* b = objName;
+        while (*a && *b && tolower((unsigned char)*a) == tolower((unsigned char)*b)) {
+            ++a;
+            ++b;
+        }
+        if (*a == '\0' && *b == '\0') {
+            return obj;
+        }
+        obj++;
+    }
+
+    return NULL;
+}
+#endif
+
 const char* dStage_getName(s16 procName, s8 argument) {
     static char tmp_name[dStage_NAME_LENGTH];
 

src/dusk/commands.cpp

@@ -0,0 +1,880 @@
+#include "commands.hpp"
+
+#include "JSystem/JUtility/JUTGamePad.h"
+#include "SSystem/SComponent/c_math.h"
+#include "SSystem/SComponent/c_sxyz.h"
+#include "SSystem/SComponent/c_xyz.h"
+#include "c/c_damagereaction.h"
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_actor.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_camera.h"
+#include "d/d_kankyo.h"
+#include "d/d_stage.h"
+#include "dusk/game_clock.h"
+#include "f_op/f_op_actor_mng.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_layer_iter.h"
+#include "f_pc/f_pc_manager.h"
+#include "f_pc/f_pc_node.h"
+
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "fmt/format.h"
+
+namespace dusk {
+namespace {
+
+static constexpr int kMaxHistory = 64;
+
+static std::vector<std::string> SplitArgs(std::string_view input) {
+    std::vector<std::string> args;
+    std::string cur;
+    for (char c : input) {
+        if (c == ' ' || c == '\t') {
+            if (!cur.empty()) {
+                args.push_back(std::move(cur));
+                cur.clear();
+            }
+        } else {
+            cur += c;
+        }
+    }
+    if (!cur.empty()) {
+        args.push_back(std::move(cur));
+    }
+    return args;
+}
+
+static std::optional<long> ParseLong(const std::string& s) {
+    if (s.empty()) {
+        return std::nullopt;
+    }
+    char* end = nullptr;
+    const long v = std::strtol(s.c_str(), &end, 0);
+    return (end != s.c_str() && *end == '\0') ? std::optional<long>{v} : std::nullopt;
+}
+
+static std::optional<float> ParseFloat(const std::string& s) {
+    if (s.empty()) {
+        return std::nullopt;
+    }
+    char* end = nullptr;
+    const float v = std::strtof(s.c_str(), &end);
+    return (end != s.c_str() && *end == '\0') ? std::optional<float>{v} : std::nullopt;
+}
+
+static const char* ActorShortName(s16 profname) {
+    const char* n = dStage_getName(profname, -1);
+    return n ? n : "?";
+}
+
+// Resolves @found / @link / @<id> to a process pointer, outputting an error on failure
+static base_process_class* ParseProcArg(
+    const std::string& s, unsigned int foundProcId, const CommandOutput& output) {
+    if (s.empty() || s[0] != '@') {
+        output("Error: proc reference must start with @");
+        return nullptr;
+    }
+    const std::string inner = s.substr(1);
+    unsigned int id;
+    if (inner == "found") {
+        if (foundProcId == 0) {
+            output("Error: @found is not set");
+            return nullptr;
+        }
+        id = foundProcId;
+    } else if (inner == "link") {
+        auto* player = dComIfGp_getPlayer(0);
+        if (player == nullptr) {
+            output("Error: player not available");
+            return nullptr;
+        }
+        id = (unsigned int)fpcM_GetID(player);
+    } else {
+        const auto v = ParseLong(inner);
+        if (!v) {
+            output("Error: invalid proc ID");
+            return nullptr;
+        }
+        id = (unsigned int)*v;
+    }
+    auto* proc = fpcM_SearchByID(id);
+    if (proc == nullptr) {
+        output(fmt::format(FMT_STRING("Error: proc {} not found"), id));
+        return nullptr;
+    }
+    return proc;
+}
+
+// Like ParseProcArg but ensures the proc is an actor
+static fopAc_ac_c* ParseActorArg(
+    const std::string& s, unsigned int foundProcId, const CommandOutput& output) {
+    auto* proc = ParseProcArg(s, foundProcId, output);
+    if (proc == nullptr) {
+        return nullptr;
+    }
+    if (!fopAcM_IsActor(proc)) {
+        output("Error: proc is not an actor");
+        return nullptr;
+    }
+    return static_cast<fopAc_ac_c*>(proc);
+}
+
+static std::optional<s16> ParseActorId(const std::string& s) {
+    if (const auto v = ParseLong(s)) {
+        return (s16)*v;
+    }
+    const auto* entry = dStage_searchNameCI(s.c_str());
+    return entry ? std::optional<s16>{entry->procname} : std::nullopt;
+}
+
+static std::optional<cXyz> ParseXYZ(const std::vector<std::string>& args, size_t i) {
+    const auto x = ParseFloat(args[i]), y = ParseFloat(args[i + 1]), z = ParseFloat(args[i + 2]);
+    return (x && y && z) ? std::optional<cXyz>{cXyz(*x, *y, *z)} : std::nullopt;
+}
+
+static bool TryAngle(
+    s16& out, const std::vector<std::string>& args, size_t i, const CommandOutput& output) {
+    if (args.size() <= i) {
+        return true;
+    }
+    const auto a = ParseLong(args[i]);
+    if (!a) {
+        output("Error: invalid angle");
+        return false;
+    }
+    out = (s16)*a;
+    return true;
+}
+
+static std::string actorLine(const base_process_class* proc) {
+    const auto* ac = static_cast<const fopAc_ac_c*>(proc);
+    return fmt::format(FMT_STRING("procId={} 0x{:04X} ({}) @ ({:.2f}, {:.2f}, {:.2f}) room={}"),
+        (unsigned int)proc->id, (unsigned int)(u16)proc->profname, ActorShortName(proc->profname),
+        ac->current.pos.x, ac->current.pos.y, ac->current.pos.z, (int)ac->current.roomNo);
+}
+
+static void recurseLayer(void* p, int (*callback)(void*, void*), void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    if (fpcBs_Is_JustOfType(g_fpcNd_type, proc->subtype)) {
+        fpcLyIt_OnlyHere(&static_cast<process_node_class*>(p)->layer, callback, ctx);
+    }
+}
+
+struct ListContext {
+    s16 targetId;
+    std::vector<std::string>* output;
+};
+struct FindContext {
+    s16 targetId;
+    std::vector<base_process_class*> matches;
+};
+
+static int ListActorCallback(void* p, void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    auto* context = static_cast<ListContext*>(ctx);
+    if (fopAcM_IsActor(proc) && (context->targetId < 0 || proc->profname == context->targetId)) {
+        context->output->push_back("  " + actorLine(proc));
+    }
+    recurseLayer(p, ListActorCallback, ctx);
+    return 1;
+}
+
+static int FindActorCallback(void* p, void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    auto* context = static_cast<FindContext*>(ctx);
+    if (fopAcM_IsActor(proc) && proc->profname == context->targetId) {
+        context->matches.push_back(proc);
+    }
+    recurseLayer(p, FindActorCallback, ctx);
+    return 1;
+}
+
+struct CameraFlyState {
+    bool active    = false;
+    cXyz startEye;
+    cXyz startCenter;
+    cXyz endEye;
+    cXyz endCenter;
+    float duration = 0.0f;
+    float elapsed  = 0.0f;
+};
+CameraFlyState s_cameraFly;
+
+static dCamera_c* getCamera() { return dCam_getBody(); }
+
+static cXyz anglesToDir(s16 h, s16 v) {
+    return cXyz(cM_scos(v) * cM_ssin(h), cM_ssin(v), cM_scos(v) * cM_scos(h));
+}
+
+static void cameraToAngles(dCamera_c* cam, s16& h, s16& v) {
+    const cXyz eye = cam->iEye();
+    const cXyz ctr = cam->iCenter();
+    const float dx = ctr.x - eye.x;
+    const float dy = ctr.y - eye.y;
+    const float dz = ctr.z - eye.z;
+    const float hDist = sqrtf(dx * dx + dz * dz);
+    h = cM_atan2s(dx, dz);
+    v = cM_atan2s(dy, hDist);
+}
+
+static float smoothstep(float t) {
+    t = std::clamp(t, 0.0f, 1.0f);
+    return t * t * (3.0f - 2.0f * t);
+}
+
+static constexpr float kCamTargetDist = 100.0f;
+
+}  // namespace
+
+bool isCameraDetached() { return s_cameraFly.active; }
+
+void processCameraCommands() {
+    if (!s_cameraFly.active) { return; }
+    dCamera_c* cam = getCamera();
+    if (cam == nullptr) { s_cameraFly.active = false; return; }
+
+    cXyz eye, center;
+
+    if (s_cameraFly.duration <= 0.0f) {
+        eye    = s_cameraFly.endEye;
+        center = s_cameraFly.endCenter;
+    } else {
+        s_cameraFly.elapsed += dusk::game_clock::sim_pace();
+        const float t = smoothstep(s_cameraFly.elapsed / s_cameraFly.duration);
+        eye    = s_cameraFly.startEye    + (s_cameraFly.endEye    - s_cameraFly.startEye)    * t;
+        center = s_cameraFly.startCenter + (s_cameraFly.endCenter - s_cameraFly.startCenter) * t;
+
+        if (s_cameraFly.elapsed >= s_cameraFly.duration) {
+            eye    = s_cameraFly.endEye;
+            center = s_cameraFly.endCenter;
+            s_cameraFly.startEye    = s_cameraFly.endEye;
+            s_cameraFly.startCenter = s_cameraFly.endCenter;
+            s_cameraFly.duration    = 0.0f;
+        }
+    }
+
+    cam->Reset(center, eye);
+    cam->mDebugFlyCam.initialized = false;
+}
+
+void runCommand(std::string_view cmdLine, CommandState& state, const CommandOutput& output) {
+    if (state.echoEnabled) {
+        output(fmt::format(FMT_STRING("> {}"), cmdLine));
+    }
+
+    if (!cmdLine.empty()) {
+        if (state.history.empty() || state.history.back() != cmdLine) {
+            state.history.push_back(std::string(cmdLine));
+            if ((int)state.history.size() > kMaxHistory) {
+                state.history.erase(state.history.begin());
+            }
+        }
+    }
+
+    auto args = SplitArgs(cmdLine);
+    if (args.empty()) {
+        return;
+    }
+    const auto& cmd = args[0];
+
+    auto requirePlayer = [&]() -> daAlink_c* {
+        auto* p = (daAlink_c*)dComIfGp_getPlayer(0);
+        if (p == nullptr) {
+            output("Error: player not available");
+        }
+        return p;
+    };
+
+    if (cmd == "tp") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+
+        if (args.size() >= 2 && args[1].starts_with('@')) {
+            auto* ac = ParseActorArg(args[1], state.foundProcId, output);
+            if (ac == nullptr) {
+                return;
+            }
+
+            if (args.size() >= 3 && args[2].starts_with('@')) {
+                auto* destAc = ParseActorArg(args[2], state.foundProcId, output);
+                if (destAc == nullptr) {
+                    return;
+                }
+                const cXyz destPos = destAc->current.pos;
+                ac->current.pos = destPos;
+                output(fmt::format(FMT_STRING("Moved actor {} to ({:.2f}, {:.2f}, {:.2f})"), ac->id,
+                    destPos.x, destPos.y, destPos.z));
+                return;
+            }
+
+            if (args.size() >= 5) {
+                const auto pos = ParseXYZ(args, 2);
+                if (!pos) {
+                    output("Error: invalid coordinates");
+                    return;
+                }
+                ac->current.pos = *pos;
+                if (!TryAngle(ac->shape_angle.y, args, 5, output)) {
+                    return;
+                }
+                output(fmt::format(FMT_STRING("Moved actor {} to ({:.2f}, {:.2f}, {:.2f})"), ac->id,
+                    pos->x, pos->y, pos->z));
+                return;
+            }
+
+            player->current.pos = ac->current.pos;
+            output(fmt::format(FMT_STRING("Teleported to actor {} ({:.2f}, {:.2f}, {:.2f})"),
+                ac->id, ac->current.pos.x, ac->current.pos.y, ac->current.pos.z));
+            return;
+        }
+
+        if (args.size() < 4) {
+            output("Usage: tp <x> <y> <z> [angle]  |  tp @<procId> [<x> <y> <z> [angle] | @link]");
+            return;
+        }
+        const auto pos = ParseXYZ(args, 1);
+        if (!pos) {
+            output("Error: invalid coordinates");
+            return;
+        }
+        player->current.pos = *pos;
+        if (!TryAngle(player->shape_angle.y, args, 4, output)) {
+            return;
+        }
+        output(fmt::format(
+            FMT_STRING("Teleported to ({:.2f}, {:.2f}, {:.2f})"), pos->x, pos->y, pos->z));
+        return;
+    }
+
+    if (cmd == "spawn") {
+        if (args.size() < 2) {
+            output("Usage: spawn <actorId> [params] [x y z] [angle]");
+            return;
+        }
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+
+        const auto actorId = ParseActorId(args[1]);
+        if (!actorId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+
+        long paramsL = -1;
+        if (args.size() >= 3) {
+            const auto p = ParseLong(args[2]);
+            if (!p) {
+                output("Error: invalid params");
+                return;
+            }
+            paramsL = *p;
+        }
+
+        cXyz pos = player->current.pos;
+        if (args.size() >= 6) {
+            const auto spawnPos = ParseXYZ(args, 3);
+            if (!spawnPos) {
+                output("Error: invalid spawn coordinates");
+                return;
+            }
+            pos = *spawnPos;
+        }
+
+        s16 angleY = 0;
+        if (!TryAngle(angleY, args, 6, output)) {
+            return;
+        }
+        csXyz angle;
+        angle.set(0, angleY, 0);
+        cXyz scale(1.0f, 1.0f, 1.0f);
+
+        layer_class* savedLayer = fpcLy_CurrentLayer();
+        base_process_class* playScene = fpcM_SearchByName(fpcNm_PLAY_SCENE_e);
+        if (playScene != nullptr) {
+            fpcLy_SetCurrentLayer(&((process_node_class*)playScene)->layer);
+        }
+        unsigned int result = fopAcM_create(
+            *actorId, (u32)paramsL, &pos, player->current.roomNo, &angle, &scale, (s8)-1);
+        fpcLy_SetCurrentLayer(savedLayer);
+
+        output(result != 0 ? fmt::format(FMT_STRING("Spawned actorId=0x{:04X} procId={}"),
+                                 (unsigned int)(u16)*actorId, result) :
+                             fmt::format(FMT_STRING("Failed to spawn actorId=0x{:04X}"),
+                                 (unsigned int)(u16)*actorId));
+        return;
+    }
+
+    if (cmd == "reset") {
+        JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
+        output("Soft reset triggered");
+        return;
+    }
+
+    if (cmd == "warp") {
+        if (args.size() < 4) {
+            output("Usage: warp <stageName> <point> <roomNo> [layer=-1]");
+            output("  e.g.  warp F_SP121 0 0");
+            return;
+        }
+        const auto pointL = ParseLong(args[2]), roomL = ParseLong(args[3]);
+        if (!pointL || !roomL) {
+            output("Error: invalid point or room number");
+            return;
+        }
+        long layerL = -1;
+        if (args.size() >= 5) {
+            const auto l = ParseLong(args[4]);
+            if (!l) {
+                output("Error: invalid layer");
+                return;
+            }
+            layerL = *l;
+        }
+        state.lastWarpStage = args[1];
+        dComIfGp_setNextStage(state.lastWarpStage.c_str(), (s16)*pointL, (s8)*roomL, (s8)layerL);
+        output(fmt::format(FMT_STRING("Warping to {} point={} room={} layer={}"), args[1],
+            (int)(s16)*pointL, (int)(s8)*roomL, (int)(s8)layerL));
+        return;
+    }
+
+    if (cmd == "list") {
+        s16 targetId = -1;
+        if (args.size() >= 2) {
+            const auto id = ParseActorId(args[1]);
+            if (!id) {
+                output("Error: unknown actor ID or name");
+                return;
+            }
+            targetId = *id;
+        }
+        std::vector<std::string> results;
+        ListContext ctx{targetId, &results};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), ListActorCallback, &ctx);
+        output(results.empty() ? "No matching actors found" :
+                                 fmt::format(FMT_STRING("Found {} actor(s):"), results.size()));
+        for (const auto& r : results) {
+            output(r);
+        }
+        return;
+    }
+
+    if (cmd == "killall") {
+        if (args.size() < 2) {
+            output("Usage: killall <actorId|name>");
+            return;
+        }
+        const auto targetId = ParseActorId(args[1]);
+        if (!targetId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+        FindContext ctx{*targetId, {}};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), FindActorCallback, &ctx);
+        for (auto* proc : ctx.matches) {
+            fpcM_Delete(proc);
+        }
+        output(fmt::format(FMT_STRING("Deleted {} actor(s) of type {} ({})"),
+            (int)ctx.matches.size(), (unsigned int)(u16)*targetId, ActorShortName(*targetId)));
+        return;
+    }
+
+    if (cmd == "heal") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+        const u16 maxLife = dComIfGs_getMaxLife() / 5 * 4;
+        u16 newLife = maxLife;
+        if (args.size() >= 2) {
+            const auto amount = ParseLong(args[1]);
+            if (!amount) {
+                output("Error: invalid amount");
+                return;
+            }
+            newLife =
+                (u16)std::max(0L, std::min((long)maxLife, (long)dComIfGs_getLife() + *amount));
+        }
+        dComIfGs_setLife(newLife);
+        output(fmt::format(FMT_STRING("Health: {}/{}"), (int)newLife, (int)maxLife));
+        return;
+    }
+
+    if (cmd == "kill") {
+        if (args.size() >= 2) {
+            auto* proc = ParseProcArg(args[1], state.foundProcId, output);
+            if (proc == nullptr) {
+                return;
+            }
+            fpcM_Delete(proc);
+            output(fmt::format(FMT_STRING("Deleted proc {}"), proc->id));
+        } else {
+            auto* player = requirePlayer();
+            if (player == nullptr) {
+                return;
+            }
+            dComIfGs_setLife(0);
+            output("Set Link's health to 0");
+        }
+        return;
+    }
+
+    if (cmd == "freeze" || cmd == "unfreeze") {
+        const bool doFreeze = (cmd == "freeze");
+        if (args.size() < 2) {
+            g_dComIfAc_gameInfo.mPause = doFreeze;
+            output(doFreeze ? "Global freeze on" : "Global freeze off");
+            return;
+        }
+        auto* ac = ParseActorArg(args[1], state.foundProcId, output);
+        if (ac == nullptr) {
+            return;
+        }
+        if (doFreeze) {
+            fpcM_PauseEnable(ac, 1);
+            output(fmt::format(FMT_STRING("Froze actor {}"), (unsigned int)ac->id));
+        } else {
+            fpcM_PauseDisable(ac, 1);
+            output(fmt::format(FMT_STRING("Unfroze actor {}"), (unsigned int)ac->id));
+        }
+        return;
+    }
+
+    if (cmd == "rate") {
+        if (args.size() >= 2) {
+            const auto hz = ParseLong(args[1]);
+            if (!hz || *hz <= 0) {
+                output("Error: rate must be a positive integer");
+                return;
+            }
+            dusk::game_clock::set_sim_rate((float)*hz);
+        }
+        output(fmt::format(FMT_STRING("Sim rate: {} hz"), (int)dusk::game_clock::get_sim_rate()));
+        return;
+    }
+
+    if (cmd == "ebf") {
+        if (args.size() >= 2) {
+            const auto val = ParseLong(args[1]);
+            if (!val || *val < 0 || *val > 255) {
+                output("Error: value must be 0-255");
+                return;
+            }
+            cDmr_SkipInfo = (u8)*val;
+        }
+        output(fmt::format(FMT_STRING("EBF = {}"), (int)cDmr_SkipInfo));
+        return;
+    }
+
+    if (cmd == "time") {
+        if (args.size() >= 2) {
+            const auto t = ParseFloat(args[1]);
+            if (!t || *t < 0.0f || *t > 360.0f) {
+                output("Error: time must be a float between 0 and 360");
+                return;
+            }
+            dKy_instant_timechg(*t);
+        }
+        output(fmt::format(FMT_STRING("Time: {:.2f} ({}:{:02d})"), dComIfGs_getTime(),
+            dKy_getdaytime_hour(), dKy_getdaytime_minute()));
+        return;
+    }
+
+    if (cmd == "rupees") {
+        const u16 maxRupees = dComIfGs_getRupeeMax();
+        if (args.size() >= 2) {
+            const auto amount = ParseLong(args[1]);
+            if (!amount) {
+                output("Error: invalid amount");
+                return;
+            }
+            dComIfGs_setRupee((u16)std::max(0L, std::min((long)maxRupees, *amount)));
+        }
+        output(fmt::format(FMT_STRING("Rupees: {}/{}"), (int)dComIfGs_getRupee(), (int)maxRupees));
+        return;
+    }
+
+    if (cmd == "find") {
+        if (args.size() < 2) {
+            if (state.foundProcId == 0) {
+                output("@found is not set");
+                return;
+            }
+            auto* proc = fpcM_SearchByID(state.foundProcId);
+            output(proc != nullptr && fopAcM_IsActor(proc) ?
+                       "@found = " + actorLine(proc) :
+                       fmt::format(FMT_STRING("@found = {} (no longer exists)"),
+                           (unsigned int)state.foundProcId));
+            return;
+        }
+
+        const auto targetId = ParseActorId(args[1]);
+        if (!targetId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+
+        int targetN = 1;
+        if (args.size() >= 3) {
+            const auto n = ParseLong(args[2]);
+            if (!n || *n < 1) {
+                output("Error: index must be >= 1");
+                return;
+            }
+            targetN = (int)*n;
+        }
+
+        FindContext ctx{*targetId, {}};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), FindActorCallback, &ctx);
+
+        if (ctx.matches.empty()) {
+            output(fmt::format(FMT_STRING("No actors found for '{}'"), args[1]));
+            return;
+        }
+
+        std::sort(ctx.matches.begin(), ctx.matches.end(),
+            [](const base_process_class* a, const base_process_class* b) { return a->id < b->id; });
+
+        if (targetN > (int)ctx.matches.size()) {
+            output(fmt::format(
+                FMT_STRING("Error: only {} actor(s) of that type exist"), (int)ctx.matches.size()));
+            return;
+        }
+
+        auto* picked = ctx.matches[(size_t)(targetN - 1)];
+        state.foundProcId = picked->id;
+        output(fmt::format(
+            FMT_STRING("@found [{}/{}] {}"), targetN, (int)ctx.matches.size(), actorLine(picked)));
+        return;
+    }
+
+    if (cmd == "camera") {
+        const std::string sub = args.size() >= 2 ? args[1] : "";
+
+        if (sub == "attach") {
+            s_cameraFly.active = false;
+            output("Camera attached");
+            return;
+        }
+
+        auto* cam = getCamera();
+        if (cam == nullptr) { output("Error: camera not available"); return; }
+
+        if (sub == "detach") {
+            s_cameraFly.active      = true;
+            s_cameraFly.duration    = 0.0f;
+            s_cameraFly.startEye    = s_cameraFly.endEye    = cam->iEye();
+            s_cameraFly.startCenter = s_cameraFly.endCenter = cam->iCenter();
+            output("Camera detached");
+            return;
+        }
+
+        if (sub == "tp") {
+            // camera tp @<ref>
+            if (args.size() >= 3 && !args[2].empty() && args[2][0] == '@') {
+                auto* ac = ParseActorArg(args[2], state.foundProcId, output);
+                if (ac == nullptr) { return; }
+                const cXyz actorPos = ac->current.pos;
+                const cXyz dir = anglesToDir(ac->shape_angle.y, 0);
+                const cXyz newEye    = cXyz(actorPos.x - dir.x * kCamTargetDist,
+                                            actorPos.y - dir.y * kCamTargetDist + 50.0f,
+                                            actorPos.z - dir.z * kCamTargetDist);
+                s_cameraFly.active = true; s_cameraFly.duration = 0.0f;
+                s_cameraFly.startEye = s_cameraFly.endEye = newEye;
+                s_cameraFly.startCenter = s_cameraFly.endCenter = actorPos;
+                    output(fmt::format(FMT_STRING("Camera moved to actor {}"), ac->id));
+                return;
+            }
+            // camera tp x y z [h] [v]
+            if (args.size() < 5) {
+                output("Usage: camera tp <x> <y> <z> [h_angle] [v_angle]  |  camera tp @<ref>");
+                return;
+            }
+            const auto pos = ParseXYZ(args, 2);
+            if (!pos) { output("Error: invalid coordinates"); return; }
+            s16 h = 0, v = 0;
+            cameraToAngles(cam, h, v);
+            if (args.size() >= 6) {
+                const auto hv = ParseLong(args[5]);
+                if (!hv) { output("Error: invalid h_angle"); return; }
+                h = (s16)*hv;
+            }
+            if (args.size() >= 7) {
+                const auto vv = ParseLong(args[6]);
+                if (!vv) { output("Error: invalid v_angle"); return; }
+                v = (s16)*vv;
+            }
+            const cXyz dir = anglesToDir(h, v);
+            const cXyz center = cXyz(pos->x + dir.x * kCamTargetDist,
+                                     pos->y + dir.y * kCamTargetDist,
+                                     pos->z + dir.z * kCamTargetDist);
+            s_cameraFly.active = true; s_cameraFly.duration = 0.0f;
+            s_cameraFly.startEye = s_cameraFly.endEye = *pos;
+            s_cameraFly.startCenter = s_cameraFly.endCenter = center;
+            output(fmt::format(FMT_STRING("Camera teleported to ({:.2f}, {:.2f}, {:.2f})"),
+                pos->x, pos->y, pos->z));
+            return;
+        }
+
+        if (sub == "pos") {
+            s16 h = 0, v = 0;
+            cameraToAngles(cam, h, v);
+            const cXyz eye = cam->iEye();
+            output(fmt::format(FMT_STRING("Camera: ({:.2f}, {:.2f}, {:.2f}) h={} v={}"),
+                eye.x, eye.y, eye.z, (int)h, (int)v));
+            return;
+        }
+
+        if (sub == "fly") {
+            // camera fly <time> <x> <y> <z> [h] [v]  |  camera fly <time> @<ref>
+            if (args.size() < 4) {
+                output("Usage: camera fly <time> <x> <y> <z> [h_angle] [v_angle]  |  camera fly <time> @<ref>");
+                return;
+            }
+            const auto t = ParseFloat(args[2]);
+            if (!t || *t <= 0) { output("Error: invalid time"); return; }
+            const float flyTime = *t;
+
+            cXyz targetPos;
+            s16 h = 0, v = 0;
+
+            if (!args[3].empty() && args[3][0] == '@') {
+                auto* ac = ParseActorArg(args[3], state.foundProcId, output);
+                if (ac == nullptr) { return; }
+                targetPos = ac->current.pos;
+                h = ac->shape_angle.y;
+                v = 0;
+            } else {
+                if (args.size() < 6) {
+                    output("Usage: camera fly <time> <x> <y> <z> [h_angle] [v_angle]  |  camera fly <time> @<ref>");
+                    return;
+                }
+                const auto pos = ParseXYZ(args, 3);
+                if (!pos) { output("Error: invalid coordinates"); return; }
+                targetPos = *pos;
+                cameraToAngles(cam, h, v);
+                if (args.size() >= 7) {
+                    const auto hv = ParseLong(args[6]); if (!hv) { output("Error: invalid h_angle"); return; } h = (s16)*hv;
+                }
+                if (args.size() >= 8) {
+                    const auto vv = ParseLong(args[7]); if (!vv) { output("Error: invalid v_angle"); return; } v = (s16)*vv;
+                }
+            }
+
+            const cXyz dir = anglesToDir(h, v);
+            const cXyz endCenter = cXyz(targetPos.x + dir.x * kCamTargetDist,
+                                        targetPos.y + dir.y * kCamTargetDist,
+                                        targetPos.z + dir.z * kCamTargetDist);
+
+            s_cameraFly.active      = true;
+            s_cameraFly.startEye    = cam->iEye();
+            s_cameraFly.startCenter = cam->iCenter();
+            s_cameraFly.endEye      = targetPos;
+            s_cameraFly.endCenter   = endCenter;
+            s_cameraFly.duration    = flyTime;
+            s_cameraFly.elapsed     = 0.0f;
+            output(fmt::format(FMT_STRING("Camera flying to ({:.2f}, {:.2f}, {:.2f}) over {:.1f}s"),
+                targetPos.x, targetPos.y, targetPos.z, flyTime));
+            return;
+        }
+
+        output("Usage: camera detach | attach | tp ... | fly ... | pos");
+        return;
+    }
+
+    if (cmd == "echo") {
+        if (args.size() >= 2 && args[1] == "off") {
+            state.echoEnabled = false;
+            output("Echo disabled");
+        } else if (args.size() >= 2 && args[1] == "on") {
+            state.echoEnabled = true;
+            output("Echo enabled");
+        } else {
+            output(state.echoEnabled ? "Echo: on" : "Echo: off");
+        }
+        return;
+    }
+
+    if (cmd == "transform") {
+        auto* player = requirePlayer();
+        if (player == nullptr) { return; }
+        player->procCoMetamorphoseInit();
+        output("Transforming");
+        return;
+    }
+
+    if (cmd == "angle") {
+        auto* player = requirePlayer();
+        if (player == nullptr) { return; }
+        if (args.size() >= 2) {
+            const auto a = ParseLong(args[1]);
+            if (!a) { output("Error: invalid angle"); return; }
+            player->shape_angle.y = (s16)*a;
+            output(fmt::format(FMT_STRING("Angle set to {}"), (int)(s16)*a));
+        } else {
+            output(fmt::format(FMT_STRING("Angle: {}"), (int)player->shape_angle.y));
+        }
+        return;
+    }
+
+    if (cmd == "pos") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+        output(fmt::format(FMT_STRING("pos: {:.4f} {:.4f} {:.4f}"), player->current.pos.x,
+            player->current.pos.y, player->current.pos.z));
+        output(
+            fmt::format(FMT_STRING("stage: {}  room: {}  entry: {}"), dComIfGp_getStartStageName(),
+                (int)player->current.roomNo, (int)dComIfGp_getStartStagePoint()));
+        return;
+    }
+
+    if (cmd == "help") {
+        output("@<ref>  =  @<procId> | @found | @link");
+        output("");
+        output("angle [value]                               Get or set Link's facing angle");
+        output("camera detach | attach                      Detach or reattach camera");
+        output("camera pos                                  Print camera position and angles");
+        output("camera tp <x> <y> <z> [h] [v]               Teleport camera (h/v are s16 angles)");
+        output("camera tp @<ref>                            Teleport camera to actor");
+        output("camera fly <t> <x> <y> <z> [h] [v]          Fly camera over t seconds (h/v are s16 angles)");
+        output("camera fly <t> @<ref>                       Fly camera to actor");
+        output("ebf [0-255]                                 Get or set cDmr_SkipInfo");
+        output("echo on | off                               Enable or disable command echo");
+        output("find <id|name> [n=1]                        Store nth actor as @found");
+        output("freeze [@<ref>]                             Freeze globally, or freeze actor");
+        output("heal [amount]                               Heal to max, or by relative amount");
+        output("kill                                        Set Link health to 0");
+        output("kill @<ref>                                 Delete proc");
+        output("killall <id|name>                           Delete all actors of a type");
+        output("list [id|name]                              List actors in scene");
+        output("pos                                         Print player position and stage");
+        output("rate [hz]                                   Get or set sim rate (1-1000, default 30)");
+        output("reset                                       Soft reset");
+        output("rupees [amount]                             Get or set rupee count");
+        output("spawn <id|name> [params] [x y z] [angle]    Spawn actor");
+        output("time [0-360]                                Get or set time of day");
+        output("tp <x> <y> <z> [angle]                      Teleport Link to coords");
+        output("tp @<ref>                                   Teleport Link to actor");
+        output("tp @<ref> <x> <y> <z> [angle]               Move actor to coords");
+        output("tp @<ref> @<ref>                            Move actor to actor");
+        output("transform                                   Force transform");
+        output("unfreeze [@<ref>]                           Unfreeze globally, or unfreeze actor");
+        output("warp <stage> <point> <room> [layer]         Warp to stage");
+        return;
+    }
+
+    output(fmt::format(FMT_STRING("Unknown command '{}' (try 'help')"), cmd));
+}
+
+}  // namespace dusk

src/dusk/commands.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk {
+
+using CommandOutput = std::function<void(std::string)>;
+
+struct CommandState {
+    std::vector<std::string> history;
+    unsigned int foundProcId = 0;
+    std::string lastWarpStage;
+    bool echoEnabled = true;
+};
+
+// Execute a single command line. Calls output() for every line of response.
+// Manages history internally; callers need only hold a CommandState.
+void runCommand(std::string_view cmdLine, CommandState& state, const CommandOutput& output);
+
+// Per-sim-tick update for camera fly animation.
+void processCameraCommands();
+
+// Returns true when the dev camera is detached (suppresses the game's camera update).
+bool isCameraDetached();
+
+}  // namespace dusk

src/dusk/d_trigger_view.cpp

@@ -0,0 +1,417 @@
+#include "dusk/d_trigger_view.h"
+#include "dusk/settings.h"
+#include "d/d_debug_viewer.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_stage.h"
+#include "d/d_path.h"
+#include "d/d_attention.h"
+#include "d/actor/d_a_alink.h"
+#include "d/actor/d_a_kytag08.h"
+#include "d/actor/d_a_e_rb.h"
+#include "d/actor/d_a_e_rd.h"
+#include "f_op/f_op_actor_mng.h"
+#include "f_op/f_op_actor_tag.h"
+#include "f_pc/f_pc_name.h"
+#include "m_Do/m_Do_mtx.h"
+#include "SSystem/SComponent/c_tag.h"
+#include "SSystem/SComponent/c_list.h"
+#include "JSystem/JMath/JMath.h"
+
+namespace dusk {
+namespace TriggerView {
+
+static u8 s_opacity;
+
+typedef void (*DrawCallback)(fopAc_ac_c*);
+
+static void searchActorForCallback(s16 actorName, DrawCallback callback) {
+    node_class* node = g_fopAcTg_Queue.mpHead;
+
+    for (int i = 0; i < g_fopAcTg_Queue.mSize; i++) {
+        if (node != NULL) {
+            create_tag_class* tag = (create_tag_class*)node;
+            fopAc_ac_c* actorData = (fopAc_ac_c*)tag->mpTagData;
+
+            bool checkAll = actorName == -1;
+            if (actorData != NULL && (fopAcM_GetName(actorData) == actorName || checkAll)) {
+                callback(actorData);
+            }
+            node = node->mpNextNode;
+        }
+    }
+}
+
+static void drawSceneExit(fopAc_ac_c* actor) {
+    struct daScex_c : public fopAc_ac_c {
+        /* 0x568 */ Mtx mMatrix;
+    };
+    daScex_c* scex = (daScex_c*)actor;
+
+    cXyz points[8];
+    points[0].set(-actor->scale.x, actor->scale.y, -actor->scale.z);
+    points[1].set(actor->scale.x, actor->scale.y, -actor->scale.z);
+    points[2].set(-actor->scale.x, actor->scale.y, actor->scale.z);
+    points[3].set(actor->scale.x, actor->scale.y, actor->scale.z);
+    points[4].set(-actor->scale.x, 0.0f, -actor->scale.z);
+    points[5].set(actor->scale.x, 0.0f, -actor->scale.z);
+    points[6].set(-actor->scale.x, 0.0f, actor->scale.z);
+    points[7].set(actor->scale.x, 0.0f, actor->scale.z);
+
+    mDoMtx_inverse(scex->mMatrix, mDoMtx_stack_c::get());
+    mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+    GXColor color = {0xFF, 0x00, 0xFF, s_opacity};
+    dDbVw_drawCube8pXlu(points, color);
+}
+
+static void drawMidnaStop(fopAc_ac_c* actor) {
+    struct daMidnaStop_c : public fopAc_ac_c {
+        /* 0x568 */ u8 data[0x5C0 - 0x568];
+        /* 0x5C0 */ f32 mRangeXZ;
+        /* 0x5C4 */ f32 mRangeY;
+    };
+    daMidnaStop_c* mstop = (daMidnaStop_c*)actor;
+
+    GXColor color = {0x4A, 0x36, 0xBA, s_opacity};
+    dDbVw_drawCylinderXlu(mstop->current.pos, mstop->scale.x * 100.0f, mstop->scale.y, color, 1);
+}
+
+static void drawPlumTag(fopAc_ac_c* actor) {
+    GXColor color = {0x00, 0xFF, 0x00, s_opacity};
+    dDbVw_drawCylinderXlu(actor->current.pos, actor->scale.x * 100.0f, 1000000.0f, color, 1);
+}
+
+static void drawPlumSearch(fopAc_ac_c* actor) {
+    GXColor color = {0xFF, 0x00, 0x00, s_opacity};
+    const f32 search_dist = 500.0f;
+    dDbVw_drawCircleXlu(actor->attention_info.position, search_dist + 160.0f, color, 1, 12);
+}
+
+static void drawSwitchArea(fopAc_ac_c* actor) {
+    struct daSwc00_c : public fopAc_ac_c {
+        /* 0x568 */ cXyz mStart;
+        /* 0x574 */ cXyz mEnd;
+        /* 0x580 */ u16 mEventID;
+        /* 0x582 */ u8 mAction;
+    };
+    daSwc00_c* swc = (daSwc00_c*)actor;
+    int shape_type = (fopAcM_GetParam(actor) >> 0x12) & 3;
+
+    GXColor color = {0x00, 0x00, 0xFF, s_opacity};
+    if (shape_type == 3) {
+        dDbVw_drawCylinderXlu(swc->current.pos, JMAFastSqrt(swc->scale.x) - 30.0f, swc->scale.y, color, 1);
+    } else if (shape_type == 0) {
+        cXyz size = swc->mEnd - swc->mStart;
+        size *= 0.5f;
+        cXyz pos = swc->mStart + size;
+        csXyz angle(swc->current.angle.x, swc->current.angle.y, swc->current.angle.z);
+        dDbVw_drawCubeXlu(pos, size, angle, color);
+    }
+}
+
+static void drawEventArea(fopAc_ac_c* actor) {
+    u8 type = (actor->shape_angle.z & 0xFF);
+    if (type == 0xFF) {
+        type = 0;
+    }
+
+    if (type == 15 || type == 16) {
+        GXColor color = {0xFF, 0xFF, 0x00, s_opacity};
+        cXyz points[8];
+        points[0].set(-actor->scale.x, actor->scale.y, -actor->scale.z);
+        points[1].set(actor->scale.x, actor->scale.y, -actor->scale.z);
+        points[2].set(-actor->scale.x, actor->scale.y, actor->scale.z);
+        points[3].set(actor->scale.x, actor->scale.y, actor->scale.z);
+        points[4].set(-actor->scale.x, 0.0f, -actor->scale.z);
+        points[5].set(actor->scale.x, 0.0f, -actor->scale.z);
+        points[6].set(-actor->scale.x, 0.0f, actor->scale.z);
+        points[7].set(actor->scale.x, 0.0f, actor->scale.z);
+
+        mDoMtx_stack_c::transS(actor->home.pos.x, actor->home.pos.y, actor->home.pos.z);
+        mDoMtx_stack_c::YrotS(actor->current.angle.y);
+        mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+        dDbVw_drawCube8pXlu(points, color);
+    } else {
+        GXColor outer_color = {0xFF, 0x00, 0x00, s_opacity};
+        GXColor inner_color = {0x00, 0xFF, 0x00, s_opacity};
+        cXyz pos = actor->current.pos;
+
+        daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+        if (player != NULL && pos.y < player->mLinkAcch.GetGroundH()) {
+            pos.y = player->mLinkAcch.GetGroundH() + 100.0f;
+        }
+
+        const f32 inner_scale = 0.83f;
+        dDbVw_drawCircleXlu(pos, actor->scale.x * inner_scale, inner_color, 1, 20);
+        dDbVw_drawCircleXlu(pos, actor->scale.x, outer_color, 1, 20);
+    }
+}
+
+static void drawEventTag(fopAc_ac_c* actor) {
+    GXColor color = {0x00, 0xC8, 0xFF, s_opacity};
+    u16 area_type = actor->home.angle.x & 0x8000;
+
+    if (area_type == 0x8000) {
+        cXyz start(actor->current.pos.x - (actor->scale.x * 0.5f), actor->current.pos.y,
+                   actor->current.pos.z - (actor->scale.z * 0.5f));
+        cXyz end(actor->current.pos.x + (actor->scale.x * 0.5f),
+                 actor->current.pos.y + actor->scale.y,
+                 actor->current.pos.z + (actor->scale.z * 0.5f));
+
+        cXyz points[8];
+        points[0].set(start.x, start.y, start.z);
+        points[1].set(start.x, start.y, end.z);
+        points[2].set(end.x, start.y, end.z);
+        points[3].set(end.x, start.y, start.z);
+        points[4].set(start.x, end.y, start.z);
+        points[5].set(start.x, end.y, end.z);
+        points[6].set(end.x, end.y, end.z);
+        points[7].set(end.x, end.y, start.z);
+
+        dDbVw_drawCube8pXlu(points, color);
+    } else {
+        cXyz pos = actor->current.pos;
+        pos.y -= actor->scale.y;
+        dDbVw_drawCylinderXlu(pos, actor->scale.x, actor->scale.y * 2, color, 1);
+    }
+}
+
+static void drawTWGate(fopAc_ac_c* actor) {
+    GXColor color = {0xFF, 0xFF, 0xFF, s_opacity};
+    dDbVw_drawCylinderXlu(actor->current.pos, actor->scale.x * 100.0f, actor->scale.y * 100.0f, color, 1);
+}
+
+static u8 s_pathColorIndex = 0;
+
+static void drawPaths(dStage_dPath_c* paths) {
+    static const GXColor colors[8] = {
+        {0xFF, 0xFF, 0xFF}, {0x00, 0x00, 0x00}, {0xFF, 0x00, 0x00}, {0x00, 0xFF, 0x00},
+        {0x00, 0x00, 0xFF}, {0xFF, 0xFF, 0x00}, {0xFF, 0x00, 0xFF}, {0x00, 0xFF, 0xFF},
+    };
+
+    cXyz cubeSize = {30.0f, 30.0f, 30.0f};
+    csXyz cubeAngle = {0, 0, 0};
+
+    for (int i = 0; i < (int)paths->num; i++) {
+        dPath* path = &paths->m_path[i];
+        GXColor color = colors[(s_pathColorIndex++) & 7];
+        color.a = s_opacity;
+        cXyz a, b;
+
+        if (dPath_ChkClose(path) && path->m_num > 2) {
+            a = (Vec)path->m_points[0].m_position;
+            b = (Vec)path->m_points[(int)path->m_num - 1].m_position;
+            dDbVw_drawLineXlu(a, b, color, 1, 10);
+        }
+
+        for (int j = 0; j < (int)path->m_num - 1; j++) {
+            a = (Vec)path->m_points[j].m_position;
+            b = (Vec)path->m_points[j + 1].m_position;
+            dDbVw_drawLineXlu(a, b, color, 1, 10);
+            dDbVw_drawCubeXlu(a, cubeSize, cubeAngle, color);
+        }
+        dDbVw_drawCubeXlu(b, cubeSize, cubeAngle, color);
+    }
+}
+
+static void drawStagePaths() {
+    dStage_dPath_c* stagePaths = g_dComIfG_gameInfo.play.getStage().getPath2Inf();
+    if (stagePaths != nullptr) {
+        drawPaths(stagePaths);
+    }
+}
+
+static void drawCurrentRoomPaths() {
+    fopAc_ac_c* player = dComIfGp_getPlayer(0);
+    if (player == nullptr) {
+        return;
+    }
+
+    s32 roomNo = fopAcM_GetRoomNo(player);
+    if (roomNo < 0 || roomNo >= 64) {
+        return;
+    }
+
+    dStage_dPath_c* roomPaths = dStage_roomControl_c::mStatus[roomNo].mRoomDt.getPath2Inf();
+    if (roomPaths != nullptr) {
+        drawPaths(roomPaths);
+    }
+}
+
+static void drawCheckpointTag(fopAc_ac_c* actor) {
+    struct daTagChgRestart_c : public fopAc_ac_c {
+        /* 0x568 */ cXyz mVertices[4];
+    };
+    daTagChgRestart_c* chk = (daTagChgRestart_c*)actor;
+
+    GXColor color = {0x29, 0xF0, 0xFF, s_opacity};
+    cXyz points[8];
+
+    mDoMtx_stack_c::transS(actor->current.pos.x, actor->current.pos.y, actor->current.pos.z);
+    mDoMtx_stack_c::YrotM(actor->current.angle.y);
+
+    points[0] = chk->mVertices[0];
+    points[1] = chk->mVertices[1];
+    points[2] = chk->mVertices[3];
+    points[3] = chk->mVertices[2];
+    points[4] = chk->mVertices[0];
+    points[5] = chk->mVertices[1];
+    points[6] = chk->mVertices[3];
+    points[7] = chk->mVertices[2];
+
+    mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+    fopAc_ac_c* player = dComIfGp_getPlayer(0);
+    if (player != nullptr) {
+        for (int i = 0; i < 8; i++) {
+            points[i].y = player->current.pos.y;
+        }
+    }
+
+    for (int i = 0; i < 4; i++) {
+        points[i].y += 1000.0f;
+    }
+
+    dDbVw_drawCube8pXlu(points, color);
+}
+
+static void drawTransformDists(fopAc_ac_c* actor) {
+    if (fopAcM_GetGroup(actor) == 4 && !(actor->actor_status & fopAcStts_UNK_0x8000000_e)) {
+        GXColor near_color = {0x00, 0xFF, 0x00, s_opacity};
+        GXColor far_color = {0xFF, 0x00, 0x00, s_opacity};
+
+        const f32 near_dist = 400.0f;
+        const f32 far_dist = 5000.0f;
+
+        dDbVw_drawCircleXlu(actor->eyePos, near_dist, near_color, 1, 20);
+        dDbVw_drawCircleXlu(actor->eyePos, far_dist, far_color, 1, 20);
+
+        const s16 view_range = 0x4000;
+        cXyz offset(0.0f, 0.0f, far_dist);
+        cXyz endpos;
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::YrotM(-view_range);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::YrotM(view_range);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+    }
+}
+
+static void drawAttentionDists(fopAc_ac_c* actor) {
+    if (fopAcM_GetGroup(actor) != 4) {
+        return;
+    }
+
+    GXColor lock_color = {0x00, 0x00, 0xFF, s_opacity};
+    GXColor talk_color = {0x00, 0xFF, 0x00, s_opacity};
+
+    dist_entry& lock_inf = dAttention_c::getDistTable(actor->attention_info.distances[fopAc_attn_LOCK_e]);
+    dist_entry& talk_inf = dAttention_c::getDistTable(actor->attention_info.distances[fopAc_attn_TALK_e]);
+
+    dDbVw_drawCircleXlu(actor->attention_info.position, lock_inf.mDistMax, lock_color, 1, 20);
+    dDbVw_drawCircleXlu(actor->attention_info.position, talk_inf.mDistMax, talk_color, 1, 20);
+}
+
+static void drawPurpleMistAvoid(fopAc_ac_c* actor) {
+    kytag08_class* tag = (kytag08_class*)actor;
+
+    GXColor avoidColor = {0x00, 0xFF, 0x00, s_opacity};
+    GXColor targetColor = {0xFF, 0x00, 0xFF, s_opacity};
+
+    dDbVw_drawCircleXlu(tag->mAvoidPos, tag->mSize.x * 45.0f * tag->mSizeScale, avoidColor, 1, 20);
+
+    cXyz cubeSize(10.0f, 10.0f, 10.0f);
+    csXyz cubeAngle(0, 0, 0);
+    dDbVw_drawCubeXlu(tag->mAvoidPos, cubeSize, cubeAngle, avoidColor);
+    dDbVw_drawCubeXlu(tag->mTargetAvoidPos, cubeSize, cubeAngle, targetColor);
+}
+
+static void drawLeeverData(fopAc_ac_c* actor) {
+    e_rb_class* leever = (e_rb_class*)actor;
+
+    if (leever->isChild) {
+        return;
+    }
+
+    GXColor color = {0xFF, 0x00, 0x00, s_opacity};
+    GXColor color2 = {0x00, 0x00, 0xFF, s_opacity};
+
+    cXyz pos = actor->current.pos;
+    daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+    if (player != nullptr && pos.y < player->mLinkAcch.GetGroundH()) {
+        pos.y = player->mLinkAcch.GetGroundH() + 100.0f;
+    }
+
+    dDbVw_drawCircleXlu(pos, leever->appearRange * 100.0f, color, 1, 20);
+    dDbVw_drawCircleXlu(pos, leever->field_0xa69 * 100.0f, color2, 1, 20);
+}
+
+void execute() {
+    const auto& settings = getTransientSettings().triggerView;
+    s_opacity = (u8)(255.0f * (settings.opacity / 100.0f));
+
+    if (settings.loadZones) {
+        searchActorForCallback(fpcNm_SCENE_EXIT_e, drawSceneExit);
+    }
+
+    if (settings.midnaStops) {
+        searchActorForCallback(fpcNm_Tag_Mstop_e, drawMidnaStop);
+    }
+
+    if (settings.switchAreas) {
+        searchActorForCallback(fpcNm_SWC00_e, drawSwitchArea);
+    }
+
+    if (settings.eventAreas) {
+        searchActorForCallback(fpcNm_TAG_EVENT_e, drawEventTag);
+        searchActorForCallback(fpcNm_TAG_EVTAREA_e, drawEventArea);
+        searchActorForCallback(fpcNm_TAG_MYNA2_e, drawPlumTag);
+        searchActorForCallback(fpcNm_MYNA2_e, drawPlumSearch);
+    }
+
+    if (settings.twilightGates) {
+        searchActorForCallback(fpcNm_Tag_TWGate_e, drawTWGate);
+    }
+
+    if (settings.paths) {
+        s_pathColorIndex = 0;
+        drawStagePaths();
+        drawCurrentRoomPaths();
+    }
+
+    if (settings.checkpoints) {
+        searchActorForCallback(fpcNm_Tag_ChgRestart_e, drawCheckpointTag);
+    }
+
+    if (settings.transformDists) {
+        searchActorForCallback(-1, drawTransformDists);
+    }
+
+    if (settings.attentionDists) {
+        searchActorForCallback(-1, drawAttentionDists);
+    }
+
+    if (settings.purpleMistAvoid) {
+        searchActorForCallback(fpcNm_KYTAG08_e, drawPurpleMistAvoid);
+    }
+
+    if (settings.leevers) {
+        searchActorForCallback(fpcNm_E_RB_e, drawLeeverData);
+    }
+}
+
+}  // namespace TriggerView
+}  // namespace dusk

src/dusk/d_trigger_view.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace dusk {
+namespace TriggerView {
+void execute();
+}
+}

src/dusk/game_clock.cpp

@@ -16,8 +16,9 @@ clock::time_point s_current_snapshot_time{};
 
 std::unordered_map<uintptr_t, clock::time_point> s_interval_last_sample;
 
-constexpr clock::duration kSimPeriodDuration =
+float s_sim_rate_hz = 30.0f;
-    std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(sim_pace()));
+clock::duration s_sim_period_duration = std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(sim_pace()));
+
 constexpr clock::duration kAbnormalGapResetThreshold = std::chrono::milliseconds(250);
 constexpr int kMaxSimTicksPerFrame = 2;
 
@@ -32,7 +33,17 @@ void ensure_initialized() {
 
 void reset_frame_timer() {
     s_previous_sample = clock::now();
-    s_current_snapshot_time = s_previous_sample - kSimPeriodDuration;
+    s_current_snapshot_time = s_previous_sample - s_sim_period_duration;
+}
+
+void set_sim_rate(float hz) {
+    s_sim_rate_hz = std::max(1.0f, std::min(hz, 1000.0f));
+    s_sim_period_duration = std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(1.0f / s_sim_rate_hz));
+    reset_frame_timer();
+}
+
+float get_sim_rate() {
+    return s_sim_rate_hz;
 }
 
 MainLoopPacer advance_main_loop() {
@@ -45,12 +56,12 @@ MainLoopPacer advance_main_loop() {
 
     MainLoopPacer out{};
     out.presentation_dt_seconds = presentation_dt;
+    out.sim_pace = 1.0f / s_sim_rate_hz;
 
     const bool should_interpolate = dusk::getSettings().game.enableFrameInterpolation.getValue() !=
                                         dusk::FrameInterpMode::Off &&
                                     !dusk::getTransientSettings().skipFrameRateLimit;
     out.is_interpolating = should_interpolate;
-    out.sim_pace = sim_pace();
 
     if (!should_interpolate) {
         s_current_snapshot_time = now;
@@ -59,16 +70,16 @@ MainLoopPacer advance_main_loop() {
     }
 
     if (frame_gap > kAbnormalGapResetThreshold) {
-        s_current_snapshot_time = now - kSimPeriodDuration;
+        s_current_snapshot_time = now - s_sim_period_duration;
         out.sim_ticks_to_run = 0;
         return out;
     }
 
     int sim_ticks_to_run = 0;
     clock::time_point projected_snapshot_time = s_current_snapshot_time;
-    const clock::time_point render_time = now - kSimPeriodDuration;
+    const clock::time_point render_time = now - s_sim_period_duration;
     while (sim_ticks_to_run < kMaxSimTicksPerFrame && projected_snapshot_time < render_time) {
-        projected_snapshot_time += kSimPeriodDuration;
+        projected_snapshot_time += s_sim_period_duration;
         sim_ticks_to_run++;
     }
     out.sim_ticks_to_run = sim_ticks_to_run;
@@ -77,13 +88,13 @@ MainLoopPacer advance_main_loop() {
 
 void commit_sim_tick() {
     ensure_initialized();
-    s_current_snapshot_time += kSimPeriodDuration;
+    s_current_snapshot_time += s_sim_period_duration;
 }
 
 float sample_interpolation_step() {
     ensure_initialized();
     const float step =
-        std::chrono::duration<float>(clock::now() - s_current_snapshot_time).count() / sim_pace();
+        std::chrono::duration<float>(clock::now() - s_current_snapshot_time).count() / (1.0f / s_sim_rate_hz);
     return std::clamp(step, 0.0f, 1.0f);
 }
 

src/dusk/game_clock.h

@@ -23,4 +23,8 @@ float sample_interpolation_step();
 
 float consume_interval(const void* consumer);
 
+// Runtime sim rate override (default 30 hz). Resets the frame timer.
+void set_sim_rate(float hz);
+float get_sim_rate();
+
 } // namespace dusk::game_clock

src/dusk/game_combos.cpp

@@ -0,0 +1,136 @@
+#include "dusk/game_combos.h"
+
+#include "SSystem/SComponent/c_API_controller_pad.h"
+#include "SSystem/SComponent/c_xyz.h"
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_game.h"
+#include "dusk/settings.h"
+#include "m_Do/m_Do_controller_pad.h"
+
+namespace dusk {
+namespace {
+
+cXyz s_savedTeleportPos{};
+s16 s_savedTeleportAngle = 0;
+bool s_hasTeleportPos = false;
+
+static daAlink_c* getPlayer() {
+    return (daAlink_c*)dComIfGp_getPlayer(0);
+}
+
+static void consumeButtons(u32 mask) {
+    mDoCPd_c::getCpadInfo(PAD_1).mPressedButtonFlags &= ~mask;
+    mDoCPd_c::getCpadInfo(PAD_1).mButtonFlags &= ~mask;
+}
+
+// Table: holdMask, trigMask, strict, condition, action, consumeMask, exclusive
+static const GameCombo kCombos[] = {
+    // Move Link (L+R+Y), pass-through, non-exclusive
+    {
+        PAD_TRIGGER_R | PAD_TRIGGER_L,
+        PAD_BUTTON_Y,
+        false,
+        [] { return (bool)getSettings().game.enableMoveLinkCombo; },
+        [] { getTransientSettings().moveLinkActive = !getTransientSettings().moveLinkActive; },
+        0,
+        false,
+    },
+    // Quick Transform (R+Y, strictly only R held)
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_Y,
+        true,
+        [] { return getPlayer() != nullptr; },
+        [] { getPlayer()->handleQuickTransform(); },
+        PAD_BUTTON_Y,
+        false,
+    },
+    // Wolf Howl (R+X)
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_X,
+        false,
+        [] { return getPlayer() != nullptr; },
+        [] { getPlayer()->handleWolfHowl(); },
+        PAD_BUTTON_X,
+        false,
+    },
+    // Teleport save (R+D-pad Up), consumes D-pad Up, exclusive
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_UP,
+        false,
+        [] { return getSettings().game.enableTeleportCombo && getPlayer() != nullptr; },
+        [] {
+            auto* p = getPlayer();
+            s_savedTeleportPos = p->current.pos;
+            s_savedTeleportAngle = p->shape_angle.y;
+            s_hasTeleportPos = true;
+        },
+        PAD_BUTTON_UP,
+        true,
+    },
+    // Teleport load (R+D-pad Down), consumes D-pad Down, exclusive
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_DOWN,
+        false,
+        [] {
+            return getSettings().game.enableTeleportCombo && s_hasTeleportPos &&
+                   getPlayer() != nullptr;
+        },
+        [] {
+            auto* p = getPlayer();
+            p->current.pos = s_savedTeleportPos;
+            p->shape_angle.y = s_savedTeleportAngle;
+            p->mNormalSpeed = 0.0f;
+        },
+        PAD_BUTTON_DOWN,
+        true,
+    },
+    // Moon Jump (R+A, hold), continuous, pass-through, non-exclusive
+    {
+        PAD_TRIGGER_R | PAD_BUTTON_A,
+        0,
+        false,
+        [] { return getSettings().game.moonJump && getPlayer() != nullptr; },
+        [] { getPlayer()->speed.y = 56.0f; },
+        0,
+        false,
+    },
+};
+
+}  // namespace
+
+void processGameCombos() {
+    if (!getSettings().game.enableMoveLinkCombo) {
+        getTransientSettings().moveLinkActive = false;
+    }
+
+    const u32 held = mDoCPd_c::getHold(PAD_1);
+    const u32 trig = mDoCPd_c::getTrig(PAD_1);
+
+    for (const auto& combo : kCombos) {
+        if ((held & combo.holdMask) != combo.holdMask) {
+            continue;
+        }
+        if (combo.strict && (held & ~combo.trigMask) != combo.holdMask) {
+            continue;
+        }
+        if (combo.trigMask != 0 && !(trig & combo.trigMask)) {
+            continue;
+        }
+        if (combo.condition != nullptr && !combo.condition()) {
+            continue;
+        }
+        combo.action();
+        if (combo.consumeMask != 0) {
+            consumeButtons(combo.consumeMask);
+        }
+        if (combo.exclusive) {
+            return;
+        }
+    }
+}
+
+}  // namespace dusk

src/dusk/game_combos.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <dolphin/types.h>
+
+namespace dusk {
+
+struct GameCombo {
+    using ConditionFn = bool(*)();
+    using ActionFn    = void(*)();
+
+    u32         holdMask;    // all of these must be held (getHold)
+    u32         trigMask;    // at least one must be newly triggered (getTrig); 0 = fires every frame while holdMask is held
+    bool        strict;      // if true: (held & ~trigMask) must equal holdMask exactly, no extra buttons held
+    ConditionFn condition;   // extra game-state guard; nullptr = no extra check
+    ActionFn    action;      // runs when the combo is fired
+    u32         consumeMask; // buttons to clear after firing; 0 = pass-through
+    bool        exclusive;   // stop evaluating future combos if this fires
+};
+
+void processGameCombos();
+
+}  // namespace dusk

src/dusk/imgui/ImGuiConsole.cpp

@@ -238,12 +238,6 @@ namespace dusk {
         getTransientSettings().skipFrameRateLimit = getSettings().game.enableTurboKeybind &&
             (ImGui::IsKeyDown(ImGuiKey_Tab) || getActionBindHoldAnyPort(ActionBinds::TURBO_SPEED_BUTTON));
 
-        if (dusk::frame_interp::get_ui_tick_pending() && mDoMain::developmentMode == 1 && (mDoCPd_c::getHold(PAD_1) & (PAD_TRIGGER_R | PAD_TRIGGER_L)) == (PAD_TRIGGER_R | PAD_TRIGGER_L) && mDoCPd_c::getTrigY(PAD_1)) {
-            getTransientSettings().moveLinkActive = !getTransientSettings().moveLinkActive;
-        }
-        if (mDoMain::developmentMode != 1) {
-            getTransientSettings().moveLinkActive = false;
-        }
     }
 
     void ImGuiConsole::PreDraw() {

src/dusk/imgui/ImGuiMenuTools.cpp

@@ -93,6 +93,26 @@ namespace dusk {
                 ImGui::EndMenu();
             }
 
+            auto& triggerView = getTransientSettings().triggerView;
+            if (ImGui::BeginMenu("Trigger View")) {
+                ImGui::Checkbox("Load Zones", &triggerView.loadZones);
+                ImGui::Checkbox("Event Areas", &triggerView.eventAreas);
+                ImGui::Checkbox("Event Tags", &triggerView.eventTags);
+                ImGui::Checkbox("Switch Areas", &triggerView.switchAreas);
+                ImGui::Checkbox("Midna Stops", &triggerView.midnaStops);
+                ImGui::Checkbox("Twilight Gates", &triggerView.twilightGates);
+                ImGui::Checkbox("Checkpoints", &triggerView.checkpoints);
+                ImGui::Checkbox("Paths", &triggerView.paths);
+                ImGui::Separator();
+                ImGui::Checkbox("Transform Distances", &triggerView.transformDists);
+                ImGui::Checkbox("Attention Distances", &triggerView.attentionDists);
+                ImGui::Checkbox("Purple Mist Avoid", &triggerView.purpleMistAvoid);
+                ImGui::Checkbox("Leever Ranges", &triggerView.leevers);
+                ImGui::Separator();
+                ImGui::SliderFloat("Opacity##triggers", &triggerView.opacity, 0.0f, 100.0f);
+                ImGui::EndMenu();
+            }
+
             if (!dusk::IsGameLaunched) {
                 ImGui::BeginDisabled();
             }

src/dusk/settings.cpp

@@ -154,7 +154,9 @@ UserSettings g_userSettings = {
         .recordingMode {"game.recordingMode", false},
         .removeQuestMapMarkers {"game.removeQuestMapMarkers", false},
         .showInputViewer {"game.showInputViewer", false},
-        .showInputViewerGyro {"game.showInputViewerGyro", false}
+        .showInputViewerGyro {"game.showInputViewerGyro", false},
+        .enableMoveLinkCombo {"game.enableMoveLinkCombo", false},
+        .enableTeleportCombo {"game.enableTeleportCombo", false}
     },
 
     .backend = {
@@ -302,6 +304,8 @@ void registerSettings() {
     Register(g_userSettings.game.removeQuestMapMarkers);
     Register(g_userSettings.game.showInputViewer);
     Register(g_userSettings.game.showInputViewerGyro);
+    Register(g_userSettings.game.enableMoveLinkCombo);
+    Register(g_userSettings.game.enableTeleportCombo);
     Register(g_userSettings.game.fastSpinner);
     Register(g_userSettings.game.infiniteHearts);
     Register(g_userSettings.game.infiniteArrows);
@@ -392,7 +396,22 @@ static TransientSettings g_transientSettings = {
         .colliderViewOpacity = 50.0f,
         .drawRange = 100.0f,
     },
-    .skipFrameRateLimit = false,
+    .triggerView = {
+        .loadZones = false,
+        .eventAreas = false,
+        .switchAreas = false,
+        .eventTags = false,
+        .midnaStops = false,
+        .twilightGates = false,
+        .checkpoints = false,
+        .paths = false,
+        .transformDists = false,
+        .attentionDists = false,
+        .purpleMistAvoid = false,
+        .leevers = false,
+        .opacity = 75.0f,
+    },
+    .skipFrameRateLimit = false
 };
 
 TransientSettings& getTransientSettings() {

src/dusk/settings.h

@@ -282,6 +282,8 @@ struct UserSettings {
         ConfigVar<bool> removeQuestMapMarkers;
         ConfigVar<bool> showInputViewer;
         ConfigVar<bool> showInputViewerGyro;
+        ConfigVar<bool> enableMoveLinkCombo;
+        ConfigVar<bool> enableTeleportCombo;
     } game;
 
     struct {
@@ -323,8 +325,25 @@ struct CollisionViewSettings {
     float drawRange;
 };
 
+struct TriggerViewSettings {
+    bool loadZones;
+    bool eventAreas;
+    bool switchAreas;
+    bool eventTags;
+    bool midnaStops;
+    bool twilightGates;
+    bool checkpoints;
+    bool paths;
+    bool transformDists;
+    bool attentionDists;
+    bool purpleMistAvoid;
+    bool leevers;
+    float opacity;
+};
+
 struct TransientSettings {
     CollisionViewSettings collisionView;
+    TriggerViewSettings triggerView;
     bool skipFrameRateLimit;
     bool moveLinkActive;
     bool stateShareLoadActive;

src/dusk/ui/command_console.cpp

@@ -0,0 +1,209 @@
+#include "command_console.hpp"
+
+#include <RmlUi/Core.h>
+#include <RmlUi/Core/Elements/ElementFormControlInput.h>
+#include <SDL3/SDL_keyboard.h>
+#include <aurora/rmlui.hpp>
+#include <imgui.h>
+
+#include "dusk/settings.h"
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+
+#include "fmt/format.h"
+#include "ui.hpp"
+
+namespace dusk::ui {
+namespace {
+
+static const Rml::String kDocumentSource = R"RML(
+<rml>
+<head>
+    <link type="text/rcss" href="res/rml/command_console.rcss" />
+</head>
+<body>
+    <console id="console">
+        <output id="console-output"></output>
+        <input id="console-input" type="text" maxlength="255" />
+    </console>
+</body>
+</rml>
+)RML";
+
+static bool isCommand(std::string_view text) {
+    return text.size() >= 2 && text[0] == '>' && text[1] == ' ';
+}
+
+}  // namespace
+
+CommandConsole::CommandConsole() : Document(kDocumentSource) {
+    mConsole = mDocument ? mDocument->GetElementById("console") : nullptr;
+    mOutput = mDocument ? mDocument->GetElementById("console-output") : nullptr;
+    auto* rawInput = mDocument ? mDocument->GetElementById("console-input") : nullptr;
+    mInput = rmlui_dynamic_cast<Rml::ElementFormControlInput*>(rawInput);
+
+    listen(
+        Rml::EventId::Keydown,
+        [this](Rml::Event& event) {
+            if (!mInputActive) {
+                return;
+            }
+            const auto key = static_cast<Rml::Input::KeyIdentifier>(event.GetParameter<int>("key_identifier", Rml::Input::KI_UNKNOWN));
+            if (key == Rml::Input::KI_RETURN) {
+                executeFromInput();
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_ESCAPE) {
+                hide(true);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_UP) {
+                navigateHistory(-1);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_DOWN) {
+                navigateHistory(+1);
+                event.StopImmediatePropagation();
+            }
+        },
+        true);
+}
+
+bool CommandConsole::handle_nav_command(Rml::Event&, NavCommand) {
+    return false;
+}
+
+void CommandConsole::update() {
+    if (!getSettings().backend.enableAdvancedSettings) {
+        return;
+    }
+
+    const float dt = std::max(ImGui::GetIO().DeltaTime, 0.0f);
+    for (auto& line : mOutputLines) {
+        line.remain -= dt;
+    }
+    const auto [first, last] =
+        std::ranges::remove_if(mOutputLines, [](const OutputLine& l) { return l.remain <= 0.0f; });
+    mOutputLines.erase(first, last);
+
+    if (mOutputLines.empty() && !mInputActive) {
+        Document::hide(mPendingClose);
+        return;
+    }
+
+    if (mOutput == nullptr) {
+        return;
+    }
+
+    Rml::String html;
+    if (mInputActive) {
+        for (const auto& msg : mMsgHistory) {
+            html += isCommand(msg) ? "<line class=\"cmd\">" + escape(msg) + "</line>" : "<line>" + escape(msg) + "</line>";
+        }
+        mOutput->SetAttribute("open", "");
+    } else {
+        const int total = (int)mOutputLines.size();
+        const int startIdx = std::max(0, total - kMaxVisibleLines);
+        for (int i = startIdx; i < total; ++i) {
+            const auto& line = mOutputLines[i];
+            const float alpha = line.remain < kFadeSeconds ? line.remain / kFadeSeconds : 1.0f;
+            const Rml::String cls = isCommand(line.text) ? " class=\"cmd\"" : "";
+            html += fmt::format(FMT_STRING("<line{} style=\"opacity: {:.3f}\">{}</line>"), cls,
+                alpha, escape(line.text));
+        }
+        mOutput->RemoveAttribute("open");
+    }
+
+    mOutput->SetInnerRML(html);
+
+    if (mScrollToBottom && mInputActive) {
+        mOutput->SetScrollTop(1e9f);
+        mScrollToBottom = false;
+    }
+}
+
+void CommandConsole::show() {
+    if (mDocument != nullptr) {
+        mDocument->Show(Rml::ModalFlag::None, Rml::FocusFlag::None, Rml::ScrollFlag::None);
+    }
+    mInputActive = true;
+    mScrollToBottom = true;
+    if (mConsole != nullptr) {
+        mConsole->SetAttribute("open", "");
+    }
+    focus();
+}
+
+bool CommandConsole::focus() {
+    if (mInput != nullptr) {
+        mInput->SetValue("");
+        aurora::rmlui::set_input_type(aurora::rmlui::InputType::Text);
+        return mInput->Focus(true);
+    }
+    return false;
+}
+
+void CommandConsole::hide(bool close) {
+    mInputActive = false;
+    mHistoryPos = -1;
+    if (mConsole != nullptr) {
+        mConsole->RemoveAttribute("open");
+    }
+    if (mInput != nullptr) {
+        mInput->SetValue("");
+    }
+    mPendingClose = close;
+    // Immediately refocus
+    if (auto* doc = top_document()) {
+        doc->focus();
+    }
+}
+
+void CommandConsole::executeFromInput() {
+    if (mInput == nullptr) {
+        return;
+    }
+    const Rml::String value = mInput->GetValue();
+    hide(true);
+    if (!value.empty()) {
+        runCommand(value, mState, [this](std::string text) { ConsolePrint(std::move(text)); });
+    }
+    mScrollToBottom = true;
+}
+
+void CommandConsole::navigateHistory(int dir) {
+    if (mState.history.empty() || mInput == nullptr) {
+        return;
+    }
+    const int prev = mHistoryPos;
+    if (dir < 0) {
+        if (mHistoryPos == -1) {
+            mHistoryPos = (int)mState.history.size() - 1;
+        } else if (mHistoryPos > 0) {
+            --mHistoryPos;
+        }
+    } else {
+        if (mHistoryPos != -1 && ++mHistoryPos >= (int)mState.history.size()) {
+            mHistoryPos = -1;
+        }
+    }
+    if (prev != mHistoryPos) {
+        const char* str = mHistoryPos >= 0 ? mState.history[mHistoryPos].c_str() : "";
+        mInput->SetValue(str);
+        const int end = static_cast<int>(Rml::StringUtilities::LengthUTF8(mInput->GetValue()));
+        mInput->SetSelectionRange(end, end);
+    }
+}
+
+void CommandConsole::ConsolePrint(std::string text) {
+    mMsgHistory.push_back(text);
+    if ((int)mMsgHistory.size() > kMaxMsgHistory) {
+        mMsgHistory.erase(mMsgHistory.begin());
+    }
+    mOutputLines.push_back({std::move(text), kDurationNormal});
+    mScrollToBottom = true;
+    if ((int)mOutputLines.size() > kMaxStoredLines) {
+        mOutputLines.erase(mOutputLines.begin());
+    }
+}
+
+}  // namespace dusk::ui

src/dusk/ui/command_console.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "document.hpp"
+#include "dusk/commands.hpp"
+
+#include <string>
+#include <vector>
+
+namespace Rml {
+class ElementFormControlInput;
+}
+
+namespace dusk::ui {
+
+class CommandConsole : public Document {
+public:
+    CommandConsole();
+
+    void update() override;
+    void show() override;
+    bool focus() override;
+    void hide(bool close) override;
+
+private:
+    struct OutputLine {
+        std::string text;
+        float remain;
+    };
+
+    static constexpr float kDurationNormal = 6.0f;
+    static constexpr float kFadeSeconds = 0.8f;
+    static constexpr int kMaxStoredLines = 64;
+    static constexpr int kMaxVisibleLines = 24;
+    static constexpr int kMaxMsgHistory = 500;
+
+    Rml::Element* mConsole = nullptr;
+    Rml::Element* mOutput = nullptr;
+    Rml::ElementFormControlInput* mInput = nullptr;
+
+    std::vector<OutputLine> mOutputLines;
+    std::vector<std::string> mMsgHistory;
+    int mHistoryPos = -1;
+    bool mInputActive = false;
+    bool mScrollToBottom = false;
+
+    CommandState mState;
+
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+    void ConsolePrint(std::string text);
+    void executeFromInput();
+    void navigateHistory(int dir);
+};
+
+}  // namespace dusk::ui

src/dusk/ui/document.cpp

@@ -84,6 +84,7 @@ void Document::show() {
             focus();
         }
     }
+    mPendingClose = false;
 }
 
 void Document::hide(bool close) {

src/dusk/ui/document.hpp

@@ -65,6 +65,7 @@ public:
         uncover_top_document();
     }
 
+    bool pending_close() const { return mPendingClose; }
     bool closed() const { return mClosed; }
 
     bool handle_nav_event(Rml::Event& event);

src/dusk/ui/menu_bar.cpp

@@ -13,6 +13,7 @@
 #include "dusk/settings.h"
 #include "dusk/speedrun.h"
 #include "editor.hpp"
+#include "f_op/f_op_scene_mng.h"
 #include "f_pc/f_pc_manager.h"
 #include "f_pc/f_pc_name.h"
 #include "imgui.h"
@@ -142,6 +143,10 @@ MenuBar::MenuBar()
             if (getSettings().game.liveSplitEnabled) {
                 dusk::speedrun::reset();
             }
+            auto* playScene = fpcM_SearchByName(fpcNm_PLAY_SCENE_e);
+            if (playScene != nullptr) {
+                fopScnM_ChangeReq((scene_class*)playScene, fpcNm_NAME_SCENE_e, 0x7FFF, 0);
+            }
             hide(false);
         });
     }

src/dusk/ui/settings.cpp

@@ -1536,6 +1536,20 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             "Recording Mode",
             "Disables the game HUD and all background music.<br/><br/>Useful for recording footage.");
     });
+
+    add_tab("Tools", [this](Rml::Element* content) {
+        auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
+        auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
+
+        leftPane.add_section("Link");
+        add_speedrun_disabled_option(leftPane, rightPane, getSettings().game.enableMoveLinkCombo,
+            "Move Link (L+R+Y)",
+            "Enables the L+R+Y button combo to toggle freely repositioning Link.");
+        add_speedrun_disabled_option(leftPane, rightPane, getSettings().game.enableTeleportCombo,
+            "Teleport (R+D-pad Up/Down)",
+            "R+D-pad Up stores Link's current position.<br/>"
+            "R+D-pad Down teleports Link back to it.");
+    });
 }
 
 void SettingsWindow::update() {

src/dusk/ui/ui.cpp

@@ -18,6 +18,7 @@
 #include "dusk/config.hpp"
 #include "dusk/io.hpp"
 #include <borealis/io.hpp>
+#include "command_console.hpp"
 #include "icon_provider.hpp"
 #include "input.hpp"
 #include "mod_texture_provider.hpp"
@@ -216,6 +217,19 @@ void handle_event(const SDL_Event& event) noexcept {
         sConnectedGamepads.erase(event.gdevice.which);
     }
     input::handle_event(event);
+    // TODO: don't overlap with PAD bindings?
+    if (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_SLASH) {
+        bool found = false;
+        for (auto& doc : sDocumentStack) {
+            if (auto* console = dynamic_cast<CommandConsole*>(doc.get())) {
+                console->show();
+                found = true;
+            }
+        }
+        if (!found) {
+            push_document(std::make_unique<CommandConsole>(), true, false);
+        }
+    }
 }
 
 bool register_scoped_styles(DocumentScope scope, std::string id, const std::string& rcss) noexcept {
@@ -269,7 +283,7 @@ void uncover_top_document() noexcept {
 
 bool any_document_visible() noexcept {
     return std::any_of(sDocumentStack.begin(), sDocumentStack.end(),
-        [](const auto& doc) { return doc && doc->visible(); });
+        [](const auto& doc) { return doc && doc->visible() && !doc->pending_close(); });
 }
 
 bool is_prelaunch_open() noexcept {

src/f_ap/f_ap_game.cpp

@@ -759,23 +759,7 @@ static void duskExecute() {
         isRecording = false;
     }
 
-    if (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getTrigX(PAD_1)) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            dynamic_cast<daAlink_c*>(link)->handleWolfHowl();
-        }
-    }
 
-    if ((mDoCPd_c::getHold(PAD_1) & (PAD_TRIGGER_R | PAD_TRIGGER_L)) == PAD_TRIGGER_R && mDoCPd_c::getTrigY(PAD_1)) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            dynamic_cast<daAlink_c*>(link)->handleQuickTransform();
-        }
-    }
-
-    if (dusk::getSettings().game.moonJump && (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1))) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            link->speed.y = 56.0f;
-        }
-    }
 
     if (dusk::getSettings().game.fastSpinner && mDoCPd_c::getHoldR(PAD_1)) {
         if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {

src/m_Do/m_Do_main.cpp

@@ -60,6 +60,8 @@
 #include "dusk/frame_interpolation.h"
 #include "dusk/game_clock.h"
 #include "dusk/gyro.h"
+#include "dusk/commands.hpp"
+#include "dusk/game_combos.h"
 #include "dusk/imgui/ImGuiConsole.hpp"
 #include "dusk/imgui/ImGuiEngine.hpp"
 #include "dusk/iso_validate.hpp"
@@ -70,6 +72,7 @@
 #include "dusk/mouse.h"
 #include "dusk/os.h"
 #include "dusk/presentation.hpp"
+#include "dusk/ui/command_console.hpp"
 #include "dusk/ui/menu_bar.hpp"
 #include "dusk/ui/overlay.hpp"
 #include "dusk/ui/prelaunch.hpp"
@@ -300,7 +303,9 @@ void main01(void) {
                     mDoCPd_c::read();
                     dusk::mouse::read();
                     dusk::gyro::read(pacing.sim_pace);
+                    dusk::processGameCombos();
                     fapGm_Execute();
+                    dusk::processCameraCommands();
                     mDoAud_Execute();
                     dusk::game_clock::commit_sim_tick();
                 }
@@ -316,13 +321,15 @@ void main01(void) {
             dusk::frame_interp::end_presentation_camera();
             dusk::frame_interp::set_ui_tick_pending(false);
         } else {
-            dusk::frame_interp::begin_frame(dusk::FrameInterpMode::Off, true, 0.0f);
-            dusk::frame_interp::set_ui_tick_pending(true);
-
             // Game Inputs
             mDoCPd_c::read();
             dusk::mouse::read();
             dusk::gyro::read(pacing.presentation_dt_seconds);
+            dusk::processGameCombos();
+            dusk::processCameraCommands();
+
+            dusk::frame_interp::begin_frame(dusk::FrameInterpMode::Off, true, 0.0f);
+            dusk::frame_interp::set_ui_tick_pending(true);
 
             // EXECUTE GAME LOGIC & RENDER
             // This calls mDoGph_Painter -> JFWDisplay -> GX Functions
@@ -354,6 +361,15 @@ void main01(void) {
 
             Limiter::duration_t sleepTime = main_loop_limiter.Sleep(target_ns);
             dusk::frameUsagePct = 100.0f * (1.0f - static_cast<float>(sleepTime) / static_cast<float>(target_ns));
+        } else if (!pacing.is_interpolating && !dusk::getTransientSettings().skipFrameRateLimit) {
+            // Non-interp: throttle display rate to the configured sim rate so /rate works
+            const double sim_fps = static_cast<double>(dusk::game_clock::get_sim_rate());
+            const Limiter::duration_t sim_target_ns = static_cast<Limiter::duration_t>(1'000'000'000.0 / sim_fps);
+            main_loop_limiter.Sleep(sim_target_ns);
+        } else if (dusk::getTransientSettings().skipFrameRateLimit) {
+            // Turbo: cap at 120 hz rather than running fully unlimited
+            constexpr Limiter::duration_t kTurboTargetNs = 1'000'000'000LL / 120LL;
+            main_loop_limiter.Sleep(kTurboTargetNs);
         } else {
             main_loop_limiter.Reset();
         }