re9_noclip.lua

-- RE9 NoClip
-- SRC: https://github.com/VIPO777/REFrameworkScripts/blob/main/re9_noclip.lua
if reframework:get_game_name() ~= "re9" then
    return
end

local SCRIPT_NAME = "RE9 NoClip"
local SCRIPT_VERSION = "1.1.0"

-- Method candidates
local METHOD_IDS = {
    get_player_position = {
        "get_PositionFast232258",
        "get_PositionFast()",
        "get_PositionFast",
        "get_Position231767",
        "get_Position()",
        "get_Position",
    },
    set_player_position = {
        "set_PositionFast232259",
        "set_PositionFast(via.vec3)",
        "set_PositionFast",
        "set_Position231768",
        "set_Position(via.vec3)",
        "set_Position(System.Numerics.Vector3)",
        "set_Position",
    },
    get_player_rotation = { "get_Rotation231769", "get_Rotation()", "get_Rotation" },
    set_player_rotation = { "set_Rotation(via.Quaternion)", "set_Rotation(System.Numerics.Quaternion)", "set_Rotation" },
    get_player_transform = { "get_Transform231793", "get_Transform()", "get_Transform" },
    get_player_common = { "get_Common232225", "get_Common()", "get_Common" },
    common_set_fall_type = { "set_FallType232069", "set_FallType(System.Int32)", "set_FallType" },
    common_set_is_fast_game_over = { "set_IsFastGameOver232097", "set_IsFastGameOver(System.Boolean)", "set_IsFastGameOver" },
    common_set_is_damage_continue_state = { "set_IsDamageContinueState232085", "set_IsDamageContinueState(System.Boolean)", "set_IsDamageContinueState" },
    get_body_gameobject = { "get_BodyGameObject45547", "get_BodyGameObject()", "get_BodyGameObject" },
    get_player_updater = { "get_Updater232238", "get_Updater()", "get_Updater" },
    get_gameobject = { "get_GameObject()", "get_GameObject" },
    transform_get_position = { "get_Position()", "get_Position(System.Void)", "get_Position" },
    transform_set_position = { "set_Position(via.vec3)", "set_Position(System.Numerics.Vector3)", "set_Position" },
    transform_get_rotation = { "get_Rotation()", "get_Rotation" },
    transform_set_rotation = { "set_Rotation(via.Quaternion)", "set_Rotation(System.Numerics.Quaternion)", "set_Rotation" },
    get_character_controller = {
        "get_CharacterController",
        "get_CharacterController618555",
        "getCharacterController",
        "getCharacterController631010",
        "get_MainCharacterController",
    },
    character_controller_warp = { "warp", "warp125040", "warp188755" },
    updater_set_requested_falling_hash = {
        "set_RequestedFallingHash208544",
        "set_RequestedFallingHash(System.UInt32)",
        "set_RequestedFallingHash",
    },
    updater_get_anim_fall_ground_checker = {
        "get_AnimFallGroundChecker208659",
        "get_AnimFallGroundChecker()",
        "get_AnimFallGroundChecker",
    },
    updater_set_anim_fall_ground_checker = {
        "set_AnimFallGroundChecker208660",
        "set_AnimFallGroundChecker(anim.AnimFallGroundChecker)",
        "set_AnimFallGroundChecker",
    },
    updater_off_animation = {
        "offAnimation208870",
        "offAnimation()",
        "offAnimation",
    },
    updater_set_requested_landing_hash = {
        "set_RequestedLandingHash208546",
        "set_RequestedLandingHash(System.UInt32)",
        "set_RequestedLandingHash",
    },
    updater_set_is_other_game_over = {
        "set_IsOtherGameOver208714",
        "set_IsOtherGameOver(System.Boolean)",
        "set_IsOtherGameOver",
    },
    updater_set_back_turn_dir_from_run_landing = {
        "set_BackTurnDirFromRunLanding208565",
        "set_BackTurnDirFromRunLanding(System.Int32)",
        "set_BackTurnDirFromRunLanding",
    },
    env_stop_free_fall_ctrl = {
        "stopFreeFallCtrl188782",
        "stopFreeFallCtrl()",
        "stopFreeFallCtrl",
    },
    env_set_fall_damage = {
        "set_FallDamage188679",
        "set_FallDamage(System.Int32)",
        "set_FallDamage",
    },
    env_set_fall_height = {
        "set_FallHeight188717",
        "set_FallHeight(System.Single)",
        "set_FallHeight",
    },
    env_set_prev_fall_height = {
        "set_PrevFallHeight188719",
        "set_PrevFallHeight(System.Single)",
        "set_PrevFallHeight",
    },
    env_set_height_prevent_fall = {
        "set_HeightPreventFall188695",
        "set_HeightPreventFall(System.Single)",
        "set_HeightPreventFall",
    },
    env_set_height_keep_ground = {
        "set_HeightKeepGround188693",
        "set_HeightKeepGround(System.Single)",
        "set_HeightKeepGround",
    },
    env_set_disable_gravity_until_motion_end = {
        "set_IsDisableGravityUntilMotionEnd188742",
        "set_IsDisableGravityUntilMotionEnd(System.Boolean)",
        "set_IsDisableGravityUntilMotionEnd",
    },
    env_prevent_fall = {
        "preventFall188776",
        "preventFall()",
        "preventFall",
    },
    player_env_clear_landing_to_fall_loop_check = {
        "clearLandingToFallLoopCheck195507",
        "clearLandingToFallLoopCheck()",
        "clearLandingToFallLoopCheck",
    },
    player_env_set_landing_action = {
        "setLandingAction195499",
        "setLandingAction(System.Boolean)",
        "setLandingAction",
    },
    player_env_check_safe_area_fall_end = {
        "checkSafeAreaFallEnd195501",
        "checkSafeAreaFallEnd()",
        "checkSafeAreaFallEnd",
    },
    hook_player_update_dead_request = {
        "updateDeadRequest208838",
        "updateDeadRequest()",
        "updateDeadRequest",
    },
    hook_player_on_dead = {
        "onDead208840",
        "onDead()",
        "onDead",
    },
    hook_player_check_execute_dead_action = {
        "checkExecuteDeadActionOnDead208841",
        "checkExecuteDeadActionOnDead()",
        "checkExecuteDeadActionOnDead",
    },
    hook_player_select_dead_action = {
        "selectDeadAction208839",
        "selectDeadAction()",
        "selectDeadAction",
    },
    hook_player_exec_safe_proc_fall_limit = {
        "execSafeProcFallLimit208946",
        "execSafeProcFallLimit()",
        "execSafeProcFallLimit",
    },
    hook_character_manager_request_game_over = {
        "requestGameOver185454",
        "requestGameOver()",
        "requestGameOver",
    },
    hook_game_over_manager_request_game_over = {
        "requestGameOver249161",
        "requestGameOver()",
        "requestGameOver",
    },
    hook_game_over_manager_transit_phase = {
        "transitPhase249163",
        "transitPhase()",
        "transitPhase",
    },
    hook_game_over_manager_update = {
        "update249158",
        "update()",
        "update",
    },
    hook_game_over_manager_final_update = {
        "FinalUpdate249184",
        "FinalUpdate()",
        "FinalUpdate",
    },
    hook_character_manager_set_requested_game_over = {
        "set_RequestedGameOver185287",
        "set_RequestedGameOver(System.Boolean)",
        "set_RequestedGameOver",
    },
    hook_character_manager_set_requested_game_over_fade = {
        "set_RequestedGameOverIsFade185289",
        "set_RequestedGameOverIsFade(System.Boolean)",
        "set_RequestedGameOverIsFade",
    },
    hook_character_manager_set_is_game_overed = {
        "set_IsGameOvered185453",
        "set_IsGameOvered(System.Boolean)",
        "set_IsGameOvered",
    },
    hook_player_context_set_is_dead_static = {
        "set_IsDeadStatic232253",
        "set_IsDeadStatic(System.Boolean)",
        "set_IsDeadStatic",
    },
    hook_dead_body_set_is_dead_release = {
        "set_IsDeadRelease204103",
        "set_IsDeadRelease(System.Boolean)",
        "set_IsDeadRelease",
    },
    hook_dead_body_update_check_dead_space = {
        "updateCheckDeadSpace204109",
        "updateCheckDeadSpace()",
        "updateCheckDeadSpace",
    },
    hook_dead_body_update_dead_space_ray_permit = {
        "updateDeadSpaceRayPermit204108",
        "updateDeadSpaceRayPermit()",
        "updateDeadSpaceRayPermit",
    },
    hook_player_env_set_landing_action = {
        "setLandingAction195499",
        "setLandingAction(System.Boolean)",
        "setLandingAction",
    },
    hook_player_env_on_update_scan_phase = {
        "onUpdateScanPhase195495",
        "onUpdateScanPhase()",
        "onUpdateScanPhase",
    },
    hook_player_env_landing_player_process = {
        "landingPlayerProcess195496",
        "landingPlayerProcess()",
        "landingPlayerProcess",
    },
    hook_player_env_late_update_additional_action = {
        "lateUpdateAdditionalAction195497",
        "lateUpdateAdditionalAction()",
        "lateUpdateAdditionalAction",
    },
    hook_player_env_is_prevent_fall = {
        "isPreventFall195500",
        "isPreventFall()",
        "isPreventFall",
    },
    hook_player_env_is_skip_prevent_fall = {
        "isSkipPreventFall195502",
        "isSkipPreventFall()",
        "isSkipPreventFall",
    },
    hook_player_env_update_climb_start_type = {
        "updateClimbStartType195503",
        "updateClimbStartType()",
        "updateClimbStartType",
    },
    hook_player_env_check_climb_start_type = {
        "checkClimbStartType195504",
        "checkClimbStartType()",
        "checkClimbStartType",
    },
    hook_player_env_on_action_locked = {
        "onActionLocked195506",
        "onActionLocked()",
        "onActionLocked",
    },
    player_env_set_seq_override_climb_start_type = {
        "set_SeqOverrideClimbStartType195490",
        "set_SeqOverrideClimbStartType(app.PlayerEnvironmentProcessDriver.ClimbStartType)",
        "set_SeqOverrideClimbStartType(System.Int32)",
        "set_SeqOverrideClimbStartType",
    },
    player_env_warp = {
        "warp195508",
        "warp()",
        "warp",
    },
    hook_player_env_check_fall_length_hash = {
        "checkFallLengthRequestedFallingHash195498",
        "checkFallLengthRequestedFallingHash()",
        "checkFallLengthRequestedFallingHash",
    },
    hook_player_env_check_safe_area_fall_end = {
        "checkSafeAreaFallEnd195501",
        "checkSafeAreaFallEnd()",
        "checkSafeAreaFallEnd",
    },
    stance_continue_hand_down = {
        "continueHandDown204352",
        "continueHandDown()",
        "continueHandDown",
    },
    stance_update_hand_down = {
        "updateHandDown204345",
        "updateHandDown()",
        "updateHandDown",
    },
    stance_update_hand_down_motion = {
        "updateHandDownMotion204354",
        "updateHandDownMotion()",
        "updateHandDownMotion",
    },
    stance_update_hand_down_internal = {
        "updateHandDownInternal204346",
        "updateHandDownInternal()",
        "updateHandDownInternal",
    },
    hook_player_stance_update_hand_up_motion = {
        "updateHandUpMotion204355",
        "updateHandUpMotion()",
        "updateHandUpMotion",
    },
    hook_player_stance_is_enable_hand_up_change_action = {
        "isEnableHandUpChangeAction204349",
        "isEnableHandUpChangeAction()",
        "isEnableHandUpChangeAction",
    },
    hook_player_stance_on_update_act_phase = {
        "onUpdateActPhase204331",
        "onUpdateActPhase()",
        "onUpdateActPhase",
    },
    hook_player_stance_update_stance = {
        "updateStance204333",
        "updateStance()",
        "updateStance",
    },
    hook_player_stance_update_stance_state = {
        "updateStanceState204332",
        "updateStanceState()",
        "updateStanceState",
    },
    hook_player_stance_update_stance_trigger = {
        "updateStanceTrigger204335",
        "updateStanceTrigger()",
        "updateStanceTrigger",
    },
    hook_player_stance_update_stance_bank_type = {
        "updateStanceBankType204336",
        "updateStanceBankType()",
        "updateStanceBankType",
    },
    stance_update_temp_hand_down = {
        "updateTempHandDown204350",
        "updateTempHandDown()",
        "updateTempHandDown",
    },
    stance_update_temp_hand_down_internal = {
        "updateTempHandDownInternal204351",
        "updateTempHandDownInternal()",
        "updateTempHandDownInternal",
    },
    hook_anim_fall_update_animation = {
        "updateAnimation148414",
        "updateAnimation()",
        "updateAnimation",
    },
    hook_anim_fall_check_ground = {
        "checkFallGround148415",
        "checkFallGround()",
        "checkFallGround",
    },
    hook_anim_fall_check_ground_core = {
        "checkFallGroundCore148416",
        "checkFallGroundCore()",
        "checkFallGroundCore",
    },
    hook_env_update_fall_info = {
        "updateFallInfo188758",
        "updateFallInfo()",
        "updateFallInfo",
    },
    hook_env_detect_ground_auto_fall = {
        "detectGroundForAutoFallAction188780",
        "detectGroundForAutoFallAction()",
        "detectGroundForAutoFallAction",
    },
    hook_env_update_climb_step = {
        "updateClimbStep188752",
        "updateClimbStep()",
        "updateClimbStep",
    },
    anim_fall_end_animation = {
        "endAnimation148413",
        "endAnimation()",
        "endAnimation",
    },
    dead_body_set_is_dead_release = {
        "set_IsDeadRelease204103",
        "set_IsDeadRelease(System.Boolean)",
        "set_IsDeadRelease",
    },
}

