local Players = game:GetService("Players")
local workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

local SilentAim = {
    Enabled = true,
    TeamCheck = true,
    WallCheck = true,
    FOV = 35,
    AimPart = "Head"
}

local function getCharacter(player)
    return player and player.Character
end

local function isAlive(character)
    if not character then
        return false
    end

    if character:GetAttribute("Dead") then
        return false
    end

    local health = character:GetAttribute("Health")

    return health == nil or health > 0
end

local function isObstructed(origin, target, character)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = { character, LocalPlayer.Character }

    local ray = workspace:Raycast(origin, target - origin, params)

    return ray ~= nil
        and ray.Instance ~= nil
        and not ray.Instance:IsDescendantOf(character)
end

local function getTarget(origin)
    local localTeam = LocalPlayer:GetAttribute("Team")
    local look = Camera.CFrame.LookVector
    local best, bestAngle = nil, math.rad(SilentAim.FOV)

    for _, player in ipairs(Players:GetPlayers()) do
        if player == LocalPlayer then
            continue
        end

        local character = getCharacter(player)

        if not isAlive(character) then
            continue
        end

        if SilentAim.TeamCheck and player:GetAttribute("Team") == localTeam then
            continue
        end

        local part = character:FindFirstChild(SilentAim.AimPart)
            or character:FindFirstChild("Head")
            or character:FindFirstChild("HumanoidRootPart")

        if not part then
            continue
        end

        local targetPos = part.Position
        local direction = (targetPos - origin).Unit
        local angle = math.acos(math.clamp(look:Dot(direction), -1, 1))

        if angle < bestAngle then
            if SilentAim.WallCheck and isObstructed(origin, targetPos, character) then
                continue
            end

            best, bestAngle = part, angle
        end
    end

    return best
end

local function buildHit(origin, part)
    local targetPos = part.Position
    local direction = (targetPos - origin).Unit

    return {
        Distance = (targetPos - origin).Magnitude,
        Instance = part,
        Position = targetPos,
        Normal = -direction,
        Material = part.Material.Name,
        Exit = false
    }
end

local ok, Remotes = pcall(require, game:GetService("ReplicatedStorage").Database.Security.Remotes)
local shootRemote = ok and Remotes and Remotes.Inventory and Remotes.Inventory.ShootWeapon

if not shootRemote or not shootRemote.Send then
    warn("BloxStrike silent aim: Remotes.Inventory.ShootWeapon.Send not found, hook skipped")
    return
end

local oldSend

local function hookedSend(packet, ...)
    if SilentAim.Enabled and packet and packet.Bullets then
        for _, bullet in ipairs(packet.Bullets) do
            local origin = bullet.Origin

            if origin then
                local part = getTarget(origin)

                if part then
                    bullet.Direction = (part.Position - origin).Unit
                    bullet.Hits = { buildHit(origin, part) }
                end
            end
        end
    end

    return oldSend(packet, ...)
end

if typeof(hookfunction) == "function" then
    oldSend = hookfunction(shootRemote.Send, hookedSend)
else
    oldSend = shootRemote.Send
    shootRemote.Send = hookedSend
end