getgenv().

Howl = {
["Type"] = "Target",
["UpdateNotification"] = true,
["Keybind"] = {
Aimbot = "C",
Resolver = "N",
Flip360 = "V",
Macro = "X",
},
["Aimbot"] = {
Prediction = 0.143,
Smoothness = 0.1222,
Part = "HumanoidRootPart",
PredictionAdjuster = true,

["MultipleParts"] = {
Enabled = false,
Parts = { "Head", "UpperTorso", "HumanoidRootPart",
"LowerTorso" },
},

["Shake"] = {
Enabled = false,
Amount = 5,
},

["MouseTp"] = {
Smoothness = 0.1,
Prediction = 0.1,
Part = "HumanoidRootPart",
},

["360"] = {
Enabled = true,
Speed = 2500,
},
},
["Silent"] = {
Prediction = 0.12731,
Part = "HumanoidRootPart",
PredictionAdjuster = true,
Detection = { Close = 35, Mid = 65, Far = [Link] },

["MultipleParts"] = {
Enabled = false,
Parts = { "Head", "UpperTorso", "HumanoidRootPart",
"LowerTorso" },
},

["Offsets"] = {
Jump = { Amount = -0.15 },
Fall = { Amount = 0.00 },
},
},
["FieldOfView"] = {
Enabled = false,
Size = 250,
Color = [Link](255, 255, 255),
Transparency = 1,
 Filled = false,

["Dotted FieldOfView"] = {
Enabled = true,
Visible = false,
Rainbow = true,

AmountOfDots = 80,
DotsSize = 1.5,
Thickness = 0.5,

["Pulse"] = {
Enabled = true,
Amplitude = 50,
Speed = 0.2,
},

["Spin"] = {
Enabled = true,
Speed = 2500,
},
},
},
["PredictionAdjuster"] = {
VelocityThreshold = 250,
},
["Checks"] = {
KnockedChecks = true,
TargetDeath = true,
PlayerDeath = true,
WallCheck = false,
},
["Resolver"] = {
Enabled = false,
Notification = true,
},
["Macro"] = {
Enabled = true,
Speed = 0.065,
Type = "Electron",
},
}

if getgenv().Loaded == true then

if [Link] == true then
game:GetService("StarterGui"):SetCore("SendNotification", {
Title = "[Link]/howlcc",
Text = "Updated Script Settings.",
Duration = 0.001,
})
end
return
end

local players = game:GetService("Players")

local starterGui = game:GetService("StarterGui")
local replicatedStorage = game:GetService("ReplicatedStorage")
local inputService = game:GetService("UserInputService")
local virtualInputManager = game:GetService("VirtualInputManager")
local runService = game:GetService("RunService")

local Games = {
[2788229376] = { Name = "Da Hood", Argument = "UpdateMousePosI2", Remote =
"MainEvent" },
[16033173781] = { Name = "Da Hood Macro", Argument = "UpdateMousePosI2", Remote
= "MainEvent" },
[7213786345] = { Name = "Da Hood VC", Argument = "UpdateMousePosI2", Remote =
"MainEvent" },
[9825515356] = { Name = "Hood Customs", Argument = "MousePosUpdate", Remote =
"MainEvent" },
[5602055394] = { Name = "Hood Modded", Argument = "MousePos", Remote =
"Bullets" },
[17403265390] = { Name = "Da Downhill", Argument = "MOUSE", Remote =
"MAINEVENT" },
[18111448661] = { Name = "Da Uphill", Argument = "MOUSE", Remote =
"MAINEVENT" },
[15186202290] = { Name = "Da Strike", Argument = "MOUSE", Remote =
"MAINEVENT" },
[17344804827] = { Name = "Yeno Hood", Argument = "UpdateMousePos", Remote =
"MainEvent" },
[17564718305] = { Name = "Da Nuketown", Argument = "MOUSE", Remote =
"MAINEVENT" },
[11143225577] = { Name = "1v1 Hood Aim Trainer", Argument = "UpdateMousePos",
Remote = "MainEvent" },
[17380542873] = { Name = "DA NUKE", Argument = "UpdateMousePos", Remote =
"MAINEVENT" },
[17061444544] = { Name = "Rae Hood", Argument = "UpdateMousePos", Remote =
"MainEvent" },
[14277620939] = { Name = "Custom FFA", Argument = "UpdateMousePos", Remote =
"MainEvent" },
[9183932460] = { Name = "Untitled Hood", Argument = "UpdateMousePos", Remote =
".gg/untitledhood" },
}

