-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6ae96651dcf09e8263a403ae"))()
	end)
end)
--[[rscripts:analytics:end]]

--[[* If you enjoy the script, please consider liking the post.
It helps motivate me to release more open-source scripts and keep existing ones updated.
MADE BY: [https://rscripts.net/@Yamis_Scripts] *]]

-- UNLOAD WITH: getgenv().deagleSilentAim.Unload()

local OPTIONS = {
	Enabled = true,
	AimCone = 360,
	MaxDistance = 600,
	TargetBots = true,
}

local SILENT_AIM_SESSION_NAME = "deagleSilentAim"
local HIT_PARTS = { "HeadHitbox", "Head", "BodyHitbox", "UpperTorso", "Torso", "HumanoidRootPart" }
local getgenv, hookmetamethod, newcclosure, getnamecallmethod, setnamecallmethod, identifyexecutor =
	getgenv, hookmetamethod, newcclosure, getnamecallmethod, setnamecallmethod, identifyexecutor
local StarterGui = game:GetService("StarterGui")

local function notify(title, description)
	for attempt = 1, 5 do
		local delivered = pcall(StarterGui.SetCore, StarterGui, "SendNotification", {
			Title = title,
			Text = description,
			Duration = 8,
		})
		if delivered then
			return
		end
		if attempt < 5 then
			task.wait(0.2)
		end
	end
	warn(title .. ": " .. description)
end

if game.PlaceId ~= 84556640895285 then
	notify("Unsupported game", "This script only supports Deagle Arena.")
	return
end

local executorName = "Unknown executor"
if type(identifyexecutor) == "function" then
	local identified, name = pcall(identifyexecutor)
	if identified and type(name) == "string" then
		executorName = name
	end
end

if not (type(getgenv) == "function" and type(hookmetamethod) == "function"
	and type(newcclosure) == "function" and type(getnamecallmethod) == "function"
	and type(setnamecallmethod) == "function") then
	notify("[" .. executorName .. "] is not supported.",
		"Your executor is missing required functions.")
	return
end

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Workspace = game:GetService("Workspace")
local loaded, DeagleShared, GamemodeShared, remote = pcall(function()
	local modules = ReplicatedStorage.Modules
	return require(modules.Shared.DeagleShared), require(modules.Shared.GamemodeShared),
		modules.Packages.Network.NetworkRemote
end)

if not loaded then
	notify("Game scripts unavailable", "Join Deagle Arena fully, then execute again.")
	return
end

assert(remote:IsA("RemoteEvent"), "NetworkRemote is not a RemoteEvent")
local localPlayer = Players.LocalPlayer
local environment = getgenv()
local session = rawget(environment, SILENT_AIM_SESSION_NAME)
if session ~= nil then
	assert(type(session) == "table" and rawget(session, "purpose") == "deagle-silent-aim"
		and rawget(session, "schema") == 1
		and rawequal(rawget(session, "environment"), environment)
		and type(rawget(session, "Unload")) == "function", "Silent aim session key is occupied")
	session.Unload()
else
	session = { purpose = "deagle-silent-aim", schema = 1, environment = environment }
	rawset(environment, SILENT_AIM_SESSION_NAME, session)
end

session.Options = OPTIONS
session.remote = remote
session.lastError = nil

function session.Unload()
	session.active = false
	session.Options.Enabled = false
	session.redirect = nil
	local noticeThread = session.noticeThread
	if noticeThread and coroutine.status(noticeThread) ~= "dead" then
		task.cancel(noticeThread)
	end
	session.noticeThread = nil
end

local function selectTarget(origin, originalAim)
	local localCharacter = localPlayer.Character
	if not localCharacter or not localCharacter:FindFirstChild("Deagle") then
		return nil
	end
	local localHumanoid = localCharacter:FindFirstChildOfClass("Humanoid")
	local aimDirection = originalAim - origin
	if not localHumanoid or localHumanoid.Health <= 0 or aimDirection.Magnitude <= 0 then
		return nil
	end

	local direction = aimDirection.Unit
	local minimumDot = math.cos(math.rad(math.clamp(OPTIONS.AimCone, 0, 360) * 0.5))
	local maximumDistance = math.clamp(OPTIONS.MaxDistance, 0, 600)
	local candidates = {}
	local seen = {}

	local function consider(character)
		if not character or seen[character] or character == localCharacter then
			return
		end
		seen[character] = true
		if character:GetAttribute("Alive") == false
			or character:GetAttribute("SpawnProtection") == true
			or character:GetAttribute("Ragdolled") == true
			or GamemodeShared.AreTeammates(localCharacter, character) then
			return
		end
		local humanoid = character:FindFirstChildOfClass("Humanoid")
		if not humanoid or humanoid.Health <= 0 then
			return
		end
		for _, partName in ipairs(HIT_PARTS) do
			local part = character:FindFirstChild(partName)
			if part and part:IsA("BasePart") then
				local offset = part.Position - origin
				local distance = offset.Magnitude
				if distance > 0 and distance <= maximumDistance then
					local alignment = direction:Dot(offset.Unit)
					if alignment >= minimumDot then
						table.insert(candidates, {
							character = character, alignment = alignment, distance = distance,
						})
					end
				end
				return
			end
		end
	end

	for _, player in ipairs(Players:GetPlayers()) do
		if player ~= localPlayer and player:GetAttribute("InRound") == true then
			consider(player.Character)
		end
	end
	if OPTIONS.TargetBots then
		for _, character in ipairs(Workspace:GetChildren()) do
			if character:IsA("Model") and (character:GetAttribute("IsBot") == true
				or character:GetAttribute("TutorialTarget") == true) then
				consider(character)
			end
		end
	end
	table.sort(candidates, function(first, second)
		if first.alignment == second.alignment then
			return first.distance < second.distance
		end
		return first.alignment > second.alignment
	end)

	for _, candidate in ipairs(candidates) do
		for _, partName in ipairs(HIT_PARTS) do
			local part = candidate.character:FindFirstChild(partName)
			if part and part:IsA("BasePart") then
				local aimPosition = part.Position
				local offset = aimPosition - origin
				if offset.Magnitude > 0 and offset.Magnitude <= maximumDistance
					and direction:Dot(offset.Unit) >= minimumDot then
					local hit = DeagleShared.Raycast(localCharacter, origin, aimPosition)
					if hit and DeagleShared.GetCharacterFromHit(hit.Instance) == candidate.character then
						return aimPosition, hit.Instance, hit.Position
					end
				end
			end
		end
	end
	return nil
end

function session.redirect(arguments)
	if arguments.n ~= 6 or arguments[1] ~= "Shoot"
		or typeof(arguments[2]) ~= "Vector3" or typeof(arguments[3]) ~= "Vector3" then
		return nil
	end
	local selected, aimPosition, hitPart, hitPosition = pcall(selectTarget, arguments[2], arguments[3])
	if not selected then
		OPTIONS.Enabled = false
		session.lastError = tostring(aimPosition)
		session.noticeThread = task.defer(function()
			if session.active then
				notify("Silent aim stopped", string.sub(session.lastError, 1, 180))
			end
			session.noticeThread = nil
		end)
		return nil
	end
	if aimPosition then
		arguments[3], arguments[4], arguments[5] = aimPosition, hitPart, hitPosition
		return arguments
	end
	return nil
end

if not session.installed then
	local installed, original = pcall(function()
		return hookmetamethod(game, "__namecall", newcclosure(function(receiver, ...)
			local method = getnamecallmethod()
			if session.active and receiver == session.remote and method == "FireServer"
				and session.Options.Enabled then
				local arguments = session.redirect(table.pack(...))

				setnamecallmethod(method)
				if arguments then
					return session.forward(receiver, table.unpack(arguments, 1, arguments.n))
				end
			end
			return session.forward(receiver, ...)
		end))
	end)
	if not installed or type(original) ~= "function" then
		session.Unload()
		notify("[" .. executorName .. "] is not supported.",
			"Your executor could not install the required hook.")
		return
	end
	session.forward = original
	session.installed = true
end

session.active = true