local NothingLibrary =

loadstring(game:HttpGetAsync('https://raw.githubusercontent.com/3345-c-a-t-s-u-s/
NOTHING/main/source.lua'))()
local Notification = NothingLibrary.Notification()

Notification.new({
Title = "ikorz",
Description = "Auto Parry BETA Loaded",
Duration = 5,
Icon = "rbxassetid://8997385628"
})

local Windows = NothingLibrary.new({

Title = "ikorz",
Description = "Advanced Auto Parry System",
Keybind = Enum.KeyCode.LeftControl,
Logo = 'http://www.roblox.com/asset/?id=18898582662'
})

-- Services
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local VirtualInputManager = game:GetService("VirtualInputManager")
local Stats = game:GetService("Stats")

-- Player
local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local Humanoid = Character:WaitForChild("Humanoid")

-- Variables
local Alive = Workspace:FindFirstChild("Alive")
local Aerodynamic = false
local Aerodynamic_Time = tick()
local Last_Input = UserInputService:GetLastInputType()
local Vector2_Mouse_Location = nil
local Grab_Parry = nil
local Parry_Key = nil
local Remotes = {}
local Parries = 0
local disableParryUntil = 0
local abilityLastUsed = 0
local Connections_Manager = {}
local Animation = {storage = {}, current = nil, track = nil}
local Parried = false
local Closest_Entity = nil
local spectate_Enabled = false
local manualSpamSpeed = 10
local pingBased = true
local TargetSelectionMethod = ""
local Spamming = false

-- Get Parry Keys

task.spawn(function()
for _, Value in getgc() do
if type(Value) == 'function' and islclosure(Value) then
 local Protos = debug.getprotos(Value)
local Upvalues = debug.getupvalues(Value)
local Constants = debug.getconstants(Value)
if #Protos == 4 and #Upvalues == 24 and #Constants >= 102 then
local c62 = Constants[62]
local c64 = Constants[64]
local c65 = Constants[65]
Remotes[debug.getupvalue(Value, 16)] = c62
Parry_Key = debug.getupvalue(Value, 17)
Remotes[debug.getupvalue(Value, 18)] = c64
Remotes[debug.getupvalue(Value, 19)] = c65
break
end
end
end
end)

-- Auto Parry Functions

local Auto_Parry = {}
Auto_Parry.Parry_Type = "Straight"
Auto_Parry.Spam_Sensitivity = 50
Auto_Parry.Ping_Based_Spam = false

-- Parry Animation
Auto_Parry.Parry_Animation = function()
local Parry_Animation =
ReplicatedStorage.Shared.SwordAPI.Collection.Default:FindFirstChild("GrabParry")
local Current_Sword =
LocalPlayer.Character:GetAttribute("CurrentlyEquippedSword")

if (not Current_Sword or not Parry_Animation) then

return
end

local Sword_Data =
ReplicatedStorage.Shared.ReplicatedInstances.Swords.GetSword:Invoke(Current_Sword)

if (not Sword_Data or not Sword_Data['AnimationType']) then

return
end

for _, object in
pairs(ReplicatedStorage.Shared.SwordAPI.Collection:GetChildren()) do
if (object.Name == Sword_Data['AnimationType']) then
local sword_animation_type = (object:FindFirstChild("GrabParry") and
"GrabParry") or "Grab"
Parry_Animation = object[sword_animation_type]
end
end

Grab_Parry =
LocalPlayer.Character.Humanoid.Animator:LoadAnimation(Parry_Animation)
Grab_Parry:Play()
end

-- Play Animation
Auto_Parry.Play_Animation = function(animationName)
local Animations = Animation.storage[animationName]
 if not Animations then
return false
end

local Animator = LocalPlayer.Character.Humanoid.Animator

if (Animation.track and Animation.track:IsA("AnimationTrack")) then

Animation.track:Stop()
end

Animation.track = Animator:LoadAnimation(Animations)

if (Animation.track and Animation.track:IsA("AnimationTrack")) then

Animation.track:Play()
end

Animation.current = animationName
end

-- Get Balls
Auto_Parry.Get_Balls = function()
local Balls = {}

for _, instance in pairs(Workspace.Balls:GetChildren()) do

if instance:GetAttribute("realBall") then
instance.CanCollide = false
table.insert(Balls, instance)
end
end

return Balls
end

-- Get Ball
Auto_Parry.Get_Ball = function()
for _, instance in pairs(Workspace.Balls:GetChildren()) do
if instance:GetAttribute("realBall") then
instance.CanCollide = false
return instance
end
end
end

-- Get Parry Data

Auto_Parry.Parry_Data = function()
local Camera = workspace.CurrentCamera

if not Camera then

return {0, CFrame.new(), {}, {0, 0}}
end

local ViewportSize = Camera.ViewportSize

local MouseLocation = (Last_Input == Enum.UserInputType.MouseButton1 or
Last_Input == Enum.UserInputType.MouseButton2 or Last_Input ==
Enum.UserInputType.Keyboard)
and UserInputService:GetMouseLocation()
or Vector2.new(ViewportSize.X / 2, ViewportSize.Y / 2)

local Used = {MouseLocation.X, MouseLocation.Y}

 if TargetSelectionMethod == "ClosestToPlayer" then
Auto_Parry.Closest_Player()
local targetPlayer = Closest_Entity
if targetPlayer and targetPlayer.PrimaryPart then
Used = targetPlayer.PrimaryPart.Position
end
end

local Alive = workspace.Alive:GetChildren()

local Events = table.create(#Alive)

for _, v in ipairs(Alive) do
Events[tostring(v)] = Camera:WorldToScreenPoint(v.PrimaryPart.Position)
end

local pos = Camera.CFrame.Position

local look = Camera.CFrame.LookVector
local up = Camera.CFrame.UpVector
local right = Camera.CFrame.RightVector

local directions = {
Backwards = pos - look * 1000,
Random = Vector3.new(math.random(-3000, 3000), math.random(-3000, 3000),
math.random(-3000, 3000)),
Straight = pos + look * 1000,
Up = pos + up * 1000,
Right = pos + right * 1000,
Left = pos - right * 1000
}

local lookTarget = directions[Auto_Parry.Parry_Type] or (pos + look * 1000)

local DirectionCF = CFrame.new(pos, lookTarget)

return {0, DirectionCF, Events, Used}

end

-- Execute Parry
Auto_Parry.Parry = function()
local Parry_Data = Auto_Parry.Parry_Data()

local foundFake = false

for _, Args in pairs(Remotes) do
if Args == "PARRY_HASH_FAKE_1" or Args == "_G" then
foundFake = true
break
end
end

for Remote, Args in pairs(Remotes) do

local Hash
if foundFake then
Hash = nil
else
Hash = Args
end
Remote:FireServer(Hash, Parry_Key, Parry_Data[1], Parry_Data[2],
Parry_Data[3], Parry_Data[4])
end
 if Parries > 7 then
return false
end

Parries += 1

task.delay(0.5, function()
if Parries > 0 then
Parries -= 1
end
end)
end

-- Curve Detection
local Lerp_Radians = 0
local Last_Warping = tick()
local Previous_Velocity = {}
local Curving = tick()

Auto_Parry.Linear_Interpolation = function(a, b, time_volume)

return a + ((b - a) * time_volume)
end

Auto_Parry.Is_Curved = function()
local Ball = Auto_Parry.Get_Ball()

if not Ball then

return false
end

local Zoomies = Ball:FindFirstChild("zoomies")

if not Zoomies then

return false
end

local Velocity = Zoomies.VectorVelocity

local Ball_Direction = Velocity.Unit
local Direction = (LocalPlayer.Character.PrimaryPart.Position -
Ball.Position).Unit
local Dot = Direction:Dot(Ball_Direction)
local Speed = Velocity.Magnitude
local Distance = (LocalPlayer.Character.PrimaryPart.Position -
Ball.Position).Magnitude

if not pingBased then

if Speed < 100 then return false end
if Dot < 0.8 then return true end
if Distance > 100 then return false end
return false
end

local Ping = game:GetService("Stats").Network.ServerStatsItem["Data

Ping"]:GetValue()
local Speed_Threshold = math.min(Speed / 100, 40)
local Angle_Threshold = 40 * math.max(Dot, 0)
local Direction_Difference = (Ball_Direction - Velocity).Unit
local Direction_Similarity = Direction:Dot(Direction_Difference)
 local Dot_Difference = Dot - Direction_Similarity
local Dot_Threshold = 0.5 - (Ping / 975)
local Reach_Time = (Distance / Speed) - (Ping / 1000)
local Enough_Speed = Speed > 100
local Ball_Distance_Threshold = ((math.max(Ping/10,15) - math.min(Distance /
1000, 15)) + Angle_Threshold + Speed_Threshold)*(1+Ping/925)

table.insert(Previous_Velocity, Velocity)
if (#Previous_Velocity > 4) then
table.remove(Previous_Velocity, 1)
end

if (Enough_Speed and (Reach_Time > (Ping / 10))) then

Ball_Distance_Threshold = math.max(Ball_Distance_Threshold - 15, 15)
end

if (Distance < Ball_Distance_Threshold) then

return false
end

if ((tick() - Curving) < (Reach_Time / 1.5)) then

return true
end

if (Dot_Difference < Dot_Threshold) then

return true
end

local Radians = math.rad(math.asin(Dot))

Lerp_Radians = Auto_Parry.Linear_Interpolation(Lerp_Radians, Radians, 0.8)
if (Lerp_Radians < 0.018) then
Last_Warping = tick()
end

if ((tick() - Last_Warping) < (Reach_Time / 1.5)) then

return true
end

if (#Previous_Velocity == 4) then
local Intended_Direction_Difference = (Ball_Direction -
Previous_Velocity[1].Unit).Unit
local Intended_Dot = Direction:Dot(Intended_Direction_Difference)
local Intended_Dot_Difference = Dot - Intended_Dot
local Intended_Direction_Difference2 = (Ball_Direction -
Previous_Velocity[2].Unit).Unit
local Intended_Dot2 = Direction:Dot(Intended_Direction_Difference2)
local Intended_Dot_Difference2 = Dot - Intended_Dot2

if ((Intended_Dot_Difference < Dot_Threshold) or (Intended_Dot_Difference2

< Dot_Threshold)) then
return true
end
end

if ((tick() - Last_Warping) < (Reach_Time / 1.5)) then

return true
end

return Dot < Dot_Threshold

end

-- Find Closest Player

Auto_Parry.Closest_Player = function()
local Max_Distance = math.huge
Closest_Entity = nil

for _, Entity in pairs(Workspace.Alive:GetChildren()) do

if ((tostring(Entity) ~= tostring(LocalPlayer)) and Entity.PrimaryPart)
then
local Distance =
LocalPlayer:DistanceFromCharacter(Entity.PrimaryPart.Position)
if (Distance < Max_Distance) then
Max_Distance = Distance
Closest_Entity = Entity
end
end
end

return Closest_Entity
end

-- Get Entity Properties

Auto_Parry.Get_Entity_Properties = function(self)
Auto_Parry.Closest_Player()

if not Closest_Entity then

return false
end

local Entity_Velocity = Closest_Entity.PrimaryPart.Velocity

local Entity_Direction = (LocalPlayer.Character.PrimaryPart.Position -
Closest_Entity.PrimaryPart.Position).Unit
local Entity_Distance = (LocalPlayer.Character.PrimaryPart.Position -
Closest_Entity.PrimaryPart.Position).Magnitude

return {Velocity=Entity_Velocity, Direction=Entity_Direction,

Distance=Entity_Distance}
end

-- Get Ball Properties

Auto_Parry.Get_Ball_Properties = function(self)
local ball = Auto_Parry.Get_Ball()

if not ball then

return false
end

local character = LocalPlayer.Character

if (not character or not character.PrimaryPart) then

return false
end

local ballVelocity = ball.AssemblyLinearVelocity

local ballDirection = (character.PrimaryPart.Position - ball.Position).Unit
local ballDistance = (character.PrimaryPart.Position - ball.Position).Magnitude
local ballDot = ballDirection:Dot(ballVelocity.Unit)
 return {Velocity=ballVelocity, Direction=ballDirection, Distance=ballDistance,
Dot=ballDot}
end

-- Spam Service
Auto_Parry.Spam_Service = function(self)
local ball = Auto_Parry.Get_Ball()

if not ball then

return false
end

Auto_Parry.Closest_Player()

local spamDelay = 0
local spamAccuracy = 100

if not self.Spam_Sensitivity then

self.Spam_Sensitivity = 50
end

if not self.Ping_Based_Spam then

self.Ping_Based_Spam = false
end

local velocity = ball.AssemblyLinearVelocity

local speed = velocity.Magnitude
local direction = (LocalPlayer.Character.PrimaryPart.Position -
ball.Position).Unit
local dot = direction:Dot(velocity.Unit)
local targetPosition = Closest_Entity.PrimaryPart.Position
local targetDistance = LocalPlayer:DistanceFromCharacter(targetPosition)
local maximumSpamDistance = self.Ping + math.min(speed / 6.5, 95)

maximumSpamDistance = maximumSpamDistance * self.Spam_Sensitivity

if self.Ping_Based_Spam then
maximumSpamDistance = maximumSpamDistance + self.Ping
end

if ((self.Entity_Properties.Distance > maximumSpamDistance) or

(self.Ball_Properties.Distance > maximumSpamDistance) or (targetDistance >
maximumSpamDistance)) then
return spamAccuracy
end

local maximumSpeed = 5 - math.min(speed / 5, 5)

local maximumDot = math.clamp(dot, -1, 0) * maximumSpeed
spamAccuracy = maximumSpamDistance - maximumDot

task.wait(spamDelay)

return spamAccuracy
end

-- Ball Visualizer
local visualizerEnabled = false
local visualizer = Instance.new("Part")
visualizer.Shape = Enum.PartType.Ball
visualizer.Anchored = true
visualizer.CanCollide = false
visualizer.Material = Enum.Material.ForceField
visualizer.Transparency = 0.5
visualizer.Parent = Workspace
visualizer.Size = Vector3.zero

local function calculate_visualizer_radius(ball)

local velocity = ball:FindFirstChild("zoomies").VectorVelocity
return Spamming and 25 or math.clamp((velocity.Magnitude / 2.4) + 10, 15, 200)
end

local function toggle_visualizer(state)

visualizerEnabled = state
if not state then
visualizer.Size = Vector3.zero
end
end

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

local char = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()

local primaryPart = char and char.PrimaryPart
local ball = Auto_Parry.Get_Ball()

if not (primaryPart and ball) then

visualizer.Size = Vector3.zero
return
end

local target = ball:GetAttribute("target")

local isTargetingPlayer = (target == LocalPlayer.Name)
local radius = calculate_visualizer_radius(ball)

visualizer.Size = Vector3.new(radius, radius, radius)

visualizer.CFrame = primaryPart.CFrame
visualizer.Color = Spamming and Color3.fromRGB(255, 0, 0) or isTargetingPlayer
and Color3.fromRGB(255, 0, 0) or Color3.fromRGB(255, 255, 255)
end)

-- Create Tabs
local MainTab = Windows:NewTab({
Title = "Main",
Description = "Core Features",
Icon = "rbxassetid://7733960981"
})

local VisualTab = Windows:NewTab({

Title = "Visuals",
Description = "Visual Options",
Icon = "rbxassetid://7733964719"
})

local SettingsTab = Windows:NewTab({

Title = "Settings",
Description = "Advanced Settings",
Icon = "rbxassetid://7743869054"
})
-- Main Tab Sections
local CombatSection = MainTab:NewSection({
Title = "Combat",
Icon = "rbxassetid://7743869054",
Position = "Left"
})

local SpamSection = MainTab:NewSection({

Title = "Spam",
Icon = "rbxassetid://7733964719",
Position = "Right"
})

-- Visual Tab Section

local VisualSection = VisualTab:NewSection({
Title = "Visuals",
Icon = "rbxassetid://7733964719",
Position = "Left"
})

-- Settings Tab Section

local ParrySettings = SettingsTab:NewSection({
Title = "Parry",
Icon = "rbxassetid://7743869054",
Position = "Left"
})

local SpamSettings = SettingsTab:NewSection({

Title = "Spam",
Icon = "rbxassetid://7733964719",
Position = "Right"
})

-- Discord Button
CombatSection:NewButton({
Title = "Copy Discord",
Callback = function()
setclipboard('https://discord.gg/Cyeb4CJnyP')
Notification.new({
Title = "Discord",
Description = "Copied to clipboard!",
Duration = 5,
Icon = "rbxassetid://8997385628"
})
end
})

-- Auto Parry Toggle

CombatSection:NewToggle({
Title = "Auto Parry",
Default = false,
Callback = function(v)
if v then
Connections_Manager["Auto Parry"] =
RunService.PreSimulation:Connect(function()
local One_Ball = Auto_Parry.Get_Ball()
local Balls = Auto_Parry.Get_Balls()
 if (not Balls or (#Balls == 0)) then
return
end

for _, Ball in pairs(Balls) do

if not Ball then
return
end

local Zoomies = Ball:FindFirstChild("zoomies")

if not Zoomies then

return
end

Ball:GetAttributeChangedSignal("target"):Once(function()
Parried = false
end)

if Parried then
return
end

local Ball_Target = Ball:GetAttribute("target")

local One_Target = One_Ball and One_Ball:GetAttribute("target")
local Velocity = Zoomies.VectorVelocity
local character = LocalPlayer.Character

if (not character or not character.PrimaryPart) then

return
end

local Distance = (character.PrimaryPart.Position -

Ball.Position).Magnitude
local Speed = Velocity.Magnitude
local Ping =
game:GetService("Stats").Network.ServerStatsItem["Data Ping"]:GetValue() / 10
local Parry_Accuracy = (Speed / 3.25) + Ping
local Curved = Auto_Parry.Is_Curved()

if ((Ball_Target == tostring(LocalPlayer)) and Aerodynamic)

then
local Elapsed_Tornado = tick() - Aerodynamic_Time

if (Elapsed_Tornado > 0.6) then

Aerodynamic_Time = tick()
Aerodynamic = false
end

return
end

if ((One_Target == tostring(LocalPlayer)) and Curved) then

return
end

if ((Ball_Target == tostring(LocalPlayer)) and (Distance <=

Parry_Accuracy)) then
Auto_Parry.Parry()
 Parried = true
end

local Last_Parrys = tick()

while (tick() - Last_Parrys) < 1 do

if not Parried then
break
end

task.wait()
end

Parried = false
end
end)
elseif Connections_Manager["Auto Parry"] then
Connections_Manager["Auto Parry"]:Disconnect()
Connections_Manager["Auto Parry"] = nil
end
end
})

-- Auto Spam Toggle

local autoSpamCoroutine = nil
local targetPlayer = nil

SpamSection:NewToggle({
Title = "Auto Spam",
Default = false,
Callback = function(v)
if v then
if autoSpamCoroutine then
coroutine.resume(autoSpamCoroutine, "stop")
autoSpamCoroutine = nil
end

autoSpamCoroutine = coroutine.create(function(signal)
while v and (signal ~= "stop") do
local ball = Auto_Parry.Get_Ball()

if ball and ball:IsDescendantOf(workspace) then

local zoomies = ball:FindFirstChild("zoomies")

if zoomies then
Auto_Parry.Closest_Player()
targetPlayer = Closest_Entity

if targetPlayer and targetPlayer.PrimaryPart and

targetPlayer:IsDescendantOf(workspace) then
local playerDistance =
LocalPlayer:DistanceFromCharacter(ball.Position)
local targetPosition =
targetPlayer.PrimaryPart.Position
local targetDistance =
LocalPlayer:DistanceFromCharacter(targetPosition)

if targetPlayer.Parent then
if ball:IsDescendantOf(workspace) and
(ball.Position.Magnitude >= 1) then
local ballVelocity =
ball.Velocity.Magnitude
local ballSpeed = math.max(ballVelocity, 0)
local ping =
game:GetService("Stats").Network.ServerStatsItem["Data Ping"]:GetValue()
local pingThreshold = math.clamp(ping / 10,
10, 16)
local ballProperties =
Auto_Parry:Get_Ball_Properties()
local entityProperties =
Auto_Parry:Get_Entity_Properties()

local spamAccuracy =
Auto_Parry.Spam_Service({
Ball_Properties = ballProperties,
Entity_Properties = entityProperties,
Ping = pingThreshold,
Spam_Sensitivity =
Auto_Parry.Spam_Sensitivity,
Ping_Based_Spam =
Auto_Parry.Ping_Based_Spam
})

if (zoomies.Parent == ball) and

((playerDistance <= 30) or (targetDistance <= 30)) and (Parries > 1) then
Spamming = true
Auto_Parry.Parry()
task.wait(0.1)
Spamming = false
end
else
local waitTime = 0
repeat
task.wait(0.1)
waitTime = waitTime + 0.1
ball = Auto_Parry.Get_Ball()
until (ball and
ball:IsDescendantOf(workspace) and (ball.Position.Magnitude > 1)) or (waitTime >=
2.5)
end
end
end
end
end

task.wait(0.001)
end
end)

coroutine.resume(autoSpamCoroutine)
elseif autoSpamCoroutine then
coroutine.resume(autoSpamCoroutine, "stop")
autoSpamCoroutine = nil
end
end
})

-- Manual Spam Toggle

local manualSpamEnabled = false
local manualSpamConnection = nil

SpamSection:NewToggle({
Title = "Manual Spam",
Default = false,
Callback = function(v)
manualSpamEnabled = v

if manualSpamConnection then
manualSpamConnection:Disconnect()
manualSpamConnection = nil
end

if v then
manualSpamConnection =
UserInputService.InputBegan:Connect(function(input, gameProcessed)
if gameProcessed then return end

if input.KeyCode == Enum.KeyCode.E then

Spamming = not Spamming

if Spamming then
spawn(function()
while Spamming and manualSpamEnabled do
for _ = 1, manualSpamSpeed do
if not Spamming or not manualSpamEnabled then
break
end

local success, err = pcall(function()

Auto_Parry.Parry()
end)

if not success then

warn("Error in Auto_Parry.Parry:", err)
end

task.wait()
end

task.wait(0.001)
end
end)
end
end
end)
end
end
})

-- Parry Method Dropdown

ParrySettings:NewDropdown({
Title = "Parry Method",
Data = {"Random", "Backwards", "Straight", "Up", "Right", "Left"},
Default = "Straight",
Callback = function(selected)
Auto_Parry.Parry_Type = selected
end
})

-- Visualizer Toggle
VisualSection:NewToggle({
Title = "Ball Visualizer",
Default = false,
Callback = function(v)
toggle_visualizer(v)
end
})

-- Ping Based Toggle

ParrySettings:NewToggle({
Title = "Ping Based",
Default = false,
Callback = function(state)
pingBased = state
Auto_Parry.Ping_Based_Spam = state
end
})

-- Spam Sensitivity Slider

SpamSettings:NewSlider({
Title = "Spam Sensitivity",
Min = 1,
Max = 100,
Default = 50,
Callback = function(value)
Auto_Parry.Spam_Sensitivity = value
end
})

-- Spam Speed Slider

SpamSettings:NewSlider({
Title = "Spam Speed",
Min = 1,
Max = 20,
Default = 1,
Callback = function(value)
manualSpamSpeed = value
end
})

-- Load Notification
Notification.new({
Title = "ikorz Auto Parry",
Description = "Script loaded successfully!",
Duration = 5,
Icon = "rbxassetid://8997385628"
})