-- Field candidates
local FIELD_IDS = {
    character_manager_player_fast = {
        "_PlayerContextFast_k__BackingField",
        "<PlayerContextFast>k__BackingField",
        "PlayerContextFast",
    },
    character_manager_player_list = {
        "_PlayerContextList_k__BackingField",
        "<PlayerContextList>k__BackingField",
        "PlayerContextList",
    },
    player_transform = {
        "_Transform_k__BackingField",
        "<Transform>k__BackingField",
        "Transform",
    },
    player_position_fast = {
        "_PositionFast_k__BackingField",
        "<PositionFast>k__BackingField",
        "PositionFast",
    },
    player_common = {
        "_Common_k__BackingField",
        "<Common>k__BackingField",
        "Common",
    },
    player_updater = {
        "_Updater_k__BackingField",
        "<Updater>k__BackingField",
        "Updater",
        "_CharacterUpdaterBase_k__BackingField",
        "<CharacterUpdaterBase>k__BackingField",
    },
    updater_environment_process_driver = {
        "_EnvironmentProcessDriver_k__BackingField",
        "<EnvironmentProcessDriver>k__BackingField",
        "EnvironmentProcessDriver",
    },
    updater_anim_fall_ground_checker = {
        "_AnimFallGroundChecker_k__BackingField",
        "<AnimFallGroundChecker>k__BackingField",
        "AnimFallGroundChecker",
    },
    updater_dead_body_driver = {
        "_DeadBodyDriver_k__BackingField",
        "<DeadBodyDriver>k__BackingField",
        "DeadBodyDriver",
    },
    updater_player_stance_driver = {
        "_PlayerStanceDriver_k__BackingField",
        "<PlayerStanceDriver>k__BackingField",
        "PlayerStanceDriver",
    },
    updater_is_dead_trigger = {
        "_IsDeadTrigger",
        "IsDeadTrigger",
    },
    updater_is_other_game_over = {
        "_IsOtherGameOver_k__BackingField",
        "<IsOtherGameOver>k__BackingField",
        "_IsOtherGameOver",
    },
    updater_requested_falling_hash = {
        "_RequestedFallingHash_k__BackingField",
        "<RequestedFallingHash>k__BackingField",
        "_RequestedFallingHash",
    },
    updater_requested_landing_hash = {
        "_RequestedLandingHash_k__BackingField",
        "<RequestedLandingHash>k__BackingField",
        "_RequestedLandingHash",
    },
    env_landing_fall_loop_check_state = {
        "_LandingFallLoopCheckState",
        "LandingFallLoopCheckState",
    },
    env_check_landing_to_fall_loop_y_pos = {
        "_CheckLandingToFallLoopYPos",
        "CheckLandingToFallLoopYPos",
    },
    updater_back_turn_dir_from_run_landing = {
        "_BackTurnDirFromRunLanding_k__BackingField",
        "<BackTurnDirFromRunLanding>k__BackingField",
        "_BackTurnDirFromRunLanding",
    },
    common_body_gameobject = {
        "_BodyGameObject_k__BackingField",
        "<BodyGameObject>k__BackingField",
        "BodyGameObject",
    },
    updater_gameobject = {
        "_GameObject_k__BackingField",
        "<GameObject>k__BackingField",
        "GameObject",
    },
    character_manager_requested_game_over = {
        "_RequestedGameOver_k__BackingField",
        "<RequestedGameOver>k__BackingField",
        "_RequestedGameOver",
    },
    character_manager_requested_game_over_fade = {
        "_RequestedGameOverIsFade_k__BackingField",
        "<RequestedGameOverIsFade>k__BackingField",
        "_RequestedGameOverIsFade",
    },
    character_manager_is_game_overed = {
        "_IsGameOvered_k__BackingField",
        "<IsGameOvered>k__BackingField",
        "_IsGameOvered",
    },
    player_is_dead_static = {
        "_IsDeadStatic_k__BackingField",
        "<IsDeadStatic>k__BackingField",
        "_IsDeadStatic",
    },
    common_fall_type = {
        "_FallType_k__BackingField",
        "<FallType>k__BackingField",
        "_FallType",
    },
    common_damage_continue_state = {
        "_IsDamageContinueState_k__BackingField",
        "<IsDamageContinueState>k__BackingField",
        "_IsDamageContinueState",
    },
    common_is_fast_game_over = {
        "_IsFastGameOver_k__BackingField",
        "<IsFastGameOver>k__BackingField",
        "_IsFastGameOver",
    },
    common_is_terrain_action = {
        "_IsTerrainAction_k__BackingField",
        "<IsTerrainAction>k__BackingField",
        "_IsTerrainAction",
    },
    env_free_fall_ctrl = {
        "_FreeFallCtrl_k__BackingField",
        "<FreeFallCtrl>k__BackingField",
        "FreeFallCtrl",
    },
    env_fall_process_id = {
        "FallProcessID",
        "_FallProcessID_k__BackingField",
        "<FallProcessID>k__BackingField",
    },
    env_fall_damage = {
        "_FallDamage_k__BackingField",
        "<FallDamage>k__BackingField",
        "_FallDamage",
    },
    env_prev_fall_height = {
        "_PrevFallHeight_k__BackingField",
        "<PrevFallHeight>k__BackingField",
        "_PrevFallHeight",
    },
    env_fall_height = {
        "_FallHeight_k__BackingField",
        "<FallHeight>k__BackingField",
        "_FallHeight",
    },
    env_height_prevent_fall = {
        "_HeightPreventFall_k__BackingField",
        "<HeightPreventFall>k__BackingField",
        "_HeightPreventFall",
    },
    env_height_keep_ground = {
        "_HeightKeepGround_k__BackingField",
        "<HeightKeepGround>k__BackingField",
        "_HeightKeepGround",
    },
    env_is_disable_gravity_until_motion_end = {
        "_IsDisableGravityUntilMotionEnd_k__BackingField",
        "<IsDisableGravityUntilMotionEnd>k__BackingField",
        "_IsDisableGravityUntilMotionEnd",
    },
    env_is_falling_into_crack = {
        "_IsFallingIntoCrack",
        "IsFallingIntoCrack",
    },
    env_is_found_crack = {
        "_IsFoundCrack",
        "IsFoundCrack",
    },
    env_init_fall_speed_store_timing_trigger = {
        "InitFallSpeedStoreTimingTrigger",
    },
    env_apply_hip_init_fall_speed_trigger = {
        "ApplyHipInitFallSpeedTrigger",
    },
    env_is_keep_ground = {
        "IsKeepGround",
    },
    env_is_prev_keep_ground = {
        "IsPrevKeepGround",
    },
    freefall_initial_frame_speed = {
        "_InitialFrameSpeed_k__BackingField",
        "<InitialFrameSpeed>k__BackingField",
        "_InitialFrameSpeed",
    },
    freefall_frame_gravity = {
        "FrameGravity",
    },
    freefall_max_fall_frame_speed = {
        "MaxFallFrameSpeed",
    },
    freefall_add_frame_for_gravity = {
        "AddFrameForGravity",
    },
    freefall_is_active = {
        "_IsActive_k__BackingField",
        "<IsActive>k__BackingField",
        "_IsActive",
    },
    freefall_is_rise = {
        "_IsRise_k__BackingField",
        "<IsRise>k__BackingField",
        "_IsRise",
    },
    anim_fall_input_delta_move = {
        "_InputDeltaMove_k__BackingField",
        "<InputDeltaMove>k__BackingField",
        "_InputDeltaMove",
    },
    anim_fall_is_adjust = {
        "_IsAdjust_k__BackingField",
        "<IsAdjust>k__BackingField",
        "_IsAdjust",
    },
    dead_body_is_dead_release = {
        "_IsDeadRelease_k__BackingField",
        "<IsDeadRelease>k__BackingField",
        "_IsDeadRelease",
    },
}

local transform_type = sdk.find_type_definition("via.Transform")
local m_transform_get_position = transform_type ~= nil and transform_type:get_method("get_Position") or nil
local m_transform_set_position = transform_type ~= nil and transform_type:get_method("set_Position") or nil
local m_transform_get_rotation = transform_type ~= nil and transform_type:get_method("get_Rotation") or nil
local m_transform_set_rotation = transform_type ~= nil and transform_type:get_method("set_Rotation") or nil
local gameobject_type = sdk.find_type_definition("via.GameObject")
local m_gameobject_get_transform = gameobject_type ~= nil and gameobject_type:get_method("get_Transform") or nil

local function call_method_handle(handle, ...)
    if handle == nil then
        return nil, false
    end

    local args = { n = select("#", ...), ... }
    local unpack_args = table.unpack or unpack
    local ok, result = pcall(function()
        return handle:call(unpack_args(args, 1, args.n))
    end)

    return result, ok
end

local cfg = {
    enabled = false,
    speed = 7.5,
    vertical_speed = 7.5,
    boost_multiplier = 3.0,
    slow_multiplier = 0.35,
    movement_yaw_offset_deg = 180.0,
    anti_death_always = false,
    anti_death_cooldown_seconds = 10.0,
    anti_death_use_invincible = true,
    block_game_over = true,
    block_fall_death = true,
    disable_fall_system_and_animation = true,
    patch_update_climb_step_shake = true,
    teleport_to_camera_apply_rotation = false,
    aggressive_pose_kill = true,
    mouse_steering = true,
    sync_rotation_yaw_offset_deg = 180.0,
    gamepad_turn_speed_deg = 240.0,
    toggle_key = 0x71, -- F2
}

local EMPTY_NAME_HASH = 2180083513

local state = {
    hotkey_was_down = false,
    context = nil,
    noclip_pos = nil,
    noclip_rot = nil,
    last_tick = os.clock(),
    status = "Ready.",
    resolved_singleton = "",
    resolved_chain = "",
    player_type = "",
    transform_type = "",
    last_resolve_time = 0.0,
    resolve_retry_seconds = 0.5,
    last_resolve_reason = "",
    last_log_message = "",
    original_invincible = nil,
    invincible_state_saved = false,
    invincible_applied = false,
    hooks_installed = false,
    hook_count = 0,
    anti_death_cooldown_until = 0.0,
    anti_death_active_last_frame = false,
    fall_suppress_status = "",
    saved_anim_fall_checker = nil,
    is_ingame_502171 = false,
    is_ingame_502171_source = "uninitialized",
    gamepad_device = nil,
    gamepad_last_refresh = 0.0,
    gamepad_debug_line = "",
    fall_reset_internal_call = false,
}

local function push_log(msg)
    if msg == nil then
        return
    end
    local text = tostring(msg)
    if text == state.last_log_message then
        return
    end
    state.last_log_message = text
    if log and log.info then
        log.info("[NoClip] " .. text)
    end
end

local PREHOOK_CONTINUE = sdk.PreHookResult.CALL_ORIGINAL
local PREHOOK_SKIP = sdk.PreHookResult.SKIP_ORIGINAL

local function anti_death_cooldown_left(now)
    local tnow = now or os.clock()
    local left = state.anti_death_cooldown_until - tnow
    if left < 0.0 then
        return 0.0
    end
    return left
end

local function is_anti_death_active(now)
    if state.is_ingame_502171 ~= true then
        return false
    end
    if cfg.anti_death_always then
        return true
    end
    if cfg.enabled then
        return true
    end
    return anti_death_cooldown_left(now) > 0.0
end

local function method_name_matches(actual, candidate)
    if actual == nil or candidate == nil then
        return false
    end
    if actual == candidate then
        return true
    end

    local c = tostring(candidate)
    c = string.gsub(c, "%(.*", "")
    if c == "" then
        return false
    end
    return string.find(tostring(actual), c, 1, true) == 1
end

local function resolve_method_for_hook(type_name, method_candidates)
    local tdef = sdk.find_type_definition(type_name)
    if tdef == nil then
        return nil, nil
    end

    for _, name in ipairs(method_candidates) do
        local m = nil
        local ok = pcall(function()
            m = tdef:get_method(name)
        end)
        if ok and m ~= nil then
            return m, name
        end
    end

    local methods = nil
    local ok_methods = pcall(function()
        methods = tdef:get_methods()
    end)
    if not ok_methods or methods == nil then
        return nil, nil
    end

    for _, method in ipairs(methods) do
        local actual = tostring(method:get_name() or "")
        for _, candidate in ipairs(method_candidates) do
            if method_name_matches(actual, candidate) then
                return method, actual
            end
        end
    end

    return nil, nil
end

local function install_guard_hook(type_name, method_candidates, should_skip_cb, label)
    local method, resolved = resolve_method_for_hook(type_name, method_candidates)
    if method == nil then
        push_log("Hook unresolved: " .. tostring(label) .. " in " .. tostring(type_name))
        return false
    end

    -- Core runtime patch behavior
    local ok = pcall(function()
        sdk.hook(method,
            function(_args)
                if should_skip_cb ~= nil and should_skip_cb() then
                    return PREHOOK_SKIP
                end
                return PREHOOK_CONTINUE
            end,
            function(retval)
                return retval
            end
        )
    end)

    if ok then
        state.hook_count = state.hook_count + 1
        push_log("Installed hook: " .. tostring(label) .. " -> " .. tostring(type_name) .. "." .. tostring(resolved))
        return true
    end

    push_log("Hook install failed: " .. tostring(label) .. " -> " .. tostring(type_name))
    return false
end

local function should_block_death()
    return cfg.block_game_over and is_anti_death_active()
end

local function should_block_fall_anim()
    return state.is_ingame_502171 == true
        and cfg.enabled
        and cfg.disable_fall_system_and_animation
        and (not state.fall_reset_internal_call)
end

local function should_block_update_climb_step()
    return should_block_fall_anim() and cfg.patch_update_climb_step_shake
end

local function should_block_fall_stance()
    return should_block_fall_anim()
end

local function should_block_fall_anim_update()
    return should_block_fall_anim()
end

local function should_block_death_setters()
    return is_anti_death_active()
end