local mousePositionArgument = Games[[Link]] or { Argument = "UpdateMousePos",

Remote = "MainEvent" }

local localPlayer = [Link]

local camera = [Link]
local mainEvent = replicatedStorage:FindFirstChild([Link])

local isA = [Link]

local findFirstChild = [Link]

local findPartOnRayWithIgnoreList = [Link]

local getChildren = [Link]
local getPlayers = [Link]

local getMouseLocation = function() return inputService:GetMouseLocation() end

local worldToViewportPoint = function(pos) return camera:WorldToViewportPoint(pos)
end

local fireServer = mainEvent and [Link]

local twait = [Link]

local tspawn = [Link]

local tinsert = [Link]

local tfind = [Link]

local newVector3 = [Link]

local newVector2 = [Link]
local newCFrame = [Link]
local fromAxisAngle = [Link]

local newRay = [Link]

local fromHSV = [Link]

local min = [Link]

local random = [Link]
local abs = [Link]
local rad = [Link]
local sin = [Link]
local cos = [Link]
local inf = [Link]
local pi = [Link]

local upper = [Link]

local sub = [Link]

local freeFall = [Link]

local jumping = [Link]
local enumKeyCode = [Link]

local isLocking, targetPlayer = false, nil

local miniDots, aimbotCircle = {}, [Link]("Circle")
local toggle360, totalRotation, fullCircleRotation = false, 0, 2 * pi
local speedGlitching = false

local updateFieldOfViewDrawings = function()

local fieldOfView = [Link]
local pulseEffect = fieldOfView["Dotted FieldOfView"].Pulse

[Link] = [Link] and not fieldOfView["Dotted

FieldOfView"].Enabled
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = getMouseLocation()

if [Link] then
local time = tick()
local pulse = sin(time * [Link]) * [Link]
[Link] = [Link] + pulse
else
[Link] = [Link]
end
end

local createMiniDots = function()

local fieldOfView = [Link]
local dottedFieldOfView = fieldOfView["Dotted FieldOfView"]
local angleIncrement = 360 / [Link]

for i = 1, [Link] do
local miniDot = [Link]("Circle")
 [Link] = [Link]
[Link] = false
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]

tinsert(miniDots, { dot = miniDot, angleRad = rad(i * angleIncrement) })

end
end

local isPlayerAlive = function(player)

return [Link] and findFirstChild([Link], "Humanoid")
end

local wallCheck = function(character)

if not [Link] then
return true
end

local targetPosition = [Link]

local cameraPosition = [Link]
local distance = (targetPosition - cameraPosition).Magnitude

local hitPart, hitPosition = findPartOnRayWithIgnoreList(

workspace,
newRay(cameraPosition, (targetPosition - cameraPosition).Unit * distance),
{ [Link], character }
)

return hitPart == nil or (hitPosition - cameraPosition).Magnitude >= distance

end

local velocityCheck = function(character)

if not [Link] then
return false
end

local humanoidRootPart = [Link]

local humanoid = [Link]
local velocity = [Link]
local yVelocity = abs(velocity.Y)

if (yVelocity > 5 and humanoid:GetState() ~= freeFall) or yVelocity > 35 or

abs(velocity.X) > 35 or abs(velocity.Z) > 35 then
return true
end

return false
end

local adjustPrediction = function(config, part)

if not [Link] then
return [Link]
end

local prediction = [Link]

local velocity = [Link]
local max = [Link]
 return prediction + ((prediction * 1.5) - prediction) *
min([Link] / max, 1)
end

local getClosestPlayerToCursor = function(radius)

local shortestDistance = radius
local closestPlayer = nil
local mousePosition = getMouseLocation()
local part = [Link]

for _, player in next, getPlayers(players) do

local character = [Link]

if player ~= localPlayer and isPlayerAlive(player) and wallCheck(character)

then
local onScreenPosition, isOnScreen =
worldToViewportPoint(character[part].Position)
local distance = (newVector2(onScreenPosition.X, onScreenPosition.Y) -
mousePosition).Magnitude

if distance < shortestDistance and isOnScreen then

closestPlayer = player
shortestDistance = distance
end
end
end
return closestPlayer
end

local getClosestPartFromPlayerToCursor = function(multipleParts, character)

