-- [[ 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 ]]
--//==============================================================
--// KR7 UNIVERSAL
--//==============================================================

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 SoundService = game:GetService("SoundService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local VirtualInputManager = game:GetService("VirtualInputManager")
local VirtualUser = game:GetService("VirtualUser")

local Player = Players.LocalPlayer

--==============================================================
-- RAYFIELD (GEN2)
--==============================================================

local RayfieldSuccess, Rayfield = pcall(function()
	return loadstring(game:HttpGet(
		"https://sirius.menu/gen2"
	))()
end)

if not RayfieldSuccess or not Rayfield then
	warn("[KR7] Rayfield failed to load")
	warn(Rayfield)
	return
end

--==============================================================
-- WINDOW
--==============================================================

local Window = Rayfield:CreateWindow({
	name = "KR7 Warfare Tycoon",
	subtitle = "Skin • Aim • Movement • Weapon • Misc"
})

--==============================================================
-- TABS
--==============================================================

local SkinTab = Window:CreateTab({
	name = "Skin",
	icon = 4483362458
})

local PlayerTab = Window:CreateTab({
	name = "Player",
	icon = 4483362458
})

local StatTab = Window:CreateTab({
	name = "Stat Changer",
	icon = 4483362458
})

local AimTab = Window:CreateTab({
	name = "Aim",
	icon = 4483362458
})

local MiscTab = Window:CreateTab({
	name = "Misc",
	icon = 4483362458
})

--################################################################
-- SKIN CHANGER
--################################################################

local SkinEnabled = false
local SkinColor = Color3.fromRGB(255, 255, 255)

local Originals = {}

local function saveOriginal(part)
	if not part:IsA("BasePart") then
		return
	end

	if Originals[part] then
		return
	end

	Originals[part] = {
		Material = part.Material,
		Color = part.Color
	}
end

local function applyToPart(part)
	if not part:IsA("BasePart") then
		return
	end

	saveOriginal(part)

	part.Material = Enum.Material.ForceField
	part.Color = SkinColor
end

local function applyToContainer(container)
	if not container then
		return
	end

	if container:IsA("BasePart") then
		applyToPart(container)
	end

	for _, object in ipairs(container:GetDescendants()) do
		if object:IsA("BasePart") then
			applyToPart(object)
		end
	end
end

local function updateSkin()
	if not SkinEnabled then
		return
	end

	local character = Player.Character

	if character then
		applyToContainer(character)
	end

	local backpack = Player:FindFirstChildOfClass("Backpack")

	if backpack then
		for _, object in ipairs(backpack:GetChildren()) do
			if object:IsA("Tool") then
				applyToContainer(object)
			end
		end
	end

	local camera = workspace.CurrentCamera

	if camera then
		for _, object in ipairs(camera:GetChildren()) do
			if object:IsA("Model") then
				applyToContainer(object)
			elseif object:IsA("BasePart") then
				applyToPart(object)
			end
		end
	end

	local fpsContainers = {
		workspace:FindFirstChild("Viewmodel"),
		workspace:FindFirstChild("Viewmodels"),
		workspace:FindFirstChild("FPS"),
		workspace:FindFirstChild("Arms"),
		workspace:FindFirstChild("FirstPerson"),
		workspace:FindFirstChild("FirstPersonArms")
	}

	for _, container in ipairs(fpsContainers) do
		if container then
			applyToContainer(container)
		end
	end
end

local function restoreSkin()
	for part, original in pairs(Originals) do
		if part and part.Parent then
			pcall(function()
				part.Material = original.Material
				part.Color = original.Color
			end)
		end
	end

	table.clear(Originals)
end

SkinTab:CreateToggle({
	name = "Skin Changer",
	currentValue = false,
	callback = function(value)
		SkinEnabled = value

		if value then
			updateSkin()
		else
			restoreSkin()
		end
	end
})

SkinTab:CreateColorPicker({
	name = "Skin Changer Colour",
	color = SkinColor,
	callback = function(color)
		SkinColor = color

		if SkinEnabled then
			updateSkin()
		end
	end
})

--################################################################
-- PLAYER
--################################################################

local SpeedEnabled = false
local SpeedValue = 50

PlayerTab:CreateSlider({
	name = "Speed",
	range = {1, 500},
	increment = 1,
	suffix = " studs/s",
	currentValue = 50,
	callback = function(value)
		SpeedValue = value
	end
})

PlayerTab:CreateToggle({
	name = "Speed",
	currentValue = false,
	callback = function(value)
		SpeedEnabled = value
	end
})

RunService.RenderStepped:Connect(function()
	if not SpeedEnabled then
		return
	end

	local character = Player.Character

	if not character then
		return
	end

	local humanoid =
		character:FindFirstChildOfClass("Humanoid")

	local root =
		character:FindFirstChild("HumanoidRootPart")

	if not humanoid or not root then
		return
	end

	local direction =
		humanoid.MoveDirection

	local vertical =
		root.AssemblyLinearVelocity.Y

	if direction.Magnitude > 0 then
		root.AssemblyLinearVelocity =
			Vector3.new(
				direction.X * SpeedValue,
				vertical,
				direction.Z * SpeedValue
			)
	else
		root.AssemblyLinearVelocity =
			Vector3.new(
				0,
				vertical,
				0
			)
	end
end)

--################################################################
-- GUN STAT CHANGER
--################################################################

local GunStatsEnabled = false
local AutomaticEnabled = false

local GunStats = {
	Damage = 24,
	HeadDamage = 30,

	Ammo = 17,
	StoredAmmo = 204,

	ShootRate = 700,
	Bullets = 1,

	MuzzleVelocity = 1000,

	MinSpread = 5,
	MaxSpread = 10,

	BulletPenetration = 40,

	RecoilMultiplier = 1,

	ReloadTime = 2.5
}

--==============================================================
-- RECOIL ORIGINALS
--==============================================================

local OriginalRecoil = {}

local function saveRecoilTable(recoilTable)
	if type(recoilTable) ~= "table" then
		return
	end

	if OriginalRecoil[recoilTable] then
		return
	end

	local original = {}

	for index, value in pairs(recoilTable) do
		if type(value) == "number" then
			original[index] = value
		end
	end

	OriginalRecoil[recoilTable] = original
end

local function applyRecoilTable(
	recoilTable,
	multiplier
)
	if type(recoilTable) ~= "table" then
		return
	end

	saveRecoilTable(recoilTable)

	local original =
		OriginalRecoil[recoilTable]

	if not original then
		return
	end

	for index, value in pairs(original) do
		recoilTable[index] =
			value * multiplier
	end
end

--==============================================================
-- GUN HELPERS
--==============================================================

local function getEquippedTool()
	local character = Player.Character

	if not character then
		return nil
	end

	return character:FindFirstChildOfClass("Tool")
end

local function getGunSettings(tool)
	if not tool then
		return nil
	end

	local module =
		tool:FindFirstChild("ACS_Settings")

	if not module
		or not module:IsA("ModuleScript") then
		return nil
	end

	local success, result =
		pcall(require, module)

	if success and type(result) == "table" then
		return result
	end

	return nil
end

local function getGunAnimations(tool)
	if not tool then
		return nil
	end

	local module =
		tool:FindFirstChild("ACS_Animations")

	if not module
		or not module:IsA("ModuleScript") then
		return nil
	end

	local success, result =
		pcall(require, module)

	if success and type(result) == "table" then
		return result
	end

	return nil
end

--==============================================================
-- GENERIC AUTOMATIC MODE
--==============================================================

local function setAutomatic(
	settings,
	enabled
)
	if type(settings) ~= "table" then
		return
	end

	if type(settings.FireModes) ~= "table" then
		settings.FireModes = {
			ChangeFiremode = false,
			Semi = true,
			Burst = false,
			Auto = false
		}
	end

	settings.FireModes.Auto =
		enabled

	settings.FireModes.Semi =
		not enabled

	settings.FireModes.Burst =
		false

	if settings.MobileAutoFire ~= nil then
		settings.MobileAutoFire =
			enabled
	end

	if settings.Auto ~= nil then
		settings.Auto =
			enabled
	end

	if settings.Automatic ~= nil then
		settings.Automatic =
			enabled
	end
end

--==============================================================
-- RELOAD PATCH
--==============================================================

local ReloadPatched = {}

local ORIGINAL_RELOAD_DURATION = 2.55

local function patchReloadAnimation(tool)
	if not tool then
		return
	end

	local animations =
		getGunAnimations(tool)

	if not animations then
		return
	end

	if type(animations.ReloadAnim) ~= "function" then
		return
	end

	if ReloadPatched[animations] then
		return
	end

	ReloadPatched[animations] = true

	animations.ReloadAnim = function(p)
		local requested =
			tonumber(GunStats.ReloadTime)

		if not requested
			or requested <= 0 then

			requested =
				ORIGINAL_RELOAD_DURATION
		end

		local multiplier =
			requested /
			ORIGINAL_RELOAD_DURATION

		local function waitScaled(seconds)
			task.wait(
				seconds * multiplier
			)
		end

		pcall(function()
			TweenService:Create(
				p[1],
				TweenInfo.new(
					0.25 * multiplier,
					Enum.EasingStyle.Sine
				),
				{
					C1 = (
						CFrame.new(
							0,
							-0.15,
							0
						)
						* CFrame.Angles(
							math.rad(90),
							math.rad(-25),
							0
						)
					):Inverse()
				}
			):Play()
		end)

		pcall(function()
			TweenService:Create(
				p[2],
				TweenInfo.new(
					0.25 * multiplier,
					Enum.EasingStyle.Sine
				),
				{
					C1 = (
						CFrame.new(
							-0.6,
							-0.3,
							0
						)
						* CFrame.Angles(
							math.rad(60),
							math.rad(50),
							math.rad(30)
						)
					):Inverse()
				}
			):Play()
		end)

		waitScaled(0.3)

		pcall(function()
			p[4].Handle.MagOut:Play()
		end)

		pcall(function()
			p[4].Mag.Transparency = 1
		end)

		waitScaled(0.5)

		pcall(function()
			p[4].Handle.AimUp:Play()
		end)

		waitScaled(0.75)

		pcall(function()
			TweenService:Create(
				p[2],
				TweenInfo.new(
					0.25 * multiplier,
					Enum.EasingStyle.Sine
				),
				{
					C1 = (
						CFrame.new(
							-0.6,
							-0.3,
							0
						)
						* CFrame.Angles(
							math.rad(60),
							math.rad(50),
							math.rad(30)
						)
					):Inverse()
				}
			):Play()
		end)

		waitScaled(0.25)

		pcall(function()
			p[4].Handle.MagIn:Play()
		end)

		pcall(function()
			TweenService:Create(
				p[1],
				TweenInfo.new(
					0.15 * multiplier,
					Enum.EasingStyle.Sine
				),
				{
					C1 = (
						CFrame.new(
							0,
							-0.15,
							0
						)
						* CFrame.Angles(
							math.rad(90),
							math.rad(-25),
							0
						)
					):Inverse()
				}
			):Play()
		end)

		pcall(function()
			p[4].Mag.Transparency = 0
		end)

		waitScaled(0.15)
	end
end

--==============================================================
-- APPLY GUN STATS
--==============================================================

local function applyGunStats()
	if not GunStatsEnabled then
		return
	end

	local tool =
		getEquippedTool()

	if not tool then
		return
	end

	local settings =
		getGunSettings(tool)

	if not settings then
		return
	end

	settings.LimbDamage = {
		GunStats.Damage,
		GunStats.Damage
	}

	settings.TorsoDamage = {
		GunStats.Damage,
		GunStats.Damage
	}

	settings.HeadDamage = {
		GunStats.HeadDamage,
		GunStats.HeadDamage
	}

	settings.Ammo =
		GunStats.Ammo

	settings.AmmoInGun =
		GunStats.Ammo

	settings.StoredAmmo =
		GunStats.StoredAmmo

	settings.MaxStoredAmmo =
		GunStats.StoredAmmo * 2

	settings.ShootRate =
		GunStats.ShootRate

	settings.Bullets =
		GunStats.Bullets

	settings.MuzzleVelocity =
		GunStats.MuzzleVelocity

	settings.MinSpread =
		GunStats.MinSpread

	settings.MaxSpread =
		GunStats.MaxSpread

	settings.BulletPenetration =
		GunStats.BulletPenetration

	setAutomatic(
		settings,
		AutomaticEnabled
	)

	settings.ReloadTime =
		GunStats.ReloadTime

	if settings.camRecoil then
		for _, recoilTable in pairs(
			settings.camRecoil
		) do
			if type(recoilTable) == "table" then
				applyRecoilTable(
					recoilTable,
					GunStats.RecoilMultiplier
				)
			end
		end
	end

	if settings.gunRecoil then
		for _, recoilTable in pairs(
			settings.gunRecoil
		) do
			if type(recoilTable) == "table" then
				applyRecoilTable(
					recoilTable,
					GunStats.RecoilMultiplier
				)
			end
		end
	end

	patchReloadAnimation(tool)
end

--==============================================================
-- STAT UI
--==============================================================

StatTab:CreateToggle({
	name = "Stat Changer",
	currentValue = false,
	callback = function(value)
		GunStatsEnabled = value

		if value then
			applyGunStats()
		end
	end
})

StatTab:CreateToggle({
	name = "Automatic Fire",
	currentValue = false,
	callback = function(value)
		AutomaticEnabled = value
		applyGunStats()
	end
})

local function createNumberInput(
	name,
	defaultValue,
	callback
)
	StatTab:CreateInput({
		name = name,
		currentValue = tostring(defaultValue),
		placeholderText = "Enter value",
		removeTextAfterFocusLost = false,
		callback = function(value)
			local number =
				tonumber(value)

			if number then
				callback(number)
				applyGunStats()
			end
		end
	})
end

createNumberInput(
	"Damage",
	24,
	function(value)
		GunStats.Damage = value
	end
)

createNumberInput(
	"Head Damage",
	30,
	function(value)
		GunStats.HeadDamage = value
	end
)

createNumberInput(
	"Magazine Ammo",
	17,
	function(value)
		GunStats.Ammo =
			math.max(
				0,
				math.floor(value)
			)
	end
)

createNumberInput(
	"Stored Ammo",
	204,
	function(value)
		GunStats.StoredAmmo =
			math.max(
				0,
				math.floor(value)
			)
	end
)

createNumberInput(
	"Fire Rate",
	700,
	function(value)
		if value > 0 then
			GunStats.ShootRate = value
		end
	end
)

createNumberInput(
	"Bullets Per Shot",
	1,
	function(value)
		GunStats.Bullets =
			math.max(
				1,
				math.floor(value)
			)
	end
)

createNumberInput(
	"Muzzle Velocity",
	1000,
	function(value)
		GunStats.MuzzleVelocity = value
	end
)

createNumberInput(
	"Minimum Spread",
	5,
	function(value)
		GunStats.MinSpread = value
	end
)

createNumberInput(
	"Maximum Spread",
	10,
	function(value)
		GunStats.MaxSpread = value
	end
)

createNumberInput(
	"Bullet Penetration",
	40,
	function(value)
		GunStats.BulletPenetration = value
	end
)

createNumberInput(
	"Recoil Multiplier %",
	100,
	function(value)
		GunStats.RecoilMultiplier =
			math.max(
				0,
				value
			) / 100
	end
)

createNumberInput(
	"Reload Time",
	2.5,
	function(value)
		if value > 0 then
			GunStats.ReloadTime = value
		end
	end
)

--################################################################
-- AIM (AIMBOT & SILENT AIM)
--################################################################

local AimbotEnabled = false
local AimSmoothness = 5

local SilentAimEnabled = false
local SilentAimFOV = 150

local TriggerBotEnabled = false

local DrawFOVAimbot = false
local DrawFOVSilent = false

local AimbotFOVRadius = 150
local SilentAimFOVRadius = 150

local FOVColor = Color3.fromRGB(255, 255, 255)

local Aiming = false
local Shooting = false

--==============================================================
-- AIM GUI
--==============================================================

local AimGui = Instance.new("ScreenGui")
AimGui.Name = "KR7AimGui"
AimGui.ResetOnSpawn = false
AimGui.IgnoreGuiInset = true
AimGui.DisplayOrder = 100
AimGui.Parent = Player:WaitForChild("PlayerGui")

-- FOV Circle for Aimbot
local FOVCircleAimbot = Instance.new("Frame")
FOVCircleAimbot.Name = "FOVCircleAimbot"
FOVCircleAimbot.AnchorPoint = Vector2.new(0.5, 0.5)
FOVCircleAimbot.BackgroundTransparency = 1
FOVCircleAimbot.BorderSizePixel = 0
FOVCircleAimbot.Visible = false
FOVCircleAimbot.Parent = AimGui

local FOVCornerAimbot = Instance.new("UICorner")
FOVCornerAimbot.CornerRadius = UDim.new(1, 0)
FOVCornerAimbot.Parent = FOVCircleAimbot

local FOVStrokeAimbot = Instance.new("UIStroke")
FOVStrokeAimbot.Thickness = 2
FOVStrokeAimbot.Color = FOVColor
FOVStrokeAimbot.Parent = FOVCircleAimbot

-- FOV Circle for Silent Aim
local FOVCircleSilent = Instance.new("Frame")
FOVCircleSilent.Name = "FOVCircleSilent"
FOVCircleSilent.AnchorPoint = Vector2.new(0.5, 0.5)
FOVCircleSilent.BackgroundTransparency = 1
FOVCircleSilent.BorderSizePixel = 0
FOVCircleSilent.Visible = false
FOVCircleSilent.Parent = AimGui

local FOVCornerSilent = Instance.new("UICorner")
FOVCornerSilent.CornerRadius = UDim.new(1, 0)
FOVCornerSilent.Parent = FOVCircleSilent

local FOVStrokeSilent = Instance.new("UIStroke")
FOVStrokeSilent.Thickness = 2
FOVStrokeSilent.Color = FOVColor
FOVStrokeSilent.Parent = FOVCircleSilent

--==============================================================
-- SCREEN COORDINATES
--==============================================================

local function getGuiInset()
	local inset = GuiService:GetGuiInset()
	return inset.X, inset.Y
end

local function getCameraCenterScreenPosition()
	local camera = workspace.CurrentCamera
	if not camera then return Vector2.zero end
	local viewport = camera.ViewportSize
	local insetX, insetY = getGuiInset()
	return Vector2.new(viewport.X / 2 + insetX, viewport.Y / 2 + insetY)
end

local function getAimScreenPosition()
	local camera = workspace.CurrentCamera
	if not camera then return Vector2.zero end

	if not UserInputService.MouseEnabled then
		return getCameraCenterScreenPosition()
	end

	if Aiming then
		return getCameraCenterScreenPosition()
	end

	local mouse = UserInputService:GetMouseLocation()
	return Vector2.new(mouse.X, mouse.Y)
end

local function worldToScreen(worldPosition)
	local camera = workspace.CurrentCamera
	if not camera then return nil, false end

	local viewportPosition, onScreen = camera:WorldToViewportPoint(worldPosition)
	local insetX, insetY = getGuiInset()
	local screenPosition = Vector2.new(
		viewportPosition.X + insetX,
		viewportPosition.Y + insetY
	)
	return screenPosition, onScreen and viewportPosition.Z > 0
end

--==============================================================
-- TARGET VALIDATION
--==============================================================

local function isValidTarget(player)
	if player == Player then return false end
	local character = player.Character
	if not character then return false end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return false end
	return true
end

local function getTargetPart(character)
	if not character then return nil end
	local head = character:FindFirstChild("Head")
	if head then return head end
	return character:FindFirstChild("HumanoidRootPart")
end

--==============================================================
-- TARGET SEARCH (uses aim screen point and given FOV)
--==============================================================

local function getClosestTarget(fovRadius)
	local aimPoint = getAimScreenPosition()
	local closestPlayer = nil
	local closestDistance = fovRadius

	for _, player in ipairs(Players:GetPlayers()) do
		if isValidTarget(player) then
			local targetPart = getTargetPart(player.Character)
			if targetPart then
				local targetScreen, onScreen = worldToScreen(targetPart.Position)
				if onScreen and targetScreen then
					local distance = (targetScreen - aimPoint).Magnitude
					if distance <= closestDistance then
						closestDistance = distance
						closestPlayer = player
					end
				end
			end
		end
	end

	return closestPlayer
end

--==============================================================
-- LINE OF SIGHT CHECK (for silent aim & trigger bot)
--==============================================================

local function hasClearLineOfSight(targetPlayer)
	local camera = workspace.CurrentCamera
	if not camera or not targetPlayer or not targetPlayer.Character then
		return false
	end

	local targetPart = getTargetPart(targetPlayer.Character)
	if not targetPart then return false end

	local origin = camera.CFrame.Position
	local direction = (targetPart.Position - origin).Unit * 1000

	local ignoreList = { Player.Character }
	for _, containerName in ipairs({"Viewmodel", "Viewmodels", "FPS", "Arms", "FirstPerson", "FirstPersonArms"}) do
		local container = workspace:FindFirstChild(containerName)
		if container then table.insert(ignoreList, container) end
	end

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = ignoreList
	params.IgnoreWater = true

	local result = workspace:Raycast(origin, direction, params)
	if not result then return false end

	local hitPart = result.Instance
	local hitModel = hitPart:FindFirstAncestorOfClass("Model")
	if not hitModel then return false end

	local hitPlayer = Players:GetPlayerFromCharacter(hitModel)
	return hitPlayer == targetPlayer
end

--==============================================================
-- AIMBOT AIMING
--==============================================================

local function aimAtTarget(target, smoothness)
	if not target then return end
	local camera = workspace.CurrentCamera
	if not camera then return end
	local character = target.Character
	if not character then return end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local targetPart = getTargetPart(character)
	if not humanoid or not targetPart or humanoid.Health <= 0 then return end

	local desired = CFrame.lookAt(camera.CFrame.Position, targetPart.Position)

	local smooth = smoothness or AimSmoothness
	if smooth <= 0 then
		camera.CFrame = desired
		return
	end

	local alpha = math.clamp(1 / (smooth + 1), 0.05, 1)
	camera.CFrame = camera.CFrame:Lerp(desired, alpha)
end

--==============================================================
-- TRIGGER BOT CHECK
--==============================================================

local function getTargetUnderCursor()
	local camera = workspace.CurrentCamera
	if not camera then return false end

	local mouse = UserInputService:GetMouseLocation()
	local ray = camera:ScreenPointToRay(mouse.X, mouse.Y, 0)

	local ignoreList = { Player.Character }
	for _, containerName in ipairs({"Viewmodel", "Viewmodels", "FPS", "Arms", "FirstPerson", "FirstPersonArms"}) do
		local container = workspace:FindFirstChild(containerName)
		if container then table.insert(ignoreList, container) end
	end

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = ignoreList
	params.IgnoreWater = true

	local result = workspace:Raycast(ray.Origin, ray.Direction * 1000, params)
	if not result then return false end

	local hitPart = result.Instance
	local model = hitPart:FindFirstAncestorOfClass("Model")
	if not model then return false end

	local humanoid = model:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then return false end

	local player = Players:GetPlayerFromCharacter(model)
	if not player or player == Player then return false end

	return true
end

local function fireWeapon()
	pcall(function()
		VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 0)
		VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 0)
	end)
	-- Fallback
	pcall(function()
		VirtualUser:Button1Down()
		wait(0.05)
		VirtualUser:Button1Up()
	end)