local function should_block_dead_space()
    return cfg.block_fall_death and is_anti_death_active()
end

local function install_runtime_hooks_once()
    if state.hooks_installed then
        return
    end
    state.hooks_installed = true

    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.hook_player_update_dead_request, should_block_death, "Player.updateDeadRequest")
    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.hook_player_on_dead, should_block_death, "Player.onDead")
    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.hook_player_check_execute_dead_action, should_block_death, "Player.checkExecuteDeadActionOnDead")
    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.hook_player_select_dead_action, should_block_death, "Player.selectDeadAction")
    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.hook_player_exec_safe_proc_fall_limit, should_block_death, "Player.execSafeProcFallLimit")
    install_guard_hook("app.CharacterManager", METHOD_IDS.hook_character_manager_request_game_over, should_block_death, "CharacterManager.requestGameOver")
    install_guard_hook("app.GameOverManager", METHOD_IDS.hook_game_over_manager_request_game_over, should_block_death, "GameOverManager.requestGameOver")
    install_guard_hook("app.GameOverManager", METHOD_IDS.hook_game_over_manager_transit_phase, should_block_death, "GameOverManager.transitPhase")
    install_guard_hook("app.GameOverManager", METHOD_IDS.hook_game_over_manager_update, should_block_death, "GameOverManager.update")
    install_guard_hook("app.GameOverManager", METHOD_IDS.hook_game_over_manager_final_update, should_block_death, "GameOverManager.FinalUpdate")
    install_guard_hook("app.CharacterManager", METHOD_IDS.hook_character_manager_set_requested_game_over, should_block_death, "CharacterManager.set_RequestedGameOver")
    install_guard_hook("app.CharacterManager", METHOD_IDS.hook_character_manager_set_requested_game_over_fade, should_block_death, "CharacterManager.set_RequestedGameOverIsFade")
    install_guard_hook("app.CharacterManager", METHOD_IDS.hook_character_manager_set_is_game_overed, should_block_death, "CharacterManager.set_IsGameOvered")
    install_guard_hook("app.PlayerContext", METHOD_IDS.hook_player_context_set_is_dead_static, should_block_death_setters, "PlayerContext.set_IsDeadStatic")
    install_guard_hook("app.PlayerDeadBodyDriver", METHOD_IDS.hook_dead_body_set_is_dead_release, should_block_death_setters, "PlayerDeadBodyDriver.set_IsDeadRelease")
    install_guard_hook("app.PlayerDeadBodyDriver", METHOD_IDS.hook_dead_body_update_check_dead_space, should_block_dead_space, "PlayerDeadBodyDriver.updateCheckDeadSpace")
    install_guard_hook("app.PlayerDeadBodyDriver", METHOD_IDS.hook_dead_body_update_dead_space_ray_permit, should_block_dead_space, "PlayerDeadBodyDriver.updateDeadSpaceRayPermit")

    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.updater_set_requested_falling_hash, should_block_fall_anim, "Player.set_RequestedFallingHash")
    install_guard_hook("app.PlayerUpdaterBase", METHOD_IDS.updater_set_requested_landing_hash, should_block_fall_anim, "Player.set_RequestedLandingHash")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_set_landing_action, should_block_fall_anim, "PlayerEnv.setLandingAction")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_on_update_scan_phase, should_block_fall_anim, "PlayerEnv.onUpdateScanPhase")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_landing_player_process, should_block_fall_anim, "PlayerEnv.landingPlayerProcess")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_late_update_additional_action, should_block_fall_anim, "PlayerEnv.lateUpdateAdditionalAction")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_is_prevent_fall, should_block_fall_anim, "PlayerEnv.isPreventFall")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_is_skip_prevent_fall, should_block_fall_anim, "PlayerEnv.isSkipPreventFall")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_update_climb_start_type, should_block_fall_anim, "PlayerEnv.updateClimbStartType")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_check_climb_start_type, should_block_fall_anim, "PlayerEnv.checkClimbStartType")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_on_action_locked, should_block_fall_anim, "PlayerEnv.onActionLocked")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_check_fall_length_hash, should_block_fall_anim, "PlayerEnv.checkFallLengthRequestedFallingHash")
    install_guard_hook("app.PlayerEnvironmentProcessDriver", METHOD_IDS.hook_player_env_check_safe_area_fall_end, should_block_fall_anim, "PlayerEnv.checkSafeAreaFallEnd")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_update_hand_up_motion, should_block_fall_stance, "PlayerStanceDriver.updateHandUpMotion")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_is_enable_hand_up_change_action, should_block_fall_stance, "PlayerStanceDriver.isEnableHandUpChangeAction")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_on_update_act_phase, should_block_fall_stance, "PlayerStanceDriver.onUpdateActPhase")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_update_stance, should_block_fall_stance, "PlayerStanceDriver.updateStance")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_update_stance_state, should_block_fall_stance, "PlayerStanceDriver.updateStanceState")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_update_stance_trigger, should_block_fall_stance, "PlayerStanceDriver.updateStanceTrigger")
    install_guard_hook("app.PlayerStanceDriver", METHOD_IDS.hook_player_stance_update_stance_bank_type, should_block_fall_stance, "PlayerStanceDriver.updateStanceBankType")
    install_guard_hook("anim.AnimFallGroundChecker", METHOD_IDS.hook_anim_fall_update_animation, should_block_fall_anim_update, "AnimFallGroundChecker.updateAnimation")
    install_guard_hook("anim.AnimFallGroundChecker", METHOD_IDS.hook_anim_fall_check_ground, should_block_fall_anim_update, "AnimFallGroundChecker.checkFallGround")
    install_guard_hook("anim.AnimFallGroundChecker", METHOD_IDS.hook_anim_fall_check_ground_core, should_block_fall_anim_update, "AnimFallGroundChecker.checkFallGroundCore")
    install_guard_hook("app.EnvironmentProcessDriver", METHOD_IDS.hook_env_update_fall_info, should_block_fall_anim, "Env.updateFallInfo")
    install_guard_hook("app.EnvironmentProcessDriver", METHOD_IDS.hook_env_detect_ground_auto_fall, should_block_fall_anim, "Env.detectGroundForAutoFallAction")
    install_guard_hook("app.EnvironmentProcessDriver", METHOD_IDS.hook_env_update_climb_step, should_block_update_climb_step, "Env.updateClimbStep")
end

local VK = {
    W = 0x57,
    A = 0x41,
    S = 0x53,
    D = 0x44,
    Q = 0x51,
    C = 0x43,
    E = 0x45,
    SHIFT = 0x10,
    CTRL = 0x11,
}

local GP = {
    mask_l3 = { 0x1000 },
    mask_r3 = { 0x2000 },
    mask_l1 = { 0x0100 },
    mask_r1 = { 0x0400 },
    mask_l2_button = { 0x0200 },
    get_button = { "get_Button()", "get_Button" },
    get_lx = { "get_LStickX()", "get_LStickX", "get_LeftStickX()", "get_LeftStickX" },
    get_ly = { "get_LStickY()", "get_LStickY", "get_LeftStickY()", "get_LeftStickY" },
    get_rx = { "get_RStickX()", "get_RStickX", "get_RightStickX()", "get_RightStickX" },
    get_axis_x = { "get_AxisX()", "get_AxisX" },
    get_axis_y = { "get_AxisY()", "get_AxisY" },
    get_axis_z = { "get_AxisZ()", "get_AxisZ" },
    get_axis_l = { "get_AxisL()", "get_AxisL" },
    get_axis_r = { "get_AxisR()", "get_AxisR" },
    get_left_stick_vec = { "get_LStick()", "get_LStick", "get_LeftStick()", "get_LeftStick" },
    get_right_stick_vec = { "get_RStick()", "get_RStick", "get_RightStick()", "get_RightStick" },
    get_l2 = { "get_LTrigger()", "get_LTrigger", "get_LeftTrigger()", "get_LeftTrigger" },
}

local GP_DEADZONE = 0.20

local function as_number(value)
    if type(value) == "number" then
        return value
    end
    local ok, converted = pcall(function()
        return tonumber(value)
    end)
    if ok and type(converted) == "number" then
        return converted
    end
    return nil
end

local function is_managed_object(obj)
    if obj == nil then
        return false
    end

    local ok, result = pcall(function()
        return sdk.is_managed_object(obj)
    end)

    return ok and result == true
end

local function normalize_managed_object(value)
    if value == nil then
        return nil
    end

    if is_managed_object(value) then
        return value
    end

    local ok, managed = pcall(function()
        return sdk.to_managed_object(value)
    end)

    if ok and managed ~= nil and is_managed_object(managed) then
        return managed
    end

    return value
end

local function try_call(obj, methods, ...)
    if obj == nil or methods == nil then
        return nil, nil, false
    end

    local args = { n = select("#", ...), ... }
    local unpack_args = table.unpack or unpack

    for _, method_name in ipairs(methods) do
        local ok, result = pcall(function()
            return obj:call(method_name, unpack_args(args, 1, args.n))
        end)

        if ok then
            return normalize_managed_object(result), method_name, true
        end
    end

    return nil, nil, false
end

local function safe_get_field_or_property(obj, field_name)
    if obj == nil or field_name == nil or field_name == "" then
        return nil
    end

    local plain_name = string.gsub(field_name, "%(%)$", "")

    local ok_field, field_val = pcall(function()
        return obj:get_field(plain_name)
    end)
    if ok_field and field_val ~= nil then
        return normalize_managed_object(field_val)
    end

    local ok_call, call_val = pcall(function()
        return obj:call(field_name)
    end)
    if ok_call and call_val ~= nil then
        return normalize_managed_object(call_val)
    end

    if string.sub(plain_name, -2) ~= "()" then
        local ok_call2, call_val2 = pcall(function()
            return obj:call(plain_name .. "()")
        end)
        if ok_call2 and call_val2 ~= nil then
            return normalize_managed_object(call_val2)
        end
    end

    local getter_candidates = {
        "get_" .. plain_name,
        "get_" .. plain_name .. "()",
    }

    for _, getter in ipairs(getter_candidates) do
        local ok_getter, getter_val = pcall(function()
            return obj:call(getter)
        end)
        if ok_getter and getter_val ~= nil then
            return normalize_managed_object(getter_val)
        end
    end

    return nil
end

local function first_non_nil_field(obj, names)
    if obj == nil or names == nil then
        return nil, nil
    end

    for _, name in ipairs(names) do
        local value = safe_get_field_or_property(obj, name)
        if value ~= nil then
            return value, name
        end
    end

    return nil, nil
end

local function safe_get_index(obj, idx)
    if obj == nil then
        return nil
    end

    local count = nil
    local ok_count, count_val = pcall(function()
        return obj:call("get_Count")
    end)
    if ok_count and type(count_val) == "number" then
        count = count_val
    end

    if count ~= nil and count <= idx then
        return nil
    end

    local ok, item = pcall(function()
        return obj:call("get_Item(System.Int32)", idx)
    end)
    if ok and item ~= nil then
        return normalize_managed_object(item)
    end

    local ok2, item2 = pcall(function()
        return obj:call("get_Item", idx)
    end)
    if ok2 and item2 ~= nil then
        return normalize_managed_object(item2)
    end

    local ok3, elements = pcall(function()
        return obj:get_elements()
    end)
    if ok3 and elements ~= nil then
        local ok4, indexed = pcall(function()
            return elements[idx + 1]
        end)
        if ok4 and indexed ~= nil then
            return normalize_managed_object(indexed)
        end
    end

    return nil
end