local shortestDistance = inf
local closestPart = nil
local mousePosition = getMouseLocation()
local parts = [Link]
local indexAmount = 0

for _, part in next, getChildren(character) do

if isA(part, "BasePart") and tfind(parts, [Link]) then
local onScreenPosition = worldToViewportPoint([Link])
local distance = (newVector2(onScreenPosition.X, onScreenPosition.Y) -
mousePosition).Magnitude

if distance < shortestDistance then

closestPart = part
shortestDistance = distance
end
indexAmount = indexAmount + 1
end

if indexAmount >= #parts then

break
end
end
return closestPart
end

local resolvePartVelocity = function(part)

local lastPosition = [Link]
 twait(0.145)
local currentPosition = [Link]

return (currentPosition - lastPosition) / 0.145

end

local getRandomVector3 = function(aimbot)

local positiveShakeAmount = [Link]
local negativeShakeAmount = -positiveShakeAmount
local factor = 0.01

return newVector3(
random(negativeShakeAmount, positiveShakeAmount) * factor,
random(negativeShakeAmount, positiveShakeAmount) * factor,
random(negativeShakeAmount, positiveShakeAmount) * factor
)
end

local spinAngle = 0
createMiniDots()

[Link]:Connect(function(deltaTime)
updateFieldOfViewDrawings()

local mainDotPosition = getMouseLocation()

local aimbot = [Link]
local dottedFieldOfView = [Link]["Dotted FieldOfView"]

if [Link] then
local baseRadius = [Link]
local radius = baseRadius

spinAngle = spinAngle + ([Link] * deltaTime / 1000)

if spinAngle >= 360 then
spinAngle = spinAngle - 360
end

for _, data in ipairs(miniDots) do

local miniDot = [Link]
local angle = [Link] + rad(spinAngle)
local offsetX = cos(angle) * radius
local offsetY = sin(angle) * radius

[Link] = mainDotPosition + newVector2(offsetX, offsetY)

if [Link] then
local hue = (tick() % 5) / 5
[Link] = fromHSV(hue, 1, 1)
end
end
end

if targetPlayer and isLocking and [Link] then

local character = [Link]
local isFalling = [Link]:GetState() == freeFall
local targetData = isFalling and [Link] or aimbot

local targetPart = isFalling and character[[Link]]

or ([Link] and
getClosestPartFromPlayerToCursor([Link], character)
or character[[Link]])

local alpha = [Link]

local prediction = adjustPrediction(targetData, targetPart)

local goalPosition = not velocityCheck(character) and ([Link]

+ [Link] * prediction)
or ([Link] + resolvePartVelocity(targetPart) * prediction)

if [Link] then
goalPosition = goalPosition + getRandomVector3(aimbot)
end

local goal = newCFrame([Link], goalPosition)

[Link] = [Link]:Lerp(goal, 1 - alpha)

local checks = [Link]

if [Link] then
local bodyEffects = findFirstChild(character, "BodyEffects")
local isKO = bodyEffects and bodyEffects["K.O"].Value
local isGrabbed = findFirstChild(character, "GRABBING_CONSTRAINT") ~=
nil
if [Link] <= 0 or isKO or isGrabbed then
targetPlayer = nil
isLocking = false
end
end

if [Link] and [Link] <= 0 then

targetPlayer = nil
isLocking = false
end

if [Link] and [Link] and

[Link] <= 0 then
targetPlayer = nil
isLocking = false
end
end
end)

[Link]:Connect(function(deltaTime)
if toggle360 and [Link]["360"].Enabled then
local rotationIncrement = rad([Link]["360"].Speed * deltaTime)
local remainingRotation = fullCircleRotation - totalRotation
rotationIncrement = min(rotationIncrement, remainingRotation)

local rotation = fromAxisAngle(newVector3(0, 1, 0), rotationIncrement)

[Link] = [Link] * rotation
totalRotation = totalRotation + rotationIncrement

if totalRotation >= fullCircleRotation then

toggle360 = false
totalRotation = 0
end
end
end)
local childActivatedConnection
local childAddedConnection
local childRemovedConnection

local childActivatedFunction = function()

local silentTarget = (upper([Link]) == "FOV" and
getClosestPlayerToCursor([Link])) or targetPlayer

if isLocking and silentTarget and [Link] and mainEvent then