end

--==============================================================
-- SILENT AIM: SAFE RAYCAST HOOK
--==============================================================

local silentAimActive = false
local hookSuccessful = false

-- Try to use hookfunction if available (most executors)
if hookfunction then
	pcall(function()
		local oldRaycast = workspace.Raycast
		hookfunction(workspace.Raycast, function(self, origin, direction, params)
			if silentAimActive and SilentAimEnabled and Shooting then
				local target = getClosestTarget(SilentAimFOVRadius)
				if target and target.Character then
					local targetPart = getTargetPart(target.Character)
					if targetPart then
						-- Check line of sight using oldRaycast
						local losParams = RaycastParams.new()
						losParams.FilterType = Enum.RaycastFilterType.Exclude
						losParams.FilterDescendantsInstances = { Player.Character }
						losParams.IgnoreWater = true
						local losResult = oldRaycast(self, origin, (targetPart.Position - origin).Unit * 1000, losParams)
						if losResult and losResult.Instance then
							local hitModel = losResult.Instance:FindFirstAncestorOfClass("Model")
							if hitModel then
								local hitPlayer = Players:GetPlayerFromCharacter(hitModel)
								if hitPlayer == target then
									-- Redirect bullet
									local newDirection = (targetPart.Position - origin).Unit * direction.Magnitude
									return oldRaycast(self, origin, newDirection, params)
								end
							end
						end
					end
				end
			end
			return oldRaycast(self, origin, direction, params)
		end)
		hookSuccessful = true
	end)
