local OriginalMode = {
    maxSpeed = 700, tiltIntensity = 60, tiltSpeed = 10, activeSideTiltAmplitude = 100, acceleration = 10,
    bobAmplitude = -0.5, bobFrequency = 2, idleTiltAmplitude = 5, idleTiltFrequency = 2, idleTiltOffset = 0,
    idleSideTiltAmplitude = 3, idleSideTiltFrequency = -1, idleSideTiltOffset = math.pi,
    idleSideMoveAmplitude = 1, idleSideMoveFrequency = -1, heightOffset = 4,
    rotation = Vector3.new(0, 0, 0), idleTurningAmplitude = 0, idleTurningFrequency = 0,
    moveAnimationIds = { "rbxassetid://97171309" }, moveAnimSpeed = 0
}

local GlitcherMode = {
    maxSpeed = 700, tiltIntensity = 60, tiltSpeed = 10, activeSideTiltAmplitude = 100, acceleration = 10,
    bobAmplitude = 1, bobFrequency = 3.5, idleTiltAmplitude = 7, idleTiltFrequency = 3.5, idleTiltOffset = math.pi/2,
    idleSideTiltAmplitude = 3, idleSideTiltFrequency = -1.75, idleSideTiltOffset = math.pi,
    idleSideMoveAmplitude = 0.3, idleSideMoveFrequency = -1.75, heightOffset = 7,
    rotation = Vector3.new(0, 0, 0), idleTurningAmplitude = 0, idleTurningFrequency = 0,
    moveAnimationIds = { "rbxassetid://97171309" }, moveAnimSpeed = 0
}

local TurboMode = {
    maxSpeed = 30, tiltIntensity = 83, tiltSpeed = 10, activeSideTiltAmplitude = 0, acceleration = 10,
    bobAmplitude = 1, bobFrequency = 1, idleTiltAmplitude = 7, idleTiltFrequency = 1, idleTiltOffset = math.pi,
    idleSideTiltAmplitude = 0, idleSideTiltFrequency = 0, idleSideTiltOffset = math.pi,
    idleSideMoveAmplitude = 0, idleSideMoveFrequency = 0, heightOffset = 7,
    rotation = Vector3.new(60, 0, 0), idleTurningAmplitude = 0, idleTurningFrequency = 0,
    moveAnimationIds = { "rbxassetid://235542946" }, moveAnimSpeed = 1
}

local CustomMode = {
    maxSpeed = 700, tiltIntensity = 60, tiltSpeed = 10, activeSideTiltAmplitude = 100, acceleration = 10,
    bobAmplitude = 1, bobFrequency = 3.5, idleTiltAmplitude = 8, idleTiltFrequency = 3.5, idleTiltOffset = -math.pi/-2,
    idleSideTiltAmplitude = 3, idleSideTiltFrequency = 1.7, idleSideTiltOffset = math.pi,
    idleSideMoveAmplitude = 0, idleSideMoveFrequency = 0, heightOffset = 7,
    rotation = Vector3.new(0, -30, 0), idleTurningAmplitude = 0, idleTurningFrequency = 0,
    moveAnimationIds = { "rbxassetid://90872539" }, moveAnimSpeed = 0
}

local QMode = {
    maxSpeed = 40, tiltIntensity = 15, tiltSpeed = 10, activeSideTiltAmplitude = 40, acceleration = 0,
    bobAmplitude = 0, bobFrequency = 2, idleTiltAmplitude = 5, idleTiltFrequency = 2, idleTiltOffset = math.pi/2,
    idleSideTiltAmplitude = 0, idleSideTiltFrequency = 0, idleSideTiltOffset = math.pi,
    idleSideMoveAmplitude = 0, idleSideMoveFrequency = 0, forwardBackwardMoveAmplitude = -0.01, forwardBackwardMoveFrequency = 2,
    heightOffset = 3, rotation = Vector3.new(0, 0, 0), idleTurningAmplitude = 0, idleTurningFrequency = 0,
    moveAnimationIds = { "rbxassetid://125749145", "rbxassetid://79094862" }, moveAnimSpeed = 0.7
}

