Andrew tate cc

getgenv().AndrewTate = {
    ["GunFov"] = {
        ['Enabled'] = false,
        ['DoubleBarrel'] = 22.5,
        ['Revolver'] = 27.5,
        ['Shotgun'] = 35,
        ['TacticalShotgun'] = 35,
        ['Smg'] = 25,
        ['Silencer'] = 32.5,
    },
    ["Resolver"] = {
        ['Enabled'] = 'false',
    },
    ["Spin"] = {
        ['Enabled'] = true,
        ['SpinSpeed'] = 4900,
        ['Degrees'] = 360,
        ['Keybind'] = Enum.KeyCode.V,
    },
    ["KOChecks"] = {
        ['Wall'] = true,
        ['Knocked'] = false,
        ['DisableOnDeath'] = true,
        ['DisableOutsideFov'] = false,
        ['AntiGroundShots'] = true,
    },
    ["Fov"] = {
        ['HolSilentV'] = {
            ['Visible'] = false,
            ['Filled'] = false,
            ['Size'] = 50,
            ['Thickness'] = 2.5,
            ['Transparency'] = 0.15,
            ['Sides'] = 100,
            ['Color'] = Color3.fromRGB(0, 0, 0),
        },
        ["AimAssist"] = {
            ['Visible'] = false,
            ['Filled'] = false,
            ['Size'] = 60,
            ['Thickness'] = 3,
            ['Transparency'] = 0.25,
            ['Sides'] = 100,
            ['Color'] = Color3.fromRGB(255, 0, 0),
        },
    },
    ["AimAssist"] = {
        ['Enabled'] = true,
        ['Keybind'] = 'c',
        ['Predict'] = true,
        ['Prediction'] = 0.129,
        ['SmoothnessValue'] = 0.9818,
        ['Shake'] = false,
        ['ShakeValue'] = 1,
        ['Aimpart'] = 'Head',
        ['NearestCursorAimpart'] = true,
    },
    ["RobloxTextures"] = {
        ['Enabled'] = true,
        ['Material'] = Enum.Material.Brick,
        ['Color'] = Color3.fromRGB(244, 244, 244)
    },
    ["Config"] = {
        ['Shake'] = false,
        ['Smoothness'] = true,
        ['AirShakeValue'] = 4,
        ['AirSmoothnessValue'] = 0.217,
        ['GroundShakeValue'] = 10,
        ['GroundSmoothnessValue'] = '0.0576',
    },
    ["Range"] = {
        ['Enabled'] = false,
        ['Type'] = 'Fov',
        ['CloseDetection'] = 25,
        ['MidDetection'] = 60,
        ['FarDetection'] = 115,
        ['VeryFarDetection'] = math.huge,
        ['CloseFov'] = 60,
        ['ClosePrediction'] = 0.121,
        ['MidFov'] = 45,
        ['MidPrediction'] = 0.127,
        ['FarFov'] = 35,
        ['FarPrediction'] = 0.131,
        ['VeryFarFov'] = 20,
        ['VeryFarPrediction'] = 0.134,
    },
    ["HolSilentV"] = {
        ['Enabled'] = true,
        ['UseKeybind'] = false,
        ['Keybind'] = 'j',
        ['Predict'] = true,
        ['Prediction'] = 0.116,
        ['Aimpart'] = 'UpperTorso',
        ['NearestCursorAimpart'] = false,
    },
}

for Key, Object in pairs(getgc(true)) do
    if type(Object) == "table" then
        setreadonly(Object, false)
        local indexInstance = rawget(Object, "indexInstance")
        if type(indexInstance) == "table" and indexInstance[1] == "kick" then
            setreadonly(indexInstance, false)
            rawset(Object, "Table", {"kick", function() coroutine.yield() end}) --> By using coroutine.yield() we are preventing script table from communicating with the server.
            warn("\n---[ INFO ]---\nBypassed Adonis Anti-Cheat/Anti-Exploit.\nBypass Method: Preventing Script Table From Communicating With The Server.")
            break
        end
    end
end