end

-- Fallback: try direct reassignment (not recommended, but if it works)
if not hookSuccessful then
	pcall(function()
		local oldRaycast = workspace.Raycast
		workspace.Raycast = function(self, origin, direction, params)
			if silentAimActive and SilentAimEnabled and Shooting then
				local target = getClosestTarget(SilentAimFOVRadius)
				if target and target.Character then
					local targetPart = getTargetPart(target.Character)
					if targetPart then
						local losParams = RaycastParams.new()
						losParams.FilterType = Enum.RaycastFilterType.Exclude
						losParams.FilterDescendantsInstances = { Player.Character }
						losParams.IgnoreWater = true
						local losResult = oldRaycast(self, origin, (targetPart.Position - origin).Unit * 1000, losParams)
						if losResult and losResult.Instance then
							local hitModel = losResult.Instance:FindFirstAncestorOfClass("Model")
							if hitModel then
								local hitPlayer = Players:GetPlayerFromCharacter(hitModel)
								if hitPlayer == target then
									local newDirection = (targetPart.Position - origin).Unit * direction.Magnitude
									return oldRaycast(self, origin, newDirection, params)
								end
							end
						end
					end
				end
			end
			return oldRaycast(self, origin, direction, params)
		end
		hookSuccessful = true
	end)