local silent = [Link]
local character = [Link]
local targetPart = [Link]
and getClosestPartFromPlayerToCursor([Link], character)
or character[[Link]]
local hitPosition = [Link]
local humanoidStateType = [Link]:GetState()

if humanoidStateType == jumping then

hitPosition = hitPosition + newVector3(0, [Link],
0)
elseif humanoidStateType == freeFall then
hitPosition = hitPosition + newVector3(0, [Link],
0)
end

local targetVector = velocityCheck(character) and

resolvePartVelocity(targetPart) or [Link]

local currentGame = Games[[Link]] or { Argument = "UpdateMousePos",

Remote = "MainEvent" }
local adjustedPosition = hitPosition + (targetVector *
adjustPrediction(silent, targetPart))

if [Link] == "Hood Customs" then

fireServer(mainEvent, [Link], adjustedPosition +
newVector3(0, 0, 0))
else
fireServer(mainEvent, [Link], adjustedPosition)
end
end
end

local function onChildAdded(child)

if child:IsA("Tool") then
if childActivatedConnection then
childActivatedConnection:Disconnect()
end
childActivatedConnection = [Link]:Connect(childActivatedFunction)
end
end

local function onChildRemoved(child)

if child:IsA("Tool") and childActivatedConnection then
childActivatedConnection:Disconnect()
end
end

local function onCharacterAdded(character)

 if childAddedConnection then
childAddedConnection:Disconnect()
end
if childRemovedConnection then
childRemovedConnection:Disconnect()
end
if childActivatedConnection then
childActivatedConnection:Disconnect()
end

childAddedConnection = [Link]:Connect(onChildAdded)
childRemovedConnection = [Link]:Connect(onChildRemoved)
end

if [Link] then
onCharacterAdded([Link])
end

[Link]:Connect(onCharacterAdded)

local currentTool
for _, v in next, getChildren([Link] or {}) do
if isA(v, "Tool") then
currentTool = v
[Link] = localPlayer:FindFirstChildOfClass("Backpack")
break
end
end

[Link]:Connect(function(input, gameProcessedEvent)
if gameProcessedEvent then
return
end

local inputKeyCode = [Link]

local keyBind = [Link]

if inputKeyCode == enumKeyCode[upper([Link])] then

isLocking = not isLocking
targetPlayer = isLocking and getClosestPlayerToCursor(inf) or nil
elseif inputKeyCode == enumKeyCode[upper([Link])] then
local resolver = [Link]
[Link] = not [Link]
if [Link] then
starterGui:SetCore("SendNotification", {
Title = "Resolver",
Text = tostring([Link]),
Duration = 5,
})
end
elseif inputKeyCode == enumKeyCode[upper(keyBind.Flip360)] then
toggle360 = not toggle360
elseif inputKeyCode == enumKeyCode[upper([Link])] and [Link]
then
local macro = [Link]
speedGlitching = not speedGlitching

if speedGlitching then
if [Link] == "Third" then
 tspawn(function()
while speedGlitching do
local waittime = [Link] / 100
virtualInputManager:SendKeyEvent(true, "I", false, game)
twait(waittime)
virtualInputManager:SendKeyEvent(true, "O", false, game)
twait(waittime)
virtualInputManager:SendKeyEvent(true, "I", false, game)
twait(waittime)
virtualInputManager:SendKeyEvent(true, "O", false, game)
twait(waittime)
end
end)
elseif [Link] == "First" then
tspawn(function()
while speedGlitching do
local waittime = [Link] / 100
virtualInputManager:SendMouseWheelEvent(0, 0, true, game)
twait(waittime)
virtualInputManager:SendMouseWheelEvent(0, 0, false, game)
twait(waittime)
virtualInputManager:SendMouseWheelEvent(0, 0, true, game)
twait(waittime)
virtualInputManager:SendMouseWheelEvent(0, 0, false, game)
twait(waittime)
end
end)
elseif [Link] == "Electron" then
tspawn(function()
while speedGlitching do
virtualInputManager:SendKeyEvent(true, 0x49, false, game)
[Link]:Wait()
virtualInputManager:SendKeyEvent(true, 0x4F, false, game)
[Link]:Wait()
virtualInputManager:SendKeyEvent(false, 0x49, false, game)
[Link]:Wait()
virtualInputManager:SendKeyEvent(false, 0x4F, false, game)
[Link]:Wait()
end
end)
end
end
end
end)

getgenv().Loaded = true