if AndrewTate.RobloxTextures.Enabled then
    local function safeSetProperty(obj, prop, value)
        local success, err =
            pcall(
            function()
                obj[prop] = value
            end
        )
        return success
    end

    local function applyTextures(obj)
        if obj:IsA("BasePart") and not obj:IsDescendantOf(game.Players.LocalPlayer.Character) then
            safeSetProperty(obj, "Material", AndrewTate.RobloxTextures.Material)
            safeSetProperty(obj, "Color", AndrewTate.RobloxTextures.Color)
        elseif obj:IsA("Texture") or obj:IsA("Decal") then
            pcall(
                function()
                    obj.Transparency = 1
                end
            )
        end
    end

    local function applyToExisting()
        for _, obj in ipairs(workspace:GetDescendants()) do
            applyTextures(obj)
            if _ % 500 == 0 then
                task.wait()
            end -- Yield every 500 objects
        end
    end

    -- Apply to new objects
    local connection
    connection = workspace.DescendantAdded:Connect(applyTextures)

    -- Apply to existing objects and disconnect after a delay
    task.spawn(
        function()
            applyToExisting()
            task.wait(30) -- Run for 30 seconds, adjust as needed
            if connection then
                connection:Disconnect()
            end
        end
    )

    -- Reapply periodically to catch any missed changes
    task.spawn(
        function()
            while AndrewTate.RobloxTextures.Enabled do
                applyToExisting()
                task.wait(60) -- Reapply every 60 seconds, adjust as needed
            end
        end
    )
end

if getgenv().AndrewTate.Spin.Enabled == true then
    
    local Players = game:GetService("Players")
    local UserInputService = game:GetService("UserInputService")
    local RunService = game:GetService("RunService")
    local Camera = workspace.CurrentCamera
    local Toggle = getgenv().AndrewTate.Spin.Enabled
    local RotationSpeed = getgenv().AndrewTate.Spin.SpinSpeed
    local Keybind = getgenv().AndrewTate.Spin.Keybind
    
    local function OnKeyPress(Input, GameProcessedEvent)
        if Input.KeyCode == Keybind and not GameProcessedEvent then 
            Toggle = not Toggle
        end
    end
    
    UserInputService.InputBegan:Connect(OnKeyPress)
    
    local LastRenderTime = 0
    local TotalRotation = 0
    
    local function RotateCamera()
        if Toggle then
            local CurrentTime = tick()
            local TimeDelta = math.min(CurrentTime - LastRenderTime, 0.01)
            LastRenderTime = CurrentTime
    
            local RotationAngle = RotationSpeed * TimeDelta
            local Rotation = CFrame.fromAxisAngle(Vector3.new(0, 1, 0), math.rad(RotationAngle))
            Camera.CFrame = Camera.CFrame * Rotation
    
            TotalRotation = TotalRotation + RotationAngle
            if TotalRotation >= getgenv().AndrewTate.Spin.Degrees then 
                Toggle = false
                TotalRotation = 0
            end
        end
    end
    
    RunService.RenderStepped:Connect(RotateCamera)
    end

local targ = nil
local Plr  = nil

local Players, Client, Mouse, RS, Camera =
    game:GetService("Players"),
    game:GetService("Players").LocalPlayer,
    game:GetService("Players").LocalPlayer:GetMouse(),
    game:GetService("RunService"),
    game:GetService("Workspace").CurrentCamera

local HolSilentVcircle = Drawing.new("Circle")

local tracercircle = Drawing.new("Circle")

HolSilentVcircle.Transparency = getgenv().AndrewTate.Fov.HolSilentV.Transparency
HolSilentVcircle.Thickness = getgenv().AndrewTate.Fov.HolSilentV.Thickness
HolSilentVcircle.Color = getgenv().AndrewTate.Fov.HolSilentV.Color
HolSilentVcircle.Filled = getgenv().AndrewTate.Fov.HolSilentV.Filled