end

if not hookSuccessful then
	print("[KR7] Silent Aim hook failed. Magic bullets disabled.")
end

--==============================================================
-- AIM UI ELEMENTS
--==============================================================

-- Aimbot Toggle
AimTab:CreateToggle({
	name = "Aimbot",
	currentValue = false,
	callback = function(value)
		AimbotEnabled = value
	end
})

-- Aimbot Smoothness
AimTab:CreateSlider({
	name = "Aim Smoothness",
	range = {0, 10},
	increment = 1,
	suffix = "",
	currentValue = 5,
	callback = function(value)
		AimSmoothness = value
	end
})

-- Aimbot Draw FOV
AimTab:CreateToggle({
	name = "Draw FOV (Aimbot)",
	currentValue = false,
	callback = function(value)
		DrawFOVAimbot = value
		if not value then FOVCircleAimbot.Visible = false end
	end
})

-- Aimbot FOV Radius
AimTab:CreateSlider({
	name = "FOV Radius (Aimbot)",
	range = {25, 1000},
	increment = 1,
	suffix = " px",
	currentValue = 150,
	callback = function(value)
		AimbotFOVRadius = value
	end
})

--==============================================================
-- INPUT HANDLING
--==============================================================

UserInputService.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		Aiming = true
	end
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		Shooting = true
		if SilentAimEnabled then
			silentAimActive = true
		end
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		Aiming = false
	end
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		Shooting = false
		silentAimActive = false
	end
