Astral Lock MODIFIED

local library = loadstring(game:HttpGet("https://raw.githubusercontent.com/bobbbb-b/nyulabutlowbudget/main/Lib%20(1).txt"))()

-- Gui to Lua
-- Version: 3.2

-- Instances:

local ScreenGui = Instance.new("ScreenGui")
local Frame = Instance.new("Frame")
local TextButton = Instance.new("TextButton")
local UITextSizeConstraint = Instance.new("UITextSizeConstraint")

--Properties:

ScreenGui.Parent = game.Players.LocalPlayer:WaitForChild("PlayerGui")
ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
ScreenGui.ResetOnSpawn = false

Frame.Parent = ScreenGui
Frame.BackgroundColor3 = Color3.fromRGB(48, 113, 169)
Frame.BackgroundTransparency = 0
Frame.Position = UDim2.new(1, -120, 0, 0)
Frame.Size = UDim2.new(0, 100, 0, 50)

TextButton.Parent = Frame
TextButton.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
TextButton.BackgroundTransparency = 1.000
TextButton.Size = UDim2.new(1, 0, 1, 0)
TextButton.Font = Enum.Font.SourceSans
TextButton.Text = "Astral"
TextButton.TextColor3 = Color3.fromRGB(0, 0, 0)
TextButton.TextScaled = true
TextButton.TextSize = 30
TextButton.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)
TextButton.TextStrokeTransparency = 0.000
TextButton.TextWrapped = true
TextButton.MouseButton1Down:Connect(function()
library:ToggleMenu()
end)

UITextSizeConstraint.Parent = TextButton
UITextSizeConstraint.MaxTextSize = 30

local player = game.Players.LocalPlayer

local hitsounds = {
    {name = "bell.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/bell.wav?raw=true"},
    {name = "bepis.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/bepis.wav?raw=true"},
    {name = "bubble.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/bubble.wav?raw=true"},
    {name = "cock.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/cock.wav?raw=true"},
    {name = "cod.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/cod.wav?raw=true"},
    {name = "fatality.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/fatality.wav?raw=true"},
    {name = "phonk.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/phonk.wav?raw=true"},
    {name = "sparkle.wav", url = "https://github.com/nyulachan/nyula/blob/main/Sounds/sparkle.wav?raw=true"}
}

if not isfolder("hitsounds") then
    makefolder("hitsounds")
end

for _, sound in pairs(hitsounds) do
    local path = "hitsounds" .. "/" .. sound.name
    if not isfile(path) then
        writefile(path, game:HttpGet(sound.url))
    end
end

local woah = library:New("Astral.lua")
local misc = woah:Tab("Combat")
local gaey = woah:Tab("Mods")
local visu = woah:Tab("Visualization")
local braeuh = woah:Tab("Configs")

local Haka = gaey:MSector("Mods", "Left")
local Lalaka = Haka:Tab("Local")
local Halaka = Haka:Tab("Anti")
local Galala = Haka:Tab("CSync")
local Bakala = Haka:Tab("Fun")

-- Add Target Filter feature to the Mods tab
local TargetFilterTab = Haka:Tab("Target Filter")

TargetFilterTab:Element("Dropdown", "Target Type", {options = {"Both", "Players Only", "NPCs Only"}, default = "Both"}, function(tbll)
    getgenv().TargetFilter = tbll.Dropdown
    if tbll.Dropdown == "Both" then
        game.StarterGui:SetCore("SendNotification", {
            Title = "Astral.lua",
            Text = "Target Filter: Both Players and NPCs",
            Duration = 3
        })
    elseif tbll.Dropdown == "Players Only" then
        game.StarterGui:SetCore("SendNotification", {
            Title = "Astral.lua",
            Text = "Target Filter: Players Only",
            Duration = 3
        })
    else
        game.StarterGui:SetCore("SendNotification", {
            Title = "Astral.lua",
            Text = "Target Filter: NPCs Only",
            Duration = 3
        })
    end
end)

-- Add Wall Check feature to the Mods tab
local WallCheckTab = Haka:Tab("Wall Check")

WallCheckTab:Element("Toggle", "Enable Wall Check", {default = false}, function(tbll)
    getgenv().WallCheck = tbll.Toggle
    if tbll.Toggle then
        game.StarterGui:SetCore("SendNotification", {
            Title = "Astral.lua",
            Text = "Wall Check: Enabled - Only targets outside walls",
            Duration = 3
        })
    else
        game.StarterGui:SetCore("SendNotification", {
            Title = "Astral.lua",
            Text = "Wall Check: Disabled",
            Duration = 3
        })
    end
end)

