Further enhance and add in lock-on system.

```
-- LocalScript: Player Tracking and ESP Tool
-- Place this script in StarterPlayer > StarterPlayerScripts

-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

-- Configuration Table
local CONFIG = {
    ROTATION = {
        Kp = 15,                 -- Proportional gain
        Ki = 5,                  -- Integral gain
        Kd = 3,                  -- Derivative gain
        MaxTorque = 50,          -- Maximum rotational force
        MinThreshold = 0.01      -- Minimum angle threshold to apply torque
    },
    ESP = {
        Text = "Targeted",
        Color = Color3.fromRGB(255, 0, 0),
        Size = UDim2.new(0, 100, 0, 50),
        Offset = Vector3.new(0, 2, 0)
    },
    TRACKING = {
        PredictionFactor = 0.3,  -- Seconds ahead to predict
        MaxDistance = 100,       -- Maximum distance to track a target
        RefreshInterval = 1      -- Seconds between target searches
    },
    DEBUG = {
        Enabled = true,
        Verbose = true
    }
}

-- Variables
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
local playerGui = player:WaitForChild("PlayerGui")

local trackedTarget = nil
local espIndicator = nil

-- PID Controller State
local pidState = {
    integral = 0,
    previousError = 0
}

-- External table to store Kalman data for each target
local kalmanData = {}

-- Debug Functions
local function debugLog(message, level)
    level = level or "INFO"
    if CONFIG.DEBUG.Enabled then
        if CONFIG.DEBUG.Verbose or level ~= "DEBUG" then
            print(string.format("[TrackerDebug][%s]: %s", level, message))
        end
    end
end

-- Helper Functions
local function hasHumanoid(model)
    return model and model:FindFirstChildOfClass("Humanoid") ~= nil
end

local function squaredDistance(pos1, pos2)
    local diff = pos1 - pos2
    return diff.X * diff.X + diff.Y * diff.Y + diff.Z * diff.Z
end

-- Advanced Prediction Function: Basic Kalman Filter Implementation
local function predictPosition(target)
    local hrp = target:FindFirstChild("HumanoidRootPart")
    local humanoid = target:FindFirstChildOfClass("Humanoid")
    
    if not hrp or not humanoid then
        debugLog("Target missing HumanoidRootPart or Humanoid.", "ERROR")
        return nil
    end

    -- Initialize Kalman data for the target if not already present
    if not kalmanData[target] then
        kalmanData[target] = {
            Position = hrp.Position,
            Velocity = Vector3.new(0, 0, 0),
            LastUpdate = tick()
        }
    end

    local data = kalmanData[target]
    local currentTick = tick()
    local timeElapsed = currentTick - data.LastUpdate

    if timeElapsed >= 1/60 then -- Update at ~60Hz
        local newVelocity = (hrp.Position - data.Position) / timeElapsed
        data.Velocity = newVelocity
        data.Position = hrp.Position
        data.LastUpdate = currentTick
    end

    -- Predict future position
    local predictedPos = hrp.Position + (data.Velocity * CONFIG.TRACKING.PredictionFactor)
    debugLog(string.format("Predicted Position for %s: %s", target.Parent.Name, tostring(predictedPos)), "DEBUG")
    return predictedPos
end

-- Target Finding Function with Refresh Interval
local function findClosestPlayer()
    local closestPlayer = nil
    local shortestDistanceSq = CONFIG.TRACKING.MaxDistance * CONFIG.TRACKING.MaxDistance

    for _, otherPlayer in ipairs(Players:GetPlayers()) do
        if otherPlayer ~= player and otherPlayer.Character and hasHumanoid(otherPlayer.Character) then
            local otherHRP = otherPlayer.Character:FindFirstChild("HumanoidRootPart")
            if otherHRP then
                local distanceSq = squaredDistance(otherHRP.Position, humanoidRootPart.Position)
                if distanceSq < shortestDistanceSq then
                    shortestDistanceSq = distanceSq
                    closestPlayer = otherPlayer
                end
            end
        end
    end

    if closestPlayer then
        debugLog("Closest player found: " .. closestPlayer.Name, "INFO")
    else
        debugLog("No players within tracking range.", "INFO")
    end

    return closestPlayer
end

-- ESP Management Functions
local function createESP(target)
    if not target or not target:FindFirstChild("Head") then
        debugLog("Cannot create ESP: Target does not have a Head.", "ERROR")
        return nil
    end

    -- Create BillboardGui
    local billboard = Instance.new("BillboardGui")
    billboard.Adornee = target.Head
    billboard.Size = CONFIG.ESP.Size
    billboard.StudsOffset = CONFIG.ESP.Offset
    billboard.AlwaysOnTop = true
    billboard.Name = "TargetESP"

    -- Create TextLabel
    local textLabel = Instance.new("TextLabel")
    textLabel.Parent = billboard
    textLabel.Size = UDim2.new(1, 0, 1, 0)
    textLabel.BackgroundTransparency = 1
    textLabel.Text = CONFIG.ESP.Text
    textLabel.TextColor3 = CONFIG.ESP.Color
    textLabel.Font = Enum.Font.SourceSansBold
    textLabel.TextScaled = true
    textLabel.TextStrokeTransparency = 0.8

    -- Parent to PlayerGui
    billboard.Parent = playerGui
    debugLog("ESP Indicator created for " .. target.Parent.Name, "DEBUG")

    return billboard
end

local function removeESP()
    if espIndicator then
        espIndicator:Destroy()
        espIndicator = nil
        debugLog("ESP Indicator removed.", "DEBUG")
    end
end

-- PID Controller Function
local function pidController(targetCFrame, deltaTime)
    -- Desired look vector
    local desiredLook = (targetCFrame.Position - humanoidRootPart.Position).Unit
    local currentLook = humanoidRootPart.CFrame.LookVector.Unit

    -- Calculate the angle between current and desired directions
    local dotProduct = math.clamp(currentLook:Dot(desiredLook), -1, 1) -- Ensure within acos range
    local angle = math.acos(dotProduct)

    -- Calculate the rotation direction
    local cross = currentLook:Cross(desiredLook)
    local rotationDirection = (cross.Y >= 0) and 1 or -1 -- Assuming Y-axis is up

    -- Error terms
    local error = angle
    pidState.integral = pidState.integral + error * deltaTime
    local derivative = (error - pidState.previousError) / deltaTime

    -- PID Output
    local output = (CONFIG.ROTATION.Kp * error) + (CONFIG.ROTATION.Ki * pidState.integral) + (CONFIG.ROTATION.Kd * derivative)
    output = math.clamp(output, 0, CONFIG.ROTATION.MaxTorque)

    -- Apply rotation if error is significant
    if error > CONFIG.ROTATION.MinThreshold then
        humanoidRootPart.CFrame = humanoidRootPart.CFrame * CFrame.Angles(0, rotationDirection * math.rad(output), 0)
        debugLog(string.format("Applying PID Output: %f", output), "DEBUG")
    end

    -- Update previous error
    pidState.previousError = error
end

-- Rotation and ESP Update Function
local function updateTracking(deltaTime)
    if not trackedTarget or not trackedTarget.Parent or not trackedTarget:FindFirstChild("HumanoidRootPart") then
        debugLog("Tracked target is invalid. Removing tracking.", "WARN")
        trackedTarget = nil
        removeESP()
        return
    end

    -- Predict target position
    local predictedPos = predictPosition(trackedTarget)
    if not predictedPos then
        debugLog("Failed to predict target position. Removing tracking.", "ERROR")
        trackedTarget = nil
        removeESP()
        return
    end

    -- Rotate towards predicted position using PID controller
    local targetCFrame = CFrame.new(humanoidRootPart.Position, predictedPos)
    pidController(targetCFrame, deltaTime)

    -- Update ESP
    if espIndicator and trackedTarget:FindFirstChild("Head") then
        espIndicator.Adornee = trackedTarget.Head
    else
        debugLog("Target lost Head. Removing ESP.", "WARN")
        removeESP()
        trackedTarget = nil
    end
end

-- Target Selection Toggle Function
local function toggleLockOn()
    if trackedTarget then
        -- Deselect current target
        debugLog("Deselecting target: " .. trackedTarget.Parent.Name, "INFO")
        trackedTarget = nil
        removeESP()
    else
        -- Find and select the closest target
        local closestPlayer = findClosestPlayer()
        if closestPlayer and closestPlayer.Character then
            trackedTarget = closestPlayer.Character
            espIndicator = createESP(trackedTarget)
            debugLog("Tracking target: " .. trackedTarget.Parent.Name, "INFO")
        else
            debugLog("No valid target found to track.", "INFO")
        end
    end
end

-- Event Connections
local inputConnection
local characterAddedConnection
local heartbeatConnection

-- Function to handle player removal
local function onPlayerRemoving(player)
    if player.Character and kalmanData[player.Character] then
        kalmanData[player.Character] = nil
        debugLog("Kalman data cleaned up for " .. player.Name, "DEBUG")
    end
end

-- Function to handle character removal
local function onCharacterRemoving(character)
    if kalmanData[character] then
        kalmanData[character] = nil
        debugLog("Kalman data cleaned up for character.", "DEBUG")
    end
end

-- Initialize Function
local function initialize()
    -- External table for kalman data is already initialized above

    -- Input Listener for E key
    inputConnection = UserInputService.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed then return end
        if input.KeyCode == Enum.KeyCode.E then
            toggleLockOn()
        end
    end)
    debugLog("Input connection established for toggleLockOn.", "DEBUG")

    -- Character Respawn Listener
    characterAddedConnection = player.CharacterAdded:Connect(function(newCharacter)
        character = newCharacter
        humanoidRootPart = character:WaitForChild("HumanoidRootPart")
        pidState = { integral = 0, previousError = 0 }
        trackedTarget = nil
        removeESP()
        debugLog("Character respawned. Resetting tracking.", "INFO")
    end)

    -- Heartbeat Listener for Smooth Updates
    heartbeatConnection = RunService.Heartbeat:Connect(function(deltaTime)
        if trackedTarget then
            updateTracking(deltaTime)
        end
    end)
    debugLog("Heartbeat connection established for tracking updates.", "DEBUG")

    -- Connect to PlayerRemoving
    Players.PlayerRemoving:Connect(onPlayerRemoving)

    -- Connect to existing players' character removal
    for _, p in ipairs(Players:GetPlayers()) do
        if p.Character then
            p.Character.AncestryChanged:Connect(function(_, parent)
                if not parent then
                    onCharacterRemoving(p.Character)
                end
            end)
        end
    end

    -- Connect to future players' character removal
    Players.PlayerAdded:Connect(function(p)
        p.CharacterAdded:Connect(function(c)
            c.AncestryChanged:Connect(function(_, parent)
                if not parent then
                    onCharacterRemoving(c)
                end
            end)
        end)
    end)
end

-- Cleanup Function
local function cleanup()
    if inputConnection then
        inputConnection:Disconnect()
        debugLog("Input connection disconnected.", "DEBUG")
    end
    if characterAddedConnection then
        characterAddedConnection:Disconnect()
        debugLog("CharacterAdded connection disconnected.", "DEBUG")
    end
    if heartbeatConnection then
        heartbeatConnection:Disconnect()
        debugLog("Heartbeat connection disconnected.", "DEBUG")
    end
    removeESP()
    -- Clear all Kalman data
    for k in pairs(kalmanData) do
        kalmanData[k] = nil
    end
    debugLog("Cleanup complete. All connections disconnected and resources freed.", "INFO")
end

-- Monitor Ancestry Changes for Cleanup
script.AncestryChanged:Connect(function(_, parent)
    if not parent then
        -- Script is being removed
        cleanup()
    end
end)

-- Initialize Script
initialize()
debugLog("Tracking script initialized successfully.", "INFO")
```