end)

--==============================================================
-- UPDATE FOV CIRCLES
--==============================================================

local function updateFOVCircles()
	local aimPoint = getAimScreenPosition()

	if DrawFOVAimbot then
		FOVCircleAimbot.Size = UDim2.fromOffset(AimbotFOVRadius * 2, AimbotFOVRadius * 2)
		FOVCircleAimbot.Position = UDim2.fromOffset(aimPoint.X, aimPoint.Y)
		FOVCircleAimbot.Visible = true
	else
		FOVCircleAimbot.Visible = false
	end

	if DrawFOVSilent then
		FOVCircleSilent.Size = UDim2.fromOffset(SilentAimFOVRadius * 2, SilentAimFOVRadius * 2)
		FOVCircleSilent.Position = UDim2.fromOffset(aimPoint.X, aimPoint.Y)
		FOVCircleSilent.Visible = true
	else
		FOVCircleSilent.Visible = false
	end
end

--==============================================================
-- MAIN RENDER LOOP
--==============================================================

pcall(function()
	RunService:UnbindFromRenderStep("KR7AimAssist")
end)

RunService:BindToRenderStep("KR7AimAssist", Enum.RenderPriority.Camera.Value + 1, function()
	updateFOVCircles()

	-- Aimbot
	if AimbotEnabled and Aiming then
		local target = getClosestTarget(AimbotFOVRadius)
		if target then
			aimAtTarget(target, AimSmoothness)
		end
	end

	-- Trigger Bot
	if TriggerBotEnabled and not Shooting then
		if getTargetUnderCursor() then
			fireWeapon()
		end
	end
end)