tracercircle.Transparency = getgenv().AndrewTate.Fov.AimAssist.Transparency
tracercircle.Thickness = getgenv().AndrewTate.Fov.AimAssist.Thickness
tracercircle.Color = getgenv().AndrewTate.Fov.AimAssist.Color
tracercircle.Filled = getgenv().AndrewTate.Fov.AimAssist.Filled

local UpdateFOV = function ()
    if (not HolSilentVcircle and not tracercircle) then
        return HolSilentVcircle and tracercircle
    end
    tracercircle.Visible  = getgenv().AndrewTate.Fov.AimAssist.Visible
    tracercircle.Radius   = getgenv().AndrewTate.Fov.AimAssist.Size * 2
    tracercircle.Filled = getgenv().AndrewTate.Fov.AimAssist.Filled
    tracercircle.Thickness = getgenv().AndrewTate.Fov.AimAssist.Thickness
    tracercircle.Transparency = getgenv().AndrewTate.Fov.AimAssist.Transparency
    tracercircle.Position = Vector2.new(Mouse.X, Mouse.Y + (game:GetService("GuiService"):GetGuiInset().Y))
    tracercircle.Color = getgenv().AndrewTate.Fov.AimAssist.Color
    tracercircle.NumSides = getgenv().AndrewTate.Fov.AimAssist.Sides
    
    HolSilentVcircle.Visible  = getgenv().AndrewTate.Fov.HolSilentV.Visible
    HolSilentVcircle.Radius   = getgenv().AndrewTate.Fov.HolSilentV.Size * 2
    HolSilentVcircle.Filled = getgenv().AndrewTate.Fov.HolSilentV.Filled
    HolSilentVcircle.Thickness = getgenv().AndrewTate.Fov.HolSilentV.Thickness
    HolSilentVcircle.Transparency = getgenv().AndrewTate.Fov.HolSilentV.Transparency
    HolSilentVcircle.Position = Vector2.new(Mouse.X, Mouse.Y + (game:GetService("GuiService"):GetGuiInset().Y))
    HolSilentVcircle.Color = getgenv().AndrewTate.Fov.HolSilentV.Color
    HolSilentVcircle.NumSides = getgenv().AndrewTate.Fov.HolSilentV.Sides
    return HolSilentVcircle and tracercircle
end

RS.Heartbeat:Connect(UpdateFOV)

local WallCheck = function(destination, ignore)
    local Origin    = Camera.CFrame.p
    local CheckRay  = Ray.new(Origin, destination - Origin)
    local Hit       = game.workspace:FindPartOnRayWithIgnoreList(CheckRay, ignore)
    return Hit      == nil
end


local WTS = function (Object)
    local ObjectVector = Camera:WorldToScreenPoint(Object.Position)
    return Vector2.new(ObjectVector.X, ObjectVector.Y)
end

local IsOnScreen = function (Object)
    local IsOnScreen = Camera:WorldToScreenPoint(Object.Position)
    return IsOnScreen
end

local FilterObjs = function (Object)
    if string.find(Object.Name, "Gun") then
        return
    end
    if table.find({"Part", "MeshPart", "BasePart"}, Object.ClassName) then
        return true
    end
end