Reference script (REFERENCE ONLY):

```
--[[
    Enhanced Lock-On and ESP Script with GUI for Body Part Selection and Layered Tracking
    - Allows selection of specific humanoid body parts: Left Arm, Left Leg, Torso, Torso (Back), Head, Right Leg, Right Arm.
    - Implements a layered tracking method to prioritize and manage target selections based on Field of View (FOV) and distance.
    - Integrates a user-friendly and visually appealing GUI for real-time body part selection.
    - Maintains all previous functionalities including ShiftLock support, predictive algorithms, and hitbox detection.
--]]

-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local GuiService = game:GetService("GuiService")
local TweenService = game:GetService("TweenService")
local Workspace = game:GetService("Workspace")
local CurrentCamera = Workspace.CurrentCamera

-- Configuration
local DEBUG = true  -- Toggle debug logs
local ROTATION_SPEED = 25        -- Smooth rotation speed multiplier (reduced for smoother effect)
local ESP_TEXT_PREFIX = "Targeted: " -- Prefix Text displayed in ESP
local ESP_COLOR = Color3.fromRGB(0, 255, 0)  -- Color of the ESP text
local PREDICTION_TIME_BASE = 0.2 -- Base time in seconds to predict target movement (reduced for responsiveness)
local PREDICTION_TIME_ADJUSTMENT_FACTOR = 0.3 -- Factor to adjust prediction time based on velocity and distance
local VELOCITY_ALPHA = 0.8 -- Alpha value for Exponential Moving Average
local LOCK_ON_KEY = Enum.KeyCode.E -- Key to toggle lock-on
local SHIFT_LOCK_TOGGLE_KEY = Enum.KeyCode.LeftShift -- Key to toggle ShiftLock mode
local BACK_OFFSET = 3 -- Studs behind the target's torso to aim (reduced for accuracy)
local MAX_FOV_ANGLE = 60 -- Maximum angle (in degrees) for FOV-based target selection
local GUI_CONFIG = {
    ScreenGuiName = "EnhancedLockOnESPGUI",
    FrameSize = UDim2.new(0, 220, 0, 350),
    FramePosition = UDim2.new(0, 10, 0.5, -175),
    ButtonSize = UDim2.new(1, -20, 0, 35),
    BodyParts = {
        "Left Arm",
        "Left Leg",
        "Torso",
        "Torso (Back)",
        "Head",
        "Right Leg",
        "Right Arm"
    },
    SelectedColor = Color3.fromRGB(70, 130, 180), -- Steel Blue
    UnselectedColor = Color3.fromRGB(50, 50, 50),
    HoverColor = Color3.fromRGB(100, 100, 100),
    TextColor = Color3.fromRGB(255, 255, 255),
    BackgroundColor = Color3.fromRGB(30, 30, 30),
    StrokeColor = Color3.fromRGB(255, 255, 255)
}

-- Debug Function
local function debugLog(message)
    if DEBUG then
        print("[EnhancedLockOnScript]: " .. message)
    end
end

-- Variables
local player = Players.LocalPlayer
if not player then
    error("LocalPlayer not found!")
    return
end

local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
local trackedTarget = nil          -- Currently tracked target (another player)
local espIndicator = nil           -- BillboardGui for ESP
local shiftLockMode = false        -- ShiftLock mode toggle
local lockOnMode = false           -- Lock-On mode toggle
local velocityEMA = Vector3.new(0, 0, 0) -- Exponential Moving Average for target velocity
local selectedBodyPart = "Torso (Back)" -- Default selected body part

-- Determine Rig Type and set the torso part name
local isR15 = humanoid.RigType == Enum.HumanoidRigType.R15
local torsoPartName = isR15 and "UpperTorso" or "Torso"
debugLog("Rig type determined: " .. (isR15 and "R15" or "R6"))
debugLog("Torso part set to: " .. torsoPartName)

-- Mapping for R6 and R15 body parts
local bodyPartMappings = {
    ["Left Arm"] = isR15 and "LeftUpperArm" or "Left Arm",
    ["Left Leg"] = isR15 and "LeftUpperLeg" or "Left Leg",
    ["Torso"] = torsoPartName,
    ["Torso (Back)"] = torsoPartName, -- Special handling
    ["Head"] = "Head",
    ["Right Leg"] = isR15 and "RightUpperLeg" or "Right Leg",
    ["Right Arm"] = isR15 and "RightUpperArm" or "Right Arm"
}

-- Helper Function: Check if a model has a Humanoid
local function hasHumanoid(model)
    return model and model:FindFirstChildOfClass("Humanoid") ~= nil
end

-- Helper Function: Calculate angle between two vectors
local function calculateAngle(direction)
    local viewVector = CurrentCamera.CFrame.LookVector
    local directionUnit = direction.Unit
    local dotProduct = viewVector:Dot(directionUnit)
    local angle = math.acos(dotProduct) * (180 / math.pi)
    return angle
end

-- Helper Function: Find the best target based on FOV and distance
local function findBestTarget()
    local bestTarget = nil
    local shortestDistance = math.huge
    local bestAngle = MAX_FOV_ANGLE

    for _, otherPlayer in ipairs(Players:GetPlayers()) do
        if otherPlayer ~= player and otherPlayer.Character and hasHumanoid(otherPlayer.Character) then
            local targetPartName = bodyPartMappings[selectedBodyPart]
            local otherTorso = otherPlayer.Character:FindFirstChild(targetPartName)
            if otherTorso and otherTorso:IsA("BasePart") then
                local direction = otherTorso.Position - humanoidRootPart.Position
                local distance = direction.Magnitude
                local angle = calculateAngle(direction)
                
                if angle <= MAX_FOV_ANGLE and distance < shortestDistance then
                    shortestDistance = distance
                    bestTarget = otherPlayer
                    bestAngle = angle
                end
            end
        end
    end

    if bestTarget then
        debugLog(string.format("Best target found: %s | Distance: %.2f | Angle: %.2f", bestTarget.Name, shortestDistance, bestAngle))
    else
        debugLog("No suitable target found within FOV.")
    end

    return bestTarget
end

-- Function: Toggle Lock-On to the Best Target based on layered selection
local function toggleLockOn()
    if lockOnMode then
        -- Deselect the current target
        debugLog("Deselecting current target: " .. (trackedTarget and trackedTarget.Name or "None"))
        trackedTarget = nil
        lockOnMode = false
        if espIndicator then
            espIndicator:Destroy()
            espIndicator = nil
            debugLog("ESP indicator destroyed.")
        end
    else
        -- Find and select the best target
        local bestPlayer = findBestTarget()
        if bestPlayer and bestPlayer.Character then
            trackedTarget = bestPlayer.Character
            lockOnMode = true
            debugLog("Tracking new target: " .. bestPlayer.Name)
            -- Create ESP indicator
            local targetPartName = bodyPartMappings[selectedBodyPart]
            local targetPart = trackedTarget:FindFirstChild(targetPartName)
            if targetPart then
                -- Ensure previous ESP is removed
                if espIndicator then
                    espIndicator:Destroy()
                    espIndicator = nil
                    debugLog("Previous ESP indicator destroyed.")
                end

                -- Create BillboardGui for ESP
                espIndicator = Instance.new("BillboardGui")
                espIndicator.Adornee = targetPart
                espIndicator.Size = UDim2.new(0, 150, 0, 50)
                espIndicator.StudsOffset = Vector3.new(0, 2, 0)
                espIndicator.AlwaysOnTop = true
                espIndicator.Name = "TargetESP"

                -- Create TextLabel for ESP
                local textLabel = Instance.new("TextLabel")
                textLabel.Parent = espIndicator
                textLabel.Size = UDim2.new(1, 0, 1, 0)
                textLabel.BackgroundTransparency = 1
                textLabel.Text = ESP_TEXT_PREFIX .. trackedTarget.Name .. " (" .. selectedBodyPart .. ")"
                textLabel.TextColor3 = ESP_COLOR
                textLabel.Font = Enum.Font.SourceSansBold
                textLabel.TextScaled = true
                textLabel.TextStrokeTransparency = 0.8

                -- Parent the ESP to the player's PlayerGui
                local playerGui = player:WaitForChild("PlayerGui")
                espIndicator.Parent = playerGui
                debugLog("ESP indicator created for " .. bestPlayer.Name .. " targeting " .. selectedBodyPart)
            else
                debugLog("Selected body part '" .. targetPartName .. "' not found on " .. bestPlayer.Name)
                trackedTarget = nil
            end
        else
            debugLog("No valid target to track.")
        end
    end
end

-- Function: Predict Future Position Based on Target's Velocity using EMA
local function getPredictedPosition(targetCharacter)
    local targetPartName = bodyPartMappings[selectedBodyPart]
    local targetPart = targetCharacter:FindFirstChild(targetPartName)
    if not targetPart then
        debugLog("Target does not have the part: " .. targetPartName)
        return nil
    end

    -- Get current velocity
    local currentVelocity = targetPart.Velocity

    -- Update Exponential Moving Average (EMA) for velocity
    velocityEMA = (currentVelocity * VELOCITY_ALPHA) + (velocityEMA * (1 - VELOCITY_ALPHA))

    -- Calculate dynamic prediction time based on velocity magnitude and distance
    local distance = (targetPart.Position - humanoidRootPart.Position).Magnitude
    local velocityMagnitude = velocityEMA.Magnitude
    local predictionTime = PREDICTION_TIME_BASE + (velocityMagnitude * PREDICTION_TIME_ADJUSTMENT_FACTOR) + (distance * PREDICTION_TIME_ADJUSTMENT_FACTOR)
    predictionTime = math.clamp(predictionTime, 0.1, 0.5) -- Clamp prediction time between 0.1 and 0.5 seconds for responsiveness

    -- Calculate predicted position
    local futurePosition = targetPart.Position + (velocityEMA * predictionTime)
    debugLog(string.format("Predicted position: (%.2f, %.2f, %.2f); Prediction Time: %.2f", 
        futurePosition.X, futurePosition.Y, futurePosition.Z, predictionTime))

    -- Enhanced Handling for "Torso (Back)"
    if selectedBodyPart == "Torso (Back)" then
        local targetHumanoid = targetCharacter:FindFirstChildOfClass("Humanoid")
        if targetHumanoid then
            local rootPart = targetHumanoid.RootPart or targetCharacter:FindFirstChild("HumanoidRootPart") or targetCharacter:FindFirstChild("UpperTorso")
            if rootPart then
                futurePosition = futurePosition - (rootPart.CFrame.LookVector * BACK_OFFSET)
                debugLog("Calculated back position using LookVector.")
            else
                debugLog("Root part not found for back position calculation.")
            end
        end
    end

    debugLog(string.format("Final target position: (%.2f, %.2f, %.2f)", futurePosition.X, futurePosition.Y, futurePosition.Z))
    return futurePosition
end

-- Function: Instantly rotate to face the predicted target position
local function instantRotateToPosition(targetPosition)
    if not targetPosition then return end

    local desiredCFrame = CFrame.new(humanoidRootPart.Position, targetPosition)
    humanoidRootPart.CFrame = desiredCFrame
    debugLog("Instantly rotated to face target position.")
end

-- Function: Smoothly rotate to face the predicted target position
local function smoothRotateToPosition(targetPosition, deltaTime)
    if not targetPosition then return end

    local direction = (Vector3.new(targetPosition.X, humanoidRootPart.Position.Y, targetPosition.Z) - humanoidRootPart.Position).Unit
    local desiredCFrame = CFrame.new(humanoidRootPart.Position, humanoidRootPart.Position + direction)

    -- Smoothly interpolate the CFrame
    humanoidRootPart.CFrame = humanoidRootPart.CFrame:Lerp(desiredCFrame, ROTATION_SPEED * deltaTime)
    debugLog("Smoothly rotated to face target position.")
end

-- Function: Rotate to Target (Instant or Smooth based on toggle)
local function rotateToTarget(deltaTime)
    if not trackedTarget then return end

    local targetPartName = bodyPartMappings[selectedBodyPart]
    local targetPart = trackedTarget:FindFirstChild(targetPartName)
    if targetPart and targetPart:IsA("BasePart") then
        local predictedPosition = getPredictedPosition(trackedTarget)
        if predictedPosition then
            if shiftLockMode then
                instantRotateToPosition(predictedPosition)
            else
                smoothRotateToPosition(predictedPosition, deltaTime)
            end

            -- Hitbox Detection: Ensure predicted position is within part bounds
            local partSize = targetPart.Size
            local partPosition = targetPart.Position
            local deltaPosition = predictedPosition - partPosition

            local withinX = math.abs(deltaPosition.X) <= (partSize.X / 2 + (selectedBodyPart == "Torso (Back)" and BACK_OFFSET or 0))
            local withinY = math.abs(deltaPosition.Y) <= (partSize.Y / 2)
            local withinZ = math.abs(deltaPosition.Z) <= (partSize.Z / 2 + (selectedBodyPart == "Torso (Back)" and BACK_OFFSET or 0))

            if withinX and withinY and withinZ then
                debugLog("Predicted position is within the part's hitbox.")
            else
                debugLog("Predicted position is outside the part's hitbox.")
            end
        else
            debugLog("Failed to get predicted target position.")
        end
    else
        debugLog("Target part '" .. targetPartName .. "' is invalid or missing.")
    end
end

-- Function: Handle ShiftLock Toggle
local function toggleShiftLock()
    if shiftLockMode then
        -- Disable ShiftLock Mode
        shiftLockMode = false
        CurrentCamera.CameraType = Enum.CameraType.Custom
        debugLog("ShiftLock mode disabled.")
    else
        if lockOnMode then
            -- Disable Lock-On before enabling ShiftLock to prevent conflicts
            toggleLockOn()
        end
        -- Enable ShiftLock Mode
        shiftLockMode = true
        CurrentCamera.CameraType = Enum.CameraType.Scriptable
        -- Lock the camera to look at the target
        if trackedTarget then
            local targetPartName = bodyPartMappings[selectedBodyPart]
            local targetPart = trackedTarget:FindFirstChild(targetPartName)
            if targetPart then
                local predictedPosition = getPredictedPosition(trackedTarget)
                CurrentCamera.CFrame = CFrame.new(humanoidRootPart.Position, predictedPosition)
                debugLog("ShiftLock mode enabled and camera locked onto target.")
            end
        end
    end
end

-- Function: Clean up ESP when the tracked target dies or leaves
local function onTrackedTargetRemoved()
    if not trackedTarget then return end
    debugLog("Tracked target removed or died: " .. (trackedTarget.Name or "Unknown"))
    trackedTarget = nil
    lockOnMode = false
    if espIndicator then
        espIndicator:Destroy()
        espIndicator = nil
        debugLog("ESP indicator destroyed due to target removal.")
    end
    velocityEMA = Vector3.new(0, 0, 0) -- Reset velocity EMA
    -- Reset camera if ShiftLock was active
    if shiftLockMode then
        toggleShiftLock()
    end
end

-- Function: Monitor Tracked Target for Removal or Death
local function monitorTrackedTarget(targetCharacter)
    if not targetCharacter then return end

    local humanoid = targetCharacter:FindFirstChildOfClass("Humanoid")
    if humanoid then
        humanoid.Died:Connect(function()
            debugLog("Tracked target " .. (targetCharacter.Name or "Unknown") .. " has died.")
            onTrackedTargetRemoved()
        end)
    end

    targetCharacter.AncestryChanged:Connect(function()
        if not targetCharacter:IsDescendantOf(game) then
            debugLog("Tracked target " .. (targetCharacter.Name or "Unknown") .. " has left the game.")
            onTrackedTargetRemoved()
        end
    end)
end

-- Modify toggleLockOn to monitor the tracked target
local originalToggleLockOn = toggleLockOn
toggleLockOn = function()
    originalToggleLockOn()
    if trackedTarget then
        monitorTrackedTarget(trackedTarget)
    end
end

-- Function: Handle Character Respawn
player.CharacterAdded:Connect(function(newCharacter)
    debugLog("Character respawned.")
    character = newCharacter
    humanoid = character:WaitForChild("Humanoid")
    humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    
    -- Determine rig type using RigType property
    isR15 = humanoid.RigType == Enum.HumanoidRigType.R15
    torsoPartName = isR15 and "UpperTorso" or "Torso"
    debugLog("New rig type determined: " .. (isR15 and "R15" or "R6"))
    
    -- Reset tracking and ESP on respawn
    onTrackedTargetRemoved()
end)

-- Function: Update Camera during ShiftLock Mode
local function updateCamera(deltaTime)
    if shiftLockMode and trackedTarget then
        local targetPartName = bodyPartMappings[selectedBodyPart]
        local targetPart = trackedTarget:FindFirstChild(targetPartName)
        if targetPart then
            -- Smoothly move the camera to follow the target
            local predictedPosition = getPredictedPosition(trackedTarget)
            if predictedPosition then
                local desiredCFrame = CFrame.new(humanoidRootPart.Position, predictedPosition)
                CurrentCamera.CFrame = CurrentCamera.CFrame:lerp(desiredCFrame, ROTATION_SPEED * deltaTime)
                debugLog("Camera updated to follow target in ShiftLock mode.")
            end
        end
    end
end

-- Function: Create and Setup the Body Part Selection GUI with Enhanced Aesthetics
local function createBodyPartSelectionGUI()
    -- Check if the GUI already exists to prevent duplication
    if player.PlayerGui:FindFirstChild(GUI_CONFIG.ScreenGuiName) then
        debugLog("GUI already exists. Skipping creation.")
        return
    end

    -- Create ScreenGui
    local screenGui = Instance.new("ScreenGui")
    screenGui.Name = GUI_CONFIG.ScreenGuiName
    screenGui.Parent = player.PlayerGui
    screenGui.ResetOnSpawn = false

    -- Create Background Frame
    local frame = Instance.new("Frame")
    frame.Size = GUI_CONFIG.FrameSize
    frame.Position = GUI_CONFIG.FramePosition
    frame.BackgroundColor3 = GUI_CONFIG.BackgroundColor
    frame.BackgroundTransparency = 0.8
    frame.BorderSizePixel = 0
    frame.Parent = screenGui

    -- Add UIStroke for Frame
    local frameStroke = Instance.new("UIStroke")
    frameStroke.Color = GUI_CONFIG.StrokeColor
    frameStroke.Thickness = 2
    frameStroke.Parent = frame

    -- Create Title
    local title = Instance.new("TextLabel")
    title.Size = UDim2.new(1, 0, 0, 40)
    title.Position = UDim2.new(0, 0, 0, 0)
    title.BackgroundTransparency = 1
    title.Text = "Lock-On ESP"
    title.Font = Enum.Font.GothamBold
    title.TextSize = 24
    title.TextColor3 = GUI_CONFIG.TextColor
    title.TextStrokeTransparency = 0.5
    title.TextXAlignment = Enum.TextXAlignment.Center
    title.Parent = frame

    -- Create UIListLayout for organized buttons
    local uiListLayout = Instance.new("UIListLayout")
    uiListLayout.Parent = frame
    uiListLayout.FillDirection = Enum.FillDirection.Vertical
    uiListLayout.SortOrder = Enum.SortOrder.LayoutOrder
    uiListLayout.Padding = UDim.new(0, 10)
    uiListLayout.VerticalAlignment = Enum.VerticalAlignment.Top

    -- Create UIListLayoutPadding to position buttons below the title
    local layoutPadding = Instance.new("UIPadding")
    layoutPadding.PaddingTop = UDim.new(0, 50)
    layoutPadding.Parent = frame

    -- Function to handle body part selection
    local function selectBodyPart(bodyPart, button)
        selectedBodyPart = bodyPart
        debugLog("Selected body part: " .. bodyPart)
        toggleLockOn() -- Deselect current target

        -- Update ESP text if a target is already locked on
        if lockOnMode and espIndicator then
            espIndicator:Destroy()
            espIndicator = nil
            debugLog("ESP indicator destroyed due to body part change.")
            toggleLockOn() -- Re-select target with new body part
        end

        -- Update button colors to indicate selection
        for _, btn in ipairs(frame:GetChildren()) do
            if btn:IsA("TextButton") then
                btn.BackgroundColor3 = GUI_CONFIG.UnselectedColor
            end
        end
        button.BackgroundColor3 = GUI_CONFIG.SelectedColor
    end

    -- Create Buttons for each Body Part with Enhanced Aesthetics
    for _, bodyPart in ipairs(GUI_CONFIG.BodyParts) do
        local button = Instance.new("TextButton")
        button.Size = GUI_CONFIG.ButtonSize
        button.Text = bodyPart
        button.Font = Enum.Font.Gotham
        button.TextSize = 18
        button.TextColor3 = GUI_CONFIG.TextColor
        button.BackgroundColor3 = (bodyPart == selectedBodyPart) and GUI_CONFIG.SelectedColor or GUI_CONFIG.UnselectedColor
        button.AutoButtonColor = false
        button.BorderSizePixel = 0
        button.Parent = frame

        -- Add UIStroke for Buttons
        local buttonStroke = Instance.new("UIStroke")
        buttonStroke.Color = GUI_CONFIG.StrokeColor
        buttonStroke.Thickness = 1
        buttonStroke.Parent = button

        -- Hover Effects
        button.MouseEnter:Connect(function()
            if bodyPart ~= selectedBodyPart then
                button.BackgroundColor3 = GUI_CONFIG.HoverColor
            end
        end)

        button.MouseLeave:Connect(function()
            if bodyPart ~= selectedBodyPart then
                button.BackgroundColor3 = GUI_CONFIG.UnselectedColor
            end
        end)

        button.MouseButton1Click:Connect(function()
            selectBodyPart(bodyPart, button)
        end)
    end

    debugLog("Enhanced Body Part Selection GUI created.")
end

-- Call the function to create the GUI
createBodyPartSelectionGUI()

-- Function: Setup ShiftLock and Lock-On Toggles
local function setupShiftLockToggle()
    UserInputService.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed then return end

        if input.KeyCode == LOCK_ON_KEY then
            toggleLockOn()
        elseif input.KeyCode == SHIFT_LOCK_TOGGLE_KEY then
            toggleShiftLock()
        end
    end)
end

-- Event Listeners

-- Setup ShiftLock and Lock-On Toggles
setupShiftLockToggle()

-- Render Step: Continuously update rotation and camera if a target is tracked
RunService.RenderStepped:Connect(function(deltaTime)
    if lockOnMode and trackedTarget then
        pcall(function()
            rotateToTarget(deltaTime)
            updateCamera(deltaTime)
        end)
    end
end)