--################################################################
-- MISC
--################################################################

local HeadshotSoundEnabled = false

local HeadshotSound = Instance.new("Sound")
HeadshotSound.Name = "KR7HeadshotSound"
HeadshotSound.SoundId = "rbxassetid://5043539486"
HeadshotSound.Volume = 2
HeadshotSound.PlaybackSpeed = 1
HeadshotSound.Looped = false
HeadshotSound.Parent = SoundService

MiscTab:CreateToggle({
	name = "Headshot Sound",
	currentValue = false,
	callback = function(value)
		HeadshotSoundEnabled = value
	end
})

local function playHeadshotSound()
	if not HeadshotSoundEnabled then return end
	HeadshotSound:Stop()
	HeadshotSound.TimePosition = 0
	HeadshotSound:Play()
end

-- ACS HITMARKER HOOK & MUTE BASE HS
local MuteBaseHS = false
local BaseHSOriginalVolume = nil

local function updateBaseHSMute()
	if not BaseHSOriginalVolume then return end
	local hitmarkerScript = ReplicatedStorage:FindFirstChild("ACS_Engine")
		and ReplicatedStorage.ACS_Engine:FindFirstChild("Modules")
		and ReplicatedStorage.ACS_Engine.Modules:FindFirstChild("Hitmarker")
	if hitmarkerScript and hitmarkerScript:IsA("ModuleScript") then
		local headshotSound = hitmarkerScript:FindFirstChild("HeadshotHitmarker")
		if headshotSound and headshotSound:IsA("Sound") then
			headshotSound.Volume = MuteBaseHS and 0 or BaseHSOriginalVolume
		end
	end
