Aimbot by Phoenix

local TS = require(game.ReplicatedStorage.Tortoiseshell)
TS.Console:Log("--|_Phoenix Initialized_|--", Color3.fromRGB(255,10,255))


function run()





	-----------------------------------// aimbot script


	local cam = workspace.Camera
	local camera = workspace.Camera
	local plr = game:service'Players'.LocalPlayer
	local t
	local mouse = plr:GetMouse()
	local aimbot = true
	local whitelisted = {
		plr.Name;
	}

	local ray = Ray.new
	local ray_start




	local checkifwhitelisted = function(nam)
		local asd = false

		for _, a in pairs(whitelisted) do
			if nam == a then
				asd = true
			end
		end

		return asd
	end

	_G.gofor = "Head"
	local lPlayerTeam = nil

	function checkteam(name)
		local teams = game.Teams
		local plr_team = nil
		for i,v in pairs(teams:GetDescendants()) do
			if plr_team == nil then
				if v.Name == name then
					plr_team = v.Parent
					return plr_team
				end
			end
		end
	end
	lPlayerTeam = checkteam(plr.Name)

	function CheckIf(name)
		for i,v in pairs(workspace.Characters:children()) do
			if checkteam(name) ~= lPlayerTeam then
				return true
			end
		end
		return false
	end

	local function getcloseplayer()
		--pcall(function()
			local ignorelist = workspace.Characters[plr.Name].Hitbox:children''
			for i,v in pairs(workspace:children'') do
				if v:IsA("Model") then
					table.insert(ignorelist,v)
				end
			end
			local closestDist = 2e9
			local player

			for _, a in pairs(workspace.Characters:children()) do
				if a:IsA'Model' and game:service'Players':FindFirstChild(a.Name) and a.Name ~= plr.Name and checkifwhitelisted(a.Name) == false and CheckIf(a.Name) and a ~= nil then

					local dist = (workspace.Characters[plr.Name].Root.Position - a.Root.Position).magnitude

					if dist < closestDist then
						if a ~= nil and a:FindFirstChild'Hitbox' then
							if a.Hitbox:FindFirstChild'Head' then
								pcall(function()
									ray_start = workspace.Characters[plr.Name].Hitbox.Head.Position
									local vector = ( a.Hitbox.Head.Position - ray_start)
									local new_ray = ray(ray_start, vector.unit * 1000)
									local hit, position = workspace:FindPartOnRayWithIgnoreList(new_ray, ignorelist)

									if (hit and hit:isDescendantOf(a.Hitbox)) then
										closestDist = dist
										player = a.Hitbox
									end
								end)
							end
						end
					end


				end
			end

			return player
		--end)
	end

	mouse.KeyDown:connect(function(key)
		if key == "[" then
			if aimbot then
				aimbot = false
			else
				aimbot = true
			end
		end
	end)

	local closesthead = nil


	--------------------------------------------------------------------------////////////////////////// Cam Scripto

	game.Players.LocalPlayer.PlayerScripts.CameraScript.Disabled = true
	local UserInputService = game:GetService("UserInputService")
	local ReplicatedStorage = game:GetService("ReplicatedStorage")
	local Workspace = game:GetService("Workspace")
	local Players = game:GetService("Players")
	local TS = require(ReplicatedStorage:WaitForChild("Tortoiseshell"))
	local PLAYER = Players.LocalPlayer
	local CAMERA = Workspace.CurrentCamera
	local OFFSET = Vector3.new(0, 1.6, 0)
	local SPRINT_FOV_SCALE = 0.9
	local LEAN_DISTANCE = 2
	local LEAN_TILT = 0.15
	local MIN_Y, MAX_Y = -1.5, 1.5
	local SENSITIVITY = Vector2.new(0.004, 0.004)
	local recoilSpring = TS.Math.Spring:Create(1, 200, 30, 1)
	TS.Camera.FirstPerson.RecoilSpring = recoilSpring
	local character, root, state, sprinting, lean, vaulting, grounded, climbing, aiming, look, sliding, backpack, items, equipped, item, config
	local x, y = 0, 0
	local leanOffset = CFrame.new()
	local lastUpdate = 0
	local actionSpring = TS.Math.Spring:Create(1, 100, 10, 1)
	local slideFOV = 0
	local spectateChar
	local function Equipped(newItem)
		pcall(function()
			config = nil
			item = nil
			if newItem then
				config = TS.Items:GetConfig(newItem)
				item = newItem
			end
		end)
	end
	local function HandleCharacter(newCharacter)
		if newCharacter then
			character = nil
			spectateChar = nil
			root = newCharacter:WaitForChild("Root")
			state = newCharacter:WaitForChild("State")
			sprinting = state:WaitForChild("Sprinting")
			lean = state:WaitForChild("Lean")
			vaulting = state:WaitForChild("Vaulting")
			grounded = state:WaitForChild("Grounded")
			climbing = state:WaitForChild("Climbing")
			aiming = state:WaitForChild("Aiming")
			look = state:WaitForChild("Look")
			sliding = state:WaitForChild("Sliding")
			backpack = newCharacter:WaitForChild("Backpack")
			equipped = backpack:WaitForChild("Equipped")
			items = backpack:WaitForChild("Items")
			equipped.Changed:Connect(function()
				Equipped(equipped.Value)
			end)
			vaulting.Changed:Connect(function()
				if vaulting.Value then
					actionSpring:Shove(Vector3.new(sprinting.Value and -3 or -2, 0, 0))
				end
			end)
			climbing.Changed:Connect(function()
				if climbing.Value then
					actionSpring:Shove(Vector3.new(-10, 0, 0))
				end
			end)
			grounded.Changed:Connect(function()
				if not vaulting.Value and root.Velocity.Y < -60 then
					actionSpring:Shove(Vector3.new(root.Velocity.Y / 20, 0, 0))
				end
			end)
			newCharacter.DescendantAdded:Connect(function(obj)
				if obj:IsA("BasePart") then
					obj.LocalTransparencyModifier = 1
				end
			end)
			for _, v in pairs(newCharacter:GetDescendants()) do
				if v:IsA("BasePart") then
					v.LocalTransparencyModifier = 1
				end
			end
			Equipped(equipped.Value)
			character = newCharacter
		end
	end
	TS.Damage.CharacterKilled:Connect(function(char, _, player)
		if char == character and player then
			spectateChar = TS.Characters:GetCharacter(player)
		end
	end)
	TS.Characters.CharacterAdded:Connect(function(player, character)
		if player == PLAYER then
			HandleCharacter(character)
		end
	end)
	UserInputService.InputChanged:connect(function(inputObject, processed)
		if inputObject.UserInputType == Enum.UserInputType.MouseMovement then
			local fovSens = math.clamp((CAMERA.FieldOfView / TS.Camera.FieldOfView) ^ 1.5, 0, 1)
			x = (x - inputObject.Delta.X * SENSITIVITY.X * fovSens * TS.Camera.Sensitivity) % (math.pi * 2)
			y = math.clamp(y - inputObject.Delta.Y * SENSITIVITY.Y * fovSens * TS.Camera.Sensitivity, MIN_Y, MAX_Y)
		end
	end)
	CAMERA.FieldOfView = 1
	CAMERA.CameraType = Enum.CameraType.Scriptable
	HandleCharacter(TS.Characters:GetCharacter(PLAYER))


	TS.Timer:BindToRenderStep("Camera", 1, function(deltaTime)
		if workspace.Characters:FindFirstChild(plr.Name) == nil then
			TS.Timer:UnbindFromRenderStep('Camera')
		end
		if spectateChar then
			local center = spectateChar.PrimaryPart.Position + Vector3.new(0, 0.5, 0)
			CAMERA.FieldOfView = 50
			CAMERA.CFrame = CFrame.new(center) * CFrame.Angles(0, x, 0) * CFrame.Angles(y, 0, 0) * CFrame.new(0, 0, 15)
			CAMERA.Focus = CAMERA.CFrame * CFrame.new(0, 0, -20)
		elseif character and character.Parent then
			look.Value = y
			if sliding.Value then
				local speed = Vector2.new(root.Velocity.X, root.Velocity.Z).Magnitude
				slideFOV = TS.Math:Lerp(slideFOV, speed / 3 * (TS.Camera.FieldOfView / 90), math.min(deltaTime * 10, 1))
			else
				slideFOV = TS.Math:Lerp(slideFOV, 0, math.min(deltaTime * 10, 1))
			end
			local newFOV = TS.Camera.FieldOfView
			local center = root.CFrame:PointToWorldSpace(OFFSET)
			local player = getcloseplayer()
			if sprinting.Value then
				newFOV = newFOV * SPRINT_FOV_SCALE
			elseif aiming.Value then
				if aimbot then
					if player ~= nil then
						CAMERA.CoordinateFrame = CFrame.new(center, player.Head.Position)
					end
				end
				if item then
					newFOV = newFOV * config.Stats.AimFOV
				else
					newFOV = newFOV * 0.9
				end
			end
			CAMERA.FieldOfView = TS.Math:Lerp(CAMERA.FieldOfView, math.min(newFOV + slideFOV, 120), math.min(deltaTime * 10, 1))
			local leanAmount = lean.Value
			if math.abs(leanAmount) > 0.1 then
				local hit, position = TS.Raycast:CastGeometry(center + Vector3.new(0, -1, 0), root.CFrame:VectorToWorldSpace(Vector3.new(leanAmount * LEAN_DISTANCE * 2, 0, 0)))
				if hit then
					local distance = (position - center).Magnitude
					leanAmount = math.sin(lean.Value) * distance / (LEAN_DISTANCE * 2)
				end
			end
			local heightOffset = math.cos(leanAmount * math.pi / 2) - 1
			leanOffset = leanOffset:Lerp(CFrame.new(leanAmount * LEAN_DISTANCE, heightOffset * LEAN_DISTANCE / 4, 0) * CFrame.Angles(0, 0, -leanAmount * LEAN_TILT), math.min(deltaTime * 10, 1))
			actionSpring:Update(deltaTime)
			local actionOffset = CFrame.Angles(actionSpring.Position.X, actionSpring.Position.Y, actionSpring.Position.Z)
			local recoilOffset = CFrame.Angles(recoilSpring.Position.Y * 0, recoilSpring.Position.X * 0, 0)
			if aiming.Value == false or player == nil then
				CAMERA.CFrame = CFrame.new(center) * CFrame.Angles(0, x, 0) * CFrame.Angles(y, 0, 0) * leanOffset * actionOffset * recoilOffset
			end
			CAMERA.Focus = CAMERA.CFrame * CFrame.new(0, 0, -20)
			if 0.1 <= tick() - lastUpdate then
				lastUpdate = tick()
				TS.Network:Fire("Character", "State", "Look", y)
			end
		end
	end)
end

run()

workspace.Characters.ChildAdded:Connect(function(v)
	if v.Name == game.Players.LocalPlayer.Name then
		wait(.2)
		run()
	end
end)