-- Add Random Target on Death feature to the Mods tab
local RandomTargetTab = Haka:Tab("Random Target")

RandomTargetTab:Element("Button", "Enable Random Target on Death", {}, function()
    getgenv().RandomTargetOnDeath = true
    game.StarterGui:SetCore("SendNotification", {
        Title = "Astral.lua",
        Text = "Random Target on Death: Enabled",
        Duration = 3
    })
end)

RandomTargetTab:Element("Button", "Disable Random Target on Death", {}, function()
    getgenv().RandomTargetOnDeath = false
    game.StarterGui:SetCore("SendNotification", {
        Title = "Astral.lua",
        Text = "Random Target on Death: Disabled",
        Duration = 3
    })
end)

Lalaka:Element("Button", "CFrame Speed", {}, function() 
getgenv().Speed = false
getgenv().SpeedAmount = 2
local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Parent = game.Players.LocalPlayer:WaitForChild("PlayerGui")
ScreenGui.ResetOnSpawn = false

local ToggleButton = Instance.new("TextButton")
ToggleButton.Text = "Toggle Speed"
ToggleButton.Parent = ScreenGui
ToggleButton.BackgroundTransparency = 0.5
ToggleButton.BorderSizePixel = 0
ToggleButton.Position = UDim2.new(1, -120, 0, 55)
ToggleButton.Size = UDim2.new(0, 100, 0, 18)
ToggleButton.BackgroundColor3 = Color3.fromRGB(48, 113, 169)
ToggleButton.TextColor3 = Color3.fromRGB(255, 255, 255)

local UICorner = Instance.new("UICorner")
UICorner.Parent = ToggleButton

local function onButtonClicked()
    getgenv().Speed = not getgenv().Speed
end

ToggleButton.MouseButton1Click:Connect(onButtonClicked)

game:GetService("RunService").Stepped:Connect(function()
    if getgenv().Speed then
        local lPlr = game:GetService("Players").LocalPlayer
        if lPlr.Character and lPlr.Character:FindFirstChild("HumanoidRootPart") then
            lPlr.Character.HumanoidRootPart.CFrame = lPlr.Character.HumanoidRootPart.CFrame + lPlr.Character.Humanoid.MoveDirection * getgenv().SpeedAmount
        end
    end
end)
end)

Lalaka:Element("TextBox", "SpeedaAmount", {placeholder = "Prediction"})

Lalaka:Element("Button", "Save", {}, function() 
getgenv().SpeedAmount = values.Haka.Lalaka.SpeedaAmount.Text
end)

--// TARGET LOCK

local Jaja = misc:MSector("Target Lock", "Left")
local GAGEJ = Jaja:Tab("Main")

-- Create the tool once and store it globally
local AstralLockTool = Instance.new("Tool")
AstralLockTool.RequiresHandle = false
AstralLockTool.Name = "Astral Lock"

-- Function to give the tool to the player
local function giveToolToPlayer()
    local backpack = player:FindFirstChild("Backpack")
    if backpack then
        AstralLockTool.Parent = backpack
    else
        player.CharacterAdded:Connect(function(character)
            wait(1)
            AstralLockTool.Parent = player:WaitForChild("Backpack")
        end)
    end
end

-- Give tool when script starts
giveToolToPlayer()

-- Also give tool when player respawns
player.CharacterAdded:Connect(function(character)
    wait(1)
    giveToolToPlayer()
end)