local player = game.Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")
local char = player.Character or player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
local hum = char:FindFirstChildOfClass("Humanoid")
local cam = workspace.CurrentCamera

local G2L = {}

G2L["1"] = Instance.new("ScreenGui", playerGui)
G2L["1"].ZIndexBehavior = Enum.ZIndexBehavior.Sibling

G2L["2"] = Instance.new("Frame", G2L["1"])
G2L["2"].BorderSizePixel = 0
G2L["2"].BackgroundColor3 = Color3.fromRGB(0, 0, 0)
G2L["2"].Size = UDim2.new(0, 157, 0, 25)
G2L["2"].Position = UDim2.new(0.5, 0, 1, -20)
G2L["2"].AnchorPoint = Vector2.new(0.5, 1)
G2L["2"].BorderColor3 = Color3.fromRGB(0, 0, 0)

G2L["3"] = Instance.new("UICorner", G2L["2"])
G2L["3"].CornerRadius = UDim.new(0.2, 0)

G2L["4"] = Instance.new("UIStroke", G2L["2"])
G2L["4"].ApplyStrokeMode = Enum.ApplyStrokeMode.Border
G2L["4"].Thickness = 7.6
G2L["4"].Color = Color3.fromRGB(255, 255, 255)

G2L["5"] = Instance.new("UIGradient", G2L["4"])
G2L["5"].Color = ColorSequence.new{
	ColorSequenceKeypoint.new(0.000, Color3.fromRGB(0, 0, 0)),
	ColorSequenceKeypoint.new(0.417, Color3.fromRGB(4, 4, 4)),
	ColorSequenceKeypoint.new(1.000, Color3.fromRGB(255, 255, 255))
}

task.spawn(function()
	local gradient = G2L["4"]:FindFirstChildOfClass("UIGradient")
	local speed = 30
	if not gradient then
		warn("No UIGradient found in the parent UI element.")
		return
	end
	game:GetService("RunService").RenderStepped:Connect(function(deltaTime)
		gradient.Rotation = (gradient.Rotation + speed * deltaTime) % 360
	end)
end)