end

task.spawn(function()
	local success, Hitmarker = pcall(function()
		return require(ReplicatedStorage:WaitForChild("ACS_Engine"):WaitForChild("Modules"):WaitForChild("Hitmarker"))
	end)
	if not success then
		warn("[KR7] Could not load ACS Hitmarker")
		return
	end
	if type(Hitmarker) ~= "table" then return end
	if type(Hitmarker.playMLGHitmarker) ~= "function" then return end

	local hitmarkerScript = ReplicatedStorage.ACS_Engine.Modules.Hitmarker
	local headshotSound = hitmarkerScript:FindFirstChild("HeadshotHitmarker")
	if headshotSound and headshotSound:IsA("Sound") then
		BaseHSOriginalVolume = headshotSound.Volume
	end

	updateBaseHSMute()

	local original = Hitmarker.playMLGHitmarker
	Hitmarker.playMLGHitmarker = function(hitType, isHeadshot, ...)
		if isHeadshot == true then
			playHeadshotSound()
		end
		return original(hitType, isHeadshot, ...)
	end

	print("[KR7] Headshot sound hook loaded")
end)

MiscTab:CreateToggle({
	name = "Mute Base HS",
	currentValue = false,
	callback = function(value)
		MuteBaseHS = value
		updateBaseHSMute()
	end
})