local ClosestPlrFromMouse = function()
    local Target, Closest = nil, 1/0
    
    for _ ,v in pairs(Players:GetPlayers()) do
    	if getgenv().AndrewTate.KOChecks.Wall then
    		if (v.Character and v ~= Client and v.Character:FindFirstChild("HumanoidRootPart")) then
    			local Position, OnScreen = Camera:WorldToScreenPoint(v.Character.HumanoidRootPart.Position)
    			local Distance = (Vector2.new(Position.X, Position.Y) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
    
    			if (HolSilentVcircle.Radius * 1.27 > Distance and Distance < Closest and OnScreen) and WallCheck(v.Character.HumanoidRootPart.Position, {Client, v.Character}) then
    				Closest = Distance
    				Target = v
    	

    			end
    		end
    	else
    		if (v.Character and v ~= Client and v.Character:FindFirstChild("HumanoidRootPart")) then
    			local Position, OnScreen = Camera:WorldToScreenPoint(v.Character.HumanoidRootPart.Position)
    			local Distance = (Vector2.new(Position.X, Position.Y) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
    
    			if (HolSilentVcircle.Radius * 1.27 > Distance and Distance < Closest and OnScreen) then
    				Closest = Distance
    				Target = v
    			end
    		end
    	end
    end
    return Target
end

local ClosestPlrFromMouse2 = function()
    local Target, Closest = nil, tracercircle.Radius * 1.27
    
    for _ ,v in pairs(Players:GetPlayers()) do
    	if (v.Character and v ~= Client and v.Character:FindFirstChild("HumanoidRootPart")) then
        	if getgenv().AndrewTate.KOChecks.Wall then
        		local Position, OnScreen = Camera:WorldToScreenPoint(v.Character.HumanoidRootPart.Position)
        		local Distance = (Vector2.new(Position.X, Position.Y) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
        
        		if (Distance < Closest and OnScreen) and WallCheck(v.Character.HumanoidRootPart.Position, {Client, v.Character}) then
        			Closest = Distance
        			Target = v
        		end
        	    else
        			local Position, OnScreen = Camera:WorldToScreenPoint(v.Character.HumanoidRootPart.Position)
        			local Distance = (Vector2.new(Position.X, Position.Y) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
        
        			if (Distance < Closest and OnScreen) then
        				Closest = Distance
        				Target = v
        			end
        		end
            end
        end
    return Target
end

local GetClosestBodyPart = function (character)
    local ClosestDistance = 1/0
    local BodyPart = nil
    
    if (character and character:GetChildren()) then
        for _,  x in next, character:GetChildren() do
            if FilterObjs(x) and IsOnScreen(x) then
                local Distance = (WTS(x) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
                if (HolSilentVcircle.Radius * 1.27 > Distance and Distance < ClosestDistance) then
                    ClosestDistance = Distance
                    BodyPart = x
                end
            end
        end
    end
    return BodyPart
end

local GetClosestBodyPartV2 = function (character)
    local ClosestDistance = 1/0
    local BodyPart = nil
    
    if (character and character:GetChildren()) then
        for _,  x in next, character:GetChildren() do
            if FilterObjs(x) and IsOnScreen(x) then
                local Distance = (WTS(x) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
                if (Distance < ClosestDistance) then
                    ClosestDistance = Distance
                    BodyPart = x
                end
            end
        end
    end
    return BodyPart
end

Mouse.KeyDown:Connect(function(Key)
    local Keybind = getgenv().AndrewTate.AimAssist.Keybind:lower()
    if (Key == Keybind) then
        if getgenv().AndrewTate.AimAssist.Enabled == true then
            IsTargetting = not IsTargetting
            if IsTargetting then
                Plr = ClosestPlrFromMouse2()
            else
                if Plr ~= nil then
                    Plr = nil
                    IsTargetting = false
                end
            end
        end
    end
end)

Mouse.KeyDown:Connect(function(Key)
    local Keybind = getgenv().AndrewTate.HolSilentV.Keybind:lower()
    if (Key == Keybind) and getgenv().AndrewTate.HolSilentV.UseKeybind == true then
            if getgenv().AndrewTate.HolSilentV.Enabled == true then
				getgenv().AndrewTate.HolSilentV.Enabled = false
				if getgenv().AndrewTate.Options.Notifications == true then
				    
local Notify = AkaliNotif.Notify;
				Notify({
Description = "HolSilentV Disabled";
Title = "AndrewTate";
Duration = 1.5;
});
end 
                
            else
				getgenv().AndrewTate.HolSilentV.Enabled = true
				if getgenv().AndrewTate.Options.Notifications == true then
				    
local Notify = AkaliNotif.Notify;
				Notify({
Description = "HolSilentV Enabled";
Title = "AndrewTate";
Duration = 1.5;
});
end
                
            end
        end
    end
)






                            



-- Store the original metatable and index
local grmt = getrawmetatable(game)
local backupindex = grmt.__index
setreadonly(grmt, false)

-- Hook into the __index metamethod
grmt.__index = newcclosure(function(self, key)
    if tostring(key) == "Hit" and self:IsA("Mouse") and getgenv().AndrewTate.HolSilentV.Enabled then
        if targ and targ.Character then
            local aimpart = getgenv().AndrewTate.HolSilentV.Aimpart or "HumanoidRootPart" -- Default to Head if not set

            -- Get the target part
            local targetPart = targ.Character:FindFirstChild(aimpart)
            if targetPart then
                -- Force direct aim at the target part
                local endpoint = targetPart.Position

                -- Return the CFrame of the exact target part
                return CFrame.new(endpoint)
            end
        end
    end
    return backupindex(self, key)
end)

-- Restore readonly status
setreadonly(grmt, true)

RS.Heartbeat:Connect(function()
	if getgenv().AndrewTate.HolSilentV.Enabled then
	    if targ and targ.Character and targ.Character:WaitForChild(getgenv().AndrewTate.HolSilentV.Aimpart) then
            if getgenv().AndrewTate.Resolver.Enabled == true and targ.Character:WaitForChild("HumanoidRootPart").Velocity.magnitude > 70 then            
                pcall(function()
                    local TargetVel = targ.Character[getgenv().AndrewTate.HolSilentV.Aimpart]
                    TargetVel.Velocity = Vector3.new(0, 0, 0)
                    TargetVel.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
            
                end)
            end
            if getgenv().AndrewTate.KOChecks.AntiGroundShots == true and targ.Character:FindFirstChild("Humanoid") == Enum.HumanoidStateType.Freefall then
                pcall(function()
                    local TargetVelv5 = targ.Character[getgenv().AndrewTate.HolSilentV.Aimpart]
                    TargetVelv5.Velocity = Vector3.new(TargetVelv5.Velocity.X, (TargetVelv5.Velocity.Y * 5), TargetVelv5.Velocity.Z)
                    TargetVelv5.AssemblyLinearVelocity = Vector3.new(TargetVelv5.Velocity.X, (TargetVelv5.Velocity.Y * 5), TargetVelv5.Velocity.Z)
                end)
            end
            
            if getgenv().AndrewTate.Resolver.Enabled == true then            
                pcall(function()
                    local TargetVelv2 = targ.Character[getgenv().AndrewTate.HolSilentV.Aimpart]
                    TargetVelv2.Velocity = Vector3.new(TargetVelv2.Velocity.X, 0, TargetVelv2.Velocity.Z)
                    TargetVelv2.AssemblyLinearVelocity = Vector3.new(TargetVelv2.Velocity.X, 0, TargetVelv2.Velocity.Z)
                end)
            end
	    end
	end
	



if getgenv().AndrewTate.Config.Shake == true then
       if Plr.Character.Humanoid.FloorMaterial == Enum.Material.Air then
       
           getgenv().AndrewTate.AimAssist.ShakeValue = getgenv().AndrewTate.Config.AirShakeValue
       else
        getgenv().AndrewTate.AimAssist.ShakeValue  = getgenv().AndrewTate.Config.GroundShakeValue

  end
end

if getgenv().AndrewTate.Config.Smoothness == true then
       if Plr.Character.Humanoid.FloorMaterial == Enum.Material.Air then
       
           getgenv().AndrewTate.AimAssist.SmoothnessValue = getgenv().AndrewTate.Config.AirSmoothnessValue
       else
        getgenv().AndrewTate.AimAssist.SmoothnessValue = getgenv().AndrewTate.Config.GroundSmoothnessValue
  end
end




    if getgenv().AndrewTate.AimAssist.Enabled == true then
        if getgenv().AndrewTate.Resolver.Enabled == true and Plr and Plr.Character and Plr.Character:WaitForChild(getgenv().AndrewTate.AimAssist.Aimpart) and Plr.Character:WaitForChild("HumanoidRootPart").Velocity.magnitude > 70 then
            pcall(function()
                local TargetVelv3 = Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart]
                TargetVelv3.Velocity = Vector3.new(0, 0, 0)
                TargetVelv3.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
            end)
        end
        if getgenv().AndrewTate.KOChecks.AntiGroundShots == true and Plr.Character:FindFirstChild("Humanoid") == Enum.HumanoidStateType.Freefall then
                pcall(function()
                    local TargetVelv5 = Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart]
                    TargetVelv5.Velocity = Vector3.new(TargetVelv5.Velocity.X, (TargetVelv5.Velocity.Y * 5), TargetVelv5.Velocity.Z)
                    TargetVelv5.AssemblyLinearVelocity = Vector3.new(TargetVelv5.Velocity.X, (TargetVelv5.Velocity.Y * 5), TargetVelv5.Velocity.Z)
                end)
        end
    
        if getgenv().AndrewTate.Resolver.Enabled == true and Plr and Plr.Character and Plr.Character:WaitForChild(getgenv().AndrewTate.AimAssist.Aimpart) then
            pcall(function()
                local TargetVelv4 = Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart]
                TargetVelv4.Velocity = Vector3.new(TargetVelv4.Velocity.X, 0, TargetVelv4.Velocity.Z)
                TargetVelv4.AssemblyLinearVelocity = Vector3.new(TargetVelv4.Velocity.X, 0, TargetVelv4.Velocity.Z)
            end)
        end
    end
end)

RS.RenderStepped:Connect(function()
	if getgenv().AndrewTate.HolSilentV.Enabled then
        if getgenv().AndrewTate.KOChecks.Knocked == true and targ and targ.Character then 
            local KOd = targ.Character:WaitForChild("BodyEffects")["K.O"].Value
            local Grabbed = targ.Character:FindFirstChild("GRABBING_CONSTRAINT") ~= nil
            if KOd or Grabbed then
                targ = nil
            end
        end
	end
    if getgenv().AndrewTate.AimAssist.Enabled == true then
        if getgenv().AndrewTate.KOChecks.Knocked == true and Plr and Plr.Character then 
            local KOd = Plr.Character:WaitForChild("BodyEffects")["K.O"].Value
            local Grabbed = Plr.Character:FindFirstChild("GRABBING_CONSTRAINT") ~= nil
            if KOd or Grabbed then
                Plr = nil
                IsTargetting = false
            end
        end
        
		if getgenv().AndrewTate.KOChecks.DisableOnDeath == true and Plr and Plr.Character:FindFirstChild("Humanoid") then
			if Plr.Character.Humanoid.health < 2 then
				Plr = nil
				IsTargetting = false
			end
		end
		if getgenv().AndrewTate.KOChecks.DisableOnDeath == true and Plr and Plr.Character:FindFirstChild("Humanoid") then
			if Client.Character.Humanoid.health < 2 then
				Plr = nil
				IsTargetting = false
			end
		end
        if getgenv().AndrewTate.KOChecks.DisableOutsideFov == true and Plr and Plr.Character and Plr.Character:WaitForChild("HumanoidRootPart") then
            if
            AimAssist.Radius <
                (Vector2.new(
                    Camera:WorldToScreenPoint(Plr.Character.HumanoidRootPart.Position).X,
                    Camera:WorldToScreenPoint(Plr.Character.HumanoidRootPart.Position).Y
                ) - Vector2.new(Mouse.X, Mouse.Y)).Magnitude
             then
                Plr = nil
                IsTargetting = false
            end
        end
		if getgenv().AndrewTate.AimAssist.Predict and Plr and Plr.Character and Plr.Character:FindFirstChild(getgenv().AndrewTate.AimAssist.Aimpart) then
			if getgenv().AndrewTate.AimAssist.Shake then
				local Main = CFrame.new(Camera.CFrame.p,Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Position + Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Velocity * getgenv().AndrewTate.AimAssist.Prediction +
				Vector3.new(
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue),
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue),
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue)
				) * 0.1)
				Camera.CFrame = Camera.CFrame:Lerp(Main, getgenv().AndrewTate.AimAssist.SmoothnessValue / 2, Enum.EasingStyle.Elastic, Enum.EasingDirection.InOut, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
			else
    			local Main = CFrame.new(Camera.CFrame.p,Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Position + Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Velocity * getgenv().AndrewTate.AimAssist.Prediction)
    			Camera.CFrame = Camera.CFrame:Lerp(Main, getgenv().AndrewTate.AimAssist.SmoothnessValue / 2, Enum.EasingStyle.Elastic, Enum.EasingDirection.InOut, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
			end
		elseif getgenv().AndrewTate.AimAssist.Predict == false and Plr and Plr.Character and Plr.Character:FindFirstChild(getgenv().AndrewTate.AimAssist.Aimpart) then
			if getgenv().AndrewTate.AimAssist.Shake then
				local Main = CFrame.new(Camera.CFrame.p,Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Position +
				Vector3.new(
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue),
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue),
					math.random(-getgenv().AndrewTate.AimAssist.ShakeValue, getgenv().AndrewTate.AimAssist.ShakeValue)
				) * 0.1)
				Camera.CFrame = Camera.CFrame:Lerp(Main, getgenv().AndrewTate.AimAssist.SmoothnessValue / 2, Enum.EasingStyle.Elastic, Enum.EasingDirection.InOut, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
		    else
    			local Main = CFrame.new(Camera.CFrame.p,Plr.Character[getgenv().AndrewTate.AimAssist.Aimpart].Position)
    			Camera.CFrame = Camera.CFrame:Lerp(Main, getgenv().AndrewTate.AimAssist.SmoothnessValue / 2, Enum.EasingStyle.Elastic, Enum.EasingDirection.InOut, Enum.EasingStyle.Sine, Enum.EasingDirection.Out)
		    end
		end
	end
end)

task.spawn(function ()
    while task.wait() do
    	if getgenv().AndrewTate.HolSilentV.Enabled then
            targ = ClosestPlrFromMouse()
    	end
        if Plr then
            if getgenv().AndrewTate.AimAssist.Enabled and (Plr.Character) and getgenv().AndrewTate.AimAssist.NearestCursorAimpart then
                getgenv().AndrewTate.AimAssist.Aimpart = tostring(GetClosestBodyPartV2(Plr.Character))
            end
        end
        if targ then
            if getgenv().AndrewTate.HolSilentV.Enabled and (targ.Character) and getgenv().AndrewTate.HolSilentV.NearestCursorAimpart then
                getgenv().AndrewTate.HolSilentV.Aimpart = tostring(GetClosestBodyPart(targ.Character))
            end
        end
    end
end)

getgenv().uhpoop = {
    ["Enabled"] = (getgenv().AndrewTate.GunFov.Enabled),
    ["Double-Barrel SG"] = {["FOV"] = (getgenv().AndrewTate.GunFov.DoubleBarrel)}, --// Db
    ["DoubleBarrel"] = {["FOV"] = (getgenv().AndrewTate.GunFov.DoubleBarrel)}, --// Db
    ["Revolver"] = {["FOV"] = (getgenv().AndrewTate.GunFov.Revolver)}, --// Rev
    ["SMG"] = {["FOV"] = (getgenv().AndrewTate.GunFov.Smg)}, --// Uzi/Smg
    ["Shotgun"] = {["FOV"] = (getgenv().AndrewTate.GunFov.Shotgun)}, --// Sg
    ["TacticalShotgun"] = {["FOV"] = (getgenv().AndrewTate.GunFov.TacticalShotgun)}, --// Tac
    ["Silencer"] = {["FOV"] = (getgenv().AndrewTate.GunFov.Silencer)}, -- smg
    
}                 

local Script = {Functions = {}}
    Script.Functions.getToolName = function(name)
        local split = string.split(string.split(name, "[")[2], "]")[1]
        return split
    end
    Script.Functions.getEquippedWeaponName = function()
        if (Client.Character) and Client.Character:FindFirstChildWhichIsA("Tool") then
           local Tool =  Client.Character:FindFirstChildWhichIsA("Tool")
           if string.find(Tool.Name, "%[") and string.find(Tool.Name, "%]") and not string.find(Tool.Name, "Wallet") and not string.find(Tool.Name, "Phone") then
              return Script.Functions.getToolName(Tool.Name)
           end
        end
        return nil
    end
    RS.RenderStepped:Connect(function()
    if Script.Functions.getEquippedWeaponName() ~= nil then
        local WeaponSettings = getgenv().uhpoop[Script.Functions.getEquippedWeaponName()]
        if WeaponSettings ~= nil and getgenv().AndrewTate.GunFov.Enabled == true then
            getgenv().AndrewTate.Fov.HolSilentV.Size = WeaponSettings.FOV
        else
            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Fov.HolSilentV.Size
        end
    end
end)

local Aiming = loadstring(game:HttpGet("https://raw.githubusercontent.com/GravesFr/opensourceskidded/main/s"))()
Aiming.TeamCheck(false)



local Workspace = game:GetService("Workspace")

local Players = game:GetService("Players")

local RunService = game:GetService("RunService")

local UserInputService = game:GetService("UserInputService")



local LocalPlayer = Players.LocalPlayer

local Mouse = LocalPlayer:GetMouse()

local CurrentCamera = Workspace.CurrentCamera


Aiming.FOV = 50
--------------------------------------------------
--------------------------------------------------- -fov 5.5-6.6 is legit

function Aiming.Check()
    if not (Aiming.Enabled == true and Aiming.Selected ~= LocalPlayer and Aiming.SelectedPart ~= nil) then
        return false
    end
end


game:GetService("RunService").Heartbeat:Connect(
                                function()
                                    if
                                        getgenv().AndrewTate.Range.Enabled == true and getgenv().AndrewTate.Range.Type == "Fov" and Aiming.Selected ~= nil and (Aiming.Selected.Character) and targ and targ.Character then
                                        if
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.CloseDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.CloseFov
                                            
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.MidDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.MidFov
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.FarDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.FarFov
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.VeryFarDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.VeryFarFov
                                        end
                                    end
                                end
                            )
                            
                            game:GetService("RunService").Heartbeat:Connect(
                                function()
                                    if
                                        getgenv().AndrewTate.Range.Enabled == true and getgenv().AndrewTate.Range.Type == "Prediction" and Aiming.Selected ~= nil and (Aiming.Selected.Character) and targ and Plr.Character then
                                        if
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.CloseDetection
                                         then
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.ClosePrediction
                                            
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.MidDetection
                                         then
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.MidPrediction
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.FarDetection
                                         then
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.FarPrediction
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.VeryFarDetection
                                         then
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.VeryFarPrediction
                                        end
                                    end
                                end
                            )
                            
                            game:GetService("RunService").Heartbeat:Connect(
                                function()
                                    if
                                        getgenv().AndrewTate.Range.Enabled == true and getgenv().AndrewTate.Range.Type == "Both" and Aiming.Selected ~= nil and (Aiming.Selected.Character) and targ and Plr.Character then
                                        if
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.CloseDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.CloseFov
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.ClosePrediction
                                            
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.MidDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.MidFov
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.MidPrediction
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.FarDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.FarFov
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.FarPrediction
                                        elseif
                                            (game.Players[Aiming.Selected.Name].Character.HumanoidRootPart.Position -
                                                game.Players.LocalPlayer.Character.HumanoidRootPart.Position).Magnitude <
                                                getgenv().AndrewTate.Range.VeryFarDetection
                                         then
                                            getgenv().AndrewTate.Fov.HolSilentV.Size = getgenv().AndrewTate.Range.VeryFarFov
                                            getgenv().AndrewTate.HolSilentV.Prediction = getgenv().AndrewTate.Range.VeryFarPrediction
                                        end
                                    end
                                end
                            )

            
      if getgenv().AndrewTate.Resolver.Enabled == true then 
          local hrp
local resolver = game:GetService("RunService")

demiseuwu.Heartbeat:Connect(function()
    pcall(function()
        for i,v in pairs(game.Players:GetChildren()) do
            if v ~= game.Players.LocalPlayer  then
                hrp = v.Character.HumanoidRootPart
                hrp.Velocity = Vector3.new(hrp.Velocity.X, 0, hrp.Velocity.Z)
            end
        end
    end)
end)
end