G2L["7"] = Instance.new("TextButton", G2L["1"])
G2L["7"].BorderSizePixel = 0
G2L["7"].TextSize = 19
G2L["7"].TextColor3 = Color3.fromRGB(255, 255, 255)
G2L["7"].BackgroundColor3 = Color3.fromRGB(0, 0, 0)
G2L["7"].FontFace = Font.new([[rbxasset://fonts/families/Zekton.json]], Enum.FontWeight.Regular, Enum.FontStyle.Italic)
G2L["7"].Size = UDim2.new(0, 157, 0, 25)
G2L["7"].Position = UDim2.new(0.5, 0, 1, -20)
G2L["7"].AnchorPoint = Vector2.new(0.5, 1)
G2L["7"].BorderColor3 = Color3.fromRGB(0, 0, 0)
G2L["7"].Text = "Warp"

G2L["8"] = Instance.new("UICorner", G2L["7"])
G2L["8"].CornerRadius = UDim.new(0.2, 0)

local maxSpeed, tiltIntensity, tiltSpeed, activeSideTiltAmplitude, acceleration
local bobAmplitude, bobFrequency, idleTiltAmplitude, idleTiltFrequency, idleTiltOffset, idleSideTiltAmplitude, idleSideTiltFrequency, idleSideTiltOffset
local idleSideMoveAmplitude, idleSideMoveFrequency, heightOffset
local appliedRotation = Vector3.new(0, 0, 0)
local idleTurningAmplitude = 0
local idleTurningFrequency = 0
local currentMoveAnimIds = {}
local currentMoveAnimSpeed = 1
local currentMoveAnimIndex = 1
local forwardBackwardMoveAmplitude = 0
local forwardBackwardMoveFrequency = 0

local function applyModeVars(modeTable)
    maxSpeed = modeTable.maxSpeed
    tiltIntensity = modeTable.tiltIntensity
    tiltSpeed = modeTable.tiltSpeed
    activeSideTiltAmplitude = modeTable.activeSideTiltAmplitude
    acceleration = modeTable.acceleration
    bobAmplitude = modeTable.bobAmplitude
    bobFrequency = modeTable.bobFrequency
    idleTiltAmplitude = modeTable.idleTiltAmplitude
    idleTiltFrequency = modeTable.idleTiltFrequency or modeTable.bobFrequency
    idleTiltOffset = modeTable.idleTiltOffset or 0
    idleSideTiltAmplitude = modeTable.idleSideTiltAmplitude
    idleSideTiltFrequency = modeTable.idleSideTiltFrequency
    idleSideTiltOffset = modeTable.idleSideTiltOffset
    idleSideMoveAmplitude = modeTable.idleSideMoveAmplitude
    idleSideMoveFrequency = modeTable.idleSideMoveFrequency
    heightOffset = modeTable.heightOffset
    appliedRotation = modeTable.rotation or Vector3.new(0, 0, 0)
    idleTurningAmplitude = modeTable.idleTurningAmplitude or 0
    idleTurningFrequency = modeTable.idleTurningFrequency or 0
    currentMoveAnimIds = modeTable.moveAnimationIds or { "rbxassetid://97171309" }
    currentMoveAnimSpeed = modeTable.moveAnimSpeed or 1
    currentMoveAnimIndex = 1
    forwardBackwardMoveAmplitude = modeTable.forwardBackwardMoveAmplitude or 0
    forwardBackwardMoveFrequency = modeTable.forwardBackwardMoveFrequency or 0
end

local localKeyDirections = {
    W = Vector3.new(0, 0, -1),
    S = Vector3.new(0, 0, 1),
    A = Vector3.new(-1, 0, 0),
    D = Vector3.new(1, 0, 0)
}

local uis = game:GetService("UserInputService")
local runService = game:GetService("RunService")

local originalIdleAnimationIds = {
    "rbxassetid://233087184","rbxassetid://162861977","rbxassetid://160737450",
    "rbxassetid://80979207","rbxassetid://287325678","rbxassetid://80979216"
}
local glitcherIdleAnimationIds = {
    "rbxassetid://121574294","rbxassetid://122342062","rbxassetid://160737355",
    "rbxassetid://94096418","rbxassetid://252395365"
}
local turboIdleAnimationIds = {"rbxassetid://171967794"}
local customIdleAnimationIds = {
    "rbxassetid://287325678","rbxassetid://160737450","rbxassetid://252395746","rbxassetid://190075311"
}
local qIdleAnimationIds = {
    "rbxassetid://287325678","rbxassetid://216937924"
}

local flying = false
local glitcherMode = false
local turboMode = false
local customMode = false
local qModeActive = false

local currentMoveAnimTracks = {}
local currentMoveAnimTrack = nil

local function stopAndDestroyAllMoveTracks()
    for _, track in ipairs(currentMoveAnimTracks) do
        if track.IsPlaying then track:Stop(0.4) end
        track:Destroy()
    end
    currentMoveAnimTracks = {}
    if currentMoveAnimTrack then
        if currentMoveAnimTrack.IsPlaying then currentMoveAnimTrack:Stop(0.4) end
        currentMoveAnimTrack:Destroy()
        currentMoveAnimTrack = nil
    end
end

local function loadMoveAnimation(index)
    stopAndDestroyAllMoveTracks()
    index = index or 1
    if qModeActive then
        for _, animId in ipairs(currentMoveAnimIds) do
            local anim = Instance.new("Animation")
            anim.AnimationId = animId
            local track = hum:LoadAnimation(anim)
            track.Looped = true
            track:AdjustSpeed(currentMoveAnimSpeed)
            table.insert(currentMoveAnimTracks, track)
        end
    else
        local anim = Instance.new("Animation")
        anim.AnimationId = currentMoveAnimIds[index]
        local track = hum:LoadAnimation(anim)
        track.Looped = true
        track:AdjustSpeed(currentMoveAnimSpeed)
        currentMoveAnimTrack = track
        currentMoveAnimIndex = index
    end
end

local function playMovementAnimation()
    if qModeActive then
        for _, track in ipairs(currentMoveAnimTracks) do
            if not track.IsPlaying then track:Play(0.4) end
            track:AdjustSpeed(currentMoveAnimSpeed)
        end
    else
        if currentMoveAnimTrack and not currentMoveAnimTrack.IsPlaying then
            currentMoveAnimTrack:Play(0.4)
            currentMoveAnimTrack:AdjustSpeed(currentMoveAnimSpeed)
        end
    end
end

local function stopMovementAnimation()
    if qModeActive then
        for _, track in ipairs(currentMoveAnimTracks) do
            if track.IsPlaying then track:Stop(0.4) end
        end
    else
        if currentMoveAnimTrack and currentMoveAnimTrack.IsPlaying then
            currentMoveAnimTrack:Stop(0.4)
        end
    end
end

local function updateMoveAnimSpeeds()
    if qModeActive then
        for _, track in ipairs(currentMoveAnimTracks) do
            track:AdjustSpeed(currentMoveAnimSpeed)
        end
    else
        if currentMoveAnimTrack then
            currentMoveAnimTrack:AdjustSpeed(currentMoveAnimSpeed)
        end
    end
end

uis.InputBegan:Connect(function(input, gp)
    if gp then return end
    if not flying then return end
    if input.KeyCode == Enum.KeyCode.U and #currentMoveAnimIds > 1 and not qModeActive then
        currentMoveAnimIndex = currentMoveAnimIndex % #currentMoveAnimIds + 1
        loadMoveAnimation(currentMoveAnimIndex)
        playMovementAnimation()
    end
end)

local currentIdleAnimationIds = {}
local idleAnimTracks = {}

local function loadIdleAnimations()
    for _, track in ipairs(idleAnimTracks) do
        if track.IsPlaying then
            track:Stop(0.4)
        end
        track:Destroy()
    end
    idleAnimTracks = {}

    for _, id in ipairs(currentIdleAnimationIds) do
        local anim = Instance.new("Animation")
        anim.AnimationId = id
        local track = hum:LoadAnimation(anim)
        track.Looped = true
        table.insert(idleAnimTracks, track)
    end
end

local function playIdleAnimations(smoothTransition)
    smoothTransition = smoothTransition == nil and true or smoothTransition
    if not ((currentMoveAnimTrack and currentMoveAnimTrack.IsPlaying) or (#currentMoveAnimTracks > 0 and currentMoveAnimTracks[1] and currentMoveAnimTracks[1].IsPlaying)) then
        for _, track in ipairs(idleAnimTracks) do
            if not track.IsPlaying then
                if smoothTransition then
                    track:Play(0.4)
                else
                    track:Play(0)
                end
                local id = track.Animation.AnimationId
                if id == "rbxassetid://80979216" then
                    track:AdjustSpeed(0.5)
                elseif id == "rbxassetid://252395365" then
                    track:AdjustSpeed(0.7)
                else
                    track:AdjustSpeed(0)
                end
            end
        end
    end
end

local function stopIdleAnimations(smoothTransition)
    smoothTransition = smoothTransition == nil and true or smoothTransition
    for _, track in ipairs(idleAnimTracks) do
        if track.IsPlaying then
            if smoothTransition then
                track:Stop(0.4)
            else
                track:Stop(0)
            end
        end
    end
end

local bp, bg
local initialGroundY = nil
local smoothedY = nil
local modeTransitionSpeed = 10
local targetInitialGroundY = nil
local targetHeightOffset = nil

local moveVector = Vector3.zero
local currentVelocity = Vector3.zero
local floatTime = 0
local activeInputs = {}

local speedFactor = 0
local lastTilt = 0
local lastYaw = 0
local lastMoveDirection = Vector3.zero
local currentBankTilt = 0
local isIdle = true

local function resetVariables()
    moveVector = Vector3.zero
    currentVelocity = Vector3.zero
    floatTime = 0
    activeInputs = {}
    speedFactor = 0
    lastTilt = 0
    lastYaw = 0
    lastMoveDirection = Vector3.zero
    currentBankTilt = 0
    isIdle = true
end

local function getFlatCameraCFrame()
    local camCF = cam.CFrame
    local _, y, _ = camCF:ToEulerAnglesYXZ()
    return CFrame.Angles(0, y, 0)
end

local prevShiftlock = uis.MouseBehavior == Enum.MouseBehavior.LockCenter
uis:GetPropertyChangedSignal("MouseBehavior"):Connect(function()
    if not flying and hrp then
        local pos = hrp.Position
        local _, y, _ = cam.CFrame:ToEulerAnglesYXZ()
        if uis.MouseBehavior == Enum.MouseBehavior.LockCenter then
            hrp.CFrame = CFrame.new(pos) * CFrame.Angles(0, y, 0)
        elseif prevShiftlock then
            hrp.CFrame = CFrame.new(pos) * CFrame.Angles(0, y, 0)
        end
        prevShiftlock = uis.MouseBehavior == Enum.MouseBehavior.LockCenter
    end
end)

local function initMode()
    moveVector = Vector3.zero
    currentVelocity = Vector3.zero
    floatTime = 0
    activeInputs = {}
    speedFactor = 0
    lastTilt = 0
    lastMoveDirection = Vector3.zero
    currentBankTilt = 0
    isIdle = true

    hum.PlatformStand = true

    if uis.MouseBehavior == Enum.MouseBehavior.LockCenter then
        local pos = hrp.Position
        local _, y, _ = cam.CFrame:ToEulerAnglesYXZ()
        hrp.CFrame = CFrame.new(pos) * CFrame.Angles(0, y, 0)
        lastYaw = y
    else
        local _, y, _ = hrp.CFrame:ToEulerAnglesYXZ()
        lastYaw = y
    end

    if qModeActive then
        currentIdleAnimationIds = qIdleAnimationIds
        applyModeVars(QMode)
    elseif customMode then
        currentIdleAnimationIds = customIdleAnimationIds
        applyModeVars(CustomMode)
    elseif turboMode then
        currentIdleAnimationIds = turboIdleAnimationIds
        applyModeVars(TurboMode)
    elseif glitcherMode then
        currentIdleAnimationIds = glitcherIdleAnimationIds
        applyModeVars(GlitcherMode)
    else
        currentIdleAnimationIds = originalIdleAnimationIds
        applyModeVars(OriginalMode)
    end

    loadMoveAnimation(1)

    local rayOrigin = hrp.Position
    local rayDirection = Vector3.new(0, -1000, 0)
    local raycastParams = RaycastParams.new()
    raycastParams.FilterDescendantsInstances = {char}
    raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
    local rayResult = workspace:Raycast(rayOrigin, rayDirection, raycastParams)
    local groundY = rayResult and rayResult.Position.Y or 0

    if initialGroundY == nil then
        initialGroundY = groundY
        smoothedY = groundY + heightOffset
    end
    targetInitialGroundY = groundY
    targetHeightOffset = heightOffset

    if bp then bp:Destroy() end
    bp = Instance.new("BodyPosition", hrp)
    bp.MaxForce = Vector3.new(1e9, 1e9, 1e9)
    bp.D = 800
    bp.P = 40000
    bp.Position = hrp.Position

    if bg then bg:Destroy() end
    bg = Instance.new("BodyGyro", hrp)
    bg.MaxTorque = Vector3.new(1e9, 1e9, 1e9)
    bg.P = 1e4
    bg.CFrame = hrp.CFrame

    stopIdleAnimations(false)
    loadIdleAnimations()
    playIdleAnimations(false)
    stopMovementAnimation()
end

local function toggleFlight()
    flying = not flying

    if flying then
        glitcherMode = false
        turboMode = false
        customMode = false
        qModeActive = false
        G2L["7"].Text = "Deactivate"
        initMode()
    else
        if bp then bp:Destroy() bp = nil end
        if bg then bg:Destroy() bg = nil end

        resetVariables()

        hum.PlatformStand = false
        stopIdleAnimations(true)
        stopMovementAnimation()

        G2L["7"].Text = "Warp"
        smoothedY = nil
        initialGroundY = nil
        targetInitialGroundY = nil
        targetHeightOffset = nil
    end
end

G2L["7"].MouseButton1Click:Connect(toggleFlight)

uis.InputBegan:Connect(function(input, gp)
    if gp then return end
    local keyName = input.KeyCode.Name

    if not flying then return end

    if keyName == "Q" then
        qModeActive = true
        glitcherMode = false
        turboMode = false
        customMode = false
        initMode()
        return
    end

    if keyName == "R" then
        glitcherMode = true
        turboMode = false
        customMode = false
        qModeActive = false
        initMode()
        return
    end

    if keyName == "E" then
        glitcherMode = false
        turboMode = false
        customMode = false
        qModeActive = false
        initMode()
        return
    end

    if keyName == "T" then
        turboMode = true
        glitcherMode = false
        customMode = false
        qModeActive = false
        initMode()
        return
    end

    if keyName == "Y" then
        customMode = true
        turboMode = false
        glitcherMode = false
        qModeActive = false
        initMode()
        return
    end

    if localKeyDirections[keyName] then
        activeInputs[keyName] = true
        stopIdleAnimations(true)
        playMovementAnimation()
        isIdle = false
    end
end)

uis.InputEnded:Connect(function(input, gp)
    if gp then return end
    local keyName = input.KeyCode.Name

    if not flying then return end

    if activeInputs[keyName] then
        activeInputs[keyName] = nil

        local stillMoving = false
        for _, key in ipairs({"W", "A", "S", "D"}) do
            if activeInputs[key] then
                stillMoving = true
                break
            end
        end

        if not stillMoving then
            stopMovementAnimation()
            playIdleAnimations(true)
            isIdle = true
        end
    end
end)

runService.RenderStepped:Connect(function(dt)
    if not flying then return end

    if initialGroundY and targetInitialGroundY and initialGroundY ~= targetInitialGroundY then
        local lerpAlpha = 1 - math.exp(-dt * modeTransitionSpeed)
        initialGroundY = initialGroundY + (targetInitialGroundY - initialGroundY) * lerpAlpha
        if math.abs(initialGroundY - targetInitialGroundY) < 0.01 then
            initialGroundY = targetInitialGroundY
        end
    end
    if heightOffset ~= targetHeightOffset and targetHeightOffset ~= nil then
        local lerpAlpha = 1 - math.exp(-dt * modeTransitionSpeed)
        heightOffset = heightOffset + (targetHeightOffset - heightOffset) * lerpAlpha
        if math.abs(heightOffset - targetHeightOffset) < 0.01 then
            heightOffset = targetHeightOffset
        end
    end

    local inputVector = Vector3.zero
    for key, active in pairs(activeInputs) do
        if active and localKeyDirections[key] then
            inputVector += localKeyDirections[key]
        end
    end

    if inputVector.Magnitude > 0 then
        inputVector = inputVector.Unit
    end

    local camYawCFrame = getFlatCameraCFrame()
    local worldMoveVector = camYawCFrame:VectorToWorldSpace(inputVector)
    worldMoveVector = Vector3.new(worldMoveVector.X, 0, worldMoveVector.Z)
    moveVector = worldMoveVector

    local pos = hrp.Position
    local isMoving = moveVector.Magnitude > 0

    local targetDirection = Vector3.zero
    if isMoving then
        targetDirection = moveVector.Unit
        lastMoveDirection = targetDirection
    elseif currentVelocity.Magnitude > 0 then
        targetDirection = lastMoveDirection
    end

    if qModeActive then
        if isMoving then
            speedFactor = 1
            currentVelocity = targetDirection * maxSpeed
            isIdle = false
        else
            speedFactor = 0
            currentVelocity = Vector3.zero
            if not next(activeInputs) then
                isIdle = true
            end
        end
    else
        if isMoving then
            speedFactor = math.clamp(speedFactor + 0.5 * dt, 0, 1)
            local currentMaxSpeed = maxSpeed * speedFactor
            local desiredVelocity = targetDirection * currentMaxSpeed
            currentVelocity = currentVelocity:Lerp(desiredVelocity, math.clamp(acceleration * dt, 0, 1))
            isIdle = false
        else
            speedFactor = 0
            currentVelocity = currentVelocity:Lerp(Vector3.zero, math.clamp(acceleration * dt, 0, 1))
            if not next(activeInputs) then
                isIdle = true
            end
        end
    end

    floatTime += dt

    local sineValue = (math.sin(floatTime * (idleTiltFrequency or bobFrequency) + (idleTiltOffset or 0)) + 1) / 2
    local idleTilt = -idleTiltAmplitude * sineValue
    local sideTilt = 0
    if not isMoving then
        sideTilt = idleSideTiltAmplitude * math.sin(floatTime * idleSideTiltFrequency + idleSideTiltOffset)
    end

    local targetPitchMoving = isMoving and -tiltIntensity or 0
    lastTilt = lastTilt + (targetPitchMoving - lastTilt) * math.clamp(dt * tiltSpeed, 0, 1)
    local combinedTilt = lastTilt + idleTilt

    local previousYaw = lastYaw
    if isMoving then
        if uis.MouseBehavior == Enum.MouseBehavior.LockCenter then
            _, lastYaw, _ = getFlatCameraCFrame():ToEulerAnglesYXZ()
        elseif currentVelocity.Magnitude > 0.1 then
            lastYaw = math.atan2(-currentVelocity.X, -currentVelocity.Z)
        end
    end

    local yawDiff = lastYaw - previousYaw
    local clampedYawDiff = math.clamp(yawDiff, -math.rad(10), math.rad(10))
    local targetBankTilt = (clampedYawDiff / math.rad(10)) * activeSideTiltAmplitude
    currentBankTilt += (targetBankTilt - currentBankTilt) * math.clamp(dt * 5, 0, 1)

    local bobOffset = math.sin(floatTime * bobFrequency) * bobAmplitude

    local forwardBackwardVec = Vector3.zero
    if qModeActive and isIdle and forwardBackwardMoveAmplitude ~= 0 and forwardBackwardMoveFrequency ~= 0 then
        local forward = hrp.CFrame.LookVector
        forward = Vector3.new(forward.X, 0, forward.Z).Unit
        local offset = math.sin(floatTime * forwardBackwardMoveFrequency) * forwardBackwardMoveAmplitude
        forwardBackwardVec = forward * offset
    end

    local targetY
    if initialGroundY ~= nil then
        targetY = initialGroundY + heightOffset + bobOffset
    else
        targetY = hrp.Position.Y
    end

    if smoothedY == nil then
        smoothedY = targetY
    else
        local lerpAlpha = 1 - math.exp(-dt * modeTransitionSpeed)
        smoothedY = smoothedY + (targetY - smoothedY) * lerpAlpha
    end

    local idleTurnAngle = 0
    if isIdle and idleTurningAmplitude ~= 0 and idleTurningFrequency ~= 0 then
        idleTurnAngle = idleTurningAmplitude * math.sin(floatTime * 2 * math.pi * idleTurningFrequency)
    end

    if bp then
        bp.Position = Vector3.new(
            hrp.Position.X + currentVelocity.X * dt + forwardBackwardVec.X,
            smoothedY + forwardBackwardVec.Y,
            hrp.Position.Z + currentVelocity.Z * dt + forwardBackwardVec.Z
        )
    end

    local newPos = Vector3.new(hrp.Position.X, smoothedY, hrp.Position.Z)
    if bg then
        if isIdle then
            local rotAngles = Vector3.new(
                math.rad(appliedRotation.X),
                math.rad(appliedRotation.Y + idleTurnAngle),
                math.rad(appliedRotation.Z)
            )
            bg.CFrame = CFrame.new(newPos)
                * CFrame.Angles(0, lastYaw, 0)
                * CFrame.Angles(rotAngles.X, rotAngles.Y, rotAngles.Z)
                * CFrame.Angles(0, 0, math.rad(currentBankTilt + sideTilt))
                * CFrame.Angles(math.rad(combinedTilt), 0, 0)
        else
            bg.CFrame = CFrame.new(newPos)
                * CFrame.Angles(0, lastYaw, 0)
                * CFrame.Angles(0, 0, math.rad(currentBankTilt + sideTilt))
                * CFrame.Angles(math.rad(combinedTilt), 0, 0)
        end
    end
end)

player.CharacterRemoving:Connect(function()
    if G2L["1"] then
        G2L["1"]:Destroy()
    end
end)