local function split_path(path)
    local out = {}
    if path == nil then
        return out
    end

    for token in string.gmatch(path, "[^%.]+") do
        if token ~= "" then
            out[#out + 1] = token
        end
    end

    return out
end

local function resolve_chain(root, chain)
    local cur = root
    for _, token in ipairs(split_path(chain)) do
        local idx = string.match(token, "^%[(%d+)%]$")
        if idx ~= nil then
            cur = safe_get_index(cur, tonumber(idx))
        else
            cur = safe_get_field_or_property(cur, token)
        end

        if cur == nil then
            return nil
        end
    end

    return cur
end

local function get_type_name(obj)
    if obj == nil then
        return "nil"
    end

    local ok_tdef, tdef = pcall(function()
        return obj:get_type_definition()
    end)
    if not ok_tdef or tdef == nil then
        return "unknown"
    end

    local ok_name, name = pcall(function()
        return tdef:get_full_name()
    end)
    if not ok_name or name == nil then
        return "unknown"
    end

    return tostring(name)
end

local type_field_map_cache = {}

local function get_type_field_map(obj)
    if obj == nil then
        return nil
    end

    local type_name = get_type_name(obj)
    if type_name == "unknown" or type_name == "nil" then
        return nil
    end

    local cached = type_field_map_cache[type_name]
    if cached ~= nil then
        return cached
    end

    local map = {}
    local ok_tdef, tdef = pcall(function()
        return obj:get_type_definition()
    end)
    if ok_tdef and tdef ~= nil then
        local ok_fields, fields = pcall(function()
            return tdef:get_fields()
        end)
        if ok_fields and fields ~= nil then
            for _, field in ipairs(fields) do
                local name = tostring(field:get_name() or "")
                if name ~= "" then
                    map[name] = true
                end
            end
        end
    end

    type_field_map_cache[type_name] = map
    return map
end

local function set_field_if_exists(obj, field_names, value)
    if obj == nil or field_names == nil then
        return false, nil
    end

    local field_map = get_type_field_map(obj)
    if field_map == nil then
        return false, nil
    end

    for _, name in ipairs(field_names) do
        if field_map[name] == true then
            local ok = pcall(function()
                obj:set_field(name, value)
            end)
            if ok then
                return true, name
            end
        end
    end

    return false, nil
end

local discovered_player_accessors = {}

local function discover_player_accessors(player)
    local type_name = get_type_name(player)
    local cached = discovered_player_accessors[type_name]
    if cached ~= nil then
        return cached
    end

    local found = {
        get_transform = nil,
        get_position = nil,
        set_position = nil,
        get_rotation = nil,
        get_common = nil,
        get_updater = nil,
    }

    local ok_tdef, tdef = pcall(function()
        return player:get_type_definition()
    end)
    if ok_tdef and tdef ~= nil then
        local ok_methods, methods = pcall(function()
            return tdef:get_methods()
        end)
        if ok_methods and methods ~= nil then
            for _, method in ipairs(methods) do
                local name = tostring(method:get_name() or "")
                local lower = string.lower(name)
                if found.get_transform == nil and string.find(lower, "get_transform", 1, true) ~= nil then
                    found.get_transform = name
                end
                if found.get_position == nil and string.find(lower, "get_position", 1, true) ~= nil then
                    found.get_position = name
                end
                if found.set_position == nil and string.find(lower, "set_position", 1, true) ~= nil then
                    found.set_position = name
                end
                if found.get_rotation == nil and string.find(lower, "get_rotation", 1, true) ~= nil then
                    found.get_rotation = name
                end
                if found.get_common == nil and string.find(lower, "get_common", 1, true) ~= nil then
                    found.get_common = name
                end
                if found.get_updater == nil and string.find(lower, "get_updater", 1, true) ~= nil then
                    found.get_updater = name
                end
            end
        end
    end

    discovered_player_accessors[type_name] = found
    return found
end

local function get_transform_from_gameobject(game_object)
    if game_object == nil then
        return nil
    end

    local transform = nil
    local ok = pcall(function()
        transform = game_object:call("get_Transform")
    end)
    if ok and transform ~= nil then
        return normalize_managed_object(transform)
    end

    local ok2 = pcall(function()
        transform = game_object:call("get_Transform()")
    end)
    if ok2 and transform ~= nil then
        return normalize_managed_object(transform)
    end

    return nil
end

local function resolve_transform_from_player(player)
    local accessors = discover_player_accessors(player)

    local transform_from_field, transform_field_name = first_non_nil_field(player, FIELD_IDS.player_transform)
    if transform_from_field ~= nil then
        return transform_from_field, "field:" .. tostring(transform_field_name)
    end

    local transform = select(1, try_call(player, METHOD_IDS.get_player_transform))
    if transform ~= nil then
        return transform, "player:get_Transform"
    end

    local common, common_source = first_non_nil_field(player, FIELD_IDS.player_common)
    if common == nil then
        common = select(1, try_call(player, METHOD_IDS.get_player_common))
        common_source = "method:get_Common"
    end
    if common == nil and accessors.get_common ~= nil then
        common = select(1, try_call(player, { accessors.get_common, accessors.get_common .. "()" }))
        common_source = "scan:" .. tostring(accessors.get_common)
    end
    if common ~= nil then
        local body, body_source = first_non_nil_field(common, FIELD_IDS.common_body_gameobject)
        if body == nil then
            body = select(1, try_call(common, METHOD_IDS.get_body_gameobject))
            body_source = "method:get_BodyGameObject"
        end
        local body_transform = get_transform_from_gameobject(body)
        if body_transform ~= nil then
            return body_transform,
                "player:" .. tostring(common_source) .. "->" .. tostring(body_source) .. "->get_Transform"
        end
    end

    local updater, updater_source = first_non_nil_field(player, FIELD_IDS.player_updater)
    if updater == nil then
        updater = select(1, try_call(player, METHOD_IDS.get_player_updater))
        updater_source = "method:get_Updater"
    end
    if updater == nil and accessors.get_updater ~= nil then
        updater = select(1, try_call(player, { accessors.get_updater, accessors.get_updater .. "()" }))
        updater_source = "scan:" .. tostring(accessors.get_updater)
    end
    if updater ~= nil then
        local go, go_source = first_non_nil_field(updater, FIELD_IDS.updater_gameobject)
        if go == nil then
            go = select(1, try_call(updater, METHOD_IDS.get_gameobject))
            go_source = "method:get_GameObject"
        end
        local updater_transform = get_transform_from_gameobject(go)
        if updater_transform ~= nil then
            return updater_transform,
                "player:" .. tostring(updater_source) .. "->" .. tostring(go_source) .. "->get_Transform"
        end
    end

    if accessors.get_transform ~= nil then
        local scanned_transform = select(1, try_call(player, { accessors.get_transform, accessors.get_transform .. "()" }))
        if scanned_transform ~= nil then
            return scanned_transform, "scan:" .. tostring(accessors.get_transform)
        end
    end

    return nil, "none"
end

local function build_context_from_player(singleton_name, chain_label, player)
    if not is_managed_object(player) then
        return nil
    end

    local accessors = discover_player_accessors(player)
    local transform, transform_path = resolve_transform_from_player(player)
    local updater = select(1, first_non_nil_field(player, FIELD_IDS.player_updater))
    if updater == nil then
        updater = select(1, try_call(player, METHOD_IDS.get_player_updater))
    end
    if updater == nil and accessors.get_updater ~= nil then
        updater = select(1, try_call(player, { accessors.get_updater, accessors.get_updater .. "()" }))
    end
    local cc = nil
    if updater ~= nil then
        cc = select(1, try_call(updater, METHOD_IDS.get_character_controller))
    end
    if cc == nil then
        cc = select(1, try_call(player, METHOD_IDS.get_character_controller))
    end

    local player_pos = select(1, try_call(player, METHOD_IDS.get_player_position))
    if player_pos == nil then
        player_pos = select(1, first_non_nil_field(player, FIELD_IDS.player_position_fast))
    end
    if player_pos == nil and accessors.get_position ~= nil then
        player_pos = select(1, try_call(player, { accessors.get_position, accessors.get_position .. "()" }))
    end

    local transform_pos = nil
    if transform ~= nil and m_transform_get_position ~= nil then
        local pos_from_handle, ok = call_method_handle(m_transform_get_position, transform)
        if ok and pos_from_handle ~= nil then
            transform_pos = pos_from_handle
        end
    end
    if transform_pos == nil then
        transform_pos = select(1, try_call(transform, METHOD_IDS.transform_get_position))
    end

    if player_pos == nil and transform_pos == nil then
        state.status = "Context found but no position getter. PlayerType="
            .. get_type_name(player) .. " TransformPath=" .. tostring(transform_path)
        push_log(state.status)
        return nil
    end

    state.resolved_singleton = singleton_name
    state.resolved_chain = chain_label .. " | " .. tostring(transform_path)
    state.player_type = get_type_name(player)
    state.transform_type = get_type_name(transform)
    push_log("Resolved context via " .. tostring(state.resolved_singleton) .. " | " .. tostring(state.resolved_chain)
        .. " | PlayerType=" .. tostring(state.player_type) .. " | TransformType=" .. tostring(state.transform_type))
    return {
        player = player,
        transform = transform,
        updater = updater,
        character_controller = cc,
        accessors = accessors,
    }
end

local function build_singleton_candidates()
    local candidates = { "app.CharacterManager", "app.PlayerManager", "app.PlayerContextManager" }
    local seen = {}
    local out = {}

    local function push(name)
        if name == nil or name == "" or seen[name] then
            return
        end
        seen[name] = true
        out[#out + 1] = name
    end

    for _, name in ipairs(candidates) do
        push(name)
    end

    pcall(function()
        for _, base in ipairs({ "CharacterManager", "PlayerManager", "PlayerContextManager" }) do
            local resolved = sdk.game_namespace(base)
            push(resolved)
        end
    end)

    return out
end

local PLAYER_CHAINS = {
    "getPlayerContextRef()",
    "getPlayerContextRef",
    "getPlayerContextRefFast()",
    "getPlayerContextRefFast",
    "get_PlayerContextFast",
    "get_PlayerContextFast185242",
    "get_PlayerContextFast()",
    "<PlayerContextFast>k__BackingField",
    "get_CurrentPlayer()",
    "get_CurrentPlayer",
    "get_PlayerContext()",
    "get_PlayerContext",
    "getPlayerContextRef",
    "get_ManualPlayer()",
    "get_ManualPlayer",
    "get_MasterPlayer()",
    "get_MasterPlayer",
    "PlayerContextFast",
    "CurrentPlayer",
}

local SINGLETON_CANDIDATES = build_singleton_candidates()

local function get_singleton_any(type_name)
    if type_name == nil or type_name == "" then
        return nil, nil
    end

    local ok_managed, managed_inst = pcall(sdk.get_managed_singleton, type_name)
    if ok_managed and managed_inst ~= nil then
        return managed_inst, "managed"
    end

    local ok_native, native_inst = pcall(sdk.get_native_singleton, type_name)
    if ok_native and native_inst ~= nil then
        local ok_to, managed_from_native = pcall(sdk.to_managed_object, native_inst)
        if ok_to and managed_from_native ~= nil then
            return managed_from_native, "native->managed"
        end
        return native_inst, "native"
    end

    return nil, nil
end

local INGAME_GATE_FIELD_NAMES = {
    "<IsAvairableInGame>k__BackingField",
    "_IsAvairableInGame_k__BackingField",
    "IsAvairableInGame",
    "isAvairableInGame",
}

local function query_is_ingame_502171()
    local candidates = { "app.GuiManager" }
    pcall(function()
        local ns_name = sdk.game_namespace("GuiManager")
        if ns_name ~= nil and ns_name ~= "" and ns_name ~= "app.GuiManager" then
            candidates[#candidates + 1] = ns_name
        end
    end)

    for _, type_name in ipairs(candidates) do
        local singleton, singleton_path = get_singleton_any(type_name)
        if singleton ~= nil then
            local raw_value, raw_name = first_non_nil_field(singleton, INGAME_GATE_FIELD_NAMES)
            if type(raw_value) == "boolean" then
                return raw_value, tostring(type_name) .. "." .. tostring(raw_name) .. " (" .. tostring(singleton_path) .. ")"
            end
            if type(raw_value) == "number" then
                return raw_value ~= 0, tostring(type_name) .. "." .. tostring(raw_name) .. " (" .. tostring(singleton_path) .. ")"
            end
        end
    end

    return false, "unresolved"
end

local function try_call_native(singleton_obj, type_name, methods, ...)
    if singleton_obj == nil or type_name == nil or methods == nil then
        return nil, nil, false
    end

    local tdef = sdk.find_type_definition(type_name)
    if tdef == nil then
        return nil, nil, false
    end

    local args = { n = select("#", ...), ... }
    local unpack_args = table.unpack or unpack

    for _, method_name in ipairs(methods) do
        local ok, result = pcall(function()
            return sdk.call_native_func(singleton_obj, tdef, method_name, unpack_args(args, 1, args.n))
        end)
        if ok then
            return normalize_managed_object(result), method_name, true
        end
    end

    return nil, nil, false
end

local function collect_players_from_list(singleton_name, chain_label, list_obj)
    if list_obj == nil then
        return nil
    end

    local count = select(1, try_call(list_obj, { "get_Count()", "get_Count" }))
    if type(count) ~= "number" or count <= 0 then
        return nil
    end

    local upper = math.floor(count - 1)
    if upper > 16 then
        upper = 16
    end

    for i = 0, upper do
        local player = select(1, try_call(list_obj, {
            "get_Item(System.Int32)",
            "get_Item",
        }, i))

        local ctx = build_context_from_player(singleton_name, chain_label .. "[" .. tostring(i) .. "]", player)
        if ctx ~= nil then
            return ctx
        end
    end

    return nil
end

local function value_to_player_context(singleton_name, source_label, value_obj)
    if value_obj == nil then
        return nil
    end

    local ctx_direct = build_context_from_player(singleton_name, source_label, value_obj)
    if ctx_direct ~= nil then
        return ctx_direct
    end

    local count = select(1, try_call(value_obj, { "get_Count()", "get_Count" }))
    if type(count) ~= "number" or count <= 0 then
        return nil
    end

    local upper = math.floor(count - 1)
    if upper > 16 then
        upper = 16
    end

    for i = 0, upper do
        local item = select(1, try_call(value_obj, {
            "get_Item(System.Int32)",
            "get_Item",
        }, i))
        local ctx_item = build_context_from_player(singleton_name, source_label .. ".item[" .. tostring(i) .. "]", item)
        if ctx_item ~= nil then
            return ctx_item
        end
    end

    return nil
end

local function discover_player_from_singleton(singleton, singleton_name)
    if singleton == nil then
        return nil
    end

    local tdef = nil
    local ok_tdef = pcall(function()
        tdef = singleton:get_type_definition()
    end)
    if not ok_tdef or tdef == nil then
        return nil
    end

    local methods = nil
    local ok_methods = pcall(function()
        methods = tdef:get_methods()
    end)

    if ok_methods and methods ~= nil then
        local checked = 0
        for _, method in ipairs(methods) do
            local name = tostring(method:get_name() or "")
            local lower = string.lower(name)
            if (string.find(lower, "player", 1, true) ~= nil
                or string.find(lower, "context", 1, true) ~= nil
                or string.find(lower, "current", 1, true) ~= nil)
                and string.find(lower, "set_", 1, true) == nil then
                checked = checked + 1
                if checked > 64 then
                    break
                end

                local value = select(1, try_call(singleton, { name, name .. "()" }))
                local ctx = value_to_player_context(singleton_name, "method:" .. name, value)
                if ctx ~= nil then
                    push_log("Discovered player via singleton method " .. name)
                    return ctx
                end
            end
        end
    end

    local fields = nil
    local ok_fields = pcall(function()
        fields = tdef:get_fields()
    end)

    if ok_fields and fields ~= nil then
        local checked = 0
        for _, field in ipairs(fields) do
            local fname = tostring(field:get_name() or "")
            local lower = string.lower(fname)
            if string.find(lower, "player", 1, true) ~= nil
                or string.find(lower, "context", 1, true) ~= nil
                or string.find(lower, "current", 1, true) ~= nil then
                checked = checked + 1
                if checked > 64 then
                    break
                end

                local ok_val, value = pcall(function()
                    return singleton:get_field(fname)
                end)
                if ok_val then
                    local ctx = value_to_player_context(singleton_name, "field:" .. fname, normalize_managed_object(value))
                    if ctx ~= nil then
                        push_log("Discovered player via singleton field " .. fname)
                        return ctx
                    end
                end
            end
        end
    end

    return nil
end

local function try_direct_player_from_singleton(singleton, singleton_name, singleton_path)
    local direct_methods = {
        "getPlayerContextRef185378",
        "getPlayerContextRef185380",
        "getPlayerContextRefFast185379",
        "getPlayerContextRef()",
        "getPlayerContextRef",
        "getPlayerContextRefFast()",
        "getPlayerContextRefFast",
        "get_PlayerContextFast185242",
        "get_PlayerContextFast()",
        "get_PlayerContextFast",
    }
    local list_methods = {
        "getPlayerContextRefs185365",
        "getPlayerContextRefs()",
        "getPlayerContextRefs",
        "get_PlayerContextList()",
        "get_PlayerContextList",
    }

    local direct_player = select(1, first_non_nil_field(singleton, FIELD_IDS.character_manager_player_fast))
    local direct_source = "field:_PlayerContextFast_k__BackingField"
    if direct_player == nil then
        direct_player = select(1, try_call(singleton, direct_methods))
        direct_source = "direct:getPlayerContextRef*"
    end
    local ctx_direct = build_context_from_player(singleton_name, direct_source, direct_player)
    if ctx_direct ~= nil then
        return ctx_direct
    end

    local direct_list = select(1, first_non_nil_field(singleton, FIELD_IDS.character_manager_player_list))
    local list_source = "field:_PlayerContextList_k__BackingField"
    if direct_list == nil then
        direct_list = select(1, try_call(singleton, list_methods))
        list_source = "direct:getPlayerContextRefs"
    end
    local ctx_list = collect_players_from_list(singleton_name, list_source, direct_list)
    if ctx_list ~= nil then
        return ctx_list
    end

    if singleton_path == "native" then
        local native_player = select(1, try_call_native(singleton, singleton_name, direct_methods))
        local ctx_native = build_context_from_player(singleton_name, "native:getPlayerContextRef*", native_player)
        if ctx_native ~= nil then
            return ctx_native
        end

        local native_list = select(1, try_call_native(singleton, singleton_name, list_methods))
        local ctx_native_list = collect_players_from_list(singleton_name, "native:getPlayerContextRefs", native_list)
        if ctx_native_list ~= nil then
            return ctx_native_list
        end
    end

    local discovered = discover_player_from_singleton(singleton, singleton_name)
    if discovered ~= nil then
        return discovered
    end

    return nil
end

local function resolve_player_context()
    state.resolved_singleton = ""
    state.resolved_chain = ""
    state.player_type = ""
    state.transform_type = ""

    local tried = {}
    local found_any_singleton = false

    for _, singleton_name in ipairs(SINGLETON_CANDIDATES) do
        local singleton, singleton_path = get_singleton_any(singleton_name)
        if singleton ~= nil then
            found_any_singleton = true
            tried[#tried + 1] = singleton_name .. " (" .. tostring(singleton_path) .. ")"
            local ctx_direct = try_direct_player_from_singleton(singleton, singleton_name, singleton_path)
            if ctx_direct ~= nil then
                return ctx_direct
            end

            for _, chain in ipairs(PLAYER_CHAINS) do
                local player = resolve_chain(singleton, chain)
                local ctx_chain = build_context_from_player(singleton_name, chain, player)
                if ctx_chain ~= nil then
                    return ctx_chain
                end
            end
        end
    end

    if not found_any_singleton then
        state.last_resolve_reason = "No Character/Player manager singleton found yet."
    else
        state.last_resolve_reason = "No active player context found. Tried: " .. table.concat(tried, ", ")
    end
    push_log("Context resolve failed: " .. tostring(state.last_resolve_reason))
    return nil
end

local function get_position(ctx)
    if ctx == nil then
        return nil
    end

    if ctx.transform == nil and ctx.player ~= nil then
        ctx.transform = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_transform))
    end

    if ctx.transform ~= nil and m_transform_get_position ~= nil then
        local pos, ok = call_method_handle(m_transform_get_position, ctx.transform)
        if ok and pos ~= nil then
            return pos
        end
    end

    local pos = select(1, try_call(ctx.player, METHOD_IDS.get_player_position))
    if pos ~= nil then
        return pos
    end

    if ctx.accessors ~= nil and ctx.accessors.get_position ~= nil then
        local scanned_pos = select(1, try_call(ctx.player, { ctx.accessors.get_position, ctx.accessors.get_position .. "()" }))
        if scanned_pos ~= nil then
            return scanned_pos
        end
    end

    local pos_field = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_position_fast))
    if pos_field ~= nil then
        return pos_field
    end

    return select(1, try_call(ctx.transform, METHOD_IDS.transform_get_position))