GAGEJ:Element("Button", "Load Target", {}, function() 
getgenv().Settings = {
    NyulaRemake = {
        Enabled = true,
        PREDICTION = 0.085, -- Lowered prediction
        JUMPPREDICTION = 0.09, -- Lowered jump prediction
        DOT = true,
        AIRSHOT = false,
        NOTIF = true,
        AUTOPRED = false,
        FOV = math.huge,
        RESOLVER = false,
        LOCKTYPE = "Index",
        DAMAGE_TEXT = true,
        RANDOM_TARGET_ON_DEATH = false, -- New setting
        Resolver = {
              Enabled = false,
              Type = "None",
        },
        OnHit = {
             Enabled = false,
             Hitchams = {
                   Enabled = false,
                   Color = Color3.fromRGB(255,255,255),
             },
            Hitsounds = {
                  Enabled = false,
                  Sound = "hitsounds/sparkle.wav",
            },
        }
    }
}

-- Initialize target filter if not set
if getgenv().TargetFilter == nil then
    getgenv().TargetFilter = "Both"
end

local SelectedPart = "HumanoidRootPart"
local Prediction = true

    local AnchorCount = 0
    local MaxAnchor = 50
 
    local CC = game:GetService"Workspace".CurrentCamera
    local Plr;
    local enabled = false
    local targetName = nil
    local targetType = nil
    local respawnConnection = nil
    local healthConnection = nil -- Store health connection for respawn
    local lastNoTargetNotification = 0 -- Track when we last showed "no target" notification
    local notificationCooldown = 5 -- Cooldown in seconds between "no target" notifications
    
    -- Mobile-compatible input detection
    local inputService = game:GetService("UserInputService")
    local touchInput = nil
    local mousePos = Vector2.new(0, 0)
    
    -- Handle different input methods
    if inputService.MouseEnabled then
        -- Mouse input
        local mouse = game.Players.LocalPlayer:GetMouse()
        mousePos = Vector2.new(mouse.X, mouse.Y)
        
        game:GetService("RunService").RenderStepped:Connect(function()
            mousePos = Vector2.new(mouse.X, mouse.Y)
        end)
    elseif inputService.TouchEnabled then
        -- Touch input for mobile
        inputService.TouchStarted:Connect(function(touch, processed)
            if not processed then
                mousePos = Vector2.new(touch.Position.X, touch.Position.Y)
            end
        end)
        
        inputService.TouchMoved:Connect(function(touch, processed)
            if not processed then
                mousePos = Vector2.new(touch.Position.X, touch.Position.Y)
            end
        end)
    end
    
    local placemarker = Instance.new("Part", game.Workspace)
    
    -- Function to check if target is visible (not behind wall)
    local function isTargetVisible(target)
        if not getgenv().WallCheck then
            return true -- If wall check is disabled, always return true
        end
        
        if not target or not target.Character then
            return false
        end
        
        local targetRoot = target.Character:FindFirstChild("HumanoidRootPart")
        if not targetRoot then
            return false
        end
        
        local localPlayer = game.Players.LocalPlayer
        local localCharacter = localPlayer.Character
        if not localCharacter then
            return false
        end
        
        local localRoot = localCharacter:FindFirstChild("HumanoidRootPart")
        if not localRoot then
            return false
        end
        
        -- Raycast from camera to target
        local camera = game.Workspace.CurrentCamera
        local origin = camera.CFrame.Position
        local targetPosition = targetRoot.Position
        local direction = (targetPosition - origin).Unit
        local distance = (targetPosition - origin).Magnitude
        
        -- Create raycast parameters
        local raycastParams = RaycastParams.new()
        raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
        raycastParams.FilterDescendantsInstances = {localCharacter, target.Character}
        
        -- Perform raycast
        local raycastResult = game.Workspace:Raycast(origin, direction * distance, raycastParams)
        
        -- If we hit something, target is behind a wall
        if raycastResult then
            return false
        end
        
        return true
    end
    
    -- Function to get a random player with wall check and target filter
    local function getRandomPlayer()
        local players = {}
        
        -- Add players based on target filter
        if getgenv().TargetFilter == "Both" or getgenv().TargetFilter == "Players Only" then
            for i, v in pairs(game.Players:GetPlayers()) do
                if v ~= game.Players.LocalPlayer and v.Character and v.Character:FindFirstChild("Humanoid") and v.Character.Humanoid.Health > 0 then
                    -- Wall check
                    if isTargetVisible(v) then
                        table.insert(players, v)
                    end
                end
            end
        end
        
        -- Add NPCs based on target filter
        if getgenv().TargetFilter == "Both" or getgenv().TargetFilter == "NPCs Only" then
            for i, v in pairs(workspace:GetChildren()) do
                if v:FindFirstChild("Humanoid") and v:FindFirstChild("HumanoidRootPart") and v.Humanoid.Health > 0 then
                    local isPlayerCharacter = false
                    for _, player in pairs(game.Players:GetPlayers()) do
                        if player.Character == v then
                            isPlayerCharacter = true
                            break
                        end
                    end
                    
                    if not isPlayerCharacter then
                        -- Wall check for NPCs
                        if isTargetVisible({Character = v}) then
                            table.insert(players, {Character = v})
                        end
                    end
                end
            end
        end
        
        if #players > 0 then
            return players[math.random(1, #players)]
        else
            return nil
        end
    end
    
    -- Function to create damage text (smaller version with no background box)
    local function createDamageText(target, damage, position)
        if not getgenv().Settings.NyulaRemake.DAMAGE_TEXT then return end
        
        local damageGui = Instance.new("BillboardGui")
        damageGui.Adornee = target.Character.HumanoidRootPart
        damageGui.Size = UDim2.new(0, 60, 0, 20) -- Smaller size
        damageGui.StudsOffset = Vector3.new(0, 2, 0) -- Lower offset
        damageGui.AlwaysOnTop = true
        damageGui.MaxDistance = 80 -- Shorter view distance
        damageGui.Parent = target.Character.HumanoidRootPart
        
        local textLabel = Instance.new("TextLabel")
        textLabel.Size = UDim2.new(1, 0, 1, 0)
        textLabel.BackgroundTransparency = 1 -- Completely transparent background (no box)
        textLabel.Text = "-" .. math.floor(damage)
        textLabel.TextColor3 = Color3.fromRGB(255, 50, 50)
        textLabel.TextScaled = true
        textLabel.Font = Enum.Font.GothamBold
        textLabel.TextSize = 12 -- Smaller initial text size
        textLabel.TextStrokeTransparency = 0
        textLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
        textLabel.Parent = damageGui
        
        -- Animate the damage text
        local startTime = tick()
        local duration = 0.8 -- Slightly shorter duration
        
        local connection
        connection = game:GetService("RunService").Heartbeat:Connect(function()
            local elapsed = tick() - startTime
            if elapsed > duration then
                connection:Disconnect()
                damageGui:Destroy()
                return
            end
            
            -- Move upward and fade out
            local progress = elapsed / duration
            damageGui.StudsOffset = Vector3.new(0, 2 + (progress * 3), 0) -- Less movement
            textLabel.TextTransparency = progress
            textLabel.TextStrokeTransparency = progress
            
            -- Make text even smaller as it fades
            textLabel.TextSize = 10 - (progress * 8) -- Smaller scaling
        end)
    end

    -- Function to setup health monitoring for damage text with respawn support
    local function setupHealthMonitoring(target)
        if healthConnection then
            healthConnection:Disconnect()
            healthConnection = nil
        end
        
        -- Function to actually set up the health monitoring for a character
        local function setupForCharacter(character)
            local hum = character:FindFirstChild("Humanoid")
            if hum then
                local oldHealth = hum.Health
                
                healthConnection = hum.HealthChanged:Connect(function(newHealth)
                    if newHealth < oldHealth then
                        local damage = oldHealth - newHealth
                        
                        -- Show damage text
                        createDamageText(target, damage, character.HumanoidRootPart.Position)
                        
                        if getgenv().Settings.NyulaRemake.OnHit.Hitsounds.Enabled then
                            local las = Instance.new("Sound")
                            las.Name = "a"
                            las.Volume = 1
                            las.SoundId = getcustomasset(getgenv().Settings.NyulaRemake.OnHit.Hitsounds.Sound)
                            las.Parent = game:GetService("SoundService")
                            las.Playing = true
                        end
                        
                        if getgenv().Settings.NyulaRemake.OnHit.Hitchams.Enabled then
                            -- hitchams(target) -- This function needs to be defined
                        end
                        
                        oldHealth = newHealth
                    elseif newHealth > oldHealth then
                        -- Health increased (healing), update old health
                        oldHealth = newHealth
                    end
                end)
            end
        end
        
        -- Set up for current character if it exists
        if target.Character then
            setupForCharacter(target.Character)
        end
        
        -- Also set up for when the character respawns
        if target.CharacterAdded then
            target.CharacterAdded:Connect(function(character)
                wait(1) -- Wait a moment for the character to fully load
                if enabled and target == Plr then -- Only setup if still targeting this player
                    setupForCharacter(character)
                end
            end)
        end
    end
 
    function makemarker(Parent, Adornee, Color, Size, Size2)
        local e = Instance.new("BillboardGui", Parent)
        e.Name = "PP"
        e.Adornee = Adornee
        e.Size = UDim2.new(Size, Size2, Size, Size2)
        e.AlwaysOnTop = getgenv().Settings.NyulaRemake.DOT
        local a = Instance.new("Frame", e)
        if getgenv().Settings.NyulaRemake.DOT == true then
        a.Size = UDim2.new(1, 1, 1, 1)
        else
        a.Size = UDim2.new(0, 0, 0, 0)
        end
        if getgenv().Settings.NyulaRemake.DOT == true then
        a.Transparency = 0
        a.BackgroundTransparency = 0
        else
        a.Transparency = 1
        a.BackgroundTransparency = 1
        end
        a.BackgroundColor3 = Color
        local g = Instance.new("UICorner", a)
        if getgenv().Settings.NyulaRemake.DOT == false then
        g.CornerRadius = UDim.new(1, 1)
        else
        g.CornerRadius = UDim.new(1, 1) 
        end
        return(e)
    end
 
    local function findTargetByName(name, targetType)
        if targetType == "player" then
            for i, v in pairs(game.Players:GetPlayers()) do
                if v.Name == name and v.Character and v.Character:FindFirstChild("Humanoid") and v.Character.Humanoid.Health > 0 then
                    return v
                end
            end
        elseif targetType == "npc" then
            for i, v in pairs(workspace:GetChildren()) do
                if v.Name == name and v:FindFirstChild("Humanoid") and v:FindFirstChild("HumanoidRootPart") and v.Humanoid.Health > 0 then
                    return {Character = v}
                end
            end
        end
        return nil
    end
 
    local function monitorRespawn()
        if respawnConnection then
            respawnConnection:Disconnect()
            respawnConnection = nil
        end
        
        local lastNoTargetTime = 0 -- Track when we last showed "no target" notification
        
        respawnConnection = game:GetService("RunService").Heartbeat:Connect(function()
            if enabled and targetName and (not Plr or not Plr.Character or not Plr.Character:FindFirstChild("Humanoid") or Plr.Character.Humanoid.Health <= 0) then
                -- Check if random target on death is enabled
                if getgenv().RandomTargetOnDeath then
                    local randomTarget = getRandomPlayer()
                    if randomTarget then
                        Plr = randomTarget
                        if Plr.Character then
                            targetName = Plr.Character.Name
                            if game.Players:GetPlayerFromCharacter(Plr.Character) then
                                targetType = "player"
                            else
                                targetType = "npc"
                            end
                            -- Re-setup health monitoring for the new random target
                            setupHealthMonitoring(Plr)
                            
                            if getgenv().Settings.NyulaRemake.NOTIF then
                                game.StarterGui:SetCore("SendNotification", {
                                    Title = "Astral.lua",
                                    Text = "Random target selected: "..targetName,
                                    Duration = 3
                                })
                            end
                        end
                    else
                        -- Only show notification if enough time has passed since last one
                        local currentTime = tick()
                        if currentTime - lastNoTargetTime > notificationCooldown then
                            if getgenv().Settings.NyulaRemake.NOTIF then
                                game.StarterGui:SetCore("SendNotification", {
                                    Title = "Astral.lua",
                                    Text = "No valid targets found for random selection",
                                    Duration = 3
                                })
                            end
                            lastNoTargetTime = currentTime
                        end
                    end
                else
                    -- Original behavior: wait for same target to respawn
                    local newTarget = findTargetByName(targetName, targetType)
                    if newTarget then
                        Plr = newTarget
                        -- Re-setup health monitoring for the respawned target
                        setupHealthMonitoring(Plr)
                        
                        if getgenv().Settings.NyulaRemake.NOTIF then
                            game.StarterGui:SetCore("SendNotification", {
                                Title = "Astral.lua",
                                Text = "Target respawned: "..targetName,
                                Duration = 3
                            })
                        end
                    end
                end
            end
        end)
    end
 
    local data = game.Players:GetPlayers()
    function noob(player)
        local character
        repeat wait() until player.Character
        local handler = makemarker(guimain, player.Character:WaitForChild(SelectedPart), Color3.fromRGB(107, 184, 255), 0.3, 3)
        handler.Name = player.Name
        player.CharacterAdded:connect(function(Char) handler.Adornee = Char:WaitForChild(SelectedPart) end)
 
        spawn(function()
            while wait() do
                if player.Character then
                end
            end
        end)
    end
 
    for i = 1, #data do
        if data[i] ~= game.Players.LocalPlayer then
            noob(data[i])
        end
    end
 
    game.Players.PlayerAdded:connect(function(Player)
        noob(Player)
    end)
 
    spawn(function()
        placemarker.Anchored = true
        placemarker.CanCollide = false
        if getgenv().Settings.NyulaRemake.DOT == true then
        placemarker.Size = Vector3.new(0, 0, 0)
        else
        placemarker.Size = Vector3.new(0, 0, 0)
        end
        placemarker.Transparency = 0.75
        if getgenv().Settings.NyulaRemake.DOT then
        makemarker(placemarker, placemarker, Color3.fromRGB(48, 113, 169), 1, 0)
        end
    end)

    -- Connect the tool activation to the global tool
    AstralLockTool.Activated:Connect(function()
        if getgenv().Settings.NyulaRemake.Enabled then
            if enabled == true then
                enabled = false
                targetName = nil
                targetType = nil
                if respawnConnection then
                    respawnConnection:Disconnect()
                    respawnConnection = nil
                end
                if healthConnection then
                    healthConnection:Disconnect()
                    healthConnection = nil
                end
                if getgenv().Settings.NyulaRemake.NOTIF == true then
                    game.StarterGui:SetCore("SendNotification", {
                        Title = "Astral.lua";
                        Text = "Unlocked",
                        Duration = 5
                    })
                end
            else
                Plr = getClosestPlayerToCursor()
                if Plr then
                    enabled = true
                    if Plr.Character then
                        targetName = Plr.Character.Name
                        if game.Players:GetPlayerFromCharacter(Plr.Character) then
                            targetType = "player"
                            -- Setup health monitoring for damage text with respawn support
                            setupHealthMonitoring(Plr)
                        else
                            targetType = "npc"
                            -- For NPCs, just setup initial health monitoring
                            setupHealthMonitoring(Plr)
                        end
                        monitorRespawn()
                    end
                    
                    if getgenv().Settings.NyulaRemake.NOTIF == true then
                        game.StarterGui:SetCore("SendNotification", {
                            Title = "Astral.lua";
                            Text = "Target: "..tostring(Plr.Character.Humanoid.DisplayName or Plr.Character.Name),
                            Duration = 5
                        })
                    end
                else
                    -- Only show "no target found" notification if enough time has passed
                    local currentTime = tick()
                    if currentTime - lastNoTargetNotification > notificationCooldown then
                        if getgenv().Settings.NyulaRemake.NOTIF == true then
                            game.StarterGui:SetCore("SendNotification", {
                                Title = "Astral.lua";
                                Text = "No target found",
                                Duration = 3
                            })
                        end
                        lastNoTargetNotification = currentTime
                    end
                end
            end
        end
    end)
 
    function getClosestPlayerToCursor()
        local closestTarget
        local shortestDistance = getgenv().Settings.NyulaRemake.FOV
 
        -- Check players based on target filter
        if getgenv().TargetFilter == "Both" or getgenv().TargetFilter == "Players Only" then
            for i, v in pairs(game.Players:GetPlayers()) do
                if v ~= game.Players.LocalPlayer and v.Character and v.Character:FindFirstChild("Humanoid") and v.Character.Humanoid.Health ~= 0 and v.Character:FindFirstChild("HumanoidRootPart") then
                    -- Wall check
                    if not isTargetVisible(v) then
                        -- Skip if target is behind a wall
                    else
                        local pos = CC:WorldToViewportPoint(v.Character.PrimaryPart.Position)
                        if pos.Z > 0 then
                            local magnitude = (Vector2.new(pos.X, pos.Y) - mousePos).magnitude
                            if magnitude < shortestDistance then
                                closestTarget = v
                                shortestDistance = magnitude
                            end
                        end
                    end
                end
            end
        end
        
        -- Check NPCs based on target filter
        if getgenv().TargetFilter == "Both" or getgenv().TargetFilter == "NPCs Only" then
            for i, v in pairs(workspace:GetChildren()) do
                if v:FindFirstChild("Humanoid") and v:FindFirstChild("HumanoidRootPart") and v.Humanoid.Health > 0 then
                    local isPlayerCharacter = false
                    for _, player in pairs(game.Players:GetPlayers()) do
                        if player.Character == v then
                            isPlayerCharacter = true
                            break
                        end
                    end
                    
                    if not isPlayerCharacter then
                        -- Wall check for NPCs
                        if not isTargetVisible({Character = v}) then
                            -- Skip if NPC is behind a wall
                        else
                            local pos = CC:WorldToViewportPoint(v.HumanoidRootPart.Position)
                            if pos.Z > 0 then
                                local magnitude = (Vector2.new(pos.X, pos.Y) - mousePos).magnitude
                                if magnitude < shortestDistance then
                                    closestTarget = {Character = v}
                                    shortestDistance = magnitude
                                end
                            end
                        end
                    end
                end
            end
        end
        
        return closestTarget
    end
 
    local function calculatePredictedPosition(target, prediction, jumpPrediction)
        if not target or not target.Character or not target.Character:FindFirstChild("HumanoidRootPart") then
            return nil
        end
        
        local rootPart = target.Character.HumanoidRootPart
        local velocity = rootPart.AssemblyLinearVelocity
        
        local distance = (rootPart.Position - CC.CFrame.Position).Magnitude
        local adjustedPrediction = prediction * (1 + distance / 800) -- Even less distance scaling
        
        local predictedPosition = rootPart.Position + (velocity * adjustedPrediction)
        
        if math.abs(velocity.Y) > 5 then
            predictedPosition = predictedPosition + Vector3.new(0, velocity.Y * jumpPrediction * 0.2, 0) -- Lower jump prediction
        end
        
        return predictedPosition
    end
 
    local pingvalue = nil;
    local split = nil;
    local ping = nil;

local LocalHL = Instance.new("Highlight") 
    game:GetService"RunService".Stepped:connect(function()
        if enabled and Plr and Plr.Character ~= nil and Plr.Character:FindFirstChild("HumanoidRootPart") then
            local predictedPosition = calculatePredictedPosition(Plr, getgenv().Settings.NyulaRemake.PREDICTION, getgenv().Settings.NyulaRemake.JUMPPREDICTION)
            if predictedPosition then
                placemarker.CFrame = CFrame.new(predictedPosition)
            else
                placemarker.CFrame = CFrame.new(Plr.Character.HumanoidRootPart.Position)
            end
                
            LocalHL.Parent = Plr.Character
            LocalHL.FillTransparency = 0.2
            LocalHL.FillColor = Color3.fromRGB(48, 113, 169)
            LocalHL.OutlineColor = Color3.fromRGB(0,0,0)
        else
            placemarker.CFrame = CFrame.new(0, 9999, 0)
            LocalHL.Parent = nil
        end
        
        if getgenv().Settings.NyulaRemake.AUTOPRED == true then
            pingvalue = game:GetService("Stats").Network.ServerStatsItem["Data Ping"]:GetValueString()
            split = string.split(pingvalue,'(')
            ping = tonumber(split[1]) or 100
            
            -- Much lower prediction values based on ping
            if ping < 30 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.06
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.07
            elseif ping < 50 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.065
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.075
            elseif ping < 70 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.07
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.08
            elseif ping < 90 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.075
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.085
            elseif ping < 110 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.08
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.09
            elseif ping < 130 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.085
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.095
            elseif ping < 150 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.09
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.10
            elseif ping < 170 then
                getgenv().Settings.NyulaRemake.PREDICTION = 0.095
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.105
            else
                getgenv().Settings.NyulaRemake.PREDICTION = 0.10
                getgenv().Settings.NyulaRemake.JUMPPREDICTION = 0.11
            end
        end
        
        if getgenv().Settings.NyulaRemake.Resolver.Enabled then
            if getgenv().Settings.NyulaRemake.Resolver.Type == "Delta Time" then
                print("wsg")
            end
            if getgenv().Settings.NyulaRemake.Resolver.Type == "Recalculator" then
                print("wsg")
            end
            if getgenv().Settings.NyulaRemake.Resolver.Type == "No Y Velocity" then
                print("wsg")
            end
        end
    end)
 
    local mt = getrawmetatable(game)
    local old = mt.__namecall
    setreadonly(mt, false)
    mt.__namecall = newcclosure(function(...)
        local args = {...}
        local vap = {"UpdateMousePos", "GetMousePos", "MousePos", "MOUSE", "MousePosUpdate"}
        if enabled and getnamecallmethod() == "FireServer" and table.find(vap, args[2]) and getgenv().Settings.NyulaRemake.Enabled and Plr.Character ~= nil and getgenv().Settings.NyulaRemake.LOCKTYPE == "Namecall" then
            if Prediction == true then
                local predictedPosition = calculatePredictedPosition(Plr, getgenv().Settings.NyulaRemake.PREDICTION, getgenv().Settings.NyulaRemake.JUMPPREDICTION)
                if predictedPosition then
                    args[3] = predictedPosition
                else
                    args[3] = Plr.Character.HumanoidRootPart.Position
                end
            else
                args[3] = Plr.Character[SelectedPart].Position
            end
            return old(unpack(args))
        end
        return old(...)
    end)
 
    game:GetService("RunService").RenderStepped:Connect(function()
        if getgenv().Settings.NyulaRemake.RESOLVER == true and Plr.Character ~= nil and enabled and getgenv().Settings.NyulaRemake.Enabled then
            if getgenv().Settings.NyulaRemake.AIRSHOT == true and enabled and Plr.Character ~= nil then
                if Plr.Character.Humanoid:GetState() == Enum.HumanoidStateType.Freefall then
                    if Plr.Character ~= nil and Plr.Character.HumanoidRootPart.Anchored == true then
                        AnchorCount = AnchorCount + 1
                        if AnchorCount >= MaxAnchor then
                            Prediction = false
                            wait(2)
                            AnchorCount = 0;
                        end
                    else
                        Prediction = true
                        AnchorCount = 0;
                    end
                    SelectedPart = "LeftFoot"
                else
                    if Plr.Character ~= nil and Plr.Character.HumanoidRootPart.Anchored == true then
                        AnchorCount = AnchorCount + 1
                        if AnchorCount >= MaxAnchor then
                            Prediction = false
                            wait(2)
                            AnchorCount = 0;
                        end
                    else
                        Prediction = true
                        AnchorCount = 0;
                    end
                    SelectedPart = "HumanoidRootPart"
                end
            else
                if Plr.Character ~= nil and Plr.Character.HumanoidRootPart.Anchored == true then
                    AnchorCount = AnchorCount + 1
                    if AnchorCount >= MaxAnchor then
                        Prediction = false
                        wait(2)
                        AnchorCount = 0;
                    end
                else
                    Prediction = true
                    AnchorCount = 0;
                end
                SelectedPart = "HumanoidRootPart"
            end
        else
            SelectedPart = "HumanoidRootPart"
        end
    end)

local Hooks = {}
local Client = game.Players.LocalPlayer

Hooks[1] = hookmetamethod(Client:GetMouse(), "__index", newcclosure(function(self, index)
    if index == "Hit" and getgenv().Settings.NyulaRemake.LOCKTYPE == "Index" and enabled and Plr.Character ~= nil and getgenv().Settings.NyulaRemake.Enabled then
        local predictedPosition = calculatePredictedPosition(Plr, getgenv().Settings.NyulaRemake.PREDICTION, getgenv().Settings.NyulaRemake.JUMPPREDICTION)
        if predictedPosition then
            local position = CFrame.new(predictedPosition)
            return position
        else
            local position = CFrame.new(Plr.Character.HumanoidRootPart.Position)
            return position
        end
    end
    return Hooks[1](self, index)
end))

end)

GAGEJ:Element("Dropdown", "Aim Type", {options = {"Index", "Namecall"}}, function(tbjl)
getgenv().Settings.NyulaRemake.LOCKTYPE = tbjl.Dropdown
end)

GAGEJ:Element("TextBox", "Prediction", {placeholder = "Prediction"})

GAGEJ:Element("Button", "Save", {}, function() 
getgenv().Settings.NyulaRemake.PREDICTION = values.Jaja.GAGEJ.Prediction.Text
end)

GAGEJ:Element("TextBox", "JumpPrediction", {placeholder = "Jump Prediction"})

GAGEJ:Element("Button", "Save", {}, function() 
getgenv().Settings.NyulaRemake.JUMPPREDICTION = values.Jaja.GAGEJ.JumpPrediction.Text
end)

GAGEJ:Element("Toggle", "Auto Prediction", nil, function(tbll)
getgenv().Settings.NyulaRemake.AUTOPRED = tbll.Toggle
end)

-- Add damage text toggle
GAGEJ:Element("Toggle", "Damage Text", {default = true}, function(tbll)
getgenv().Settings.NyulaRemake.DAMAGE_TEXT = tbll.Toggle
end)

--// ONHIT
local configs = Jaja:Tab("On Hit")

configs:Element("Toggle", "Hitcham", nil, function(tbll)
getgenv().Settings.NyulaRemake.OnHit.Hitchams.Enabled = tbll.Toggle
end)

configs:Element("Toggle", "Hitsound", nil, function(tbll)
getgenv().Settings.NyulaRemake.OnHit.Hitsounds.Enabled = tbll.Toggle
end)

--// MODS
local mamamoblue = Jaja:Tab("Mods")

--// RESOLVERS
local mamamored = Jaja:Tab("Resolvers")

mamamored:Element("Toggle", "Enabled", nil, function(bruh)
print(bruh.Toggle)
end)

mamamored:Element("Dropdown", "Type", {options = {"None", "Delta Time", "Recalculator", "No Y Velocity"}}, function(tbjol)
print(tbjol.Dropdown)
end)

game.StarterGui:SetCore("SendNotification", {
    Title = "@baconscript_",
    Text = "https://www.youtube.com/@baconscript_",
    Duration = 5
})