-- PREDICTED HEADSHOT SOUND
local PredictedHeadshotSoundEnabled = false

MiscTab:CreateToggle({
	name = "Predicted Headshot Sound",
	currentValue = false,
	callback = function(value)
		PredictedHeadshotSoundEnabled = value
	end
})

local function predictHeadshot()
	local camera = workspace.CurrentCamera
	if not camera then return end

	local whitelist = {}
	for _, player in ipairs(Players:GetPlayers()) do
		if player ~= Player and player.Character then
			local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
			if humanoid and humanoid.Health > 0 then
				for _, part in ipairs(player.Character:GetDescendants()) do
					if part:IsA("BasePart") then
						table.insert(whitelist, part)
					end
				end
			end
		end
	end
	if #whitelist == 0 then return end

	local origin, direction
	if UserInputService.MouseEnabled then
		local mouse = UserInputService:GetMouseLocation()
		local ray = camera:ScreenPointToRay(mouse.X, mouse.Y, 0)
		origin = ray.Origin
		direction = ray.Direction * 1000
	else
		origin = camera.CFrame.Position
		direction = camera.CFrame.LookVector * 1000
	end

	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Whitelist
	params.FilterDescendantsInstances = whitelist
	params.IgnoreWater = true

	local result = workspace:Raycast(origin, direction, params)
	if not result then return end

	local hitPart = result.Instance
	local isHeadshot = false
	if hitPart.Name == "Head" then
		isHeadshot = true
	else
		local model = hitPart:FindFirstAncestorOfClass("Model")
		if model then
			local head = model:FindFirstChild("Head")
			if head and hitPart:IsDescendantOf(head) then
				isHeadshot = true
			end
		end
	end
	if isHeadshot then
		playHeadshotSound()
	end
end

local LastPredictedShot = 0
local PredictedShotCooldown = 0.05

UserInputService.InputBegan:Connect(function(input)
	if not PredictedHeadshotSoundEnabled then return end
	if input.UserInputType == Enum.UserInputType.MouseButton1 then
		local now = os.clock()
		if now - LastPredictedShot >= PredictedShotCooldown then
			LastPredictedShot = now
			task.defer(predictHeadshot)
		end
	end
end)

--################################################################
-- WATCHERS
--################################################################

local function watchContainer(container)
	if not container then return end
	container.DescendantAdded:Connect(function(object)
		if not SkinEnabled then return end
		task.defer(function()
			if object:IsA("BasePart") then
				applyToPart(object)
			end
		end)
	end)
end

local function setupGunWatcher(character)
	if not character then return end
	character.ChildAdded:Connect(function(child)
		if not child:IsA("Tool") then return end
		task.wait(0.25)
		if child:FindFirstChild("ACS_Settings") then
			table.clear(OriginalRecoil)
			if GunStatsEnabled then
				applyGunStats()
			end
		end
	end)
end

Player.CharacterAdded:Connect(function(character)
	table.clear(Originals)
	table.clear(OriginalRecoil)
	setupGunWatcher(character)
	watchContainer(character)
	character:WaitForChild("Humanoid", 10)
	character:WaitForChild("HumanoidRootPart", 10)
	task.wait(0.5)
	if SkinEnabled then updateSkin() end
	if GunStatsEnabled then applyGunStats() end
end)

if Player.Character then
	setupGunWatcher(Player.Character)
	watchContainer(Player.Character)
end

local backpack = Player:FindFirstChildOfClass("Backpack")
if backpack then watchContainer(backpack) end
Player.ChildAdded:Connect(function(child)
	if child:IsA("Backpack") then
		watchContainer(child)
	end
end)

if workspace.CurrentCamera then
	watchContainer(workspace.CurrentCamera)
end

--################################################################
-- PERIODIC UPDATES
--################################################################

local SkinTimer = 0
local GunTimer = 0

RunService.RenderStepped:Connect(function(deltaTime)
	if SkinEnabled then
		SkinTimer += deltaTime
		if SkinTimer >= 0.1 then
			SkinTimer = 0
			updateSkin()
		end
	end
	if GunStatsEnabled then
		GunTimer += deltaTime
		if GunTimer >= 0.15 then
			GunTimer = 0
			applyGunStats()
		end
	end
end)

print("kr7 loaded, enjoy!")