end

local function get_rotation(ctx)
    if ctx == nil then
        return nil
    end

    if ctx.transform == nil and ctx.player ~= nil then
        ctx.transform = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_transform))
    end

    if ctx.transform ~= nil and m_transform_get_rotation ~= nil then
        local rot, ok = call_method_handle(m_transform_get_rotation, ctx.transform)
        if ok and rot ~= nil then
            return rot
        end
    end

    local rot = select(1, try_call(ctx.player, METHOD_IDS.get_player_rotation))
    if rot ~= nil then
        return rot
    end

    if ctx.accessors ~= nil and ctx.accessors.get_rotation ~= nil then
        local scanned_rot = select(1, try_call(ctx.player, { ctx.accessors.get_rotation, ctx.accessors.get_rotation .. "()" }))
        if scanned_rot ~= nil then
            return scanned_rot
        end
    end

    return select(1, try_call(ctx.transform, METHOD_IDS.transform_get_rotation))
end

local function get_camera_rotation()
    local cam = nil
    local ok_cam, cam_obj = pcall(function()
        return sdk.get_primary_camera()
    end)
    if ok_cam and cam_obj ~= nil then
        cam = cam_obj
    end
    if cam == nil then
        return nil
    end

    local ok_matrix, matrix = pcall(function()
        return cam:call("get_WorldMatrix")
    end)
    if ok_matrix and matrix ~= nil then
        local ok_quat, quat = pcall(function()
            return matrix:to_quat()
        end)
        if ok_quat and quat ~= nil then
            return quat
        end
    end

    local transform = nil
    local ok_go, go = pcall(function()
        return cam:call("get_GameObject")
    end)
    if ok_go and go ~= nil then
        if m_gameobject_get_transform ~= nil then
            local t, ok_t = call_method_handle(m_gameobject_get_transform, go)
            if ok_t and t ~= nil then
                transform = normalize_managed_object(t)
            end
        end
        if transform == nil then
            transform = get_transform_from_gameobject(go)
        end
    end

    if transform ~= nil then
        local rot = select(1, try_call(transform, METHOD_IDS.transform_get_rotation))
        if rot ~= nil then
            return rot
        end
    end

    return nil
end

local function get_camera_position()
    local cam = nil
    local ok_cam, cam_obj = pcall(function()
        return sdk.get_primary_camera()
    end)
    if ok_cam and cam_obj ~= nil then
        cam = cam_obj
    end
    if cam == nil then
        return nil
    end

    local ok_matrix, matrix = pcall(function()
        return cam:call("get_WorldMatrix")
    end)
    if ok_matrix and matrix ~= nil then
        local ok_row, row = pcall(function()
            return matrix[3]
        end)
        if ok_row and row ~= nil and row.x ~= nil and row.y ~= nil and row.z ~= nil then
            return Vector3f.new(row.x, row.y, row.z)
        end
    end

    local transform = nil
    local ok_go, go = pcall(function()
        return cam:call("get_GameObject")
    end)
    if ok_go and go ~= nil then
        if m_gameobject_get_transform ~= nil then
            local t, ok_t = call_method_handle(m_gameobject_get_transform, go)
            if ok_t and t ~= nil then
                transform = normalize_managed_object(t)
            end
        end
        if transform == nil then
            transform = get_transform_from_gameobject(go)
        end
    end

    if transform ~= nil then
        local pos = select(1, try_call(transform, METHOD_IDS.transform_get_position))
        if pos ~= nil then
            return pos
        end
    end

    return nil
end

local function get_updater(ctx)
    if ctx == nil or ctx.player == nil then
        return nil
    end

    if ctx.updater ~= nil and is_managed_object(ctx.updater) then
        return ctx.updater
    end

    local updater = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_updater))
    if updater == nil then
        updater = select(1, try_call(ctx.player, METHOD_IDS.get_player_updater))
    end
    if updater == nil and ctx.accessors ~= nil and ctx.accessors.get_updater ~= nil then
        updater = select(1, try_call(ctx.player, { ctx.accessors.get_updater, ctx.accessors.get_updater .. "()" }))
    end
    if updater ~= nil then
        ctx.updater = updater
    end
    return updater
end

local function get_env_process_driver(ctx)
    local updater = get_updater(ctx)
    if updater == nil then
        return nil
    end

    local env = select(1, first_non_nil_field(updater, FIELD_IDS.updater_environment_process_driver))
    if env ~= nil then
        return env
    end

    env = select(1, try_call(updater, {
        "get_EnvironmentProcessDriver()",
        "get_EnvironmentProcessDriver",
    }))
    return env
end

local function set_rotation(ctx, rot)
    if ctx == nil or rot == nil then
        return false
    end

    if ctx.transform == nil and ctx.player ~= nil then
        ctx.transform = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_transform))
    end

    local ok_transform = false
    if ctx.transform ~= nil and m_transform_set_rotation ~= nil then
        local _, ok = call_method_handle(m_transform_set_rotation, ctx.transform, rot)
        ok_transform = ok_transform or ok
    end
    local _, _, ok_transform_call = try_call(ctx.transform, METHOD_IDS.transform_set_rotation, rot)
    ok_transform = ok_transform or ok_transform_call

    local _, _, ok_player = try_call(ctx.player, METHOD_IDS.set_player_rotation, rot)
    return ok_transform or ok_player
end

local function set_position(ctx, pos)
    if ctx == nil or pos == nil then
        return false
    end

    if ctx.transform == nil and ctx.player ~= nil then
        ctx.transform = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_transform))
    end

    if ctx.character_controller ~= nil then
        try_call(ctx.character_controller, METHOD_IDS.character_controller_warp)
    end

    local ok_transform = false

    if ctx.transform ~= nil and m_transform_set_position ~= nil then
        local _, ok = call_method_handle(m_transform_set_position, ctx.transform, pos)
        ok_transform = ok_transform or ok
    end

    if ctx.transform ~= nil then
        if ctx.transform.set_position ~= nil then
            local ok_transform_method = pcall(ctx.transform.set_position, ctx.transform, pos, true)
            if not ok_transform_method then
                ok_transform_method = pcall(ctx.transform.set_position, ctx.transform, pos)
            end
            ok_transform = ok_transform or ok_transform_method
        end
    end

    local _, _, ok_transform_call = try_call(ctx.transform, METHOD_IDS.transform_set_position, pos)
    ok_transform = ok_transform or ok_transform_call

    local _, _, ok_player = try_call(ctx.player, METHOD_IDS.set_player_position, pos)
    if (not ok_player) and ctx.accessors ~= nil and ctx.accessors.set_position ~= nil then
        local _, _, ok_scanned = try_call(ctx.player, { ctx.accessors.set_position, ctx.accessors.set_position .. "(via.vec3)" }, pos)
        ok_player = ok_player or ok_scanned
    end

    if ctx.character_controller ~= nil then
        try_call(ctx.character_controller, METHOD_IDS.character_controller_warp)
    end

    return ok_player or ok_transform
end

local function teleport_player_to_camera()
    if state.is_ingame_502171 ~= true then
        state.status = "Teleport blocked: not in-game."
        return
    end

    if state.context == nil or not is_managed_object(state.context.player) then
        state.context = resolve_player_context()
    end
    if state.context == nil or not is_managed_object(state.context.player) then
        state.status = "Teleport failed: player context unavailable."
        return
    end

    local cam_pos = get_camera_position()
    if cam_pos == nil then
        state.status = "Teleport failed: camera position unavailable."
        return
    end

    local ok_pos = set_position(state.context, cam_pos)
    if not ok_pos then
        state.status = "Teleport failed: position write failed."
        return
    end
    state.noclip_pos = cam_pos

    if cfg.teleport_to_camera_apply_rotation then
        local cam_rot = get_camera_rotation()
        if cam_rot ~= nil then
            local siny = 2.0 * ((cam_rot.w * cam_rot.y) + (cam_rot.x * cam_rot.z))
            local cosy = 1.0 - 2.0 * ((cam_rot.y * cam_rot.y) + (cam_rot.x * cam_rot.x))
            local yaw = 0.0
            if math.atan2 ~= nil then
                yaw = math.atan2(siny, cosy)
            else
                yaw = math.atan(siny, cosy)
            end
            yaw = yaw + (cfg.sync_rotation_yaw_offset_deg * (math.pi / 180.0))
            local half = yaw * 0.5
            local upright_rot = Vector4f.new(0.0, math.sin(half), 0.0, math.cos(half))

            if set_rotation(state.context, upright_rot) then
                state.noclip_rot = upright_rot
                state.status = "Teleported to camera (yaw rotation applied)."
            else
                state.status = "Teleported to camera (rotation write failed)."
            end
        else
            state.status = "Teleported to camera (rotation unavailable)."
        end
    else
        state.status = "Teleported to camera."
    end
end

local function quat_get_yaw(q)
    if q == nil then
        return 0.0
    end
    local siny = 2.0 * ((q.w * q.y) + (q.x * q.z))
    local cosy = 1.0 - 2.0 * ((q.y * q.y) + (q.x * q.x))
    if math.atan2 ~= nil then
        return math.atan2(siny, cosy)
    end
    return math.atan(siny, cosy)
end

local function quat_from_yaw(yaw)
    local half = yaw * 0.5
    return Vector4f.new(0.0, math.sin(half), 0.0, math.cos(half))
end

local function deg_to_rad(deg)
    return deg * (math.pi / 180.0)
end

local function suppress_fall_system(ctx)
    -- Fall/landing suppression path used while NoClip fall system patching is active.
    if not cfg.disable_fall_system_and_animation or ctx == nil then
        state.fall_suppress_status = "disabled"
        return
    end

    local flags = {}
    state.fall_reset_internal_call = true

    local common = nil
    if ctx.player ~= nil then
        common = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_common))
        if common == nil then
            common = select(1, try_call(ctx.player, METHOD_IDS.get_player_common))
        end
    end
    if common ~= nil then
        set_field_if_exists(common, FIELD_IDS.common_fall_type, 0)
        set_field_if_exists(common, FIELD_IDS.common_damage_continue_state, false)
        set_field_if_exists(common, FIELD_IDS.common_is_fast_game_over, false)
        set_field_if_exists(common, FIELD_IDS.common_is_terrain_action, false)
        try_call(common, METHOD_IDS.common_set_fall_type, 0)
        try_call(common, METHOD_IDS.common_set_is_fast_game_over, false)
        try_call(common, METHOD_IDS.common_set_is_damage_continue_state, false)
        flags[#flags + 1] = "common"
    end

    local updater = get_updater(ctx)
    if updater ~= nil then
        flags[#flags + 1] = "updater"
        set_field_if_exists(updater, FIELD_IDS.updater_is_dead_trigger, false)
        set_field_if_exists(updater, FIELD_IDS.updater_is_other_game_over, false)
        set_field_if_exists(updater, FIELD_IDS.updater_requested_falling_hash, EMPTY_NAME_HASH)
        set_field_if_exists(updater, FIELD_IDS.updater_requested_landing_hash, EMPTY_NAME_HASH)
        set_field_if_exists(updater, FIELD_IDS.updater_back_turn_dir_from_run_landing, 0)
        try_call(updater, METHOD_IDS.updater_set_is_other_game_over, false)
        try_call(updater, METHOD_IDS.updater_set_back_turn_dir_from_run_landing, 0)
        try_call(updater, METHOD_IDS.updater_set_requested_falling_hash, EMPTY_NAME_HASH)
        try_call(updater, METHOD_IDS.updater_set_requested_landing_hash, EMPTY_NAME_HASH)

        local anim_fall = select(1, first_non_nil_field(updater, FIELD_IDS.updater_anim_fall_ground_checker))
        if anim_fall ~= nil then
            set_field_if_exists(anim_fall, FIELD_IDS.anim_fall_is_adjust, false)
            set_field_if_exists(anim_fall, FIELD_IDS.anim_fall_input_delta_move, Vector3f.new(0.0, 0.0, 0.0))
            try_call(anim_fall, METHOD_IDS.anim_fall_end_animation)
            flags[#flags + 1] = "animU"
        end

        if cfg.aggressive_pose_kill then
            if state.saved_anim_fall_checker == nil then
                local checker = select(1, try_call(updater, METHOD_IDS.updater_get_anim_fall_ground_checker))
                if checker == nil then
                    checker = select(1, first_non_nil_field(updater, FIELD_IDS.updater_anim_fall_ground_checker))
                end
                if checker ~= nil then
                    state.saved_anim_fall_checker = checker
                end
            end

            set_field_if_exists(updater, FIELD_IDS.updater_anim_fall_ground_checker, nil)
            try_call(updater, METHOD_IDS.updater_set_anim_fall_ground_checker, nil)
            try_call(updater, METHOD_IDS.updater_off_animation)
            flags[#flags + 1] = "animNil"
        end

        local dead_body = select(1, first_non_nil_field(updater, FIELD_IDS.updater_dead_body_driver))
        if dead_body ~= nil then
            set_field_if_exists(dead_body, FIELD_IDS.dead_body_is_dead_release, false)
            try_call(dead_body, METHOD_IDS.dead_body_set_is_dead_release, false)
            flags[#flags + 1] = "deadBody"
        end

        local stance = select(1, first_non_nil_field(updater, FIELD_IDS.updater_player_stance_driver))
        if stance ~= nil then
            try_call(stance, METHOD_IDS.stance_continue_hand_down)
            try_call(stance, METHOD_IDS.stance_update_hand_down)
            try_call(stance, METHOD_IDS.stance_update_hand_down_motion)
            try_call(stance, METHOD_IDS.stance_update_hand_down_internal)
            try_call(stance, METHOD_IDS.stance_update_temp_hand_down)
            try_call(stance, METHOD_IDS.stance_update_temp_hand_down_internal)
            flags[#flags + 1] = "stance"
        end

        local action_unit = select(1, try_call(updater, {
            "get_ActionBlackboardUnit()",
            "get_ActionBlackboardUnit",
        }))
        if action_unit ~= nil then
            try_call(action_unit, {
                "requestEndCurrentAction()",
                "requestEndCurrentAction",
            })
            local action_state = select(1, first_non_nil_field(action_unit, {
                "<ActionState>k__BackingField",
                "_ActionState",
                "ActionState",
            }))
            if action_state ~= nil then
                try_call(action_state, {
                    "set_ActionEnd(System.Boolean)",
                    "set_ActionEnd",
                }, true)
            end
            flags[#flags + 1] = "actEnd"
        end
    end

    local env = get_env_process_driver(ctx)
    if env ~= nil then
        flags[#flags + 1] = "env"
        try_call(env, METHOD_IDS.env_prevent_fall)
        try_call(env, METHOD_IDS.player_env_clear_landing_to_fall_loop_check)
        try_call(env, METHOD_IDS.player_env_set_landing_action, false)
        try_call(env, METHOD_IDS.player_env_check_safe_area_fall_end)
        try_call(env, METHOD_IDS.player_env_set_seq_override_climb_start_type, 0)
        try_call(env, METHOD_IDS.env_stop_free_fall_ctrl)
        try_call(env, METHOD_IDS.player_env_warp)
        try_call(env, METHOD_IDS.env_set_fall_damage, 0)
        try_call(env, METHOD_IDS.env_set_fall_height, 0.0)
        try_call(env, METHOD_IDS.env_set_prev_fall_height, 0.0)
        try_call(env, METHOD_IDS.env_set_height_keep_ground, 100000.0)
        try_call(env, METHOD_IDS.env_set_height_prevent_fall, 100000.0)
        try_call(env, METHOD_IDS.env_set_disable_gravity_until_motion_end, true)

        set_field_if_exists(env, FIELD_IDS.env_fall_process_id, nil)
        set_field_if_exists(env, FIELD_IDS.env_fall_damage, 0)
        set_field_if_exists(env, FIELD_IDS.env_prev_fall_height, 0.0)
        set_field_if_exists(env, FIELD_IDS.env_fall_height, 0.0)
        set_field_if_exists(env, FIELD_IDS.env_height_keep_ground, 100000.0)
        set_field_if_exists(env, FIELD_IDS.env_height_prevent_fall, 100000.0)
        set_field_if_exists(env, FIELD_IDS.env_is_disable_gravity_until_motion_end, true)
        set_field_if_exists(env, FIELD_IDS.env_is_falling_into_crack, false)
        set_field_if_exists(env, FIELD_IDS.env_is_found_crack, false)
        set_field_if_exists(env, FIELD_IDS.env_init_fall_speed_store_timing_trigger, false)
        set_field_if_exists(env, FIELD_IDS.env_apply_hip_init_fall_speed_trigger, false)
        set_field_if_exists(env, FIELD_IDS.env_is_keep_ground, true)
        set_field_if_exists(env, FIELD_IDS.env_is_prev_keep_ground, true)
        set_field_if_exists(env, FIELD_IDS.env_landing_fall_loop_check_state, 0)
        set_field_if_exists(env, FIELD_IDS.env_check_landing_to_fall_loop_y_pos, nil)

        local freefall = select(1, first_non_nil_field(env, FIELD_IDS.env_free_fall_ctrl))
        if freefall ~= nil then
            set_field_if_exists(freefall, FIELD_IDS.freefall_initial_frame_speed, Vector3f.new(0.0, 0.0, 0.0))
            set_field_if_exists(freefall, FIELD_IDS.freefall_frame_gravity, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_max_fall_frame_speed, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_add_frame_for_gravity, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_is_active, false)
            set_field_if_exists(freefall, FIELD_IDS.freefall_is_rise, false)
        end

        local env_anim_fall = select(1, first_non_nil_field(env, FIELD_IDS.updater_anim_fall_ground_checker))
        if env_anim_fall ~= nil then
            set_field_if_exists(env_anim_fall, FIELD_IDS.anim_fall_is_adjust, false)
            set_field_if_exists(env_anim_fall, FIELD_IDS.anim_fall_input_delta_move, Vector3f.new(0.0, 0.0, 0.0))
            try_call(env_anim_fall, METHOD_IDS.anim_fall_end_animation)
            flags[#flags + 1] = "animE"
        end
    end

    if #flags == 0 then
        state.fall_suppress_status = "no-targets"
    else
        state.fall_suppress_status = table.concat(flags, "|")
    end
    state.fall_reset_internal_call = false
end

local function restore_fall_pose_system(ctx)
    if state.saved_anim_fall_checker == nil then
        return
    end

    local target_ctx = ctx
    if target_ctx == nil then
        target_ctx = state.context
    end
    local updater = get_updater(target_ctx)
    if updater ~= nil then
        set_field_if_exists(updater, FIELD_IDS.updater_anim_fall_ground_checker, state.saved_anim_fall_checker)
        try_call(updater, METHOD_IDS.updater_set_anim_fall_ground_checker, state.saved_anim_fall_checker)
    end
    state.saved_anim_fall_checker = nil
end

local function apply_fall_reentry_fix(ctx)
    if ctx == nil then
        return
    end
    state.fall_reset_internal_call = true

    local common = nil
    if ctx.player ~= nil then
        common = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_common))
        if common == nil then
            common = select(1, try_call(ctx.player, METHOD_IDS.get_player_common))
        end
    end
    if common ~= nil then
        set_field_if_exists(common, FIELD_IDS.common_fall_type, 0)
        set_field_if_exists(common, FIELD_IDS.common_damage_continue_state, false)
        set_field_if_exists(common, FIELD_IDS.common_is_fast_game_over, false)
        set_field_if_exists(common, FIELD_IDS.common_is_terrain_action, false)
        try_call(common, METHOD_IDS.common_set_fall_type, 0)
        try_call(common, METHOD_IDS.common_set_is_fast_game_over, false)
        try_call(common, METHOD_IDS.common_set_is_damage_continue_state, false)
    end

    local updater = get_updater(ctx)
    if updater ~= nil then
        set_field_if_exists(updater, FIELD_IDS.updater_requested_falling_hash, EMPTY_NAME_HASH)
        set_field_if_exists(updater, FIELD_IDS.updater_requested_landing_hash, EMPTY_NAME_HASH)
        set_field_if_exists(updater, FIELD_IDS.updater_back_turn_dir_from_run_landing, 0)
        try_call(updater, METHOD_IDS.updater_set_requested_falling_hash, EMPTY_NAME_HASH)
        try_call(updater, METHOD_IDS.updater_set_requested_landing_hash, EMPTY_NAME_HASH)
        try_call(updater, METHOD_IDS.updater_set_back_turn_dir_from_run_landing, 0)
        local checker = select(1, try_call(updater, METHOD_IDS.updater_get_anim_fall_ground_checker))
        if checker ~= nil then
            set_field_if_exists(checker, FIELD_IDS.anim_fall_is_adjust, false)
            set_field_if_exists(checker, FIELD_IDS.anim_fall_input_delta_move, Vector3f.new(0.0, 0.0, 0.0))
            try_call(checker, METHOD_IDS.anim_fall_end_animation)
        end
        if state.saved_anim_fall_checker ~= nil then
            set_field_if_exists(updater, FIELD_IDS.updater_anim_fall_ground_checker, state.saved_anim_fall_checker)
            try_call(updater, METHOD_IDS.updater_set_anim_fall_ground_checker, state.saved_anim_fall_checker)
            set_field_if_exists(state.saved_anim_fall_checker, FIELD_IDS.anim_fall_is_adjust, false)
            set_field_if_exists(state.saved_anim_fall_checker, FIELD_IDS.anim_fall_input_delta_move, Vector3f.new(0.0, 0.0, 0.0))
            try_call(state.saved_anim_fall_checker, METHOD_IDS.anim_fall_end_animation)
        end
    end

    local env = get_env_process_driver(ctx)
    if env ~= nil then
        try_call(env, METHOD_IDS.player_env_clear_landing_to_fall_loop_check)
        try_call(env, METHOD_IDS.player_env_set_landing_action, false)
        try_call(env, METHOD_IDS.env_stop_free_fall_ctrl)
        try_call(env, METHOD_IDS.env_set_fall_damage, 0)
        try_call(env, METHOD_IDS.env_set_fall_height, 0.0)
        try_call(env, METHOD_IDS.env_set_prev_fall_height, 0.0)
        try_call(env, METHOD_IDS.env_set_height_keep_ground, 100000.0)
        try_call(env, METHOD_IDS.env_set_height_prevent_fall, 100000.0)
        try_call(env, METHOD_IDS.env_set_disable_gravity_until_motion_end, true)
        set_field_if_exists(env, FIELD_IDS.env_landing_fall_loop_check_state, 0)
        set_field_if_exists(env, FIELD_IDS.env_check_landing_to_fall_loop_y_pos, nil)
        set_field_if_exists(env, FIELD_IDS.env_fall_process_id, nil)
        set_field_if_exists(env, FIELD_IDS.env_fall_damage, 0)
        set_field_if_exists(env, FIELD_IDS.env_fall_height, 0.0)
        set_field_if_exists(env, FIELD_IDS.env_prev_fall_height, 0.0)
        set_field_if_exists(env, FIELD_IDS.env_height_keep_ground, 100000.0)
        set_field_if_exists(env, FIELD_IDS.env_height_prevent_fall, 100000.0)
        set_field_if_exists(env, FIELD_IDS.env_is_disable_gravity_until_motion_end, true)
        set_field_if_exists(env, FIELD_IDS.env_is_falling_into_crack, false)
        set_field_if_exists(env, FIELD_IDS.env_is_found_crack, false)
        set_field_if_exists(env, FIELD_IDS.env_init_fall_speed_store_timing_trigger, false)
        set_field_if_exists(env, FIELD_IDS.env_apply_hip_init_fall_speed_trigger, false)
        set_field_if_exists(env, FIELD_IDS.env_is_keep_ground, true)
        set_field_if_exists(env, FIELD_IDS.env_is_prev_keep_ground, true)

        local freefall = select(1, first_non_nil_field(env, FIELD_IDS.env_free_fall_ctrl))
        if freefall ~= nil then
            set_field_if_exists(freefall, FIELD_IDS.freefall_initial_frame_speed, Vector3f.new(0.0, 0.0, 0.0))
            set_field_if_exists(freefall, FIELD_IDS.freefall_frame_gravity, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_max_fall_frame_speed, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_add_frame_for_gravity, 0.0)
            set_field_if_exists(freefall, FIELD_IDS.freefall_is_active, false)
            set_field_if_exists(freefall, FIELD_IDS.freefall_is_rise, false)
        end
    end
    state.fall_reset_internal_call = false
end

local function get_player_hitpoint(player)
    if player == nil then
        return nil
    end

    local hp = select(1, try_call(player, {
        "get_HitPoint()",
        "get_HitPoint",
    }))
    if hp ~= nil then
        return hp
    end

    local hp_field, _ = first_non_nil_field(player, {
        "_HitPoint_k__BackingField",
        "<HitPoint>k__BackingField",
        "_HitPoint",
        "HitPoint",
    })
    return hp_field
end

local function set_player_invincible(player, enabled)
    local hp = get_player_hitpoint(player)
    if hp == nil then
        return false
    end

    local current = select(1, try_call(hp, {
        "get_Invincible()",
        "get_Invincible",
    }))

    if (not state.invincible_state_saved) and current ~= nil then
        state.original_invincible = current
        state.invincible_state_saved = true
    end

    local _, _, ok_set = try_call(hp, {
        "set_Invincible(System.Boolean)",
        "set_Invincible",
    }, enabled)

    if ok_set then
        state.invincible_applied = enabled
    end

    return ok_set
end

local function refill_player_health(player)
    local hp = get_player_hitpoint(player)
    if hp == nil then
        return false
    end

    local cur = select(1, try_call(hp, {
        "get_CurrentHitPoint()",
        "get_CurrentHitPoint",
    }))
    local max = select(1, try_call(hp, {
        "get_CurrentMaximumHitPoint()",
        "get_CurrentMaximumHitPoint",
    }))

    if type(cur) ~= "number" or type(max) ~= "number" or max <= 0 then
        return false
    end

    if cur >= max then
        return true
    end

    local _, _, ok_reset = try_call(hp, {
        "resetHitPoint(System.Int32)",
        "resetHitPoint",
    }, max)
    if ok_reset then
        return true
    end

    local delta = max - cur
    if delta > 0 then
        local _, _, ok_recovery = try_call(hp, {
            "recovery(System.Int32, app.HitPoint.RecoveryFactor)",
            "recovery",
        }, delta, 0)
        return ok_recovery
    end

    return false
end

local function apply_survival_mode(ctx)
    if not cfg.anti_death_use_invincible or ctx == nil or ctx.player == nil then
        return
    end

    set_player_invincible(ctx.player, true)
    refill_player_health(ctx.player)
end

local function clear_manager_game_over_flags()
    if not cfg.block_game_over then
        return
    end

    local mgr = select(1, get_singleton_any("app.CharacterManager"))
    if mgr == nil then
        return
    end

    set_field_if_exists(mgr, FIELD_IDS.character_manager_requested_game_over, false)
    set_field_if_exists(mgr, FIELD_IDS.character_manager_requested_game_over_fade, false)
    set_field_if_exists(mgr, FIELD_IDS.character_manager_is_game_overed, false)
end

local function clear_player_death_flags(ctx)
    if ctx == nil or ctx.player == nil then
        return
    end

    set_field_if_exists(ctx.player, FIELD_IDS.player_is_dead_static, false)

    local common = select(1, first_non_nil_field(ctx.player, FIELD_IDS.player_common))
    if common == nil then
        common = select(1, try_call(ctx.player, METHOD_IDS.get_player_common))
    end
    if common ~= nil then
        set_field_if_exists(common, FIELD_IDS.common_fall_type, 0)
        set_field_if_exists(common, FIELD_IDS.common_damage_continue_state, false)
        set_field_if_exists(common, FIELD_IDS.common_is_fast_game_over, false)
    end
end

local function apply_anti_death_mode(ctx)
    if ctx == nil or ctx.player == nil then
        return
    end

    apply_survival_mode(ctx)
    clear_player_death_flags(ctx)
    if cfg.enabled then
        suppress_fall_system(ctx)
    end
    clear_manager_game_over_flags()
end

local function restore_survival_mode(ctx)
    if not state.invincible_applied then
        state.invincible_state_saved = false
        state.original_invincible = nil
        return
    end

    local player = nil
    if ctx ~= nil and ctx.player ~= nil then
        player = ctx.player
    elseif state.context ~= nil and state.context.player ~= nil then
        player = state.context.player
    end

    if player ~= nil then
        local restore_value = false
        if state.invincible_state_saved and state.original_invincible ~= nil then
            restore_value = state.original_invincible
        end
        set_player_invincible(player, restore_value)
    end

    state.invincible_applied = false
    state.invincible_state_saved = false
    state.original_invincible = nil
end

local function key_down(vk)
    return reframework:is_key_down(vk)
end

-- Gamepad functions handlers
local function clamp(v, min_v, max_v)
    if v < min_v then
        return min_v
    end
    if v > max_v then
        return max_v
    end
    return v
end

local function normalize_stick_axis(value)
    local n = as_number(value)
    if n == nil then
        return 0.0
    end
    if math.abs(n) > 1.5 then
        local a = math.abs(n)
        if a <= 100.0 then
            n = n / 100.0
        elseif a <= 1000.0 then
            n = n / 1000.0
        else
            n = n / 32767.0
        end
    end
    return clamp(n, -1.0, 1.0)
end

local function normalize_trigger_value(value)
    local n = as_number(value)
    if n == nil then
        return 0.0
    end
    if n < 0.0 then
        n = 0.0
    end
    if n > 1.5 then
        n = n / 255.0
    end
    return clamp(n, 0.0, 1.0)
end

local function apply_deadzone_axis(value, deadzone)
    local v = normalize_stick_axis(value)
    local dz = clamp(deadzone or 0.20, 0.0, 0.95)
    local abs_v = math.abs(v)
    if abs_v <= dz then
        return 0.0
    end
    local scaled = (abs_v - dz) / (1.0 - dz)
    if v < 0.0 then
        return -scaled
    end
    return scaled
end

local function read_vec2_xy(vec)
    if vec == nil then
        return nil, nil
    end
    local x = nil
    local y = nil

    local ok_x, val_x = pcall(function()
        return vec.x
    end)
    if ok_x then
        x = as_number(val_x)
    end
    if x == nil then
        local ok_x2, val_x2 = pcall(function()
            return vec.X
        end)
        if ok_x2 then
            x = as_number(val_x2)
        end
    end

    local ok_y, val_y = pcall(function()
        return vec.y
    end)
    if ok_y then
        y = as_number(val_y)
    end
    if y == nil then
        local ok_y2, val_y2 = pcall(function()
            return vec.Y
        end)
        if ok_y2 then
            y = as_number(val_y2)
        end
    end

    return x, y
end

local function gamepad_mask_down(button_state, masks)
    local button_num = as_number(button_state)
    if button_num == nil or masks == nil then
        return false
    end
    local bits = math.floor(button_num)
    for _, mask in ipairs(masks) do
        if (bits & mask) ~= 0 then
            return true
        end
    end
    return false
end

local function resolve_gamepad_device()
    local now = os.clock()
    if state.gamepad_device ~= nil and (now - state.gamepad_last_refresh) < 0.5 then
        return state.gamepad_device
    end

    state.gamepad_last_refresh = now

    local native = sdk.get_native_singleton("via.hid.Gamepad")
    if native == nil then
        native = sdk.get_native_singleton("via.hid.GamePad")
    end

    local tdef = sdk.find_type_definition("via.hid.GamePad")
    if tdef == nil then
        tdef = sdk.find_type_definition("via.hid.Gamepad")
    end

    local device = nil
    if native ~= nil and tdef ~= nil then
        local ok_call, result = pcall(function()
            return sdk.call_native_func(native, tdef, "get_MergedDevice")
        end)
        if ok_call then
            device = result
        end
    end

    if device == nil and native ~= nil then
        local ok_call2, result2 = pcall(function()
            return native:call("get_MergedDevice")
        end)
        if ok_call2 then
            device = result2
        end
    end

    state.gamepad_device = normalize_managed_object(device)
    return state.gamepad_device
end

local function read_gamepad_input()
    local device = resolve_gamepad_device()
    if device == nil then
        state.gamepad_debug_line = "GP device: not found"
        return nil
    end

    local button_state = select(1, try_call(device, GP.get_button))

    local lx = as_number(select(1, try_call(device, GP.get_lx)))
    local ly = as_number(select(1, try_call(device, GP.get_ly)))
    local rx = as_number(select(1, try_call(device, GP.get_rx)))

    if lx == nil or ly == nil then
        local left_vec = select(1, try_call(device, GP.get_left_stick_vec))
        local vec_x, vec_y = read_vec2_xy(left_vec)
        if lx == nil then
            lx = vec_x
        end
        if ly == nil then
            ly = vec_y
        end
    end

    if lx == nil or ly == nil then
        local axis_l = select(1, try_call(device, GP.get_axis_l))
        local vec_x, vec_y = read_vec2_xy(axis_l)
        if lx == nil then
            lx = vec_x
        end
        if ly == nil then
            ly = vec_y
        end
    end

    if lx == nil then
        lx = as_number(select(1, try_call(device, GP.get_axis_x)))
    end
    if ly == nil then
        ly = as_number(select(1, try_call(device, GP.get_axis_y)))
    end

    if rx == nil then
        local right_vec = select(1, try_call(device, GP.get_right_stick_vec))
        local vec_x = select(1, read_vec2_xy(right_vec))
        rx = vec_x
    end

    if rx == nil then
        local axis_r = select(1, try_call(device, GP.get_axis_r))
        local vec_x = select(1, read_vec2_xy(axis_r))
        rx = vec_x
    end

    if rx == nil then
        rx = as_number(select(1, try_call(device, GP.get_axis_z)))
    end

    local l2 = normalize_trigger_value(select(1, try_call(device, GP.get_l2)))

    local deadzone = GP_DEADZONE
    local move_x = apply_deadzone_axis(lx or 0.0, deadzone)
    local move_y_raw = apply_deadzone_axis(ly or 0.0, deadzone)
    local turn_x = apply_deadzone_axis(rx or 0.0, deadzone)

    local move_z = move_y_raw

    local toggle_combo = gamepad_mask_down(button_state, GP.mask_l3) and gamepad_mask_down(button_state, GP.mask_r3)
    local move_up = gamepad_mask_down(button_state, GP.mask_r1)
    local move_down = gamepad_mask_down(button_state, GP.mask_l1)

    local boost = l2 > 0.25 or gamepad_mask_down(button_state, GP.mask_l2_button)

    state.gamepad_debug_line = string.format(
        "GP lx %.2f ly %.2f rx %.2f",
        normalize_stick_axis(lx or 0.0),
        normalize_stick_axis(ly or 0.0),
        normalize_stick_axis(rx or 0.0)
    )

    return {
        move_x = move_x,
        move_z = move_z,
        turn_x = turn_x,
        move_up = move_up,
        move_down = move_down,
        toggle_combo = toggle_combo,
        boost = boost,
    }
end

local function vec3_add(a, b)
    return Vector3f.new(a.x + b.x, a.y + b.y, a.z + b.z)
end

local function vec3_scale(v, s)
    return Vector3f.new(v.x * s, v.y * s, v.z * s)
end

local function vec3_len(v)
    return math.sqrt((v.x * v.x) + (v.y * v.y) + (v.z * v.z))
end

local function vec3_normalize(v)
    local l = vec3_len(v)
    if l <= 0.00001 then
        return Vector3f.new(0.0, 0.0, 0.0)
    end

    return Vector3f.new(v.x / l, v.y / l, v.z / l)
end

local function quat_rotate_vector(q, v)
    if q == nil then
        return v
    end

    local ux, uy, uz = q.x, q.y, q.z
    local s = q.w
    local dot_uv = (ux * v.x) + (uy * v.y) + (uz * v.z)
    local dot_uu = (ux * ux) + (uy * uy) + (uz * uz)
    local cross_x = (uy * v.z) - (uz * v.y)
    local cross_y = (uz * v.x) - (ux * v.z)
    local cross_z = (ux * v.y) - (uy * v.x)

    return Vector3f.new(
        (2.0 * dot_uv * ux) + ((s * s) - dot_uu) * v.x + (2.0 * s * cross_x),
        (2.0 * dot_uv * uy) + ((s * s) - dot_uu) * v.y + (2.0 * s * cross_y),
        (2.0 * dot_uv * uz) + ((s * s) - dot_uu) * v.z + (2.0 * s * cross_z)
    )
end

local function set_enabled(enable)
    if enable == cfg.enabled then
        return
    end

    if enable and state.is_ingame_502171 ~= true then
        cfg.enabled = false
        state.status = "Blocked: not in-game."
        return
    end

    cfg.enabled = enable
    if not enable then
        if cfg.anti_death_always then
            state.anti_death_cooldown_until = 0.0
        else
            state.anti_death_cooldown_until = os.clock() + cfg.anti_death_cooldown_seconds
        end
        restore_fall_pose_system(state.context)
        if not is_anti_death_active() then
            restore_survival_mode(state.context)
        end
        state.status = "NoClip disabled."
        return
    end

    state.anti_death_cooldown_until = 0.0
    state.context = resolve_player_context()
    if state.context == nil then
        state.status = "Enabled, waiting for player context..."
        return
    end

    state.noclip_pos = get_position(state.context)
    state.noclip_rot = get_rotation(state.context)
    apply_fall_reentry_fix(state.context)
    apply_anti_death_mode(state.context)
    state.status = "NoClip enabled."
end

local function try_refresh_context(force)
    local now = os.clock()
    if not force and (now - state.last_resolve_time) < state.resolve_retry_seconds then
        return state.context ~= nil
    end

    state.last_resolve_time = now
    state.context = resolve_player_context()
    return state.context ~= nil
end

re.on_pre_application_entry("UpdateBehavior", function()
    install_runtime_hooks_once()

    local ingame_value, ingame_source = query_is_ingame_502171()
    state.is_ingame_502171 = ingame_value == true
    state.is_ingame_502171_source = ingame_source or "unresolved"
    if state.is_ingame_502171 ~= true then
        state.context = nil
        return
    end

    if state.context == nil then
        try_refresh_context(false)
    elseif not is_managed_object(state.context.player) then
        state.context = nil
        try_refresh_context(false)
    end
end)

re.on_frame(function()

    -- Main runtime loop
    install_runtime_hooks_once()

    local gamepad = read_gamepad_input()

    local toggle_down = key_down(cfg.toggle_key)
    if gamepad ~= nil and gamepad.toggle_combo then
        toggle_down = true
    end
    if toggle_down and not state.hotkey_was_down then
        set_enabled(not cfg.enabled)
    end
    state.hotkey_was_down = toggle_down

    local now = os.clock()
    local dt = now - state.last_tick
    state.last_tick = now
    if dt < 0.0 or dt > 0.25 then
        dt = 1.0 / 60.0
    end

    local ingame_value, ingame_source = query_is_ingame_502171()
    state.is_ingame_502171 = ingame_value == true
    state.is_ingame_502171_source = ingame_source or "unresolved"

    if state.is_ingame_502171 ~= true then
        if cfg.enabled then
            cfg.enabled = false
            restore_fall_pose_system(state.context)
        end
        state.anti_death_cooldown_until = 0.0
        if state.anti_death_active_last_frame then
            restore_survival_mode(state.context)
            state.anti_death_active_last_frame = false
        end
        state.status = "Waiting for in-game state."
        return
    end

    local anti_death_active = is_anti_death_active(now)
    if anti_death_active then
        if state.context == nil or not is_managed_object(state.context.player) then
            try_refresh_context(false)
        end
        if state.context ~= nil and is_managed_object(state.context.player) then
            apply_anti_death_mode(state.context)
        end
        state.anti_death_active_last_frame = true
    elseif state.anti_death_active_last_frame then
        restore_survival_mode(state.context)
        state.anti_death_active_last_frame = false
    end

    if not cfg.enabled then
        if state.context ~= nil and is_managed_object(state.context.player) then
            local live_pos = get_position(state.context)
            if live_pos ~= nil then
                state.noclip_pos = live_pos
            end
            local live_rot = get_rotation(state.context)
            if live_rot ~= nil then
                state.noclip_rot = live_rot
            end
        end
        state.status = "NoClip disabled."
        return
    end

    if state.context == nil or not is_managed_object(state.context.player) then
        try_refresh_context(false)
        if state.context == nil then
            state.status = "Failed to resolve player context. " .. tostring(state.last_resolve_reason)
            return
        end
    end

    if state.noclip_pos == nil then
        state.noclip_pos = get_position(state.context)
    end
    if state.noclip_rot == nil then
        state.noclip_rot = get_rotation(state.context)
    end

    local rot_now = nil
    if cfg.mouse_steering then
        rot_now = get_camera_rotation()
    end
    if rot_now == nil then
        rot_now = get_rotation(state.context)
    end
    if rot_now ~= nil then
        state.noclip_rot = rot_now
    end

    if gamepad ~= nil and math.abs(gamepad.turn_x) > 0.00001 and state.noclip_rot ~= nil then
        local yaw = quat_get_yaw(state.noclip_rot) - (gamepad.turn_x * deg_to_rad(cfg.gamepad_turn_speed_deg) * dt)
        state.noclip_rot = quat_from_yaw(yaw)
    end

    if state.noclip_pos == nil then
        state.status = "Unable to read player position."
        return
    end

    local mx = (key_down(VK.A) and 1.0 or 0.0) - (key_down(VK.D) and 1.0 or 0.0)
    local mz = (key_down(VK.W) and 1.0 or 0.0) - (key_down(VK.S) and 1.0 or 0.0)
    local down_input = (key_down(VK.Q) or key_down(VK.C)) and 1.0 or 0.0
    local my = (key_down(VK.E) and 1.0 or 0.0) - down_input

    if gamepad ~= nil then
        mx = mx - gamepad.move_x
        mz = mz + gamepad.move_z
        if gamepad.move_up then
            my = my + 1.0
        end
        if gamepad.move_down then
            my = my - 1.0
        end
    end
    my = clamp(my, -1.0, 1.0)

    local speed = cfg.speed
    local vertical_speed = cfg.vertical_speed
    local boost_down = key_down(VK.SHIFT) or (gamepad ~= nil and gamepad.boost)
    local slow_down = key_down(VK.CTRL)
    if boost_down then
        speed = speed * cfg.boost_multiplier
        vertical_speed = vertical_speed * cfg.boost_multiplier
    elseif slow_down then
        speed = speed * cfg.slow_multiplier
        vertical_speed = vertical_speed * cfg.slow_multiplier
    end

    local move_offset_deg = cfg.movement_yaw_offset_deg
    if not cfg.mouse_steering then
        move_offset_deg = 0.0
    end
    local move_yaw = quat_get_yaw(state.noclip_rot) + deg_to_rad(move_offset_deg)
    local move_rot = quat_from_yaw(move_yaw)
    local move_input_mag = math.sqrt((mx * mx) + (mz * mz))

    if move_input_mag > 1.0 then
        mx = mx / move_input_mag
        mz = mz / move_input_mag
        move_input_mag = 1.0
    end
    
    local local_move = Vector3f.new(mx, 0.0, mz)
    local horizontal = quat_rotate_vector(move_rot, local_move)
    horizontal.y = 0.0
    if vec3_len(horizontal) > 0.00001 then
        horizontal = vec3_normalize(horizontal)
    end

    local delta_horizontal = vec3_scale(horizontal, speed * dt * move_input_mag)
    local delta_vertical = Vector3f.new(0.0, my * vertical_speed * dt, 0.0)
    local delta = vec3_add(delta_horizontal, delta_vertical)

    if vec3_len(delta) > 0.000001 then
        state.noclip_pos = vec3_add(state.noclip_pos, delta)
    end

    if not set_position(state.context, state.noclip_pos) then
        state.status = "Failed to apply NoClip position this frame."
    else
        if cfg.mouse_steering and state.noclip_rot ~= nil then
            local yaw = quat_get_yaw(state.noclip_rot) + deg_to_rad(cfg.sync_rotation_yaw_offset_deg)
            local rotation_to_apply = quat_from_yaw(yaw)
            set_rotation(state.context, rotation_to_apply)
        end
        state.status = "NoClip active."
    end
end)

re.on_draw_ui(function()

    -- UI flow
    if not imgui.tree_node(SCRIPT_NAME) then
        return
    end

    local changed = false
    local enable_now = cfg.enabled
    changed, enable_now = imgui.checkbox("Enable NoClip", enable_now)
    if changed then
        set_enabled(enable_now)
    end
    local anti_changed = false
    anti_changed, cfg.anti_death_always = imgui.checkbox("Enable Anti-Death (Always)", cfg.anti_death_always)
    if anti_changed then
        if cfg.anti_death_always then
            state.anti_death_cooldown_until = 0.0
            if state.is_ingame_502171 == true then
                if state.context == nil or not is_managed_object(state.context.player) then
                    try_refresh_context(true)
                end
                if state.context ~= nil and is_managed_object(state.context.player) then
                    apply_anti_death_mode(state.context)
                    state.anti_death_active_last_frame = true
                end
            else
                restore_survival_mode(state.context)
                state.anti_death_active_last_frame = false
                state.status = "Anti-Death blocked: not in-game."
            end
        else
            state.anti_death_cooldown_until = 0.0
            if not cfg.enabled then
                restore_survival_mode(state.context)
                state.anti_death_active_last_frame = false
            end
        end
    end

    imgui.text("Toggle key: F2")
    imgui.text("Move: W/A/S/D, Up: E, Down: Q/C, Boost: Shift, Slow: Ctrl")
    imgui.text("Gamepad: Toggle L3+R3, Move LS, Turn RS, Up R1, Down L1, Boost L2")
    
    changed, cfg.gamepad_turn_speed_deg = imgui.drag_float("Gamepad Turn Speed", cfg.gamepad_turn_speed_deg, 1.0, 30.0, 720.0, "%.0f deg/s")
    cfg.gamepad_turn_speed_deg = clamp(cfg.gamepad_turn_speed_deg, 30.0, 720.0)
    if state.gamepad_debug_line ~= "" then
        imgui.text(state.gamepad_debug_line)
    end
    imgui.spacing()

    changed, cfg.speed = imgui.drag_float("Horizontal Speed", cfg.speed, 0.05, 0.1, 100.0, "%.2f")
    changed, cfg.vertical_speed = imgui.drag_float("Vertical Speed", cfg.vertical_speed, 0.05, 0.1, 100.0, "%.2f")
    changed, cfg.boost_multiplier = imgui.drag_float("Boost Multiplier", cfg.boost_multiplier, 0.05, 1.0, 20.0, "%.2f")
    changed, cfg.slow_multiplier = imgui.drag_float("Slow Multiplier", cfg.slow_multiplier, 0.01, 0.01, 1.0, "%.2f")
    changed, cfg.movement_yaw_offset_deg = imgui.drag_float("Movement Yaw Offset", cfg.movement_yaw_offset_deg, 1.0, -180.0, 180.0, "%.0f deg")
    changed, cfg.anti_death_cooldown_seconds = imgui.drag_float("Anti-Death Cooldown (sec)", cfg.anti_death_cooldown_seconds, 0.1, 1.0, 60.0, "%.0f")
    if cfg.anti_death_cooldown_seconds < 1.0 then
        cfg.anti_death_cooldown_seconds = 1.0
    elseif cfg.anti_death_cooldown_seconds > 60.0 then
        cfg.anti_death_cooldown_seconds = 60.0
    end
    local fall_changed = false
    fall_changed, cfg.disable_fall_system_and_animation = imgui.checkbox("Disable Fall System", cfg.disable_fall_system_and_animation)
    if fall_changed and (not cfg.disable_fall_system_and_animation) then
        restore_fall_pose_system(state.context)
    end
    
    -- Toggles the SKIP_ORIGINAL hook for EnvironmentProcessDriver.updateClimbStep.
    changed, cfg.patch_update_climb_step_shake = imgui.checkbox("Prevent Collision Shake", cfg.patch_update_climb_step_shake)
    changed, cfg.mouse_steering = imgui.checkbox("Mouse Steering (Camera + Character Sync)", cfg.mouse_steering)
    if cfg.mouse_steering then
        changed, cfg.sync_rotation_yaw_offset_deg = imgui.drag_float("Character Yaw Offset", cfg.sync_rotation_yaw_offset_deg, 1.0, -180.0, 180.0, "%.0f deg")
    end

    changed, cfg.teleport_to_camera_apply_rotation = imgui.checkbox("Apply Rotation (Teleport To Camera)", cfg.teleport_to_camera_apply_rotation)
    if imgui.button("Teleport Player To Camera") then
        teleport_player_to_camera()
    end

    imgui.spacing()
    if state.noclip_pos == nil then
        state.noclip_pos = Vector3f.new(0.0, 0.0, 0.0)
    end
    changed, state.noclip_pos = imgui.drag_float3("Manual Position", state.noclip_pos, 0.05, -1000000.0, 1000000.0)
    if changed then
        if state.is_ingame_502171 ~= true then
            state.status = "Manual position blocked: not in-game."
        else
            if state.context == nil then
                state.context = resolve_player_context()
            end
            if not set_position(state.context, state.noclip_pos) then
                state.status = "Manual position write failed."
            end
        end
    end
    imgui.text(string.format("Player Pos: X %.3f | Y %.3f | Z %.3f", state.noclip_pos.x, state.noclip_pos.y, state.noclip_pos.z))
    if cfg.enabled then
        imgui.text("Anti-Death: Active")
    elseif cfg.anti_death_always then
        imgui.text("Anti-Death: Active (always)")
    elseif anti_death_cooldown_left() > 0.0 then
        imgui.text(string.format("Anti-Death: Cooldown %.1fs", anti_death_cooldown_left()))
    else
        imgui.text("Anti-Death: Off")
    end
    imgui.text("In-Game State: " .. (state.is_ingame_502171 and "True" or "False"))
    imgui.text("Status: " .. tostring(state.status))
    imgui.text("Version: " .. SCRIPT_VERSION)

    imgui.tree_pop()
end)